PAT甲级练习

最新推荐文章于 2022-03-11 16:10:09 发布
最新推荐文章于 2022-03-11 16:10:09 发布
阅读量185 收藏
点赞数
分类专栏： 考研狗 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wen_zhi/article/details/104147673
版权

目录

A1003 Emergency（点权）

PAT测试显示答案错误+段错误，可是我实在找不到哪还有问题，求指出

#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn=510;
const int INF=1000000000;

int n,m,st,ed,G[maxn][maxn],weight[maxn];
int d[maxn],w[maxn],num[maxn];
bool vis[maxn]={false};

void Dijkstra(int s)
{
    fill(d,d+maxn,INF);
    memset(num,0,sizeof(num));
    memset(w,0,sizeof(w));
    d[s]=0;
    w[s]=weight[s];
    num[s]=1;
    for(int i=0;i<n;i++)
    {
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++)
        {
            if(vis[j]==false&&d[j]<MIN)
            {
               u=j;
            MIN=d[j];
            }

        }
    if(u==-1)
        return;
    vis[u]=true;
    for(int v=0;v<n;v++)
    {
        if(vis[v]==false&&G[u][v]!=INF)
        {
            if(d[u]+G[u][v]<d[v])
            {
                d[v]=d[u]+G[u][v];
                w[v]=w[u]+weight[v];
                num[v]=num[u];
            }
            else if(d[u]+G[u][v]==d[v])
            {
                if(w[u]+weight[v]>w[v])
                {
                    w[v]=w[u]+weight[v];
                }
                num[v]+=num[u];
            }
        }
    }
    }
}


int main()
{
    cin>>n>>m>>st>>ed;
for(int i=0;i<n;i++)
{
        scanf("%d",&weight[i]);
}
int u,v;
fill(G[0],G[0]+maxn*maxn,INF);
for(int i=0;i<m;i++)
{
    scanf("%d%d",&u,&v);
    scanf("%d",&G[u][v]);
    G[v][u]=G[u][v];
}
Dijkstra(st);
printf("%d %d\n",num[ed],w[ed]);
return 0;
}

A1020 Tree Traversals

#include <cstring>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include <iostream>
#include<queue>
using namespace std;
const int maxn=50;
struct node{
int data;
node* lchild;
node* rchild;
};
int pre[maxn],in[maxn],post[maxn];
int n;

node* create(int postL,int postR,int inL,int inR){
if(postL>postR)
{
    return NULL;
}
node* root=new node;
root->data=post[postR];
int k;
for(k=inL;k<=inR;k++)
{
    if(in[k]==post[postR])
    {
        break;
    }
}
int numLeft=k-inL;
root->lchild=create(postL,postL+numLeft-1,inL,k-1);
root->rchild=create(postL+numLeft,postR-1,k+1,inR);
return root;
}
int num=0;
void BFS(node* root)
{
    queue<node*> q;
    q.push(root);
    while(!q.empty())
    {
        node* now=q.front();
        q.pop();
        printf("%d",now->data);
        num++;
        if(num<n)
            printf(" ");
            if(now->lchild!=NULL)
                q.push(now->lchild);
            if(now->rchild!=NULL)
                q.push(now->rchild);

    }
}
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++)
{
    scanf("%d",&post[i]);
}
for(int i=0;i<n;i++)
{
    scanf("%d",&in[i]);
}
node* root=create(0,n-1,0,n-1);
BFS(root);
return 0;
}

A1030 Travel Plan(边权）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn=510;
const int INF=1000000000;

int n,m,st,ed,G[maxn][maxn],weight[maxn][maxn];
int d[maxn],w[maxn],pre[maxn];
bool vis[maxn]={false};

void Dijkstra(int s)
{
    fill(d,d+maxn,INF);
    fill(w,w+maxn,INF);
    for(int i=0;i<n;i++)
    {
        pre[i]=i;
    }
    d[s]=0;
    w[s]=0;
    for(int i=0;i<n;i++)
    {
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++)
        {
            if(vis[j]==false&&d[j]<MIN)
            {
               u=j;
            MIN=d[j];
            }
        }
    if(u==-1)
        return;
    vis[u]=true;
    for(int v=0;v<n;v++)
    {
        if(vis[v]==false&&G[u][v]!=INF)
        {
            if(d[u]+G[u][v]<d[v])
            {
                d[v]=d[u]+G[u][v];
                w[v]=w[u]+weight[u][v];
                pre[v]=u;
            }
            else if(d[u]+G[u][v]==d[v])
            {
                if(w[u]+weight[u][v]<w[v])
                {
                    w[v]=w[u]+weight[u][v];
                       pre[v]=u;
                }

            }
        }
    }
    }
}

