PAT甲级刷题记录（1051-1060）

1051-1060

1051 Pop Sequence(25)

#include<cstdio>
#include<stack>
#include<vector>
#include<iostream>
using namespace std;
int main(){
    int m, n, k;
    cin >> m >> n >> k;
    for(int i = 1; i <= k; i++){
        stack<int> s;
        vector<int> v(n + 1);
        for(int j = 1; j <= n; j++){
            cin >> v[j];
        }
        int cur = 1;
        for(int j = 1; j <= n; j++){
            s.push(j);
            if(s.size() > m){
                break;
            }
            while(!s.empty() && s.top() == v[cur]){
                s.pop();
                cur++;
            }
        }
        if(cur == n + 1){
            cout << "YES\n";
        }else{
            cout << "NO\n";
        }
    }
}

1052 Linked List Sorting(25)

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 100001;
struct node{
    int address, key, next;
}nodedata[maxn];
vector<node> v;

bool cmp(node n1, node n2){
    return n1.key < n2.key;
}
int main(){
    int n, head, address, key, next;
    cin >> n >> head;
    for(int i = 1; i <= n; i++){
        cin >> address >> key >> next;
        nodedata[address].address = address;
        nodedata[address].key = key;
        nodedata[address].next = next;
    }
    while(head != -1){
        v.push_back(nodedata[head]);
        head = nodedata[head].next;
    }
    if(v.size() == 0){
        cout << "0 -1";
        return 0;
    }
    sort(v.begin(), v.end(), cmp);
    //首节点也要格式化输出！ 测试点3
    //cout << v.size() << " " << v[0].address << endl;
    printf("%d %05d\n", v.size(), v[0].address);
    for(int i = 0; i < v.size(); i++){
        if(i == v.size() - 1){
            printf("%05d %d -1\n", v[i].address, v[i].key);
        }else{
            printf("%05d %d %05d\n", v[i].address, v[i].key, v[i + 1].address);
        }
    }
}

1053 Path of Equal Weight(30)

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 101;
int weight[maxn];
vector<int> v[maxn];
int n, m, s;
vector<int> temppath;
int tempans = 0;
vector<vector<int> > path;
bool cmp(vector<int> p1, vector<int> p2){
    int len = max(p1.size(), p2.size());
    for(int i = 0; i < len; i++){
        if(p1[i] != p2[i]){
            return p1[i] > p2[i];
        }
    }
    return p1.size() > p2.size();
}

void dfs(int node){
    tempans += weight[node];
    temppath.push_back(weight[node]);
    if(tempans == s && v[node].empty()){
        path.push_back(temppath);
    }
    if(!v[node].empty()){
        for(int i = 0; i < v[node].size(); i++){
            dfs(v[node][i]);
        }
    }
    temppath.pop_back();
    tempans -= weight[node];
}
int main(){

    cin >> n >> m >> s;
    for(int i = 0; i < n; i++){
        cin >> weight[i];
    }
    for(int i = 0; i < m; i++){
        int node, len, temp;
        cin >> node >> len;
        for(int j = 1; j <= len; j++){
            cin >> temp;
            v[node].push_back(temp);
        }
    }
    dfs(0);
    sort(path.begin(), path.end(), cmp);
    for(int i = 0; i < path.size(); i++){
        for(int j = 0; j < path[i].size(); j++){
            if(j != 0){
                cout << " " << path[i][j];
            }else{
                cout << path[i][j];
            }
        }
        cout << endl;
    }
}

1054 The Dominant Color(20)

#include<cstdio>
#include<map>
using namespace std;
map<int, int> mp;
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    int temp;
    for(int i = 1; i <= m; i++){
        for(int j = 1; j <= n; j++){
            scanf("%d", &temp);
            mp[temp]++;
            if(mp[temp] > n * m / 2){
                break;
            }
        }
    }
    printf("%d", temp);
    return 0;
}

1055 The World’s Richest(25)

