PAT甲级练习题（持续更新中...）

最新推荐文章于 2022-08-14 12:07:25 发布
最新推荐文章于 2022-08-14 12:07:25 发布
阅读量597 收藏 4
点赞数 1
分类专栏： c++ 算法 文章标签： c++ pat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Stark_JC/article/details/79440951
版权
c++ 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
算法
10 篇文章 0 订阅
订阅专栏

1001- A+B Format (20)

https://www.patest.cn/contests/pat-a-practise/1001

语言用时ms内存
Java (javac 1.6.0)6310832
C (gcc 4.7.2)3384
C++ (g++ 4.7.2)3484
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
      Scanner scanner = new Scanner(System.in);
      int a = scanner.nextInt();
      int b = scanner.nextInt();
      System.out.printf("%,d",a+b);
    }
}
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
main()
{
    int a,b;
    scanf("%d %d", &a, &b);

    char s[20];
    char *p = s;
    sprintf(s,"%d",a+b);
    int len = strlen(s);
    int i = 0;
    if(*p=='-'){
        printf("-");
        len--;
        p++;
    }
    while(i++<len){
        printf("%c",*p++);
        if((len-i)%3==0&&(len-i)!=0)
            printf(",");
    }
}

只需改一下include文件即可。

# include <cstdio>
# include <cstdlib>
# include <cstring>
main()
{
    int a,b;
    scanf("%d %d", &a, &b);

    char s[20];
    char *p = s;
    sprintf(s,"%d",a+b);
    int len = strlen(s);
    int i = 0;
    if(*p=='-'){
        printf("-");
        len--;
        p++;
    }
    while(i++<len){
        printf("%c",*p++);
        if((len-i)%3==0&&(len-i)!=0)
            printf(",");
    }
}

1002- A+B for Polynomials (25)

https://www.patest.cn/contests/pat-a-practise/1002

语言用时ms内存
Java (javac 1.6.0)9712424
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
    public static void main(String[] args) throws IOException {
      BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
      String[] nums1 = bf.readLine().split(" ");
      String[] nums2 = bf.readLine().split(" ");
      float[] cons;
      if(Integer.valueOf(nums1[1])>Integer.valueOf(nums2[1]))
          cons = new float[Integer.valueOf(nums1[1])+1];
      else
          cons = new float[Integer.valueOf(nums2[1])+1];

      for(int i=1;i<Integer.valueOf(nums1[0])*2;i+=2)
          cons[Integer.valueOf(nums1[i])]+=Float.valueOf(nums1[i+1]);
      for(int i=1;i<Integer.valueOf(nums2[0])*2;i+=2)
          cons[Integer.valueOf(nums2[i])]+=Float.valueOf(nums2[i+1]);

      int count = 0;
      String str = "";
      for (int i=cons.length-1;i>=0;i--)
          if(cons[i]!=0){
              str=str+" "+i+" "+String.format("%.1f",cons[i]);
              count+=1;
          }
      str=count+str;
      System.out.println(str);
    }
}

1003- Emergency (25)

https://www.patest.cn/contests/pat-a-practise/1003

主要用了Dijkstra算法，但由于要知道最短路径的条数，则需进行修改，当某一步选出一个未访问的顶点后，我们需要更新到其他点的最短距离，此时，如果距离比进行比较的短，则数量置为比较的那个的，如果一样，则相加。看了代码会更好理解什么意思。

语言用时ms内存
C++ (g++ 4.7.2)21336
#include <iostream>
#include <cstdio>
#define MAX_DIS 10000

using namespace std;

