PAT 2014 秋

A 1084 Broken Keyboard

　　注意大小写即可。

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <string>

 using namespace std;

 int main()
 {
     string inStr, outStr;
     cin >> inStr >> outStr;
     int inIndex = , outIndex = ;
     bool charFlag[]={false};
     while(inIndex < inStr.size())
     {
         if(inStr[inIndex] == outStr[outIndex])
         {
             inIndex++;
             outIndex < outStr.size()- ? outIndex++ : outStr[outIndex] = ' ';
         }
         else
         {
             int tmpNum = (int)inStr[inIndex++];
             tmpNum = tmpNum >= 'a' ? tmpNum-'a'+'A' : tmpNum;
             if(!charFlag[tmpNum])
             {
                 charFlag[tmpNum] = ;
                 printf("%c", tmpNum);
             }
         }
     }
     return ;
 }

A 1085 Perfect Sequence

　　1.二分查找，不然会超时

　　2.注意数值的范围，有些地方需要使用long long

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

 using namespace std;
 typedef long long LL;
 vector<int> inputNumVec;
 int N, P;
 int getMaxCnt(int lIndex)
 {
     int rIndex = inputNumVec.size()-, midIndex;
     LL tmpNum = (LL)inputNumVec[lIndex]*P;
     while(lIndex <= rIndex)
     {
         midIndex = (lIndex + rIndex) >> ;
         if(inputNumVec[midIndex] > tmpNum)
             rIndex = midIndex - ;
         else
             lIndex = midIndex + ;
     }
     return rIndex;
 }
 int main()
 {
     cin >> N >> P;
     inputNumVec.resize(N);
     for(int i = ; i < N; ++ i)
         cin >> inputNumVec[i];
     sort(inputNumVec.begin(), inputNumVec.end());
     int maxCnt = , tmpNum;
     for(int i = ; i <= inputNumVec.size()-maxCnt; ++ i)
     {
         tmpNum = getMaxCnt(i)-i+;
         if(tmpNum > maxCnt)
             maxCnt = tmpNum;
     }
     cout << maxCnt;
     return ;
 }

A 1086 Tree Traversals Again

　　自己想个办法建树之后进行后续遍历即可

 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <stack>

 using namespace std;
 typedef long long LL;
 #define NoAddr -1
 typedef struct NODE
 {
     int val, lChild, rChild;
     NODE(int v):val(v),lChild(NoAddr),rChild(NoAddr){}
 }node;
 vector<node> nodeVec;
 stack<int> valVec;
 bool coutFlag = false;
 void postOrder(int tmpRoot)
 {
     if(tmpRoot >= nodeVec.size())
         return;
     if(nodeVec[tmpRoot].lChild > )
         postOrder(nodeVec[tmpRoot].lChild);
     if(nodeVec[tmpRoot].rChild > )
         postOrder(nodeVec[tmpRoot].rChild);
     coutFlag ?  printf(" ") :coutFlag = true;
     cout << nodeVec[tmpRoot].val;
 }
 int main()
 {
     int N, tmpNum, lastIndex = ;
     string tmpStr;
     bool pushFlag = true;
     cin >> N;
     while(N > )
     {
         cin >> tmpStr;
         if(tmpStr == "Push")
         {
             cin >> tmpNum;
             valVec.push(nodeVec.size());
             nodeVec.push_back(NODE(tmpNum));
             pushFlag ? nodeVec[lastIndex].lChild = nodeVec.size()- :
                        nodeVec[lastIndex].rChild = nodeVec.size()- ;
             lastIndex = nodeVec.size()-;
             pushFlag = true;
         }
         else
         {
             lastIndex = valVec.top();
             valVec.pop();
             pushFlag = false;
             N--;
         }
     }
     postOrder();
     return ;
 }

A 1087 All Roads Lead to Rome

　　1.城市名string 和 序号index的转换

　　2.Dijkstra找最短距离