//超时 每次都排序来不及 直接排一次
// #include<iostream>
// #include<vector>
// #include<algorithm>
// using namespace std;
// const int maxn = 1e5 + 1;
// struct person{
//     string name;
//     int age, worth;
// }p[maxn];
// vector<person> v;

// bool cmp(person p1, person p2){
//     if(p1.worth != p2.worth){
//         return p1.worth > p2.worth;
//     }
//     if(p1.age != p2.age){
//         return p1.age < p2.age;
//     }
//     return p1.name < p2.name;
// }
// int main(){
//     int n, k;
//     cin >> n >> k;
//     for(int i = 0; i < n; i++){
//         cin >> p[i].name >> p[i].age >> p[i].worth;
//     }
//     int num, min_age, max_age;
//     for(int i = 1; i <= k; i++){
//         cin >> num >> min_age >> max_age;
//         v.clear();
//         for(int i = 0; i < n; i++){
//             if(p[i].age >= min_age && p[i].age <= max_age){
//                 v.push_back(p[i]);
//             }
//         }
//         printf("Case #%d:\n", i);
//         if(v.empty()){
//             cout << "None" << endl;
//             continue;
//         }
//         sort(v.begin(), v.end(), cmp);
//         for(int i = 0; i < num && i < v.size(); i++){
//             printf("%s ",v[i].name.c_str());
//             cout << v[i].age << " " << v[i].worth << endl;
//             //cout << v[i].name << " " << v[i].age << " " << v[i].worth << endl;
//         }
//     }
// }


#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 1e5 + 1;
struct person{
    string name;
    int age, worth;
}p[maxn];

bool cmp(person p1, person p2){
    if(p1.worth != p2.worth){
        return p1.worth > p2.worth;
    }
    if(p1.age != p2.age){
        return p1.age < p2.age;
    }
    return p1.name < p2.name;
}
int main(){
    int n, k;
    cin >> n >> k;
    for(int i = 0; i < n; i++){
        cin >> p[i].name >> p[i].age >> p[i].worth;
    }
    sort(p, p + n, cmp);
    int num, min_age, max_age;
    for(int i = 1; i <= k; i++){
        cin >> num >> min_age >> max_age;
        printf("Case #%d:\n", i);
        int u = 0;
        int flag = 0;
        while(num != 0 && u < n){
            if(p[u].age >= min_age && p[u].age <= max_age){
                printf("%s ",p[u].name.c_str());
                cout << p[u].age << " " << p[u].worth << endl;
                num--;
                flag = 1;
            }
            u++;
        }
        if(flag == 0){
            cout << "None" << endl;
        }
    }
}

1056 Mice and Rice(25)

//开的数组太多了, 不太清晰 还是应该定义结构体
#include<iostream>
#include<queue>
using namespace std;
const int maxn = 1e4 + 1;
int weight[maxn], order[maxn], rk[maxn];
queue<int> q;

int main(){
    int np, ng;
    cin >> np >> ng;
    for(int i = 0; i < np; i++){
        cin >> weight[i];
    }
    for(int i = 0; i < np; i++){
        cin >> order[i];
        q.push(order[i]);
    }
    int group_num;
    while(!q.empty()){
        int size = q.size();
        if(size == 1){
            rk[q.front()] = 1;
            break;
        }
        if((size / ng) * ng == size){
            group_num = size / ng;
        }else{
            group_num = size / ng + 1;
        }
        int max_num_index = -1;
        int cnt = 0;
        for(int i = 0; i < size; i++){
            int index = q.front();
            rk[index] = group_num + 1;
            q.pop();
            
            cnt++;
            if(max_num_index == -1 || weight[max_num_index] < weight[index]){
                max_num_index = index;
            }
            if(cnt == ng || i == size - 1){
                q.push(max_num_index);
                cnt = 0;
                max_num_index = -1;
            }
        }
    }
    for(int i = 0; i < np; i++){
        if(i != 0){
            cout << " " << rk[i];
        }else{
            cout << rk[i];
        }
    }
}

