PAT甲级刷题记录（1091-1100）

1091-1100

1091 Acute Stroke(30)

#include<iostream>
#include<queue>
using namespace std;
struct node{
    int x, y, z;
    node(int _x, int _y, int _z){
        x = _x;
        y = _y;
        z = _z;
    }
};
int m, n, l, t;
int a[70][1290][130] = {0};
bool visit[70][1290][130] = {false};
int flag = 0;
int res = 0, temp_res = 0;
int direction[6][3] = {{-1, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, -1, 0}, {0, 0 ,1}, {0, 0, -1}};
// 用dfs的话调用层数太多会导致段错误
// void dfs(int z, int x, int y){
//     if(z < 1 || z > l || x < 1 || x > m || y < 1 || y > n){
//         return;
//     }
//     if(visit[z][x][y] || a[z][x][y] == 0){
//         return;
//     }
//     visit[z][x][y] = true;
//     temp_res++;
//     for(int i = 0; i < 6; i++){
//         dfs(z + direction[i][0], x + direction[i][1], y + direction[i][2]);
//     }
// }
bool judge(int z, int x, int y){
    if(z < 1 || z > l || x < 1 || x > m || y < 1 || y > n){
        return false;
    }
    if(visit[z][x][y] || a[z][x][y] == 0){
        return false;
    }
    return true;
}
void bfs(int z, int x, int y){
    node temp(x, y, z);
    queue<node> q;
    q.push(temp);
    visit[z][x][y] = true;
    while(!q.empty()){
        node top = q.front();
        q.pop();
        temp_res++;
        for(int i = 0; i < 6; i++){
            int tz = top.z + direction[i][0];
            int tx = top.x + direction[i][1];
            int ty = top.y + direction[i][2];
            if(judge(tz, tx, ty)){
                visit[tz][tx][ty] = true;
                node tempn(tx, ty, tz);
                q.push(tempn);
            }
        }
    }
    
}
int main(){
    cin >> m >> n >> l >> t;
    for(int i = 1; i <= l; i++){
        for(int j = 1; j <= m; j++){
            for(int k = 1; k <= n; k++){
                cin >> a[i][j][k];
            }
        }
    }
    for(int i = 1; i <= l; i++){
        for(int j = 1; j <= m; j++){
            for(int k = 1; k <= n; k++){
                if(!visit[i][j][k] && a[i][j][k] == 1){
                    bfs(i, j, k);
                    if(temp_res >= t){
                        res += temp_res;
                    }
                    temp_res = 0;
                }
            }
        }
    }
    cout << res;
    return 0;
}

1092 To Buy or Not to Buy(20)

#include<iostream>
#include<string>
using namespace std;
int colors[1000] = {0};
int main(){
    string a, b;
    cin >> a >> b;
    for(int i = 0; i < a.length(); i++){
        colors[a[i]]++;
    }
    int ans = 0;
    for(int i = 0; i < b.length(); i++){
        if(colors[b[i]] > 0){
            colors[b[i]]--;
        }else{
            ans += 1;
        }
    }
    if(ans != 0){
        cout << "No " << ans; 
    }else{
        cout << "Yes " << a.length() - b.length();
    }
}

1093 Count PAT’s(25)

#include<iostream>
using namespace std;
const int mod = 1e9 + 7;
string s;

int main(){
    cin >> s;
    int scp = 0, sct = 0;
    for(int i = 0; i < s.length(); i++){
        if(s[i] == 'P'){
            scp++;
        }
        if(s[i] == 'T'){
            sct++;
        }
    }
    int cp = 0, ct = sct;
    int res = 0;
    for(int i = 0; i < s.length(); i++){
        if(s[i] == 'A'){
            res = (res + (cp * ct) % mod) % mod;
        }else if(s[i] == 'P'){
            cp++;
        }else if(s[i] == 'T'){
            ct--;
        }
    }
    cout << res;
}

1094 The Largest Generation(25)

#include<iostream>
#include<vector>
#include<map>
using namespace std;
const int maxn = 101;
struct person{
    int level;
    vector<int> v;
    int father;
    person(){
        level = 0;
        father = 0;
    }
}node[maxn];

int n, m;
map<int, int> ma;

void dfs(int user, int height){
    node[user].level = height;
    for(int i = 0; i < node[user].v.size(); i++){
        dfs(node[user].v[i], height + 1);
    }
}

int main(){
    cin >> n >> m;
    //考虑n = 1, m = 0的情况,因此初始设置user = 1
    int user = 1, len, temp;
    for(int i = 1; i <= m; i++){
        cin >> user >> len;
        for(int j = 1; j <= len; j++){
            cin >> temp;
            node[user].v.push_back(temp);
            node[temp].father = user;
        }
    }
    //find root
    while(node[user].father != 0){
        user = node[user].father;
    }
    dfs(user, 1);
    for(int i = 1; i <= n; i++){
        ma[node[i].level]++;
    }
    int res = -1, res_level;
    for(auto it = ma.begin(); it != ma.end(); it++){
        if(it -> second > res){
            res = it -> second;
            res_level = it -> first;
        }
    }
    cout << res << " " << res_level;
}