int main()
{
    int city_count,edge_count,from,to;
    scanf("%d %d %d %d",&city_count,&edge_count,&from,&to);
    int teams[city_count];
    for (int i=0;i<city_count;++i)
        cin >> teams[i];
    int graph[city_count][city_count];
    for(int i=0;i<city_count;++i){
        graph[i][i] = -1;
        for(int j=i+1;j<city_count;++j){
            graph[i][j] = MAX_DIS;
            graph[j][i] = MAX_DIS;
        }
    }
    for (int i=0;i<edge_count;++i){
        int t_f,t_t,t_l;
        scanf("%d %d %d",&t_f,&t_t,&t_l);
        graph[t_f][t_t] = t_l;
        graph[t_t][t_f] = t_l;
    }

    int dis[city_count];//从出发点到各个点的最短距离
    int total_teams[city_count];//从出发点到各个点所能汇集的队伍数
    int nums[city_count];//最短路径数量
    bool visited[city_count];

    visited[from] = true;
    dis[from] = 0;
    nums[from] = 1;
    total_teams[from] = teams[from];
    for(int i=0; i<city_count;++i){
        if(i==from)continue;
        visited[i] = false;
        if(graph[from][i]!=MAX_DIS){
            total_teams[i] = teams[from]+teams[i];
            dis[i] = graph[from][i];
            nums[i] = 1;
        }
        else{
            total_teams[i] = 0;
            dis[i] = MAX_DIS;
        }
    }

    for (int i=0;i<city_count-1;++i){
        int min_i = -1,min_dis = MAX_DIS+1;
        for (int j=0;j<city_count;++j){
            if(visited[j])continue;
            if (dis[j]<min_dis){
                min_i = j;
                min_dis = dis[j];
            }
        }
        visited[min_i] = true;
        for (int j=0; j<city_count;++j){
            if(visited[j])continue;
            if (min_dis+graph[j][min_i]<dis[j]){
                dis[j] = min_dis+graph[j][min_i];
                nums[j] = nums[min_i];//注意是和新的一样，而不是为1。
                total_teams[j] = total_teams[min_i] + teams[j];
            }
            else if(min_dis+graph[j][min_i]==dis[j]){
                nums[j] = nums[j] +nums[min_i];//注意是两者相加，因为这两种路径都是最短的。
                if(total_teams[j]<(total_teams[min_i] + teams[j]))
                    total_teams[j] = total_teams[min_i] + teams[j];
            }
        }
    }
    cout << nums[to] <<" "<<total_teams[to];
}

1004- Counting Leaves (30)

https://www.patest.cn/contests/pat-a-practise/1004

先是老老实实建立一棵树，再用层次遍历，然后发现“段错误”，找了好久没找到问题，贴上代码，有空再研究研究，最后还是简单的用数组实现了。

一段又长又有问题的代码1：

#include <iostream>
#include <cstdio>
#include <queue>
#define MAX_NODES 100
using namespace std;

struct Node{
    int child_count;
    Node* sibling;
    Node* first_child;
    Node():child_count(0),sibling(NULL),first_child(NULL){}
};
int main()
{
    int n,m;
    scanf("%d %d",&n,&m);

    Node *content[MAX_NODES];
    for (int i=0;i<MAX_NODES;++i)
        content[i] = NULL;

    int p_id,fc_id,childnum;
    Node root;
    for(int k=0;k<m;++k){
        scanf("%d %d %d",&p_id,&childnum,&fc_id);
        if(content[p_id]==NULL){
            content[p_id] = &root;
        }
        content[p_id]->child_count = childnum;
        Node c_node;
        content[p_id]->first_child = &c_node;
        content[fc_id] = &c_node;
        int last_sibing_id = fc_id;
        int sibing_id;
        for(int i=0;i<childnum-1;++i){
            Node s_node;
            scanf("%d",&sibing_id);
            content[sibing_id] = &s_node;
            content[last_sibing_id]->sibling = &s_node;
            last_sibing_id = sibing_id;
        }
    }

    queue<Node*> *que1 = new queue<Node*>;
    queue<Node*> *que2 = new queue<Node*>;
    queue<Node*> *tmp;
    que1->push(&root);
    int sum=0;
    Node *p;
    while(!que1->empty()){
        p = que1->front();
        que1->pop();
        if(p != &root)
            cout<<" ";
        if(p->child_count==0)
            ++sum;
        else{
            que2->push(p->first_child);
            p = p->first_child;
            while(p->sibling!=NULL){
                que2->push(p->sibling);
                p = p->sibling;
            }
        }
        tmp = que1;
        que1 = que2;
        que2 = tmp;
        cout<<sum;
        sum=0;
    }
}

部分正确的代码2：

#include <iostream>
using namespace std;