1057 Stack(30)

// 最朴素的想法:vector存储 每次查询中位数都sort,只过了2个测试样例
// 可以采用树状数组 桶排序 或者二分
// #include<iostream>
// #include<vector>
// #include<algorithm>
// using namespace std;
// class mystack{
//     private:
//         int index;
//         vector<int> v;
//     public:
//         mystack(){
//             index = -1;
//         }
//         void push(int n){
//             v.push_back(n); 
//             index++;
//         }
//         void peekMedian(){
//             if(v.empty()){
//                 cout << "Invalid" << endl;
//             }else{
//                 vector<int> temp = v;
//                 sort(temp.begin(), temp.end());
//                 cout << temp[((index + 1) + 1) / 2 - 1] << endl;
// //                 if((index + 1) % 2 == 0){
// //                     cout << temp[(index + 1) / 2 - 1] << endl;
// //                 }else{
// //                     cout << temp[(index + 2) / 2 - 1] << endl;
// //                 }
//             }
//         }
//         void pop(){
//             if(v.empty()){
//                 cout << "Invalid" << endl;
//             }else{
//                 cout << v[index] << endl;
//                 v.pop_back();
//                 index--;
//             }
//         }
// };

// int main(){
//     mystack ms;
//     int n;
//     cin >> n;
    
//     string opt;
//     int opt_num;
//     for(int i = 1; i <= n; i++){
//         cin >> opt;
//         if(opt == "Pop"){
//             ms.pop();
//         }else if(opt == "PeekMedian"){
//             ms.peekMedian();
//         }else{
//             cin >> opt_num;
//             ms.push(opt_num);
//         }
//     }
// }

//桶排序 可以过
// #include <iostream>
// #include <algorithm>
// #include <stack>
// #include <string.h>
// #define max 100010
// #define v 320
// using namespace std;
// stack<int> s;
// int table[max];
// int bucket[v];
// void Push(int n){
//     s.push(n);
//     table[n]++;
//     bucket[n/v]++;
// }
// int Pop(){
//     int n=s.top();
//     table[n]--;
//     bucket[n/v]--;
//     s.pop();
//     return n;
// }


// int PeekMedian(){
//     int index=(s.size()+1)/2;
//     int i=0,j=0;
//     while(i+bucket[j]<index){
//         i+=bucket[j++];
//     }
//     int k=j*v;
//     while(i+table[k]<index){
//         i+=table[k++];
//     }
//     return k;
// }
// int main(){
//     fill(table,table+max,0);
//     fill(bucket,bucket+v,0);
//     int N;
//     char flag[20];
//     scanf("%d",&N);
//     for(int l=0;l<N;l++){
//         scanf("%s",flag);
//         if(strlen(flag)==3){
//             if(s.size()==0) printf("Invalid\n");
//             else printf("%d\n",Pop());
//         }
//         else if(strlen(flag)==4){
//             int d;
//             scanf("%d",&d);
//             Push(d);
//         }
//         else{
//             if(!s.size()) printf("Invalid\n");
//             else printf("%d\n",PeekMedian());
//         }
//     }
// return 0;
// }

//  树状数组 liuchuo
#include <iostream>
#include <stack>
#define lowbit(i) ((i) & (-i))
const int maxn = 100010;
using namespace std;
int c[maxn];
stack<int> s;
void update(int x, int v) {
    for(int i = x; i < maxn; i += lowbit(i))
        c[i] += v;
}
int getsum(int x) {
    int sum = 0;
    for(int i = x; i >= 1; i -= lowbit(i))
        sum += c[i];
    return sum;
}
void PeekMedian() {
    int left = 1, right = maxn, mid, k = (s.size() + 1) / 2;
    while(left < right) {
        mid = (left + right) / 2;
        if(getsum(mid) >= k)
            right = mid;
        else
            left = mid + 1;
    }
    printf("%d\n", left);
}
int main() {
    int n, temp;
    scanf("%d", &n);
    char str[15];
    for(int i = 0; i < n; i++) {
        scanf("%s", str);
        if(str[1] == 'u') {
            scanf("%d", &temp);
            s.push(temp);
            update(temp, 1);
        } else if(str[1] == 'o') {
            if(!s.empty()) {
                update(s.top(), -1);
                printf("%d\n", s.top());
                s.pop();
            } else {
                printf("Invalid\n");
            }
        } else {
            if(!s.empty())
                PeekMedian();
            else
                printf("Invalid\n");
        }
    }
    return 0;
}

