先把会做的做了，emmmm

1006

水题，关键就是在于如何切分字符串而已，考的应该也就是字符串了：

class sepration {
public:
    int hour = -1;
    int min = -1;
    int second = -1;

    sepration() {}

    sepration(int hour, int min, int second) {
        this->hour = hour;
        this->min = min;
        this->second = second;
    }
};

sepration getSepration(string time) {
    int sum = 0;
    sepration s;
    for (int i = 0; i < time.size(); ++i) {
        if (time[i] != ':') {
            sum = sum * 10 + (time[i] - '0');
        } else {
            if (s.hour == -1) {
                s.hour = sum;
            } else if (s.min == -1) {
                s.min = sum;
            }
            sum = 0;
        }
    }
    s.second = sum;
    return s;
}

1007

这个题目大名鼎鼎，一看就知道是动态规划，然鹅我不懂动态规划，用分治法做了，结果不过。牛客网看了一下，直接给了个9万多的数据，这样递归不爆炸才怪，先留着，学了动态规划再做了。

int getMax(int *array, int l, int r, int &left, int &right) {
    if (l == r) {
        left = right = array[l];
        return array[l];
    }
    int mid = (l + r) / 2;
    int maxLeft = INT_MIN;
    int maxLeftIndex = -1;
    int tempLeft = 0;
    for (int i = mid; i >= l; --i) {
        tempLeft += array[i];
        if (tempLeft > maxLeft) {
            maxLeftIndex = i;
            maxLeft = tempLeft;
        }
    }


    int maxRight = INT_MIN;
    int maxRightIndex = -1;
    int tempRight = 0;
    for (int i = mid + 1; i <= r; ++i) {
        tempRight += array[i];
        if (tempRight > maxRight) {
            maxRightIndex = i;
            maxRight = tempRight;
        }
    }


    int Lleft, Lright;
    int Rleft, Rright;

    int midSum = maxLeft + maxRight;
    int maxLeftSum = getMax(array, l, mid, Lleft, Lright);
    int maxRightSum = getMax(array, mid + 1, r, Rleft, Rright);


    int max = midSum;
    left = array[maxLeftIndex], right = array[maxRightIndex];


    if (max <= maxLeftSum) {
        max = maxLeftSum;
        left = array[Lleft];
        right = array[Lright];
    }
    if (max < maxRightSum) {
        max = maxRightSum;
        left = array[Rleft];
        right = array[Rright];
    }


    return max;

}

分治法思路也很简单，最大子串不是在左边就是在右边或者是跨越两边，分三个情况递归讨论即可。

1008

这个题目感觉有点小问题，特么的如果两层相同的话不应该只算等5秒吗？比如3 3，两个都是3层，那等5秒不就好了，然而去掉这个限制就过了。

//
// Created by GreenArrow on 2020/3/30.
//
#include <iostream>
#include <vector>

using namespace std;

vector<int> seperator(string s) {
    int sum = 0;
    vector<int> arr;
    for (int i = 0; i < s.size(); ++i) {
        if (s[i] != ' ')
            sum = sum * 10 + (s[i] - '0');
        else {
            arr.push_back(sum);
            sum = 0;
        }
    }
    arr.push_back(sum);
    return arr;
}

int main() {
    int n;
    vector<int> array;
    cin >> n;
    for (int j = 0; j < n; ++j) {
        int num;
        cin >> num;
        array.push_back(num);
    }
    int time = 0;
    int pre = 0;
    for (int i = 0; i < array.size(); ++i) {
        int cur = array[i];
        if (cur - pre > 0) {
            time += (cur - pre) * 6;
        } else if (cur - pre < 0) {
            time += (pre - cur) * 4;
        }

        time += 5;
        pre = cur;
    }
    cout << time;
}

1048

这个题目很明显就是索引，关键就是看你怎么存这个数字了，数据存储方式选的好，就简单。用一个数组存储次数即可。

int main() {
    int visited[MAX];
    fill(visited, visited + MAX, 0);
    int n, total;
    cin >> n >> total;
    for (int i = 0; i < n; ++i) {
        int num;
        cin >> num;
        visited[num]++;
    }

    int v1 = -1, v2 = -1;

    for (int j = 0; j < MAX; ++j) {
        if (visited[j]) {
            visited[j]--;
            if (total > j && visited[total - j]) {
                cout << j << " " << total - j;
                return 0;
            }
        }
    }

    cout << "No Solution";

}

1011

这个题目就比较水了，就是比较大小套公式就好了：

//
// Created by GreenArrow on 2020/4/1.
//
#include <iostream>

