9-10月刷题Keep On

看到日期有点慌啊……趁着这几天准备笔试，抓住9月的尾巴补一篇随笔

9.28

【字符串】Sherlock - HackerRank

Manacher算法（“马拉车”算法）

尴尬……上面这道题好像不能直接用马拉车算法，我至今也没弄出来

10.2

【字典/哈希】Frequency Queries - HackerRank

　　可能太久没做题了，逻辑半天都捋不清楚！此题的关键是维护两个Map，这样可以有两个键名供查找。易错点是注意增删操作影响的元素频数，且需要判断Map中没有该元素的两种情况（根本没有对应的键，或键名对应的值为0）

参考代码：

#include <bits/stdc++.h>
using namespace std;
string ltrim(const string &);
string rtrim(const string &);
vector<string> split(const string &);

// Complete the freqQuery function below.
vector<int> freqQuery(vector<vector<int>> queries) {
    unordered_map<int, int> UMp1;//事后发现此题的时间效率与是否是哈希的map好像没关系，只要是字典O(1)查找就行
    unordered_map<int, int> UMp2;
    vector<int> ans;
    int len = queries.size();
    for(int i = 0; i < len; i++){
        int op = queries[i][0], ob = queries[i][1];
        if(op == 1){
            if(UMp1.find(ob) != UMp1.end() && UMp1[ob] != 0){
                UMp1[ob] ++;
                if(UMp2.find(UMp1[ob]) != UMp2.end() && UMp2[UMp1[ob]] != 0){
                    UMp2[ UMp1[ob] ] ++;
                }
                else UMp2[ UMp1[ob] ] = 1;
                UMp2[ UMp1[ob]-1 ] --;
            }
            else{
                UMp1[ob] = 1;
                if(UMp2.find(1) != UMp2.end()  && UMp2[1] != 0){
                    UMp2[1] ++;
                }
                else UMp2[1] = 1;
            }
        }
        else if(op == 2){
            if(UMp1.find(ob) != UMp1.end() && UMp1[ob] != 0){
                UMp1[ob] --;
                if(UMp2.find(UMp1[ob]) != UMp2.end() && UMp2[UMp1[ob]] != 0) UMp2[ UMp1[ob] ] ++;
                else{
                    UMp2[ UMp1[ob] ] = 1;
                }
                if(UMp2[UMp1[ob]+1] > 0) UMp2[ UMp1[ob]+1 ] --;
            }           
        }
        else if(op == 3){
            if(UMp2.find(ob) == UMp2.end() || UMp2[ob] == 0) ans.push_back(0);
            else ans.push_back(1);
        }
    }
    return ans;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string q_temp;
    getline(cin, q_temp);

    int q = stoi(ltrim(rtrim(q_temp)));

    vector<vector<int>> queries(q);

    for (int i = 0; i < q; i++) {
        queries[i].resize(2);

        string queries_row_temp_temp;
        getline(cin, queries_row_temp_temp);

        vector<string> queries_row_temp = split(rtrim(queries_row_temp_temp));

        for (int j = 0; j < 2; j++) {
            int queries_row_item = stoi(queries_row_temp[j]);

            queries[i][j] = queries_row_item;
        }
    }

    vector<int> ans = freqQuery(queries);

    for (int i = 0; i < ans.size(); i++) {
        fout << ans[i];

        if (i != ans.size() - 1) {
            fout << "
";
        }
    }

    fout << "
";

    fout.close();

    return 0;
}

string ltrim(const string &str) {
    string s(str);

    s.erase(
        s.begin(),
        find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
    );

    return s;
}

string rtrim(const string &str) {
    string s(str);

    s.erase(
        find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
        s.end()
    );

    return s;
}

vector<string> split(const string &str) {
    vector<string> tokens;

    string::size_type start = 0;
    string::size_type end = 0;

    while ((end = str.find(" ", start)) != string::npos) {
        tokens.push_back(str.substr(start, end - start));

        start = end + 1;
    }

    tokens.push_back(str.substr(start));

    return tokens;
}

 10.3

【排序】Fraudulent Activity Notifications - HackerRank

　　通过此题首次接触到了基数排序和计数排序！（暂时没空自己总结了，贴两篇博文链接好了。）这题还是有点东西滴~

　　另外，桶排序是计数排序的优化版本，记得补上。

参考代码：

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