1095 Cars on Campus(30)

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<map>
using namespace std;
struct node{
    char id[10];
    int time, flag = 0;
};
bool cmp1(node a, node b){
    if(strcmp(a.id, b.id) != 0){
        return strcmp(a.id, b.id) < 0;
    }else{
        return a.time < b.time;
    }
}
bool cmp2(node a, node b){
    return a.time < b.time;
}

int main(){
    int n, k, maxtime = -1, tempindex = 0;
    cin >> n >> k;
    vector<node> record(n), car;
    for(int i = 0; i < n; i++){
        char temp[5];
        int h, m, s;
        scanf("%s %d:%d:%d %s\n", record[i].id, &h, &m, &s, temp);
        int temptime = h * 3600 + m * 60 + s;
        record[i].time = temptime;
        record[i].flag = strcmp(temp, "in") == 0 ? 1 : -1;
    }
    sort(record.begin(), record.end(), cmp1);
    map<string, int> mapp;
    for(int i = 0; i < n -1; i++){
        if(strcmp(record[i].id, record[i + 1].id) == 0
          && record[i].flag == 1
          && record[i + 1].flag == -1){
            car.push_back(record[i]);
            car.push_back(record[i + 1]);
            mapp[record[i].id] += (record[i + 1].time - record[i].time);
            if(maxtime < mapp[record[i].id]){
                maxtime = mapp[record[i].id];
            }
        }
    }
    sort(car.begin(), car.end(), cmp2);
    vector<int> cnt(n);
    for(int i = 0; i < car.size(); i++){
        if(i == 0){
            cnt[i] += car[i].flag;
        }else{
            cnt[i] = cnt[i - 1] + car[i].flag;
        }
    }
    for(int i = 0; i < k; i++){
        int h, m, s;
        scanf("%d:%d:%d", &h, &m, &s);
        int temptime = h * 3600 + m * 60 + s;
        int j;
        for(j = tempindex; j < car.size(); j++){
            //如果时间相同 那就是下一个的前一个
            if(car[j].time > temptime){
                cout << cnt[j - 1] << endl;
                break;
            }else if(j == car.size() - 1){
                cout << cnt[j] << endl;
            }
        }
        tempindex = j;
    }
    for(auto it = mapp.begin(); it != mapp.end(); it++){
        if(it -> second == maxtime){
            cout << it -> first << " ";
        }
    }
    printf("%02d:%02d:%02d", maxtime / 3600, (maxtime % 3600) / 60, maxtime % 60);
}

1096 Consecutive Factors(20)

#include<iostream>
#include<cmath>
using namespace std;
int main(){
    int n;
    scanf("%d", &n);
    int start = 0, len = 0;
    for(int i = 2; i <= sqrt(n) + 1; i++){
        int cnt = 0;
        int temp = n;
        for(int j = i; j <= sqrt(n) + 1; j++){
           if(temp % j == 0){
               temp /= j;
               cnt++;
           }else{
               break;
           }
        }
        if(cnt > len){
            start = i;
            len = cnt;
        }
    }
    if(start == 0){
        //无法分解的情况
        printf("1\n%d", n);
    }else{
        printf("%d\n", len);
        for(int i = start; i < start + len; i++){
            printf("%d", i);
            if(i !=  start + len - 1){
               printf("*");
           }
        }
    }
}

1097 Deduplication on a Linked List(25)

#include<iostream>
#include<set>
#include<vector>
using namespace std;
const int maxn = 1e5 + 1;
struct nnode{
    int address, key, next;
}node[maxn];
vector<nnode> final_list, remove_list;
set<int> s;

int main(){
    int start, n;
    cin >> start >> n;
    int ad, ke, ne;
    for(int i = 1; i <= n; i++){
        cin >> ad >> ke >> ne;
        node[ad].address = ad;
        node[ad].key = ke;
        node[ad].next = ne;
    }
    while(start != -1){
        if(!s.count(abs(node[start].key))){
            s.insert(abs(node[start].key));
            final_list.push_back(node[start]);
        }else{
            remove_list.push_back(node[start]);
        }
        start = node[start].next;
    }
    if(final_list.size() != 0){
        for(int i = 0; i < final_list.size(); i++){
            if(i == 0){
                printf("%05d %d ", final_list[i].address, final_list[i].key);
            }else{
                printf("%05d\n%05d %d ",final_list[i].address, final_list[i].address, final_list[i].key);
            }
        }
        cout << "-1\n";
    }
    if(remove_list.size() != 0){
        for(int i = 0; i < remove_list.size(); i++){
            if(i == 0){
                printf("%05d %d ", remove_list[i].address, remove_list[i].key);
            }else{
                printf("%05d\n%05d %d ",remove_list[i].address, remove_list[i].address, remove_list[i].key);
            }
        }
        cout << "-1";
    }

}

1098 Insertion or Heap Sort(25)

//https://blog.csdn.net/qq_24452475/article/details/100084698
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxn=111;

