PAT – 第7页 – 柳婼の blog

1072. 开学寄语(20)-PAT乙级真题

下图是上海某校的新学期开学寄语：天将降大任于斯人也，必先删其微博，卸其QQ，封其电脑，夺其手机，收其ipad，断其wifi，使其百无聊赖，然后，净面、理发、整衣，然后思过、读书、锻炼、明智、开悟、精进。而后必成大器也！
本题要求你写个程序帮助这所学校的老师检查所有学生的物品，以助其成大器。
输入格式：
输入第一行给出两个正整数N（<= 1000）和M（<= 6），分别是学生人数和需要被查缴的物品种类数。第二行给出M个需要被查缴的物品编号，其中编号为4位数字。随后N行，每行给出一位学生的姓名缩写（由1-4个大写英文字母组成）、个人物品数量K（0 <= K <= 10）、以及K个物品的编号。
输出格式：
顺次检查每个学生携带的物品，如果有需要被查缴的物品存在，则按以下格式输出该生的信息和其需要被查缴的物品的信息（注意行末不得有多余空格）：
姓名缩写: 物品编号1 物品编号2 ……
最后一行输出存在问题的学生的总人数和被查缴物品的总数。
输入样例：
4 2
2333 6666
CYLL 3 1234 2345 3456
U 4 9966 6666 8888 6666
GG 2 2333 7777
JJ 3 0012 6666 2333
输出样例：
U: 6666 6666
GG: 2333
JJ: 6666 2333
3 5

分析：bool类型的forbid存储禁止携带的物品，如果需要被查缴则赋值为true；flag变量表示当前学生是否已经输出过姓名，一开始flag=false，当前学生如果有需要被查缴的物品且还未输出过他的姓名，则输出name，并令flag=true；如果有需要被查缴的物品且已经输出过姓名，则输出该物品的编号，因为编号为4位数字，不满4位要在前面补0，所以用%04d输出，并将被查缴物品的总数fnum++，最后如果当前学生已经输出过姓名，则输出一个空行，并将学生的总人数snum++，最后输出snum和fnum的值～

