PAT 2018 秋

A 1148 Werewolf - Simple Version

　　思路比较直接：模拟就行。因为需要序列号最小的两个狼人，所以以狼人为因变量进行模拟。

 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #include <vector>

 using namespace std;
 int N;
 vector<int> stateVec;
 vector<int> inputVec;
 bool judgeRight(int a, int b)
 {
     int liarCnt = , wereLiarCnt = , tmpNum;
     fill(stateVec.begin(), stateVec.end(), );
     stateVec[a] = stateVec[b] = ;
     for(int i = ; i <= N; ++ i)
     {
         tmpNum = inputVec[i];
         if((tmpNum >  && stateVec[tmpNum] == ) || (tmpNum <  && stateVec[-tmpNum] == ))
         {
             liarCnt ++;
             if(i == a || i == b)
                 wereLiarCnt ++;
         }
     }
     if(liarCnt ==  && wereLiarCnt == )
         return true;
     else
         return false;
 }
 int main()
 {
     cin >> N;
     inputVec.resize(N+, );
     stateVec.resize(N+, );
     for(int i = ; i <= N; ++ i)
         cin >> inputVec[i];
     for(int i = ; i < N; ++i)
     {
         for(int j = i+; j <= N; ++ j)
         {
             if(judgeRight(i,j))
             {
                 cout << i << " " << j;
                 return ;
             }
         }
     }
     cout << "No Solution";
     return ;
 }

A 1149 Dangerous Goods Packaging

　　这个最开始使用图+二重for循环直接判，发现超时很严重。后来改用邻接表存储，每个物品更新一下与其互斥物品的标志。成功通过。

 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <unordered_map>
 using namespace std;
 int N, M;
 typedef long long LL;
 unordered_map<int, vector<int>> goodsMap;
 vector<int> goodsVec;
 bool judgeRight(void)
 {
     int tmpNum;
     int len = goodsVec.size();
     unordered_map<int, int> incomFlagMap;
     for(int i = ; i < len; ++ i)
     {
         tmpNum = goodsVec[i];
         if(incomFlagMap[tmpNum] == )
             return false;
         for(auto it = goodsMap[tmpNum].begin(); it != goodsMap[tmpNum].end(); ++it)
             incomFlagMap[*it] = ;
     }
     return true;
 }
 int main()
 {
     cin >> N >> M;
     int tmpNum2, tmpNum1;
     while(N--)
     {
         cin >> tmpNum1 >> tmpNum2;
         goodsMap[tmpNum1].push_back(tmpNum2);
         goodsMap[tmpNum2].push_back(tmpNum1);
     }
     while(M--)
     {
         cin >> N;
         goodsVec.resize(N,);
         while(N--)
             cin >> goodsVec[N];
         if(judgeRight())
             cout << "Yes" << endl;
         else
             cout << "No" << endl;
     }
     return ;
 }

A 1150 Travelling Salesman Problem

　　这个理解题意就行。需要注意的地方：

　　　　　　　　　　　　　　1.不能通过的路径，距离输出为NA

　　　　　　　　　　　　　　2.最小距离是在TS cycle 和 TS simple cycle中选出

