PAT A1001-A1004

题集通道：https://pintia.cn/problem-sets/994805342720868352/problems/type/7

A1001 ：  A+B Format (20 point(s))

　　解这道题的关键是题目所给的条件： - 10e6 <= a,b <= 10e6，所以a+b最多为7位数。

　　代码如下：

 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <algorithm>
 using namespace std;
 int main()
 {
     int a, b;
     cin >> a >> b;
     int sum = a + b;
     if(sum < )
     {
         cout << '-';
         sum = -sum;
     }
     bool flag = false;
     int tmpNum = sum/;
     sum%=;
     if(tmpNum > )    {printf("%d", tmpNum);flag = true;}
     tmpNum = sum/;
     sum%=;
     if(flag) printf(",%03d", tmpNum);
     else if(tmpNum > ){printf("%d", tmpNum);flag = true;}
     flag ? printf(",%03d", sum) : printf("%d", sum);
     return ;
 }

A1002 ： A+B for Polynomials (25 point(s))

　　解这道题的关键是题目所给的条件：每个多项式的格式是幂逐渐减小的。

　　1.可以依次找多项式的较大项进行处理。

　　2.也可以直接建立一个容量1000的数组，把他们都当做1000项的多项式处理。

　　方法1的代码如下：

 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <vector>
 #include <algorithm>
 using namespace std;
 typedef struct NODE
 {
     int exp;
     double val;
     NODE():exp(),val(){}
     NODE(int exp, double val):exp(exp),val(val){}
 }node;
 vector<node> poly1, poly2;
 vector<node> resultPoly;
 int main()
 {
     int n, tmpNum;
     double tmpDouble;
     cin >> n;
     while(n--)
     {
         cin >> tmpNum >> tmpDouble;
         poly1.push_back(NODE(tmpNum, tmpDouble));
     }
     cin >> n;
     while(n--)
     {
         cin >> tmpNum >> tmpDouble;
         poly2.push_back(NODE(tmpNum, tmpDouble));
     }
     int index1=, index2 = ;
     while(index1 < poly1.size() && index2 < poly2.size())
     {
         if(poly1[index1].exp == poly2[index2].exp)
         {
             double tmpDouble = poly1[index1].val+poly2[index2].val;
             if(tmpDouble != )
                 resultPoly.push_back(NODE(poly1[index1].exp, tmpDouble));
             index1 ++; index2 ++;
         }
         else
             (poly1[index1].exp > poly2[index2].exp) ? resultPoly.push_back(poly1[index1++]) : resultPoly.push_back(poly2[index2++]);
     }
     while(index1 < poly1.size())    resultPoly.push_back(poly1[index1++]);
     while(index2 < poly2.size())    resultPoly.push_back(poly2[index2++]);
     cout << resultPoly.size();
     for(auto it = resultPoly.begin(); it != resultPoly.end(); ++ it)
         printf(" %d %.1f", it->exp, it->val);
     return ;
 }

A1003 ： Emergency (25 point(s))

　　解这道题目的关键是：最短路径（Dijkstra）、最短路径数目（所有最短路径的上一个节点路径数之和）、最多救护人员（所有最短路径中上一个节点最多的救护人员+本节点救护人员数）

　　1.邻接矩阵存储，Dijkstra处理

　　代码如下：

 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <vector>
 #include <algorithm>
 using namespace std;
 const int INF = 0x7f7f7f7f;
 int routeMap[][];
 int dis[]={};
 int assNum[]={};
 int pathCnt[]={};
 int assistCnt[]={};
 int N, M, C1, C2;
 void Dijkstra(int u)
 {
     dis[u] = ;
     assistCnt[u] = assNum[u];
     pathCnt[u] = ;
     vector<bool> flagVec(, false);
     for(int i = ; i < N; ++ i)
     {
         int minNum = INF, v = -;
         for(int j = ; j < N; ++ j)
             if(!flagVec[j] && dis[j] < minNum)
             {
                 minNum = dis[j];v = j;
             }
         if(v == -)
             break;
         flagVec[v] = true;
         for(int j = ; j < N; ++ j)
         {
             if(!flagVec[j] && routeMap[v][j]+dis[v] < dis[j])
             {
                 dis[j] = routeMap[v][j]+dis[v];
                 assistCnt[j] = assistCnt[v] + assNum[j];
                 pathCnt[j] = pathCnt[v];
             }
             else if(!flagVec[j] && routeMap[v][j]+dis[v] == dis[j])
             {
                 pathCnt[j] += pathCnt[v];
                 if(assistCnt[j] < assistCnt[v] + assNum[j])
                     assistCnt[j] = assistCnt[v] + assNum[j];
             }
         }
     }
 }
 int main()
 {
     cin >> N >> M >> C1 >> C2;
     memset(routeMap, 0x7f, sizeof(routeMap));
     memset(dis, 0x7f, sizeof(dis));
     int tmpSt, tmpEnd, tmpDis;
     for(int i = ; i < N; ++ i)
         cin >> assNum[i];
     for(int i = ; i < M; ++ i)
     {
         cin >> tmpSt >> tmpEnd >> tmpDis;
         routeMap[tmpSt][tmpEnd] = tmpDis;
         routeMap[tmpEnd][tmpSt] = tmpDis;
     }
     Dijkstra(C1);
     cout << pathCnt[C2] << " " << assistCnt[C2];
     return ;
 }

A1003 ： Counting Leaves (30 point(s))

　　解这道题目的关键是：需要输出每层的叶子节点数。

　　注意：N为0时不处理

　 1.静态存储树，bfs

 #include <cstdio>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <vector>
 #include <queue>
 #include <algorithm>
 using namespace std;
 int N, M;
 typedef struct NODE
 {
     vector<int> child;
 }node;
 vector<node> treeVec();
 void Bfs(int u)
 {
     queue<int> bfsQue;
     bfsQue.push(u);
     bool symbolFlag = false;
     while(!bfsQue.empty())
     {
         int len = bfsQue.size();
         int leafCnt = ;
         for(int i = ; i < len; ++ i)
         {
             int tmpNum = bfsQue.front();
             bfsQue.pop();
             if(treeVec[tmpNum].child.size() == )
                 leafCnt++;
             else
             {
                 for(auto it = treeVec[tmpNum].child.begin(); it != treeVec[tmpNum].child.end(); ++ it)
                 {
                     bfsQue.push(*it);
                 }
             }
         }
         symbolFlag ? printf(" ") : symbolFlag = true;
         cout << leafCnt;
     }
 }
 int main()
 {
     cin >> N >> M;
     int tmpId, tmpChildCnt, tmpChild;
     if(N == )
         return ;
     for(int i = ; i < M; ++ i)
     {
         cin >> tmpId >> tmpChildCnt;
         for(int j = ; j < tmpChildCnt; ++j)
         {
             cin >> tmpChild;
             treeVec[tmpId].child.push_back(tmpChild);
         }
     }
     Bfs();
     return ;
 }