int origin_seq[maxn], sort_seq[maxn], changed[maxn];
int n;
bool judge(int a[], int b[]){
    for(int i=1; i<=n; i++){
        if(a[i]!=b[i]){
            return false;
        }
    }
    return true;
}

bool showArray(int A[]){
    for(int i=1; i<=n; i++){
        printf("%d", A[i]);
        if(i<n) printf(" ");
    }
}
bool insertSort(){
    bool flag = false; 
    for(int i=2; i<=n; i++) {
        if(i!=2 && judge(sort_seq, changed)){
             flag = true;
        }
        sort(sort_seq, sort_seq+i+1);
        if(flag == true){
            return true;
        }
    }
    return false;
}
void downAdjust(int low, int high){
    int i = low, j = i*2;  // i为欲调整结点，j为其左孩子结点
    while(j <= high){// 存在孩子结点
        // 如果右孩子结点存在，且右孩子结点值大于左孩子结点
        if(j+1 <= high && sort_seq[j+1] > sort_seq[j]){
            j = j+1;// 让 j存储右孩子结点下标
        }
        // 如果孩子结点中最大的权值比父亲结点大
        if(sort_seq[j] > sort_seq[i]){
            // 交换最大权值的孩子与父亲结点
            swap(sort_seq[j], sort_seq[i]);
            i = j;  // 令i为j，令j为i的左孩子结点，进入下一层
            j = i*2;
        }
        else{
            break;  // 孩子结点的权值比父亲结点的小，调整结束
        }
    }
}
void heapSort(){
    bool flag = false;
    for(int i=n/2; i>=1; i--){
        downAdjust(i, n);  // 建堆
    }
    for(int i=n; i>1; i--){
        // 中间步骤与目标相同，且不是初始序列
        if(i!=n && judge(sort_seq, changed)){
            flag = true;
        }
        // 交换heap[i]与堆顶
        swap(sort_seq[i], sort_seq[1]);
        // 调整堆顶
        downAdjust(1, i-1);
        if(flag == true){
            showArray(sort_seq);
            return;
        }
    }
}

int main(){
    scanf("%d", &n);
    for(int i=1; i<=n; i++){
        scanf("%d", &origin_seq[i]);
        sort_seq[i] = origin_seq[i];
    }
    for(int i=1; i<=n; i++){
        scanf("%d", &changed[i]);
    }
    // 插入排序中找到目标数组
    if(insertSort()){
        printf("Insertion Sort\n");
        showArray(sort_seq);
    }
    else{   // 堆排序
        printf("Heap Sort\n");
        for(int i=1; i<=n; i++)
            sort_seq[i] = origin_seq[i];
        heapSort();
    }
    return 0;
}

1099 Build A Binary Search Tree(30)

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn = 101;
vector<int> nums;
int cnt = 0;
struct treenode{
    int data, left, right;
}node[maxn];

bool cmp(int a, int b){
    return a < b;
}

void dfs(int i){
    if(node[i].left != -1){
        dfs(node[i].left);
    }
    node[i].data = nums[cnt++];
    if(node[i].right != -1){
        dfs(node[i].right);
    }
}
void leveorder(int root){
    queue<int> q;
    q.push(root);
    int flag = 0;
    while(!q.empty()){
        int temp = q.front();
        if(flag == 0){
            cout << node[temp].data;
            flag = 1;
        }
        else{
            cout << " " << node[temp].data;
        }
        if(node[temp].left != -1){
            q.push(node[temp].left);
        }
        if(node[temp].right != -1){
            q.push(node[temp].right);
        }
        q.pop();
    }
}
int main(){
    int n, temp;
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> node[i].left >> node[i].right;
    }
    for(int i = 0; i < n; i++){
        cin >> temp;
        nums.push_back(temp);
    }
    sort(nums.begin(), nums.end(), cmp);
    //sort后得到的其实就是BST的中序遍历,根据中序遍历建树
    dfs(0);
    leveorder(0);
}

1100 Mars Numbers(20)

#include<iostream>
#include<string>
using namespace std;
string a[13] = {"tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov", "dec"};
string b[13] = {"####", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer", "jou"};
void toMar(int n){
    if(n / 13){
        cout << b[n / 13];
        if(n % 13){
            cout << " ";
        }
    }
    if(n % 13 || n == 0){
        //endl加在这里要格式错误, 可能数字就是tam
        cout << a[n % 13];
    }
}
void toEarth(string s){
    int len = s.length();
    int n1 = 0, n2 = 0;
    string s1 = s.substr(0, 3);
    string s2;
    if(len > 4){
        s2 = s.substr(4, 3);
    }
    for(int i = 1; i <= 12; i++){
        if(s1 == a[i] || s2 == a[i]){
            n2 = i;
        }
        if(s1 == b[i]){
            n1 = i;
        }
    }
    cout << n1 * 13 + n2;
}
int main(){
    int n;
    cin >> n;
    getchar();
    string s;
    for(int i = 0; i < n; i++){
        getline(cin, s);
//         if(isdigit(s[0])){
        if(s[0] >= '0' && s[0] <= '9'){
            toMar(stoi(s));
        }else{
            toEarth(s);
        }
        cout << endl;
    }
}