　　　　　　　　　　　　　　3.TS cycle 需要最后一个城市为出发城市

 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 using namespace std;
 int N, M, K;
 const int INF = 0x7f7f7f7f;
 int route[][]={};
 int main()
 {
     cin >> N >> M;
     int tmpSt, tmpEnd, tmpDis, tmpNum, lastCity, nowCity, minDis = INF, minIndex;
     while(M--)
     {
         cin >> tmpSt >> tmpEnd >> tmpDis;
         route[tmpSt][tmpEnd] = tmpDis;
         route[tmpEnd][tmpSt] = tmpDis;
     }
     cin >> K;
     for(int i = ; i <= K; ++i)
     {
         tmpDis = ;
         cin >> tmpNum;
         cin >> tmpSt;
         lastCity = tmpSt;
         vector<int> flagVec(N+,);
         bool simpleFlag = true;
         int travelCityCnt = ;
         for(int j = ; j < tmpNum; j++)
         {
             cin >> nowCity;
             if(flagVec[nowCity] == )
             {
                 flagVec[nowCity] = ;
                 travelCityCnt ++;
             }
             else
                 simpleFlag = false;
             if(tmpDis >=  && route[lastCity][nowCity] > )
                 tmpDis += route[lastCity][nowCity];
             else
                 tmpDis = -;
             lastCity = nowCity;
         }
         if(lastCity == tmpSt && simpleFlag && tmpDis >=  && travelCityCnt == N)
             printf("Path %d: %d (TS simple cycle)\n", i, tmpDis);
         else if(tmpDis >=  && lastCity == tmpSt && travelCityCnt >= N)
             printf("Path %d: %d (TS cycle)\n", i, tmpDis);
         else
         {
             tmpDis >=  ? printf("Path %d: %d (Not a TS cycle)\n", i, tmpDis) : printf("Path %d: NA (Not a TS cycle)\n", i);
             tmpDis = -;
         }
         if(tmpDis >  && tmpDis < minDis)
         {
             minDis = tmpDis;
             minIndex = i;
         }
     }
     printf("Shortest Dist(%d) = %d", minIndex, minDis);
     return ;
 }

A 1151 LCA in a Binary Tree

　　只得到了22分，应该是2^10000太大了，所以这个方法行不通。更好的方法确实是和1143一样的思路去做。在输入时，保存一下中序遍历key和位置的关系。

 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <unordered_map>
 using namespace std;
 int N, M, K;
 vector<int> preOrderVec, inOrderVec;
 unordered_map<int, int> valToIndexMap;
 unordered_map<int, int> indexToValMap;
 void insertVal(int inL, int inR, int preL, int preR, int index)
 {
     if(inL > inR || preL > preR)
         return;
     int tmpNum = preOrderVec[preL];
     int tmpIndex = inL;
     while(inOrderVec[tmpIndex] != tmpNum)
         tmpIndex++;
     //treeNodeVec[index] = tmpNum;
     valToIndexMap[tmpNum] = index;
     indexToValMap[index] = tmpNum;
     insertVal(inL, tmpIndex-, preL+, preL+tmpIndex-inL, index*);
     insertVal(tmpIndex+, inR, preR-inR+tmpIndex+,preR, index*+);
     return;
 }
 void getNodeInfo(int a, int b)
 {
     int tmpIndex1 = valToIndexMap[a], tmpIndex2 = valToIndexMap[b];
     if(tmpIndex1 ==  && tmpIndex2 == )
         printf("ERROR: %d and %d are not found.\n", a, b);
     else if(tmpIndex1 ==  || tmpIndex2 == )
         tmpIndex1 ==  ? printf("ERROR: %d is not found.\n", a) : printf("ERROR: %d is not found.\n", b);
     else
     {
         while(tmpIndex1 != tmpIndex2)
             tmpIndex1 > tmpIndex2 ? tmpIndex1 /=  : tmpIndex2 /= ;
         int tmpNum = indexToValMap[tmpIndex1];
         if(tmpNum == a || tmpNum == b)
             tmpNum == a ? printf("%d is an ancestor of %d.\n", a, b) : printf("%d is an ancestor of %d.\n", b, a);
         else
             printf("LCA of %d and %d is %d.\n", a, b, tmpNum);
     }
 }
 int main()
 {
     cin >> M >> N;
     int tmpNum1, tmpNum2;
     preOrderVec.resize(N);
     inOrderVec.resize(N);
     for(int i = ; i < N; ++i)
         cin >> inOrderVec[i];
     for(int i = ; i < N; ++ i)
         cin >> preOrderVec[i];
     insertVal(, N-, , N-, );
     while(M--)
     {
         cin >> tmpNum1 >> tmpNum2;
         getNodeInfo(tmpNum1, tmpNum2);
     }
     return ;
 }