int main()
{
    int n, m, k, node, c;
    scanf("%d %d", &n, &m);

    int level[n+1],output[n],maxlevel=-1;
    bool have_child[n+1];
    for (int i=0; i<n+1; ++i){
        level[i] = -1;
        output[i] = 0;
        have_child[i] = false;
    }
    level[1] = 0;
    for(int i=0; i<m; ++i){
        scanf("%d %d", &node, &k);
        if(k>0)
            have_child[node] = true;
        for(int j=0; j<k; ++j){
            scanf("%d",&c);
            level[c] = level[node]+1;
            if(level[c]>maxlevel)
                maxlevel = level[c];
        }
    }
    for(int i=1; i<n+1; ++i){
        if(!have_child[i])
            output[level[i]]+=1;
    }
    printf("%d",output[0]);
    for(int i=1; i<=maxlevel; ++i)
        printf(" %d",output[i]);

}

别人家的正确代码3：

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
int level[100], book[100], maxlevel = -1;
vector<int> v[100];
void bfs() {
    queue<int> q;
    q.push(1);
    level[1] = 0;
    while(!q.empty()) {
        int index = q.front();
        q.pop();
        maxlevel = max(level[index], maxlevel);
        if(v[index].size() == 0)
            book[level[index]]++;
        for(int i = 0; i < v[index].size(); i++) {
            q.push(v[index][i]);
            level[v[index][i]] = level[index] + 1;
        }
    }
}
int main() {
    int n, m, k, node, c;
    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; i++) {
        scanf("%d %d",&node, &k);
        for(int j = 0; j < k; j++) {
            scanf("%d", &c);
            v[node].push_back(c);
        }
    }
    bfs();
    printf("%d", book[0]);
    for(int i = 1; i <= maxlevel; i++)
        printf(" %d", book[i]);
    return 0;
}

1005- Spell It Right (20)

https://www.patest.cn/contests/pat-a-practise/1005

字符串与整数之间的转换。

语言用时ms内存
C++ (g++ 4.7.2)2480
#include <iostream>
#include <string>
#include <sstream>
using namespace std;

int main()
{
    string str;
    string en[10] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
    getline(cin,str,'\n');
    char *p = &str[0];
    int sum = 0;
    int len = str.length();
    for(int i=0; i<len; ++i)
        sum += (*p++ - '0');
    stringstream res;
    string ss;
    res << sum;
    ss = res.str();
    p = &ss[0];
    cout << en[*p++-'0'];
    len = ss.length();
    for(int i=0; i<len-1; ++i)
        cout << " "<< en[*p++-'0'];
}

1006- Sign In and Sign Out (25)

https://www.patest.cn/contests/pat-a-practise/1006

字符串处理。

语言用时ms内存
C++ (g++ 4.7.2)2492
#include <iostream>
#include <cstring>
using namespace std;

int get_time(char *str)
{
    int hour, minute, second;
    sscanf(str, "%d:%d:%d",&hour, &minute, &second);
    return hour*3600+minute*60+second;
}
int main()
{
    char *id = new char[15];
    char *in = new char[8];
    char *out = new char[8];
    int c;
    scanf("%d", &c);
    scanf("%s %s %s", id, in, out);
    char earliest[15];
    char latest[15];
    int e_time,l_time;
    e_time = get_time(in);
    l_time = get_time(out);
    strcpy(&earliest[0],id);
    strcpy(&latest[0],id);
    int tmp;
    for(int i=0; i<c-1; ++i){
        scanf("%s %s %s", id, in, out);
        tmp = get_time(in);
        if(tmp<e_time){
            e_time = tmp;
            strcpy(&earliest[0],id);
        }
        tmp = get_time(out);
        if(tmp>l_time){
            l_time = tmp;
            strcpy(&latest[0],id);
        }
    }
    cout << earliest << " " << latest;
}

1007- Maximum Subsequence Sum (25)

https://www.patest.cn/contests/pat-a-practise/1007

两个循环，外循环从一个非0数开始作为子集起点，内循环往后找最小的下标使得和最大，然后比较这次循环和有史以来最大的和的大小，若大于则替换。

语言用时ms内存
C++ (g++ 4.7.2)23484
#include <iostream>
using namespace std;