void DFS(int v)
{
    if(v==st)
    {
        printf("%d ",v);
        return;
    }
    DFS(pre[v]);
    printf("%d ",v);
}

int main()
{
    cin>>n>>m>>st>>ed;
int u,v;
fill(G[0],G[0]+maxn*maxn,INF);
for(int i=0;i<m;i++)
{
    scanf("%d%d",&u,&v);
    scanf("%d%d",&G[u][v],&weight[u][v]);
    G[v][u]=G[u][v];
    weight[v][u]=weight[u][v];
}
Dijkstra(st);
DFS(ed);
printf("%d %d\n",d[ed],w[ed]);
return 0;
}

A1032 Sharing

#include <cstring>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include <iostream>
using namespace std;
const int maxn=100010;
struct NODE{
char data;
int next;
bool flag;
}node[maxn];
int main(){
    for(int i=0;i<maxn;i++){
    node[i].flag=false;
}
int s1,s2,n,p;
scanf("%d%d%d",&s1,&s2,&n);
int address,next;
char data;
for(int i=0;i<n;i++){
    scanf("%d %c %d",&address,&data,&next);
    node[address].data=data;
    node[address].next=next;
}
for(p=s1;p!=-1;p=node[p].next){
    node[p].flag=true;
}
for(p=s2;p!=-1;p=node[p].next){
    if(node[p].flag==true)
        break;
}
if(p!=-1){
    printf("%05d\n",p);
}
else{
    printf("-1\n");
}
return 0;
}

A1034 Head of a Gang

#include<iostream>
#include<cstring>
#include<map>
#include<string>
using namespace std;
const int maxn=2010;
const int INF=1000000000;

map<int,string> inttostring;
map<string,int> stringtoint;
map<string,int> gang;
int G[maxn][maxn]={0};
int weight[maxn]={0};
int n,k,numperson=0;
bool vis[maxn]={false};

void DFS(int nowvist,int& head,int& nummember,int &totalvalue)
{
    nummember++;
    vis[nowvist]=true;
    if(weight[nowvist]>weight[head])
    {
        head=nowvist;
    }
    for(int i=0;i<numperson;i++)
    {
        if(G[nowvist][i]>0)
        {
            totalvalue+=G[nowvist][i];
            G[nowvist][i]=G[i][nowvist]=0;
            if(vis[i]==false)
            {
                DFS(i,head,nummember,totalvalue);
            }
        }
    }
}

void DFSTrave()
{
    for(int i=0;i<numperson;i++)
    {
        if(vis[i]==false)
        {
            int head=i,nummember=0,totalvalue=0;
            DFS(i,head,nummember,totalvalue);
            if(nummember>2&&totalvalue>k)
            {
                gang[inttostring[head]]=nummember;
            }
        }
    }
}

int change(string str)
{
    if(stringtoint.find(str)!=stringtoint.end())
    {
        return stringtoint[str];
    }
    else
    {
        stringtoint[str]=numperson;
        inttostring[numperson]=str;
        return numperson++;
    }
}

int main(){
    int w;
    string str1,str2;
    cin>>n>>k;
for(int i=0;i<n;i++)
{
    cin>>str1>>str2>>w;
    int id1=change(str1);
    int id2=change(str2);
    weight[id1]+=w;
     weight[id2]+=w;
     G[id1][id2]+=w;
      G[id2][id1]+=w;
}
DFSTrave();
cout<<gang.size()<<endl;
map<string,int>::iterator it;
for(it=gang.begin();it!=gang.end();it++)
{
    cout<<it->first<<" "<<it->second<<endl;
    }
return 0;
}

A1043 Is it a Binary Search Tree

测试时显示部分正确，不知道为什么

#include <cstring>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include <iostream>
#include<queue>
#include<vector>
using namespace std;
const int maxn=110;
struct node{
int data;
node *left,*right;
};
void insert(node* &root,int data)
{
    if(root==NULL)
    {
        root=new node;
        root->data=data;
        root->left=root->right=NULL;
        return;
    }
    if(data<root->data)
        insert(root->left,data);
    else
        insert(root->right,data);
}