#define MAX 3
using namespace std;

int main() {
    double arr[MAX][MAX];
    int index_[MAX] = {-1};
    for (int i = 0; i < MAX; ++i) {
        double max = -1;
        for (int j = 0; j < MAX; ++j) {
            cin >> arr[i][j];
            if (max < arr[i][j]) {
                index_[i] = j;
                max = arr[i][j];
            }
        }
    }

    string a, b, c;
    double sum = 1;

    for (int k = 0; k < MAX; ++k) {
        if (index_[k] == 0) {
            cout << "W";
        } else if (index_[k] == 1) {
            cout << "T";
        } else if (index_[k] == 2) {
            cout << "L";
        }
        cout << " ";

        sum *= arr[k][index_[k]];

    }

    sum = (sum * 0.65 - 1) * 2;

    printf("%.2lf", sum);


}

1012

这个题目很简单，就是排序，但是有点小坑。和正常思维不一样，比如如果有并列，应该是1,1,2,3,4这样，但是这里是1,1,3,4,5，相同的也要算进去，测试点2就是这个情况，稍微处理一下即可。算法写的很麻烦，就是分开几个排序即可。

typedef struct student {
    string id;
    int A;
    int rankA;
    int C;
    int rankC;
    int M;
    int rankM;
    int E;
    int rankE;
    int origin;

    student(string id, int C, int M, int E) {
        this->id = id;
        this->C = C;
        this->M = M;
        this->E = E;
        this->A = (C + M + E) / 3;
    }
};

用一个结构体存储学生所有信息，包括原先排名，因为还准备了一个map存储数据索引。

    sort(students.begin(), students.end(), cmpA);
    setRankA(students);

    sort(students.begin(), students.end(), cmpC);
    setRankC(students);

    sort(students.begin(), students.end(), cmpM);
    setRankM(students);

    sort(students.begin(), students.end(), cmpE);
    setRankE(students);

    sort(students.begin(), students.end(), cmp);

分别排序之后进行排名赋值：

void setRankE(vector<student> &students) {
    int rank = 1;
    if (students.size() == 0)
        return;
    students[0].rankE = rank;
    for (int i = 1; i < students.size(); ++i) {
        if (students[i].E == students[i - 1].E) {
            students[i].rankE = students[i - 1].rankE;
            rank++;
        } else {
            students[i].rankE = ++rank;
        }
    }
}

赋值操作也很简单，注意特殊情况即可。

1015

这个题目就很明显是水题了，问你把相应进制的数字颠倒过来看看是不是还是一个素数。首先判断没变化前的数字是不是素数，然后判断变化之后是不是素数即可。

vector<int> getReverse(int number, int radix) {
    vector<int> results;
    while (number >= radix) {
        results.push_back(number % radix);
        number /= radix;
    }

    results.push_back(number);
    return results;
}

把数字变成进制的形式，不用翻转了，比如23的二进制，按照23%2进result，23/=2的形式，result里面就已经是翻转过来的了。

int radix2number(vector<int> result, int radix) {

    int sum = 0;
    for (int i = 0; i < result.size(); ++i) {
        sum = sum * radix + result[i];
    }

    return sum;

}

把result里面的进制转换成十进制。

int main() {
    int number, radix;
    cin >> number;
    while (number > 0) {
        cin >> radix;

        if (isPrime(number)) {

            int reversNumber = radix2number(getReverse(number, radix), radix);
            if (isPrime(reversNumber)) {
                cout << "Yes" << endl;
            } else
                cout << "No" << endl;

        } else {
            cout << "No" << endl;
        }
        cin >> number;
    }
    return 0;
}

主运行程序。

1019

这个题目很明显，水题，就是进制转换然后看看是不是回文串即可。

//
// Created by GreenArrow on 2020/4/6.
//
#include <iostream>
#include <vector>

using namespace std;

vector<int> getNumber(int number, int radix) {
    vector<int> sequences;
    while (number >= radix) {
        sequences.push_back(number % radix);
        number /= radix;
    }
    sequences.push_back(number);
    return sequences;
}

bool isPalindromic(vector<int> sequences) {
    for (int i = 0, j = sequences.size() - 1; i < j; ++i, j--) {
        if (sequences[i] != sequences[j]) {
            return false;
        }
    }
    return true;
}