int main()
{
    int n,c;
    scanf("%d",&n);
    int nums[n];
    for(int i=0; i<n; ++i){
        scanf("%d",&c);
        nums[i] = c;
    }
    int max_begin,max_end,max_value;
    int t_max_begin,t_max_end,t_max_value,tmp;
    max_begin = max_end = -1;
    t_max_begin = t_max_end = -1;
    t_max_value = max_value = tmp = 0;
    for(int i=0; i<n; ++i){
        if(nums[i]<0) continue;
        t_max_begin = t_max_end = i;
        t_max_value = tmp = nums[i];
        for(int j=i+1;j<n;++j){
            tmp += nums[j];
            if(tmp>t_max_value){
                t_max_end = j;
                t_max_value = tmp;
            }
        }
        if(t_max_value>max_value){
            max_begin = t_max_begin;
            max_end = t_max_end;
            max_value = t_max_value;
        }
    }
    if(t_max_begin==-1)
        printf("%d %d %d",0,nums[0],nums[n-1]);
    else
        printf("%d %d %d",max_value,nums[max_begin],nums[max_end]);
}

1008- Elevator (20)

https://www.patest.cn/contests/pat-a-practise/1008

简单题。

语言用时ms内存
C++ (g++ 4.7.2)3480
#include <iostream>
using namespace std;

int main()
{
    int n,now;
    scanf("%d",&n);
    int last = 0;
    int time = 0;
    for(int i=0; i<n; ++i){
        scanf("%d",&now);
        if(now>last)
            time += (6*(now-last)+5);
        else
            time += (4*(last-now)+5);
        last = now;
    }
    printf("%d",time);

}

1009- Product of Polynomials (25)

https://www.patest.cn/contests/pat-a-practise/1009

开始是打算用一个字符串来存整个输出值的，然后第一位字符随着循环而每次执行加一操作，后来发现这是个坑…字符加一并不是整数加一啊，如字符'9'加一变成A而不是10，需注意。

语言用时ms内存
C++ (g++ 4.7.2)2484
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;

int main()
{
    int k1, k2, e;
    float c;
    scanf("%d", &k1);
    int p1_exp[k1];
    float p1_coe[k1];
    for (int i=0; i<k1; ++i){
        scanf("%d %f", &e, &c);
        p1_exp[i] = e;
        p1_coe[i] = c;
    }

    scanf("%d", &k2);
    int p2_exp[k2];
    float p2_coe[k2];
    for (int i=0; i<k2; ++i){
        scanf("%d %f", &e, &c);
        p2_exp[i] = e;
        p2_coe[i] = c;
    }

    float coe[p1_exp[0]+p2_exp[0]+1];
    for(int i=0; i<p1_exp[0]+p2_exp[0]+1; ++i)
        coe[i] = 0;
    for(int i=0; i<k1; ++i)
        for(int j=0; j<k2; ++j)
            coe[p1_exp[i]+p2_exp[j]] += p1_coe[i]*p2_coe[j];

    char *s= new char[400];
    char *p = s;
    int cou = 0;
    for(int i=p1_exp[0]+p2_exp[0]; i>=0; --i){
        if(coe[i] != 0.0){
            cou += 1;
            sprintf(p, " %d %.1f", i, coe[i]);
            p += strlen(p);//p指针增加的是后续字符串的长度，与里面的数据类型（int,float）无关，不能写成p += (sizeof(int)+sizeof(float)+2)
        }
    }
    *p = '\0';
    printf("%d%s", cou, s);
}

1010- Radix (25)

https://www.patest.cn/contests/pat-a-practise/1010

此题巨坑..
暴力遍历会在测试点7超时。 二分搜索后，如果不考虑溢出会在测试点10报错。
最后测试10还是没有通过…有待解决。

#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;

int to_num(char *n)
{
    if (*n <= '9')
        return (*n-'0');
    else
        return (*n-'a'+10);
}