void preorder(node* root,vector<int>&vi)
{
    if(root==NULL)
        return;
    vi.push_back(root->data);
    preorder(root->left,vi);
     preorder(root->right,vi);
}

void preordermirror(node* root,vector<int>&vi)
{
    if(root==NULL)
        return;
    vi.push_back(root->data);
     preordermirror(root->right,vi);
      preordermirror(root->left,vi);
}

void postorder(node* root,vector<int>&vi)
{
    if(root==NULL)
        return;

    postorder(root->left,vi);
     postorder(root->right,vi);
      vi.push_back(root->data);
}

void postordermirror(node* root,vector<int>&vi)
{
    if(root==NULL)
        return;

     postordermirror(root->right,vi);
      postordermirror(root->left,vi);
        vi.push_back(root->data);
}


vector<int> origin,pre,preM,post,postM;
int main(){
    int n,data;
    node* root=NULL;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
    scanf("%d",&data);
    origin.push_back(data);
    insert(root,data);

}
preorder(root,pre);
preordermirror(root,preM);
postorder(root,post);
postordermirror(root,postM);
if(origin==pre)
{
    printf("YES\n");
    for(int i=0;i<post.size();i++)
    {
        printf("%d",post[i]);
        if(i<post.size()-1)
            printf(" ");
    }
}
else if(origin==preM)
{
    printf("YES\n");
    for(int i=0;i<postM.size();i++)
    {
        printf("%d",postM[i]);
        if(i<postM.size()-1)
            printf(" ");
    }

}
else
{
    printf("No\n");
}
return 0;
}

A1052 Linked List Sorting

#include <cstring>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include <iostream>
using namespace std;
const int maxn=100005;
struct NODE{
int data;
int next;
int address;
bool flag;
}node[maxn];
bool cmp(NODE a,NODE b){
if(a.flag==false||b.flag==false){
    return a.flag>b.flag;
}
else{
    return a.data<b.data;
}
}
int main(){
    for(int i=0;i<maxn;i++){
    node[i].flag=false;
}
int n,begin,address;
scanf("%d%d",&n,&begin);
for(int i=0;i<n;i++){
    scanf("%d",&address);
    
    scanf("%d%d",&node[address].data,&node[address].next);
 node[address].address=address;
//    node[address].next=next;
}
int count=0,p;
for(p=begin;p!=-1;p=node[p].next){
    node[p].flag=true;
    count++;
}
if(count==0){
    printf("0 -1");
}
else{
        sort(node,node+maxn,cmp);
    printf("%d %05d\n",count,node[0].address);
    for(int i=0;i<count;i++)
    {
        if(i!=count-1)
        {
            printf("%05d %d %05d\n",node[i].address,node[i].data,node[i+1].address);
        }
        else
        {
            printf("%05d %d -1\n",node[i].address,node[i].data);
        }
    }
    }

return 0;
}

A 1053

#include <cstring>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include <iostream>
#include<queue>
#include<vector>
using namespace std;
const int maxn=110;
struct node{
int weight;
vector<int> child;
}Node[maxn];

bool cmp(int a,int b)
{
    return Node[a].weight>Node[b].weight;
}

int path[maxn];
int n,m,s;


void DFS(int index,int numNode,int sum)
{
    if(sum>s)
        return;
    if(sum==s)
    {
        if(Node[index].child.size()!=0)
            return;
    }
    for(int i=0;i<numNode;i++)
    {
        printf("%d",Node[path[i]].weight);
        if(i<numNode-1)
         printf(" ");
        else
            printf("\n");
         return;

    }


for(int i=0;i<Node[index].child.size();i++)
{
    int child=Node[index].child[i];
    path[numNode]=child;
    DFS(child,numNode+1,sum+Node[child].weight);
}
}



int main(){
scanf("%d%d%d",&n,&m,&s);
for(int i=0;i<n;i++)
{
    scanf("%d",&Node[i].weight);
}
int id,k,child;
for(int i=0;i<m;i++)
{
    scanf("%d%d",&id,&child);
    for(int j=0;j<k;j++)
    {
        scanf("%d",&child);
        Node[id].child.push_back(child);
    }
    sort(Node[id].child.begin(), Node[id].child.end(), cmp);
}
path[0]=0;
DFS(0,1,Node[0].weight);
return 0;
}