1058 A+B in Hogwarts(20)

#include<cstdio>
using namespace std;

int main(){
    int g1, s1, k1, g2, s2, k2;
    scanf("%d.%d.%d %d.%d.%d", &g1, &s1, &k1, &g2, &s2, &k2);
    int k_cnt = (k1 + k2) / 29;
    int s_cnt = (s1 + s2 + k_cnt) / 17;
    printf("%d.%d.%d",s_cnt + g1 + g2, (s1 + s2 + k_cnt) % 17, (k1 + k2) % 29);
}

1059 Prime Factors(25)

#include<iostream>
#include<vector>
using namespace std;
struct factor{
    int x, power;
    factor(int _x, int _power){
        x = _x;
        power = _power;
    }
};
vector<factor> ans;
vector<int> v;
bool isPrime(int n){
    if(n == 1){
        return false;
    }
    for(int i = 2; i * i <= n; i++){
        if(n % i == 0){
            return false;
        }
    }
    return true;
}

void getPrime(int n){
    for(int i = 1; i * i <= n; i++){
        if(isPrime(i)){
            v.push_back(i);
        }
    }
}
int main(){
    int n;
    cin >> n;
    int copy_n = n;
    getPrime(n);
    cout << n << "=";
    if(n == 1){
        cout <<"1";
    }else{
        for(int i = 0; i < v.size(); i++){
            int cnt = 0;
            while(n % v[i] == 0){
                cnt++;
                n /= v[i];
            }
            if(cnt != 0){
                ans.push_back(factor(v[i], cnt));
            }
            if(n == 1){
                break;
            }
        }
        //测试点4 如果是5的应该输出 5=5
        if(ans.empty()){
            cout << copy_n;
            return 0;
        }
        
        for(int i = 0; i < ans.size(); i++){
            if(i != 0){
                cout << "*";
            }
            cout << ans[i].x;
            if(ans[i].power != 1){
                cout << "^" << ans[i].power;
            }
        }
    }
}

1060 Are They Equal(25)

#include<iostream>
using namespace std;
struct number{
    string num;
    int power;
    number(){
        num = "0.";
        power = 0;
    }
};
number change(string a, int n){
    number ans;
    int pointpos = a.length(), firstpos = 0;
    for(int i = 0; i < a.length(); i++){
        if(a[i] == '.'){
            pointpos = i;
            break;
        }
    }
    while(a[firstpos] == '0' || a[firstpos] == '.'){
        firstpos++;
    }
    if(pointpos >= firstpos){
        pointpos = pointpos - firstpos;
    }else{
        pointpos = pointpos - firstpos + 1;
    }
    if(firstpos == a.length()){
        pointpos = 0;
    }
    int index = 0;
    while(index < n){
        if(a[firstpos] != '.' && firstpos < a.length()){
            ans.num += a[firstpos];
            index++;
        }else if(firstpos >= a.length()){
            ans.num += '0';
            index++;
        }
        firstpos++;
    }
    ans.power = pointpos;
    return ans;
}
int main(){
    int n;
    string a, b;
    cin >> n >> a >> b;
    number a1 = change(a, n);
    number b1 = change(b,n);
    if(a1.num == b1.num && a1.power == b1.power){
        cout << "YES " << a1.num << "*10^" << a1.power;
    }else{
        cout << "NO " << a1.num << "*10^" << a1.power
             << " "  << b1.num << "*10^" << b1.power;
    }
}