　　3.DFS根据题目中给出的优先级找到所需的条件

 #include <cstdio>
 #include <stdlib.h>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <stack>
 #include <unordered_map>
 using namespace std;
 #define NoAddr -1
 #define MAX_CITY 210
 #define CLR(a,b) memset(a,b,sizeof(a))
 typedef long long LL;
 const int INF = 0x7f7f7f7f;
 int N, K;
 string citySt;
 int route[MAX_CITY][MAX_CITY]={};
 vector<int> preVec[MAX_CITY];
 vector<int> tmpPath;
 vector<int> outPath;
 vector<int> disVec;
 vector<int> cityHappyValVec;
 int minCityCnt = MAX_CITY, maxHappy = -, minPathCnt = , tmpMaxHappy = ;
 unordered_map<string, int> cityToIndexMap;
 unordered_map<int, string> indexToCityMap;
 void Dijkstra(int u)
 {
     vector<bool> visitFlagVec(N, false);
     disVec.resize(N, INF);
     disVec[u] = ;
     for(int i = ; i < N; ++ i)
     {
         int minDis = INF, v = -;
         for(int j = ; j < N; ++ j)
             if(!visitFlagVec[j] && disVec[j] < minDis)
             {
                 minDis = disVec[j];
                 v = j;
             }
         if(v == -)
             return;
         visitFlagVec[v] = true;
         for(int j = ; j < N; ++ j)
         {
             if(!visitFlagVec[j] && disVec[v] + route[v][j] < disVec[j])
             {
                 disVec[j] = disVec[v] + route[v][j];
                 preVec[j].clear();
                 preVec[j].push_back(v);
             }
             else if(!visitFlagVec[j] && disVec[v] + route[v][j] == disVec[j])
             {
                 preVec[j].push_back(v);
             }
         }
     }
 }
 void dfs(int u)
 {
     if(u == )
     {
         minPathCnt ++;
         tmpPath.push_back();
         if(tmpMaxHappy > maxHappy)
         {
             maxHappy = tmpMaxHappy;
             outPath = tmpPath;
             minCityCnt = tmpPath.size();
         }
         else if(tmpMaxHappy == maxHappy && tmpPath.size() < minCityCnt)
         {
             outPath = tmpPath;
         }
         tmpPath.pop_back();
     }
     tmpPath.push_back(u);
     tmpMaxHappy += cityHappyValVec[u];
     for(int i = ; i < preVec[u].size(); ++ i)
         dfs(preVec[u][i]);
     tmpMaxHappy -= cityHappyValVec[u];
     tmpPath.pop_back();
 }
 int main()
 {
     cin >> N >> K >> citySt;
     cityHappyValVec.resize(N, );
     string tmpCity, tmpSt, tmpEnd;
     int tmpHappy, tmpDis, stIndex, endIndex, endCityIndex;
     cityToIndexMap[citySt] = ;
     indexToCityMap[] = citySt;
     for(int i = ; i < N; ++ i)
     {
         cin >> tmpCity >> tmpHappy;
         cityHappyValVec[i] = tmpHappy;
         cityToIndexMap[tmpCity] = i;
         indexToCityMap[i] = tmpCity;
         if(tmpCity == "ROM")
             endCityIndex = i;
     }
     CLR(route,0x7f);
     while(K--)
     {
         cin >> tmpSt >> tmpEnd >> tmpDis;
         stIndex = cityToIndexMap[tmpSt];
         endIndex = cityToIndexMap[tmpEnd];
         route[stIndex][endIndex] = tmpDis;
         route[endIndex][stIndex] = tmpDis;
     }
     Dijkstra();
     dfs(endCityIndex);
     cout << minPathCnt << " " << disVec[endCityIndex] << " " << maxHappy << " " << (int)maxHappy/(outPath.size()-) << endl;
     bool symbolFlag = false;
     for(int i = outPath.size()-; i >= ; -- i)
     {
         symbolFlag ? printf("->") : symbolFlag = true;
         cout << indexToCityMap[outPath[i]];
     }
     return ;
 }