// Complete the activityNotifications function below.
int activityNotifications(vector<int> expenditure, int d) {
    int n = expenditure.size(), cnt = 0, Max = -1, Min = 300;
    for(int i = 0; i < n; ++i){
        Max = max(Max, expenditure[i]);
        Min = min(Min, expenditure[i]);
    }
    vector<int> votes(Max - Min + 1);//从最小到最大数，以最小数为基准。此题的范围是0-200，故桶排序很高效
    if(d%2 == 1){
        for(int i = 0; i < d; ++i){
            votes[expenditure[i] - Min] ++;
        }
        for(int i = d; i < n; ++i){
            int k = d/2+1, j = -1;//计算中位数的区间长度d为奇数时，就遍历到前d/2+1个数
            while(k > 0){
                j ++;
                k -= votes[j];
            }
            if(expenditure[i] >= 2 * (j+Min)) cnt ++;//后面不要忘了每次计算引用下标都要调整一个最小数
            votes[ expenditure[i - d] - Min] --;
            votes[ expenditure[i] - Min] ++;
        }
    }
    else{
        for(int i = 0; i < d; ++i){
            votes[expenditure[i] - Min] ++;
        }
        for(int i = d; i < n; ++i){
            int k = d/2, j = -1, tmp = 0;//对于d是偶数的情况，分两次取两个k，用tmp记录和的值
            while(k > 0){
                j ++;
                k -= votes[j];
            }
            tmp += j + Min;
            if(k<0) tmp *= 2;//如果这两个中间数相同，则k一定会减为负数
            else{
                k = 1; //如果不同，k再向后取一个
                while(k > 0){
                    j ++;
                    k -= votes[j];
                }
                tmp += j + Min;
            }
            if(expenditure[i] >= tmp) cnt ++;
            votes[ expenditure[i - d] - Min] --;
            votes[ expenditure[i] - Min] ++;
        }
    }
    return cnt;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string nd_temp;
    getline(cin, nd_temp);

    vector<string> nd = split_string(nd_temp);

    int n = stoi(nd[0]);

    int d = stoi(nd[1]);

    string expenditure_temp_temp;
    getline(cin, expenditure_temp_temp);

    vector<string> expenditure_temp = split_string(expenditure_temp_temp);

    vector<int> expenditure(n);

    for (int i = 0; i < n; i++) {
        int expenditure_item = stoi(expenditure_temp[i]);

        expenditure[i] = expenditure_item;
    }

    int result = activityNotifications(expenditure, d);

    fout << result << "
";

    fout.close();

    return 0;
}

vector<string> split_string(string input_string) {
    string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
        return x == y and x == ' ';
    });

    input_string.erase(new_end, input_string.end());

    while (input_string[input_string.length() - 1] == ' ') {
        input_string.pop_back();
    }

    vector<string> splits;
    char delimiter = ' ';

    size_t i = 0;
    size_t pos = input_string.find(delimiter);

    while (pos != string::npos) {
        splits.push_back(input_string.substr(i, pos - i));

        i = pos + 1;
        pos = input_string.find(delimiter, i);
    }

    splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

    return splits;
}

 【字符串】Sherlock And Valid String - HackerRank

　　这题也好细节啊……天。

参考代码：

#include <bits/stdc++.h>

using namespace std;

// Complete the isValid function below.
string isValid(string s) {
    int n = s.size();
    int type[26];
    memset(type, 0 ,sizeof(type));
    for(int i = 0; i < n; ++i){
        type[s[i]-'a'] ++;
    }
    int k1 = 0, k2 = 0, n1 = 0, n2 = 0;
    for(int i = 0; i < 26; ++i){
        if(n1 > 1 && n2 > 1) return "NO";//出现两种占主重复次数
        if(n1 == 1 && n2 > 1 && k1 != k2+1 && k1 != 1) return "NO";//出现两种无法调和的重复次数（无法通过-1合并为同一次数或降低字母多样性）
        if(n2 == 1 && n1 > 1 && k2 != k1+1 && k2 != 1)return "NO";
        if(type[i] > 0){//type[i]是字母('a'+i)的出现次数
            if(type[i] == k1) n1++;
            else if(type[i] == k2) n2++;
            else if(k1 == 0){
                k1 = type[i];
                n1 = 1;
            }
            else if(k2 == 0){
                k2 = type[i];
                n2 = 1;
            }
            else return "NO";//出现三种重复次数
        }
    }
    return "YES";
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    string s;
    getline(cin, s);

    string result = isValid(s);

    fout << result << "
";

    fout.close();

    return 0;
}

 10.4

【字符串】Special String Again - HackerRank

　　O(1)复杂度的解法↓ [呲牙][呲牙]

参考代码：

#include <bits/stdc++.h>
using namespace std;
// Complete the substrCount function below.
long substrCount(int n, string s) {
    long cnt = 0;
    //Save trailing numbers
    vector<int> trail(n);
    char pre = s[0];
    trail[0] = 1;
    for(int i = 1; i <n; ++i){
        if(s[i] == pre){
            trail[i] = trail[i - 1] + 1;
        }
        else{
            pre = s[i];
            trail[i] = 1;
        }
    }
    //Save trailing numbers of the reverse order
    vector<int> rev_trail(n);
    char rev_pre = s[n-1];
    rev_trail[n-1] = 1;
    for(int i = n-2; i >= 0; --i){
        if(s[i] == rev_pre){
            rev_trail[i] = rev_trail[i + 1] + 1;
        }
        else{
            rev_pre = s[i];
            rev_trail[i] = 1;
        }
    }
    //Calculate pattern 1
    for(int i = 0; i < n; ++i){
        if(i + 1 < n && trail[i] < trail[i+1]) continue;
        cnt += trail[i] * (trail[i] + 1) / 2;
    }
    //Calculate pattern 2
    for(int i = 1; i < n - 1; ++i){
        if(s[i-1] == s[i+1] && trail[i] == 1){
            int l1 = trail[i-1], l2 = rev_trail[i+1];
            cnt += min(l1, l2);
        }
    }
    return cnt;
}

int main()
{
    ofstream fout(getenv("OUTPUT_PATH"));

    int n;
    cin >> n;
    cin.ignore(numeric_limits<streamsize>::max(), '
');

    string s;
    getline(cin, s);

    long result = substrCount(n, s);

    fout << result << "
";

    fout.close();

    return 0;
}