A1060 Are They Equal

#include <cstring>
#include<cstdio>
#include<algorithm>
#include<math.h>
#include <iostream>
using namespace std;
int n;
string deal(string s,int& e){
int k=0;
while(s.length()>0&&s[0]=='0'){
      s.erase(s.begin());
      }
      if(s[0]=='.'){
        s.erase(s.begin());
        while(s.length()>0&&s[0]=='0'){
      s.erase(s.begin());
      e--;
      }
      }
      else{
        while(k<s.length()&&s[k]!='.'){
            k++;
            e++;
        }
        if(k<s.length()){
            s.erase(s.begin()+k);
        }
      }
      if(s.length()==0){
        e=0;
      }
      int num=0;
      k=0;
      string res;
      while(num<n){
        if(k<s.length())
            res+=s[k++];
        else
            res+='0';
        num++;
      }
      return res;
}
int main(){
string s1,s2,s3,s4;
cin>>n>>s1>>s2;
int e1=0,e2=0;
s3=deal(s1,e1);
s4=deal(s2,e2);
if(s3==s4&&e1==e2){
    cout<<"YES 0."<<s3<<"*10^"<<e1<<endl;
}else{
cout<<"NO 0."<<s3<<"*10^"<<e1<<" 0."<<s4<<"*10^"<<e2<<endl;
}
return 0;
}

A1076 Forwards on Weibo

#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<string>
#include<vector>
#include<queue>

using namespace std;
const int maxn=1010;

struct node{
int id;
int layer;
};

vector<node> Adj[maxn];
bool inq[maxn]={false};

int BFS(int s,int L)
{
    int numforword=0;
    queue<node> q;
    node start;
    start.id=s;
    start.layer=0;
    q.push(start);
    inq[start.id]=true;
    while(!q.empty())
    {
        node topnode=q.front();
        q.pop();
        int u=topnode.id;
        for(int i=0;i<Adj[u].size();i++)
        {
            node next=Adj[u][i];
            next.layer=topnode.layer+1;
            if(inq[next.id]==false&&next.layer<=L)
            {
                q.push(next);
                inq[next.id]=true;
                numforword++;
            }
        }
    }
    return numforword;
}