#include <iostream>
#include <algorithm>
using namespace std;
bool forbid[10000];
int main() {
    int n, m, temp, k, snum = 0, fnum = 0;
    scanf("%d %d", &n, &m);
    for (int i = 0; i < m; i++) {
        scanf("%d", &temp);
        forbid[temp] = true;
    }
    for (int i = 0; i < n; i++) {
        char name[10];
        bool flag = false;
        scanf("%s %d", name, &k);
        for (int j = 0; j < k; j++) {
            scanf("%d", &temp);
            if (forbid[temp]) {
                if (!flag) {
                    printf("%s:", name);
                    flag = true;
                }
                printf(" %04d", temp);
                fnum++;
            }
        }
        if (flag) {
            printf("\n");
            snum++;
        }
    }
    printf("%d %d\n", snum, fnum);
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

bool forbid[10000];

int main() {

int n, m, temp, k, snum = 0, fnum = 0;

scanf("%d %d", &n, &m);

for (int i = 0; i < m; i++) {

scanf("%d", &temp);

forbid[temp] = true;

}

for (int i = 0; i < n; i++) {

char name[10];

bool flag = false;

scanf("%s %d", name, &k);

for (int j = 0; j < k; j++) {

scanf("%d", &temp);

if (forbid[temp]) {

if (!flag) {

printf("%s:", name);

flag = true;

}

printf(" %04d", temp);

fnum++;

}

if (flag) {

printf("\n");

snum++;

}

printf("%d %d\n", snum, fnum);

return 0;

}

1071. 小赌怡情(15)-PAT乙级真题

常言道“小赌怡情”。这是一个很简单的小游戏：首先由计算机给出第一个整数；然后玩家下注赌第二个整数将会比第一个数大还是小；玩家下注t个筹码后，计算机给出第二个数。若玩家猜对了，则系统奖励玩家t个筹码；否则扣除玩家t个筹码。
注意：玩家下注的筹码数不能超过自己帐户上拥有的筹码数。当玩家输光了全部筹码后，游戏就结束。

输入格式：

输入在第一行给出2个正整数T和K（<=100），分别是系统在初始状态下赠送给玩家的筹码数、以及需要处理的游戏次数。随后K行，每行对应一次游戏，顺序给出4个数字：
n1 b t n2
其中n1和n2是计算机先后给出的两个[0, 9]内的整数，保证两个数字不相等。b为0表示玩家赌“小”，为1表示玩家赌“大”。t表示玩家下注的筹码数，保证在整型范围内。

输出格式：

对每一次游戏，根据下列情况对应输出（其中t是玩家下注量，x是玩家当前持有的筹码量）：
玩家赢，输出
Win t! Total = x.
玩家输，输出
Lose t. Total = x.
玩家下注超过持有的筹码量，输出
Not enough tokens. Total = x.
玩家输光后，输出
Game Over.
并结束程序。

输入样例1：
100 4
8 0 100 2
3 1 50 1
5 1 200 6
7 0 200 8

输出样例1：
Win 100! Total = 200.
Lose 50. Total = 150.
Not enough tokens. Total = 150.
Not enough tokens. Total = 150.

输入样例2：
100 4
8 0 100 2
3 1 200 1
5 1 200 6
7 0 200 8
输出样例2：
Win 100! Total = 200.
Lose 200. Total = 0.
Game Over.

分析：ans表示n1和n2真实的结果，如果n1 > n2，ans为0，表示应该赌小，否则ans = 1，表示玩家应该赌大。T表示当前玩家有的筹码数，如果T=0，表示玩家已经输光，输出Game Over；如果t > T，表示玩家下注超过持有的筹码量，输出Not enough tokens. Total = 当前的T，如果真实结果ans等于玩家猜的结果，表示玩家赢了，筹码都归玩家，T += t；如果ans不等于b，表示玩家输了，筹码要减去t～

#include <iostream>
using namespace std;
int main() {
    int T, K, n1, n2, b, t;
    scanf("%d %d", &T, &K);
    for (int i = 0; i < K; i++) {
        scanf("%d %d %d %d", &n1, &b, &t, &n2);
        int ans = n1 > n2 ? 0 : 1;
        if (T == 0) {
            printf("Game Over.\n");
            return 0;
        } else if (t > T) {
            printf("Not enough tokens.  Total = %d.\n", T);
        } else if (ans == b) {
            T += t;
            printf("Win %d!  Total = %d.\n", t, T);
        } else if (ans != b) {
            T -= t;
            printf("Lose %d.  Total = %d.\n", t, T);
        } 
    }
    return 0;
}

#include <iostream>

using namespace std;

int main() {

int T, K, n1, n2, b, t;

scanf("%d %d", &T, &K);

for (int i = 0; i < K; i++) {

scanf("%d %d %d %d", &n1, &b, &t, &n2);

int ans = n1 > n2 ? 0 : 1;

if (T == 0) {

printf("Game Over.\n");

return 0;

} else if (t > T) {

printf("Not enough tokens. Total = %d.\n", T);

} else if (ans == b) {

T += t;

printf("Win %d! Total = %d.\n", t, T);

} else if (ans != b) {

T -= t;

printf("Lose %d. Total = %d.\n", t, T);

}

return 0;

}

1080. MOOC期终成绩 (25)-PAT乙级真题

对于在中国大学MOOC（http://www.icourse163.org/）学习“数据结构”课程的学生，想要获得一张合格证书，必须首先获得不少于200分的在线编程作业分，然后总评获得不少于60分（满分100）。总评成绩的计算公式为 G = (G期中x 40% + G期末x 60%)，如果 G期中 > G期末；否则总评 G 就是 G期末。这里 G期中和 G期末分别为学生的期中和期末成绩。

现在的问题是，每次考试都产生一张独立的成绩单。本题就请你编写程序，把不同的成绩单合为一张。

输入格式：

输入在第一行给出3个整数，分别是 P（做了在线编程作业的学生数）、M（参加了期中考试的学生数）、N（参加了期末考试的学生数）。每个数都不超过10000。

接下来有三块输入。第一块包含 P 个在线编程成绩 G编程；第二块包含 M 个期中考试成绩 G期中；第三块包含 N 个期末考试成绩 G期末。每个成绩占一行，格式为：学生学号分数。其中学生学号为不超过20个字符的英文字母和数字；分数是非负整数（编程总分最高为900分，期中和期末的最高分为100分）。

输出格式：

打印出获得合格证书的学生名单。每个学生占一行，格式为：

学生学号 G编程 G期中 G期末 G

如果有的成绩不存在（例如某人没参加期中考试），则在相应的位置输出“-1”。输出顺序为按照总评分数（四舍五入精确到整数）递减。若有并列，则按学号递增。题目保证学号没有重复，且至少存在1个合格的学生。

输入样例：
6 6 7
01234 880
a1903 199
ydjh2 200
wehu8 300
dx86w 220
missing 400
ydhfu77 99
wehu8 55
ydjh2 98
dx86w 88
a1903 86
01234 39
ydhfu77 88
a1903 66
01234 58
wehu8 84
ydjh2 82
missing 99
dx86w 81
输出样例：
missing 400 -1 99 99
ydjh2 200 98 82 88
dx86w 220 88 81 84
wehu8 300 55 84 84

分析：1、因为所有人必须要G编程>=200分，所以用v数组保存所有G编程>=200的人，（一开始gm和gf都为-1），用map映射保存名字所对应v中的下标（为了避免与“不存在”混淆，保存下标+1，当为0时表示该学生的姓名在v中不存在）
2、G期中中出现的名字，如果对应的map并不存在（==0），说明该学生编程成绩不满足条件，则无须保存该学生信息。将存在的人的期中考试成绩更新
3、G期末中出现的名字，也必须保证在map中存在，先更新G期末和G总为新的成绩，当G期末<G期中时再将G总更新为(G期中x 40% + G期末x 60%)
4、将v数组中所有G总满足条件的放入ans数组中，对ans排序（总分递减，总分相同则姓名递增），最后输出ans中的学生信息～

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
struct node {
    string name;
    int gp, gm, gf, g;
};
bool cmp(node a, node b) {
    return a.g != b.g ? a.g > b.g : a.name < b.name;
}
map<string, int> idx;
int main() {
    int p, m, n, score, cnt = 1;
    cin >> p >> m >> n;
    vector<node> v, ans;
    string s;
    for (int i = 0; i < p; i++) {
        cin >> s >> score;
        if (score >= 200) {
            v.push_back(node{s, score, -1, -1, 0});
            idx[s] = cnt++;
        }
    }
    for (int i = 0; i < m; i++) {
        cin >> s >> score;
        if (idx[s] != 0) v[idx[s] - 1].gm = score;
    }
    for (int i = 0; i < n; i++) {
        cin >> s >> score;
        if (idx[s] != 0) {
            int temp = idx[s] - 1;
            v[temp].gf = v[temp].g = score;
            if (v[temp].gm > v[temp].gf) v[temp].g = int(v[temp].gm * 0.4 + v[temp].gf * 0.6 + 0.5);
        }
    }
    for (int i = 0; i < v.size(); i++)
        if (v[i].g >= 60) ans.push_back(v[i]);
    sort(ans.begin(), ans.end(), cmp);
    for (int i = 0; i < ans.size(); i++)
        printf("%s %d %d %d %d\n", ans[i].name.c_str(), ans[i].gp, ans[i].gm, ans[i].gf, ans[i].g);
    return 0;
}

#include <iostream>

#include <algorithm>

#include <vector>

#include <map>

using namespace std;

struct node {

string name;

int gp, gm, gf, g;

};

bool cmp(node a, node b) {

return a.g != b.g ? a.g > b.g : a.name < b.name;

}

map<string, int> idx;

int main() {

int p, m, n, score, cnt = 1;

cin >> p >> m >> n;

vector<node> v, ans;

string s;

for (int i = 0; i < p; i++) {

cin >> s >> score;

if (score >= 200) {

v.push_back(node{s, score, -1, -1, 0});

idx[s] = cnt++;

}

for (int i = 0; i < m; i++) {

cin >> s >> score;

if (idx[s] != 0) v[idx[s] - 1].gm = score;

}

for (int i = 0; i < n; i++) {

cin >> s >> score;

if (idx[s] != 0) {

int temp = idx[s] - 1;

v[temp].gf = v[temp].g = score;

if (v[temp].gm > v[temp].gf) v[temp].g = int(v[temp].gm * 0.4 + v[temp].gf * 0.6 + 0.5);

}

for (int i = 0; i < v.size(); i++)

if (v[i].g >= 60) ans.push_back(v[i]);

sort(ans.begin(), ans.end(), cmp);

for (int i = 0; i < ans.size(); i++)

printf("%s %d %d %d %d\n", ans[i].name.c_str(), ans[i].gp, ans[i].gm, ans[i].gf, ans[i].g);

return 0;

}

1079. 延迟的回文数 (20)-PAT乙级真题

给定一个 k+1 位的正整数 N，写成 ak…a1a0 的形式，其中对所有 i 有 0 <= ai < 10 且 ak > 0。N 被称为一个回文数，当且仅当对所有 i 有 ai = ak-i。零也被定义为一个回文数。
非回文数也可以通过一系列操作变出回文数。首先将该数字逆转，再将逆转数与该数相加，如果和还不是一个回文数，就重复这个逆转再相加的操作，直到一个回文数出现。如果一个非回文数可以变出回文数，就称这个数为延迟的回文数。（定义翻译自 https://en.wikipedia.org/wiki/Palindromic_number）
给定任意一个正整数，本题要求你找到其变出的那个回文数。
输入格式：
输入在一行中给出一个不超过1000位的正整数。
输出格式：
对给定的整数，一行一行输出其变出回文数的过程。每行格式如下
A + B = C
其中A是原始的数字，B是A的逆转数，C是它们的和。A从输入的整数开始。重复操作直到C在10步以内变成回文数，这时在一行中输出“C is a palindromic number.”；或者如果10步都没能得到回文数，最后就在一行中输出“Not found in 10 iterations.”。
输入样例 1：
97152
输出样例 1：
97152 + 25179 = 122331
122331 + 133221 = 255552
255552 is a palindromic number.
输入样例 2：
196
输出样例 2：
196 + 691 = 887
887 + 788 = 1675
1675 + 5761 = 7436
7436 + 6347 = 13783
13783 + 38731 = 52514
52514 + 41525 = 94039
94039 + 93049 = 187088
187088 + 880781 = 1067869
1067869 + 9687601 = 10755470
10755470 + 07455701 = 18211171
Not found in 10 iterations.

分析：1、将字符串倒置与原字符串比较看是否相等可知s是否为回文串
2、字符串s和它的倒置t相加，只需从头到尾相加然后再倒置（记得要处理最后一个进位carry，如果有进位要在末尾+’1’）
3、倒置可采用algorithm头文件里面的函数reverse(s.begin(), s.end())直接对s进行倒置

#include <iostream>
#include <algorithm>
using namespace std;
string rev(string s) {
    reverse(s.begin(), s.end());
    return s;
}
string add(string s1, string s2) {
    string s = s1;
    int carry = 0;
    for (int i = s1.size() - 1; i >= 0; i--) {
        s[i] = (s1[i] - '0' + s2[i] - '0' + carry) % 10 + '0';
        carry = (s1[i] - '0' + s2[i] - '0' + carry) / 10;
    }
    if (carry > 0) s = "1" + s;
    return s;
}
int main() {
    string s, sum;
    int n = 10;
    cin >> s;
    if (s == rev(s)) {
        cout << s << " is a palindromic number.\n";
        return 0;
    }
    while (n--) {
        sum = add(s, rev(s));
        cout << s << " + " << rev(s) << " = " << sum << endl;
        if (sum == rev(sum)) {
            cout << sum << " is a palindromic number.\n";
            return 0;
        }
        s = sum;
    }
    cout << "Not found in 10 iterations.\n";
    return 0;
}

#include <iostream>

#include <algorithm>

using namespace std;

string rev(string s) {

reverse(s.begin(), s.end());

return s;

}

string add(string s1, string s2) {

string s = s1;

int carry = 0;

for (int i = s1.size() - 1; i >= 0; i--) {

s[i] = (s1[i] - '0' + s2[i] - '0' + carry) % 10 + '0';

carry = (s1[i] - '0' + s2[i] - '0' + carry) / 10;

}

if (carry > 0) s = "1" + s;

return s;

}

int main() {

string s, sum;

int n = 10;

cin >> s;

if (s == rev(s)) {

cout << s << " is a palindromic number.\n";

return 0;

}

while (n--) {

sum = add(s, rev(s));

cout << s << " + " << rev(s) << " = " << sum << endl;

if (sum == rev(sum)) {

cout << sum << " is a palindromic number.\n";

return 0;

}

s = sum;

}

cout << "Not found in 10 iterations.\n";

return 0;

}

1018. Public Bike Management (30)-PAT甲级真题（Dijkstra + DFS）

There is a public bike service in Hangzhou City which provides great convenience to the tourists from all over the world. One may rent a bike at any station and return it to any other stations in the city.

The Public Bike Management Center (PBMC) keeps monitoring the real-time capacity of all the stations. A station is said to be in perfect condition if it is exactly half-full. If a station is full or empty, PBMC will collect or send bikes to adjust the condition of that station to perfect. And more, all the stations on the way will be adjusted as well.

When a problem station is reported, PBMC will always choose the shortest path to reach that station. If there are more than one shortest path, the one that requires the least number of bikes sent from PBMC will be chosen.

Snip20160825_77
Figure 1 illustrates an example. The stations are represented by vertices and the roads correspond to the edges. The number on an edge is the time taken to reach one end station from another. The number written inside a vertex S is the current number of bikes stored at S. Given that the maximum capacity of each station is 10. To solve the problem at S3, we have 2 different shortest paths:

1. PBMC -> S1 -> S3. In this case, 4 bikes must be sent from PBMC, because we can collect 1 bike from S1 and then take 5 bikes to S3, so that both stations will be in perfect conditions.

2. PBMC -> S2 -> S3. This path requires the same time as path 1, but only 3 bikes sent from PBMC and hence is the one that will be chosen.

Input Specification:

Each input file contains one test case. For each case, the first line contains 4 numbers: Cmax (<= 100), always an even number, is the maximum capacity of each station; N (<= 500), the total number of stations; Sp, the index of the problem station (the stations are numbered from 1 to N, and PBMC is represented by the vertex 0); and M, the number of roads. The second line contains N non-negative numbers Ci (i=1,…N) where each Ci is the current number of bikes at Si respectively. Then M lines follow, each contains 3 numbers: Si, Sj, and Tij which describe the time Tij taken to move betwen stations Si and Sj. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print your results in one line. First output the number of bikes that PBMC must send. Then after one space, output the path in the format: 0->S1->…->Sp. Finally after another space, output the number of bikes that we must take back to PBMC after the condition of Sp is adjusted to perfect.

Note that if such a path is not unique, output the one that requires minimum number of bikes that we must take back to PBMC. The judge’s data guarantee that such a path is unique.

Sample Input:
10 3 3 5
6 7 0
0 1 1
0 2 1
0 3 3
1 3 1
2 3 1
Sample Output:
3 0->2->3 0
题目大意：每个自行车车站的最大容量为一个偶数cmax，如果一个车站里面自行车的数量恰好为cmax / 2，那么称处于完美状态。如果一个车站容量是满的或者空的，控制中心（处于结点0处）就会携带或者从路上收集一定数量的自行车前往该车站，一路上会让所有的车站沿途都达到完美。现在给出cmax，车站的数量n，问题车站sp，m条边，还有距离，求最短路径。如果最短路径有多个，求能带的最少的自行车数目的那条。如果还是有很多条不同的路，那么就找一个从车站带回的自行车数目最少的（带回的时候是不调整的）～
分析：Dijkstra + DFS。如果只有Dijkstra是不可以的，因为minNeed和minBack在路径上的传递不满足最优子结构，不是简单的相加的过程，只有在所有路径都确定了之后才能区选择最小的need和最小的back～
Dijkstra求最短路径，dfs求minNeed和minBack和path，dfs的时候模拟一遍需要调整的过程，求出最后得到的need和back，与minNeed和minBack比较然后根据情况更新path，最后输出minNeed path 和 minBack，记得path是从最后一个结点一直到第一个结点的，所以要倒着输出～

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int inf = 99999999;
int cmax, n, sp, m;
int minNeed = inf, minBack = inf;
int e[510][510], dis[510], weight[510];
bool visit[510];
vector<int> pre[510], path, temppath;
void dfs(int v) {
    temppath.push_back(v);
    if(v == 0) {
        int need = 0, back = 0;
        for(int i = temppath.size() - 1; i >= 0; i--) {
            int id = temppath[i];
            if(weight[id] > 0) {
                back += weight[id];
            } else {
                if(back > (0 - weight[id])) {
                    back += weight[id];
                } else {
                    need += ((0 - weight[id]) - back);
                    back = 0;
                }
            }
        }
        if(need < minNeed) {
            minNeed = need;
            minBack = back;
            path = temppath;
        } else if(need == minNeed && back < minBack) {
            minBack = back;
            path = temppath;
        }
        temppath.pop_back();
        return ;
    }
    for(int i = 0; i < pre[v].size(); i++)
        dfs(pre[v][i]);
    temppath.pop_back();
}
int main() {
    fill(e[0], e[0] + 510 * 510, inf);
    fill(dis, dis + 510, inf);
    scanf("%d%d%d%d", &cmax, &n, &sp, &m);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &weight[i]);
        weight[i] = weight[i] - cmax / 2;
    }
    for(int i = 0; i < m; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        scanf("%d", &e[a][b]);
        e[b][a] = e[a][b];
    }
    dis[0] = 0;
    for(int i = 0; i <= n; i++) {
        int u = -1, minn = inf;
        for(int j = 0; j <= n; j++) {
            if(visit[j] == false && dis[j] < minn) {
                u = j;
                minn = dis[j];
            }
        }
        if(u == -1) break;
        visit[u] = true;
        for(int v = 0; v <= n; v++) {
            if(visit[v] == false && e[u][v] != inf) {
                if(dis[v] > dis[u] + e[u][v]) {
                    dis[v] = dis[u] + e[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }else if(dis[v] == dis[u] + e[u][v]) {
                    pre[v].push_back(u);
                }
            }
        }
    }
    dfs(sp);
    printf("%d 0", minNeed);
    for(int i = path.size() - 2; i >= 0; i--)
        printf("->%d", path[i]);
    printf(" %d", minBack);
    return 0;
}

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;

const int inf = 99999999;

int cmax, n, sp, m;

int minNeed = inf, minBack = inf;

int e[510][510], dis[510], weight[510];

bool visit[510];

vector<int> pre[510], path, temppath;

void dfs(int v) {

temppath.push_back(v);

if(v == 0) {

int need = 0, back = 0;

for(int i = temppath.size() - 1; i >= 0; i--) {

int id = temppath[i];

if(weight[id] > 0) {

back += weight[id];

} else {

if(back > (0 - weight[id])) {

back += weight[id];

} else {

need += ((0 - weight[id]) - back);

back = 0;

}

if(need < minNeed) {

minNeed = need;

minBack = back;

path = temppath;

} else if(need == minNeed && back < minBack) {

minBack = back;

path = temppath;

}

temppath.pop_back();

return ;

}

for(int i = 0; i < pre[v].size(); i++)

dfs(pre[v][i]);

temppath.pop_back();

}

int main() {

fill(e[0], e[0] + 510 * 510, inf);

fill(dis, dis + 510, inf);

scanf("%d%d%d%d", &cmax, &n, &sp, &m);

for(int i = 1; i <= n; i++) {

scanf("%d", &weight[i]);

weight[i] = weight[i] - cmax / 2;

}

for(int i = 0; i < m; i++) {

int a, b;

scanf("%d%d", &a, &b);

scanf("%d", &e[a][b]);

e[b][a] = e[a][b];

}

dis[0] = 0;

for(int i = 0; i <= n; i++) {

int u = -1, minn = inf;

for(int j = 0; j <= n; j++) {

if(visit[j] == false && dis[j] < minn) {

u = j;

minn = dis[j];

}

if(u == -1) break;

visit[u] = true;

for(int v = 0; v <= n; v++) {

if(visit[v] == false && e[u][v] != inf) {

if(dis[v] > dis[u] + e[u][v]) {

dis[v] = dis[u] + e[u][v];

pre[v].clear();

pre[v].push_back(u);

}else if(dis[v] == dis[u] + e[u][v]) {

pre[v].push_back(u);

}

dfs(sp);

printf("%d 0", minNeed);

for(int i = path.size() - 2; i >= 0; i--)

printf("->%d", path[i]);

printf(" %d", minBack);

return 0;

}

PAT 1130. Infix Expression (25)-甲级

Given a syntax tree (binary), you are supposed to output the corresponding infix expression, with parentheses reflecting the precedences of the operators.

Input Specification:
Each input file contains one test case. For each case, the first line gives a positive integer N ( <= 20 ) which is the total number of nodes in the syntax tree. Then N lines follow, each gives the information of a node (the i-th line corresponds to the i-th node) in the format:
data left_child right_child
where data is a string of no more than 10 characters, left_child and right_child are the indices of this node’s left and right children, respectively. The nodes are indexed from 1 to N. The NULL link is represented by -1. The figures 1 and 2 correspond to the samples 1 and 2, respectively.

Output Specification:
For each case, print in a line the infix expression, with parentheses reflecting the precedences of the operators. Note that there must be no extra parentheses for the final expression, as is shown by the samples. There must be no space between any symbols.
Sample Input 1:
8
* 8 7
a -1 -1
* 4 1
+ 2 5
b -1 -1
d -1 -1
– -1 6
c -1 -1
Sample Output 1:
(a+b)*(c*(-d))
Sample Input 2:
8
2.35 -1 -1
* 6 1
– -1 4
% 7 8
+ 2 3
a -1 -1
str -1 -1
871 -1 -1
Sample Output 2:
(a*2.35)+(-(str%871))

题目大意：给一个二叉树，输出中缀表达式，且加上括号表示运算的优先级～
分析：首先根据所有孩子结点编号寻找1～n中没有出现过的编号标记为root，即树的根结点～然后进行从root结点开始dfs～dfs递归拼接 “(” + 左子树 + 根 + 右子树 + “)”
递归有四种情况（有效的只有三种）：
1. 左右子树都空返回 “(” + 根 + “)”
2. 左空右不空返回 “(” + 根 + 右子树 + “)”
3. 左不空右空这种情况不存在
4. 左右都不空返回 “(” + 左子树 + 根 + 右子树 + “)”
最后递归返回的ans，最外层可能会被括号包起来，也可能不被包起来。要判断一下，如果被包起来，把最外层括号去掉即可～

#include <iostream>
using namespace std;
struct node {
    string data;
    int l, r;
}a[100];
string dfs(int root) {
    if(a[root].l == -1 && a[root].r == -1) return a[root].data;
    if(a[root].l == -1 && a[root].r != -1)  return "(" +  a[root].data + dfs(a[root].r) + ")";
    if(a[root].l != -1 && a[root].r != -1) return "(" +  dfs(a[root].l) + a[root].data + dfs(a[root].r) + ")";
}
int main() {
    int have[100] = {0}, n, root = 1;
    cin >> n;
    for(int i  = 1; i <= n; i++) {
        cin >> a[i].data >> a[i].l >> a[i].r;
        if(a[i].l != -1) have[a[i].l] = 1;
        if(a[i].r != -1) have[a[i].r] = 1;
    }
    while(have[root] == 1) root++;
    string ans = dfs(root);
    if(ans[0] == '(') ans = ans.substr(1,ans.size()-2);
    cout << ans;
    return 0;
}

#include <iostream>

using namespace std;

struct node {

string data;

int l, r;

}a[100];

string dfs(int root) {

if(a[root].l == -1 && a[root].r == -1) return a[root].data;

if(a[root].l == -1 && a[root].r != -1) return "(" + a[root].data + dfs(a[root].r) + ")";

if(a[root].l != -1 && a[root].r != -1) return "(" + dfs(a[root].l) + a[root].data + dfs(a[root].r) + ")";

}

int main() {

int have[100] = {0}, n, root = 1;

cin >> n;

for(int i = 1; i <= n; i++) {

cin >> a[i].data >> a[i].l >> a[i].r;

if(a[i].l != -1) have[a[i].l] = 1;

if(a[i].r != -1) have[a[i].r] = 1;

}

while(have[root] == 1) root++;

string ans = dfs(root);

if(ans[0] == '(') ans = ans.substr(1,ans.size()-2);

cout << ans;

return 0;

}