unsigned long long to_dec(char *n, unsigned long long rad)
{
    int l = strlen(n);
    unsigned long long sum = 0;
    for (int i=0; i<l; ++i){
        sum += to_num(n) * pow(rad,l-i-1);
        ++n;
    }
    return sum;
}
int get_largest_digit(char *n)
{
    int d = to_num(n);
    int l = strlen(n);
    ++n;
    for (int i=0; i<l-1; ++i){
        d = max(d,to_num(n++));
    }
    return d;
}
unsigned long long bin_search(char *n,unsigned long long low,unsigned long long high,unsigned long long dec_n)
{
    unsigned long long res = high+1;
    unsigned long long tmp = res;
    unsigned long long val;
    while(low <= high){
        val = to_dec(n,(low+high)/2);
        if(val>dec_n){
            high = (low+high)/2 - 1;
        }else if(val == dec_n){
            res = (low+high)/2;
            high = (low+high)/2 - 1;
        }else{
            low = (low+high)/2 + 1;
        }
    }
    if (res==tmp)return -1;
    return res;
}
int main()
{
    int tag;
    unsigned long long rad1, rad2;
    char *n1 = new char[11];
    char *n2 = new char[11];
    scanf("%s %s %d %llu", n1, n2, &tag, &rad1);

    if(tag==2){
        char *tmp = n2;
        n2 = n1;
        n1 = tmp;
    }
    unsigned long long dec_n = to_dec(n1, rad1);
    unsigned long long low = get_largest_digit(n2)+1;
    unsigned long long high = max(dec_n+1,low);
    unsigned long long res = bin_search(n2, low, high, dec_n);
    if (res==-1)printf("Impossible");
    else
        printf("%llu",res);
    return 0;
}

1011- World Cup Betting (20)

https://www.patest.cn/contests/pat-a-practise/1011

语言用时ms内存
C++ (g++ 4.7.2)3484
#include <iostream>
using namespace std;
int main()
{
    char c[4] = {"WTL"};
    float sum = 1.0;
    for (int i=0; i<3; ++i){
        int maxchar = 0;
        float maxvalue = 0.0;
        for (int j=0; j<3; ++j){
            float tmp;
            scanf("%f",&tmp);
            if (maxvalue <= tmp){
                maxvalue = tmp;
                maxchar = j;
            }
        }
        sum *= maxvalue;
        printf("%c ", c[maxchar]);
    }
    printf("%.2f", (sum*0.65-1)*2);
    return 0;
}

1012- The Best Rank (25)

https://www.patest.cn/contests/pat-a-practise/1012

  1. 用了map存学生表，由于数组不能直接作为value，这里用了vector做value；
  2. 然后排名时，先假定这个同学排名都是第一，然后遍历一遍所有学生，有比他好的就让排名加一。
  3. 注意，平均分是四舍五入的，所以需要按照+0.5后取整，保证是四舍五入的（听说不四舍五入也能通过…）
  4. 最后要注意的就是按照A>C>M>E的优先级输出，但我添加进map时vector里的顺序是CMEA，所以最后比较时要注意一下。
语言用时ms内存
C++ (g++ 4.7.2)10616
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main()
{
    char c[5] = {"CMEA"};
    map<string,vector<int>> mp;
    int m,n;
    scanf("%d%d", &m, &n);
    for (int i=0; i<m; ++i){
        string id;
        int s, a=0;
        vector<int> score;
        cin >> id;
        for (int j=0; j<3; ++j){
            scanf("%d",&s);
            score.push_back(s);
            a += s;
        }
        score.push_back(a);
        mp.insert(pair<string, vector<int>>(id, score));
    }
    for(int i=0; i<n; ++i){
        int rank[4] = {1,1,1,1};
        string id;
        cin >> id;
        map<string, vector<int>>::iterator it;
        int score[4];
        it = mp.find(id);
        if (it != mp.end()){
            for (int j=0; j<4; ++j)
                score[j] = (it->second)[j];

            for(map<string, vector<int>>::iterator itr = mp.begin(), itr_end = mp.end(); itr!=itr_end; itr++){
                for(int j=0; j<4; ++j){
                    if((itr->second)[j] > score[j])
                        ++ rank[j];
                }
            }
            int best_r = m+1;
            int best_j;
            for (int j=3,k=0; k<4; j=(j+1)%4,++k){
                if (rank[j] < best_r){
                    best_j = j;
                    best_r = rank[j];
                }
            }
            printf("%d %c\n", best_r, c[best_j]);
        }
        else
            printf("N/A\n");
    }
    return 0;
}

1013- Battle Over Cities (25)

https://www.patest.cn/contests/pat-a-practise/1013

图的遍历，需要加的路数是最大连通子图的个数减一。由于每一次check城市都调用至少一次DFS，所需时间有点长（最后一个测试点肯定很复杂….）。