int main(){
    node user;
    int n,L,numfollow,idfollow;
    cin>>n>>L;
for(int i=1;i<=n;i++)
{
    user.id=i;
    cin>>numfollow;
    for(int j=0;j<numfollow;j++)
    {
        scanf("%d",&idfollow);
        Adj[idfollow].push_back(user);
    }
}
int numquery,s;
scanf("%d",&numquery);
for(int i=0;i<numquery;i++)
{
    memset(inq,false,sizeof(inq));
    scanf("%d",&s);
    int numforword=BFS(s,L);
    printf("%d\n",numforword);
}
return 0;
}
wen_zhi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PAT甲级题目
绿箭侠
03-14 256
PAT甲级的题目有关于树的题目，1053，1086，1090，1102，1106，1115，1119，1110 A1053 这题目比较简单，给定一棵树，给定一个数字，要你找到所有和等于给定数字的路径。这个题目的树没有给出是二叉树，自然不能按照原来二叉树的方法来构建了。其实就是BFS，用DFS也是可以的，不过考虑到DFS还要新开一个数组来存储路径，还是使用BFS。 首先...
PAT甲级真题目录（按题型整理）
qq_29762941的博客
10-06 1万+
原文链接: PAT甲级真题目录（按题型整理） 最短路径 1003. Emergency (25)-PAT甲级真题（Dijkstra算法） 1018. Public Bike Management (30)-PAT甲级真题（Dijkstra + DFS） 1030. Travel Plan (30)-PAT甲级真题（Dijkstra + DFS，输出路径，边权） 1087. All Roa...
PAT甲级题解
姚军
08-29 761
1001 A+B Format (20 分) 1002 A+B for Polynomials (25 分) 1003 Emergency (25 分)
PAT甲级题集
galesaur_wcy
10-28 2851
1001 A+B Format （20）分题解链接 要点: 1002 A+B for Polynomials （25）分题解链接 要点: 1003 Emergency （25）分题解链接 要点: 1004 Counting Leaves （30）分题解链接 要点: 1005 Spell It Right （20）分题解链接...
pat甲级题库
以码平川的博客
08-31 1323
pat甲级题库 文章目录pat甲级题库1020 Tree TraversalsInput Specification:Output Specification:Sample Input:Sample Output:题解:1053 Path of Equal Weight (30分)Input Specification:Output Specification:Sample Input:Sample Output:题解:1043 Is It a Binary Search Tree (25分)Input S
PAT：PAT甲级练习
02-25
PAT甲级练习通常指的是PAT的高级别考试，对于想要在IT行业中提升编程技能，尤其是准备参加相关专业比赛或求职的学员来说，具有很高的学习价值。 描述中提到的是个人进行PAT甲级练习的过程，包括了自己独立完成的...
PAT甲级练习题155道分类（xmind）
07-26
PAT甲级练习题155道分类（xmind）。在【笔记】下可以看见各个分类下的习题，提高练习效率，进行专项训练，提炼出自己的代码模板。也可【大纲】下进行查看。（）括号里数字为每个分类的题目个数，可看出PAT考试的重要...
PAT甲级真题练习1
08-08
PAT甲级真题练习1 PAT（Programming Ability Test）是一种针对程序设计能力的测试，旨在评估程序员的编程能力和解决问题的能力。PAT 甲级真题练习1是其中的一份练习题，共包含15个问题，涵盖了字符串处理、数据结构...
ACM-PAT甲级题目总结及实现
03-24
本文将对PAT甲级题目进行深入的总结，并提供相应的实现思路。 首先，我们要理解ACM竞赛的核心是解决算法问题，这需要扎实的数据结构和算法基础。PAT甲级题目通常涵盖了排序、搜索、图论、动态规划、字符串处理、...
【C++】PAT甲级题目实现
01-07
为了记录我在准备PAT甲级的练习，特开此页。 在练习的过程中吸收了大量博主的经验，特别是大神柳婼:https://blog.csdn.net/liuchuo。 但是由于代码风格的不同，我在学习他们的想法的同时也在努力形成自己的C++代码...
PAT甲级（1001-1115）题库
09-09
这是PAT甲级第1001到1115的所有原题，只有题目没有答案。
PAT题库甲级题目1-110题答案代码.rar
04-19
PAT题库甲级题目1-110题答案代码，均能通过OJ测试，
2020PAT春季甲级 题目及AC代码
12-01
2020PAT甲级春季 题目以及AC满分代码
PAT甲级——1096 Consecutive Factors (数学题)
小熊猫的博客
06-09 609
1096Consecutive Factors(20分) Among all the factors of a positive integer N, there may exist several consecutive numbers. For example, 630 can be factored as 3×5×6×7, where 5, 6, and 7 are the thre...
【置顶】【PAT】PAT甲级题目及分类总结（持续更新ing）
热门推荐
elegant coder
04-29 5万+
在2019年3月底，我决定考浙大计院，经过一个月还算凑合的学习，痛定思痛，决定整理整理自己的博客。 粗略估计，大概一个月的时间里我AC了31道题，大概用时40个小时上下，毕竟还要把大部分时间花在笔试上。一开始使用Java，到十几题的时候发现有的题真的Java很难通过，痛定思痛转Cpp。这里告诫读者，千万换Cpp而不是继续Java，毕竟我们的目标是满分。 我在算法题上有点小基础，前后两次参加蓝桥杯，...
PAT甲级题目索引(题目+解析+AC代码)
漫浸天空的雨色的备忘录~
03-27 2万+
emmmm，1001~1033的题解是英文的，后面的解析就都是中文的了，（当时想借此锻炼自己的英文水平但是最后发现效果不是太好而且浪费时间遂换回中文，就在这里说一下~） 题目信息 分值 PAT 甲级 1001 A+B Format 20 PAT 甲级 1002 A+B for Polynomials 25 PAT 甲级 1003 Emergency ...
PAT甲级题目汇总（前言）
Droke_Zhou的博客
12-31 498
PAT甲级题目汇总和一些想说的话
PAT甲级题目目录
qq_43537757的博客
03-11 247
树 1004 Counting Leaves 1020 Tree Traversals
PAT甲级备考题目整理
来啦(#^.^#)
02-12 729
目录 1022 Digital Library （30 分）（模拟+不用gets读入） 1043 Is It a Binary Search Tree（25 分）（二叉搜索树） 1064 Complete Binary Search Tree （30 分）（二叉搜索树） PAT 甲级 1069~1072 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值