int main() {
    int number, radix;
    cin >> number >> radix;
    vector<int> sequences = getNumber(number, radix);
    if (isPalindromic(sequences)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    for (int i = sequences.size() - 1; i >= 0; --i) {
        cout << sequences[i];
        if (i != 0) {
            cout << " ";
        }
    }
}

1022

这个题目考的是字符串的处理，没有什么特别的地方。但是有个坑的地方，如果id是用int存储，注意需要把7位给补齐了，否则后面三个测试点过不去。我用了一个class来存储数据，keywords数量有点多，怕超时，放在map映射，keywords为key，包含了这个关键字的id放进来，如果查询keyword直接打印map里面的数据即可，不需要遍历了，其他情况就遍历。

//
// Created by GreenArrow on 2020/4/9.
//
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cstdio>

using namespace std;

map<string, vector<int>> keyWords_id;

class book {
public:
    int ID;
    string title;
    vector<string> keyWords;
    string author;
    string publisher;
    string publish_year;

    book() { keyWords.clear(); }

    book(int id, const string &title, const vector<string> &keyWords, const string &author, const string &publisher,
         const string &publishYear) : ID(id), title(title), keyWords(keyWords), author(author), publisher(publisher),
                                      publish_year(publishYear) {}
};

vector<string> getKeyWords(string keyWords, int id) {
    vector<string> keywords_contain;
    string result;
    for (int i = 0; i < keyWords.size(); ++i) {
        if (keyWords[i] != ' ') {
            result += keyWords[i];
        } else {
            keywords_contain.push_back(result);
            if (keyWords_id.count(result) > 0) {
                keyWords_id[result].push_back(id);
            } else {
                vector<int> ids;
                ids.push_back(id);
                keyWords_id[result] = ids;
            }
            result = "";
        }
    }
    keywords_contain.push_back(result);
    if (keyWords_id.count(result) > 0) {
        keyWords_id[result].push_back(id);
    } else {
        vector<int> ids;
        ids.push_back(id);
        keyWords_id[result] = ids;
    }
    return keywords_contain;
}

void print_vector(vector<int> ids) {
    if (ids.size() == 0) {
        cout << "Not Found" << endl;
        return;
    }
    for (int i = 0; i < ids.size(); ++i) {
        printf("%07d\n", ids[i]);
    }
}

int main() {
    vector<book> books;
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i) {
        int id;
        string title;
        string author;
        string keyWords_string;
        string publisher;
        string publish_year;
        cin >> id;
        cin.ignore();
        getline(cin, title);
        getline(cin, author);
        getline(cin, keyWords_string);
        getline(cin, publisher);
        cin >> publish_year;
        cin.ignore();
        vector<string> keyWords = getKeyWords(keyWords_string, id);
        book Book(id, title, keyWords, author, publisher, publish_year);
        books.push_back(Book);
    }

    int m;
    cin >> m;
    cin.ignore();
    for (int j = 0; j < m; ++j) {
        vector<int> result;
        string query;
        getline(cin, query);
        char flag = query[0];
        string target = query.substr(3, query.size() - 3);
        if (flag == '1') {
            for (int i = 0; i < books.size(); ++i) {
                if (books[i].title == target) {
                    result.push_back(books[i].ID);
                }
            }
            sort(result.begin(), result.end());
        } else if (flag == '2') {
            for (int i = 0; i < books.size(); ++i) {
                if (books[i].author == target) {
                    result.push_back(books[i].ID);
                }
            }
            sort(result.begin(), result.end());
        } else if (flag == '3') {
            result = keyWords_id[target];
            sort(result.begin(), result.end());
        } else if (flag == '4') {
            for (int i = 0; i < books.size(); ++i) {
                if (books[i].publisher == target) {
                    result.push_back(books[i].ID);
                }
            }
            sort(result.begin(), result.end());
        } else if (flag == '5') {
            for (int i = 0; i < books.size(); ++i) {
                if (books[i].publish_year == target) {
                    result.push_back(books[i].ID);
                }
            }
            sort(result.begin(), result.end());
        }

        cout << query << endl;
        print_vector(result);
    }
}

算法笔记里面有另一种做法，是用map存储，效果好像更好些。

1023

考的是大数乘法。

char int2string(int num) {
    stringstream ss;
    ss << num;
    return ss.str()[0];
}

void reverse(string &s) {
    for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
        char c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

string doubleNumber(string s) {
    int addC = 0;
    string S = s;
    reverse(S);
    for (int i = 0; i < S.size(); ++i) {
        char c = S[i];
        int number = (c - '0') * 2 + addC;
        S[i] = int2string(number % 10);
        addC = number / 10;
    }

    if (addC != 0) {
        S += int2string(addC);
    }
    reverse(S);
    return S;
}