语言用时ms内存
C++ (g++ 4.7.2)1114204
#include <iostream>
#include <stack>
using namespace std;

int main()
{
    int n, m, k;
    scanf("%d%d%d", &n, &m, &k);
    int mp[n+1][n+1];
    bool maketo[n+1];
    for (int i=0; i<n+1; ++i){
        maketo[i] = false;
        for (int j=0; j<n+1; ++j)
            mp[i][j] = 0;
    }
    int from, to;
    for (int i=0; i<m; ++i){
        scanf("%d%d", &from, &to);
        mp[from][to] = 1;
        mp[to][from] = 1;
    }

    int lost;
    for (int l=0; l<k; ++l){
        scanf("%d",&lost);
        int lines = 0;

        for (int i=1; i<n+1; ++i){
            if(i==lost || maketo[i]) continue;
            maketo[i] = true;

            stack<int> sta;
            sta.push(i);
            while(!sta.empty()){
                int now = sta.top();
                sta.pop();
                for (int j=1; j<n+1; ++j){
                    if(j!=lost && mp[now][j] && !maketo[j]){
                        sta.push(j);
                        maketo[j] = true;
                    }
                }
            }
            ++lines;
        }
        printf("%d\n",lines-1);
        for (int i=0; i<n+1; ++i)
            maketo[i] = false;
    }

}

1014- Counting Leaves (30)

https://www.patest.cn/contests/pat-a-practise/1014

有个小陷阱就是：如果是在17：00前开始服务的，无论多晚，都要输出结束时间，而不是只看最后结束时间是不是大于17：00。

语言用时ms内存
C++ (g++ 4.7.2)3488
#include <iostream>
#include <queue>
using namespace std;
//检查是不是所有的窗口都服务完了
bool all_over(int *p, int n)
{
    bool over = true;
    for (int i=0; i<n; ++i){
        if(*p>0){
            over = false;
            break;
        }
        ++p;
    }
    return over;
}
int main()
{
    int n, m ,k ,q;
    scanf("%d%d%d%d", &n, &m, &k, &q);
    int leave_time[k+1],time_need[k+1];//结束时间,处理时间
    queue<int> lines[n];//每一排的队伍
    int remaining_time[n], processing[n];//每一个窗口处理完当前顾客还需时间

    int tmp;
    for(int i=1; i<k+1; ++i){
        scanf("%d", &tmp);
        time_need[i] = tmp;
    }
    int next = 1;
    for (int i=0; i<m && next<=k; ++i){
        for (int j=0; j<n && next<=k; ++j){
                lines[j].push(next);
                ++next;
        }
    }
    for(int i=0; i<n; ++i){
        if(!lines[i].empty()){
            processing[i] = lines[i].front();
            remaining_time[i] = time_need[lines[i].front()];
        }
        else{
            processing[i] = -1;
            remaining_time[i] = -1;
        }
    }
    int base_time = 480;
    while(!all_over(remaining_time,n)){
        ++base_time;
        for(int i=0; i<n; ++i){
            remaining_time[i] -= 1;
            if(remaining_time[i]==0){
                leave_time[processing[i]] = base_time;
                lines[i].pop();
                if(next<=k){
                    lines[i].push(next);
                    ++next;
                }
                if(!lines[i].empty()){
                    processing[i] = lines[i].front();
                    remaining_time[i] = time_need[lines[i].front()];
                }
                else{
                    processing[i] = -1;
                    remaining_time[i] = -1;
                }
            }
        }
    }
    for (int i=0; i<q; ++i){
        int q_id;
        scanf("%d", &q_id);
        int hour = leave_time[q_id]/60;
        int minute = leave_time[q_id]%60;
        if(leave_time[q_id]-time_need[q_id]>=1020){
            printf("Sorry\n");
        }
        else{
            printf("%02d:%02d\n",hour,minute);
        }
    }
}

1147- Heaps (30)

https://www.patest.cn/contests/pat-a-practise/1147

主要是堆的使用，

语言用时ms内存
C++ (g++ 4.7.2)27752
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

struct Node{
    int value;
    Node *left;
    Node *right;
    Node *parent;
    Node():value(0),left(NULL),right(NULL),parent(NULL){}
};
Node nodes[1000];
int m, n;
vector<int> output;
void post_order(int index)
{
    if(2*index+1<n)
        post_order(2*index+1);
    if(2*index+2<n)
        post_order(2*index+2);
    output.push_back(nodes[index].value);
}
int main()
{
    scanf("%d %d", &m, &n);
    int c;
    for(int i=0; i<m; ++i){
        for (int j=0; j<n; ++j){
            scanf("%d", &c);
            nodes[j].value = c;
            if((j-1)/2>=0){
                nodes[j].parent = &nodes[(j-1)/2];
                if((j-1)%2==0)
                    nodes[(j-1)/2].left = &nodes[j];
                else
                    nodes[(j-1)/2].right = &nodes[j];
            }
        }
        bool tag = true;
        bool is_max = true;
        if (nodes[0].value>nodes[1].value)
            is_max = true;
        else
            is_max = false;
        for(int j=n-1; j>0; --j){
            if(is_max){
                if(nodes[j].parent->value<nodes[j].value){
                    tag = false;
                    break;
                }
            }else{
                if(nodes[j].parent->value>nodes[j].value){
                    tag = false;
                    break;
                }
            }
        }
        if(is_max && tag)
            printf("Max Heap\n");
        else if(!is_max && tag)
            printf("Min Heap\n");
        else
            printf("Not Heap\n");

        post_order(0);
        printf("%d",output[0]);
        for(int j=1; j<n; ++j)
            printf(" %d",output[j]);
        printf("\n");
        output.clear();
    }
}
Stark_JC
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浙大翁恺pat练习题_PAT|中国大学MOOC-翁恺-C语言程序设计习题集17-20
weixin_29974217的博客
02-12 1199
05-1. 约分最简分式(15)分数可以表示为“分子/分母”的形式。编写一个程序，要求用户输入一个分数，然后将其约分为最简分式。最简分式是指分子和分母不具有可以约分的成分了。如6/12可以被约分为1/2。当分子大于分母时，不需要表达为整数又分数的形式，即11/8还是11/8；而当分子分母相等时，仍然表达为1/1的分数形式。输入格式：输入在一行中给出一个分数，分子和分母中间以斜杠“/”分隔，如： 1...
PAT甲级（1001-1115）题库
09-09
这是PAT甲级第1001到1115的所有原题，只有题目没有答案。
PAT甲级解题报告索引
L_Aster的专栏
09-22 2505
PAT甲级题目地址：https://www.patest.cn/contests/pat-a-practise PAT甲级代码Github仓库已经整理更新完毕，包含最新全部代码（C++），部分代码已经加以注解，并使用尽量简单的解题思路以及简洁的代码实现：我的 Github|甲级 欢迎star或者fork，以及讨论交流 关于博客，大部分已经和github同步，但是部分未更新，可能的原因有： ...
编程提高刷题网站
qq_26318597的博客
05-31 2146
给大家推荐几个刷题网站 牛客网：有题库，会定期举办竞赛，适用于程序员、本科ACM选手和高中信息学奥林匹克竞赛选手； https://ac.nowcoder.com/acm/contest/vip-index?&headNav=www LeetCode：有题库，每周都会举办周赛，被称为offer收割机，里面收录的题目大都在真实的面试中出现过； https://leetcode-cn.com/...
【PAT】PAT甲级题库所有题解（持续更新中...）
Gnomeshgh的博客
03-16 3324
PAT 甲级题库全部题解，请您打包收下
PAT甲级题解
姚军
08-29 744
1001 A+B Format (20 分) 1002 A+B for Polynomials (25 分) 1003 Emergency (25 分)
PAT甲级练习题155道分类（xmind）
07-26
PAT甲级练习题155道分类（xmind）。在【笔记】下可以看见各个分类下的习题，提高练习效率，进行专项训练，提炼出自己的代码模板。也可【大纲】下进行查看。（）括号里数字为每个分类的题目个数，可看出PAT考试的重要...
PAT：PAT甲级练习
02-25
PAT甲级练习通常指的是PAT的高级别考试，对于想要在IT行业中提升编程技能，尤其是准备参加相关专业比赛或求职的学员来说，具有很高的学习价值。 描述中提到的是个人进行PAT甲级练习的过程，包括了自己独立完成的...
PAT甲级真题练习1
08-08
PAT 甲级真题练习1是其中的一份练习题，共包含15个问题，涵盖了字符串处理、数据结构、算法设计等多个方面。 1. A+B Format (20) A+B Format是一个基本的计算题，要求考生编写一个程序来计算A+B的值。该题目考察了...
2019秋季甲级.zip
12-02
在PAT甲级考试中，常见的算法类型包括但不限于排序算法（如快速排序、归并排序）、查找算法（如二分查找）、图论算法（如最短路径算法、最小生成树）、动态规划、贪心算法等。掌握这些算法对于解决实际问题和优化...
PAT甲级考试的题解和分类
05-15
1. **时间管理**：PAT甲级考试的题目数量和时间分配要求前3题在1小时左右完成，最后一题则需要约1.5小时。这意味着前3题每道题的解题时间应在20至30分钟之间，要求考生快速审题并做出决策。 2. **大数组处理**：...
PAT 题目精解但(包括1000题)
03-17
PAT(Process action Teams)在练习算法方面和LeetCode一样，是不可多得好工具，这里包括了PAT近1000题以上的题解，每个题目都附有完整的代码和解析
PAT甲级训练合集（1-70）
qq_51704853的博客
08-14 2293
题目链接：题目详情 - 1001 A+B Format (pintia.cn)题目大意：将两个数A和B相减，每隔3个数输出一个空格（注意，从后往前数）思路：如果是负数先把负号去掉，用一个字符串存入答案，从后往前，数到3个数存入一个逗号，并且吧cnt更新为0，用reverse函数倒过来输出实现代码： P1002 题目链接：题目详情 - 1002 A+B for Polynomials (pintia.cn)题目大意：输入两行，每行第一个为k，当前行多项式的数量，随后给出k组，N为指数，ai为项数将所有指
PAT考试报名
xioy98的博客
07-27 8224
一.进入官网 官网地址：https://www.patest.cn/，先注册一个账号，再点击报名。 二.填写报名信息 （1）填写个人信息 编辑个人信息 （2）选择考试等级 （3）选择考场 （4）填写报名信息 （5）缴费 支付宝或者微信扫一扫 三.查看报名情况 ...
2-2. 然后是几点(15)
rabbit8848的专栏
06-09 5496
有时候人们用四位数字表示一个时间，比如1106表示11点零6分。现在，你的程序要根据起始时间和流逝的时间计算出终止时间。读入两个数字，第一个数字以这样的四位数字表示当前时间，第二个数字表示分钟数，计算当前时间经过那么多分钟后是几点，结果也表示为四位数字。当小时为个位数时，没有前导的零，即5点30分表示为530。注意，第二个数字表示的分钟数可能超过60，也可能是负数。 输入格式： 输入在一行
PAT甲级-【题目+解答】汇总
卷子的博客
03-26 9343
甲级才刚刚开始，之后会陆续整理进来~ 先附上乙级链接：PAT乙级汇总
PAT 基础编程题目集（编程题1-38）题解
weixin_41801682的博客
02-04 8867
PAT 基础编程题目集（编程题1-38）题解
入门系列-记录几个可以刷题的网站
qq_38213675的博客
02-20 2994
1、 LintCode LintCode网站是国内较大的在线编程&测评网站。网站提供各大IT公司的算法面试题类型，行分门别类，由简单到中等，再到难，支持多种基本语言（C++，Java，python）便于不同水平的程序员进行刷题练习。对于不同编程能力水平、不同职位需求的人来说是很有用的刷题网站。https://www.lintcode.com 2、 PAT PAT程序设计类实验辅助教学平台...
PAT练习
ylwhxht的博客
12-05 773
刷题记录 算是第一篇记录刷题的博客吧，打了ACM一年了，没有这个习惯。。。 最近在准备PTA甲级，顺便记录一下坑（PAT的坑真的无fuck可说，数据范围也不给，题意又。。。。） 1014 Waiting in Line (30分) Suppose a bank has N windows open for service. There is a yellow line in front of th...
(pat. pub. no.: us20090284194 a1
最新发布
07-17
根据本题的要求，由于给出的信息较为简洁，我们无法具体回答关于"pat. pub. no.: us20090284194 a1"的内容。我们建议您使用专业的专利检索工具进行查询，以便获取更多相关信息。或者，您可以提供更具体的问题，以便...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值