├── .gitignore └── src ├── 乙级 ├── 1026.c ├── 1001.c ├── 1021.c ├── 1049.c ├── 1009.c ├── 1011.c ├── 1006.c ├── 1010.c ├── 1022.c ├── 1036.c ├── 1016.c ├── 1033.c ├── 1070.cpp ├── 1038.c ├── 1046.c ├── 1047.c ├── 1029.cpp ├── 1023.c ├── 1040.cpp ├── 1008.c ├── 1037.c ├── 1042.c ├── 1069.cpp ├── 1004.c ├── 1043.c ├── 1039.cpp ├── 1030.cpp ├── 1007.c ├── 1002.c ├── 1013.c ├── 1019.cpp ├── 1027.c ├── 1084.cpp ├── 1032.c ├── 1060.c ├── 1064.cpp ├── 1041.c ├── 1094.cpp ├── 1090.cpp ├── 1031.c ├── 1028.cpp ├── 1045.cpp ├── 1005.cpp ├── 1065.cpp ├── 1054.cpp ├── 1024.c ├── 1075.cpp ├── 1089.cpp ├── 1003.cpp ├── 1059.c ├── 1014.c ├── 1025.cpp ├── 1020.cpp ├── 1048.c ├── 1050.cpp ├── 1055.cpp ├── 1017.cpp ├── 1080.cpp ├── 1012.cpp ├── 1018.c ├── 1085.cpp ├── 1015.cpp ├── 1044.cpp ├── 1079.cpp └── 1034.cpp └── 甲级 ├── 1104.cpp ├── 1050.cpp ├── 1144.cpp ├── 1117.cpp ├── 1008.cpp ├── 1125.cpp ├── 1113.cpp ├── 1054.cpp ├── 1084.cpp ├── 1093.cpp ├── 1001.cpp ├── 1058.cpp ├── 1027.cpp ├── 1031.cpp ├── 1038.cpp ├── 1049.cpp ├── 1132.cpp ├── 1005.cpp ├── 1120.cpp ├── 1041.cpp ├── 1040.cpp ├── 1065.cpp ├── 1092.cpp ├── 1085.cpp ├── 1124.cpp ├── 1002.cpp ├── 1069.cpp ├── 1140.cpp ├── 1045.cpp ├── 1071.cpp ├── 1006.cpp ├── 1138.cpp ├── 1011.cpp ├── 1064.cpp ├── 1128.cpp ├── 1152.cpp ├── 1015.cpp ├── 1048.cpp ├── 1032.cpp ├── 1051.cpp ├── 1063.cpp ├── 1149.cpp ├── 1029.cpp ├── 1046.cpp ├── 1019.cpp ├── 1112.cpp ├── 1067.cpp ├── 1009.cpp ├── 1121.cpp ├── 1007.cpp ├── 1101.cpp ├── 1134.cpp ├── 1157.cpp ├── 1042.cpp ├── 1156.cpp ├── 1096.cpp ├── 1004.cpp ├── 1077.cpp ├── 1047.cpp ├── 1073.cpp ├── 1146.cpp ├── 1154.cpp ├── 1119.cpp ├── 1083.cpp ├── 1044.cpp ├── 1079.cpp ├── 1060.cpp ├── 1052.cpp ├── 1108.cpp ├── 1090.cpp ├── 1129.cpp ├── 1162.cpp ├── 1103.cpp ├── 1122.cpp ├── 1155.cpp ├── 1094.cpp ├── 1013.cpp ├── 1133.cpp ├── 1106.cpp ├── 1037.cpp ├── 1068.cpp ├── 1061.cpp ├── 1135.cpp ├── 1148.cpp ├── 1116.cpp ├── 1028.cpp ├── 1074.cpp ├── 1115.cpp ├── 1039.cpp ├── 1126.cpp ├── 1097.cpp ├── 1010.cpp ├── 1070.cpp ├── 1036.cpp ├── 1020.cpp ├── 1056.cpp ├── 1105.cpp ├── 1109.cpp ├── 1163.cpp ├── 1082.cpp ├── 1076.cpp ├── 1139.cpp ├── 1147.cpp ├── 1130.cpp ├── 1035.cpp ├── 1161.cpp ├── 1081.cpp ├── 1057.cpp ├── 1078.cpp ├── 1022.cpp ├── 1118.cpp ├── 1142.cpp ├── 1137.cpp ├── 1059.cpp ├── 1053.cpp ├── 1014.cpp ├── 1141.cpp ├── 1023.cpp ├── 1062.cpp ├── 1110.cpp ├── 1012.cpp ├── 1017.cpp ├── 1160.cpp ├── 1086.cpp ├── 1003.cpp ├── 1021.cpp ├── 1100.cpp ├── 1034.cpp ├── 1107.cpp ├── 1055.cpp ├── 1030.cpp ├── 1099.cpp ├── 1127.cpp ├── 1024.cpp ├── 1145.cpp ├── 1136.cpp ├── 1025.cpp ├── 1033.cpp ├── 1088.cpp ├── 1091.cpp ├── 1102.cpp ├── 1158.cpp ├── 1080.cpp ├── 1075.cpp ├── 1150.cpp ├── 1143.cpp ├── 1066.cpp ├── 1114.cpp └── 1098.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | input.txt 2 | output.txt 3 | *.out 4 | *.out.dsYM 5 | .DS_Store 6 | .vscode 7 | -------------------------------------------------------------------------------- /src/乙级/1026.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int c1, c2; 5 | scanf("%d%d", &c1, &c2); 6 | int count = (double)(c2 - c1) / 100 + 0.5; 7 | printf("%02d:%02d:%02d\n", count / 3600, count % 3600 / 60, count % 60); 8 | return 0; 9 | } -------------------------------------------------------------------------------- /src/乙级/1001.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, step = 0; 5 | scanf("%d", &n); 6 | while (n != 1) { 7 | if (n % 2 == 0) n = n / 2; 8 | else n = (3 * n + 1) / 2; 9 | step++; 10 | } 11 | printf("%d\n", step); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /src/乙级/1021.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | char c; 5 | int count[10] = {}; 6 | while ((c = getchar()) != EOF) 7 | count[c - '0']++; 8 | for (int i = 0; i < 10; i++) 9 | if (count[i]) 10 | printf("%d:%d\n", i, count[i]); 11 | return 0; 12 | } -------------------------------------------------------------------------------- /src/乙级/1049.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | double num, sum = 0; 7 | for (int i = 1; i <= n; i++) { 8 | scanf("%lf", &num); 9 | sum += num * i * (n - i + 1); 10 | } 11 | printf("%.2f\n", sum); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /src/乙级/1009.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int count = 0; 5 | char words[85][85]; 6 | while ((scanf("%s", words[count])) != EOF) 7 | count++; 8 | for (int i = count - 1; i >= 0; i--) 9 | printf("%s%c", words[i], i > 0 ? ' ' : '\n'); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /src/乙级/1011.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int t, kase = 0; 5 | scanf("%d", &t); 6 | while (t--) { 7 | long long a, b, c; 8 | scanf("%lld%lld%lld", &a, &b, &c); 9 | printf("Case #%d: %s\n", ++kase, a + b > c ? "true" : "false"); 10 | } 11 | return 0; 12 | } -------------------------------------------------------------------------------- /src/甲级/1104.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | cin >> n; 7 | double num, sum = 0.0; 8 | for (int i = 1; i <= n; i++) { 9 | cin >> num; 10 | sum += num * i * (n - i + 1); 11 | } 12 | printf("%.2f\n", sum); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /src/乙级/1006.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n; 5 | scanf("%d", &n); 6 | for (int i = 0; i < n / 100; i++) 7 | printf("B"); 8 | for (int i = 0; i < n % 100 / 10; i++) 9 | printf("S"); 10 | for (int i = 1; i <= n % 10; i++) 11 | printf("%d", i); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /src/乙级/1010.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int c, e, flag = 0; 5 | while (scanf("%d%d", &c, &e) == 2) { 6 | if (e == 0) break; 7 | if (flag) putchar(' '); 8 | printf("%d %d", c * e, e - 1); 9 | flag = 1; 10 | } 11 | if (!flag) printf("0 0\n"); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /src/甲级/1050.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | string str1, str2, ans; 7 | getline(cin, str1); 8 | getline(cin, str2); 9 | set s; 10 | for (auto c : str2) s.insert(c); 11 | for (auto c : str1) if (!s.count(c)) ans += c; 12 | cout << ans; 13 | return 0; 14 | } -------------------------------------------------------------------------------- /src/乙级/1022.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int a, b, d; 5 | scanf("%d%d%d", &a, &b, &d); 6 | int sum = a + b; 7 | int result[35], count = 0; 8 | do { 9 | result[count++] = sum % d; 10 | sum /= d; 11 | } while (sum); 12 | for (int i = count - 1; i >= 0; i--) 13 | printf("%d", result[i]); 14 | } -------------------------------------------------------------------------------- /src/甲级/1144.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, num; 7 | set nums; 8 | cin >> n; 9 | while (n--) { 10 | cin >> num; 11 | nums.insert(num); 12 | } 13 | int ans = 1; 14 | while (nums.count(ans)) ans++; 15 | cout << ans << endl; 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/甲级/1117.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | int nums[n]; 9 | for (int i = 0; i < n; i++) cin >> nums[i]; 10 | sort(nums, nums + n, greater()); 11 | for (int i = 0; i < n; i++) 12 | if (i + 1 >= nums[i] - 1) { cout << nums[i] - 1; break; } 13 | return 0; 14 | } -------------------------------------------------------------------------------- /src/乙级/1036.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | char c; 5 | int col; 6 | scanf("%d %c", &col, &c); 7 | int row = (col + 1) / 2; 8 | for (int i = 0; i < row; i++) { 9 | printf("%c", c); 10 | for (int j = 0; j < col - 2; j++) 11 | printf("%c", i == 0 || i == row - 1 ? c : ' '); 12 | printf("%c\n", c); 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /src/甲级/1008.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n, dest, pos = 0, ans = 0; 6 | cin >> n; 7 | while (n--) { 8 | cin >> dest; 9 | if (dest > pos) ans += (dest - pos) * 6; 10 | else ans += (pos - dest) * 4; 11 | ans += 5; 12 | pos = dest; 13 | } 14 | cout << ans << endl; 15 | return 0; 16 | } -------------------------------------------------------------------------------- /src/乙级/1016.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int new_num(int num, int digit) { 4 | int sum = 0; 5 | while (num) { 6 | if (num % 10 == digit) 7 | sum = sum * 10 + digit; 8 | num /= 10; 9 | } 10 | return sum; 11 | } 12 | 13 | int main() { 14 | int a, da, b, db; 15 | scanf("%d%d%d%d", &a, &da, &b, &db); 16 | printf("%d\n", new_num(a, da) + new_num(b, db)); 17 | } -------------------------------------------------------------------------------- /src/甲级/1125.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | int nums[n]; 9 | for (int i = 0; i < n; i++) 10 | cin >> nums[i]; 11 | sort(nums, nums + n); 12 | int ans = nums[0]; 13 | for (int i = 1; i < n; i++) 14 | ans = (ans + nums[i]) / 2; 15 | cout << ans << endl; 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/乙级/1033.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char c; 6 | int invalid[128] = {}; 7 | while ((c = getchar()) != '\n') 8 | invalid[(int)c] = invalid[tolower(c)] = 1; 9 | while ((c = getchar()) != EOF) { 10 | if (invalid[c]) continue; 11 | if (isupper((int)c) && invalid['+']) continue; 12 | putchar(c); 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /src/乙级/1070.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | int nums[n]; 9 | for (int i = 0; i < n; i++) 10 | cin >> nums[i]; 11 | sort(nums, nums + n); 12 | int ans = nums[0]; 13 | for (int i = 1; i < n; i++) 14 | ans = (ans + nums[i]) / 2; 15 | cout << (int)ans << endl; 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/乙级/1038.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, k, score; 5 | int count[101] = {}; 6 | scanf("%d", &n); 7 | while (n--) { 8 | scanf("%d", &score); 9 | count[score]++; 10 | } 11 | scanf("%d", &k); 12 | for (int i = 0; i < k; i++) { 13 | scanf("%d", &score); 14 | printf("%d%c", count[score], i < k - 1 ? ' ' : '\n'); 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/甲级/1113.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, ans = 0; 7 | cin >> n; 8 | int nums[n]; 9 | for (int i = 0; i < n; i++) cin >> nums[i]; 10 | sort(nums, nums + n, greater()); 11 | for (int i = 0; i < n; i++) 12 | ans += i < (n + 1) / 2 ? nums[i] : -nums[i]; 13 | printf("%d %d\n", n & 1, ans); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /src/乙级/1046.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, count_a = 0, count_b = 0; 5 | scanf("%d", &n); 6 | while (n--) { 7 | int a1, a2, b1, b2; 8 | scanf("%d%d%d%d", &a1, &a2, &b1, &b2); 9 | int sum = a1 + b1; 10 | count_a += sum != a2 && sum == b2; 11 | count_b += sum == a2 && sum != b2; 12 | } 13 | printf("%d %d\n", count_a, count_b); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /src/甲级/1054.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int m, n, color; 7 | cin >> m >> n; 8 | int total = m * n; 9 | map count; 10 | for (int i = 0; i < total; i++) 11 | { cin >> color; count[color]++; } 12 | for (auto pair : count) 13 | if (pair.second > total / 2) 14 | cout << pair.first; 15 | return 0; 16 | } -------------------------------------------------------------------------------- /src/乙级/1047.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, team, id, score; 5 | int total[1005] = {}; 6 | scanf("%d", &n); 7 | while (n--) { 8 | scanf("%d-%d %d", &team, &id, &score); 9 | total[team] += score; 10 | } 11 | int max = 0; 12 | for (int i = 1; i <= 1000; i++) 13 | max = total[i] > total[max] ? i : max; 14 | printf("%d %d\n", max, total[max]); 15 | return 0; 16 | } -------------------------------------------------------------------------------- /src/乙级/1029.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | string s1, s2; 7 | cin >> s1 >> s2; 8 | set printed; 9 | for (int i = 0, j = 0; i < s1.size(); i++, j++) { 10 | while (s1[i] != s2[j]) { 11 | char c = toupper(s1[i++]); 12 | if (!printed.count(c)) cout << c; 13 | printed.insert(c); 14 | } 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/甲级/1084.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | string s1, s2; 7 | cin >> s1 >> s2; 8 | set printed; 9 | for (int i = 0, j = 0; i < s1.size(); i++, j++) { 10 | while (s1[i] != s2[j]) { 11 | char c = toupper(s1[i++]); 12 | if (!printed.count(c)) cout << c; 13 | printed.insert(c); 14 | } 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/乙级/1023.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int count[10]; 5 | for (int i = 0; i < 10; i++) 6 | scanf("%d", &count[i]); 7 | for (int i = 1; i < 10; i++) { 8 | if (count[i]) { 9 | printf("%d", i); 10 | count[i]--; 11 | break; 12 | } 13 | } 14 | for (int i = 0; i < 10; i++) 15 | while (count[i]--) 16 | printf("%d", i); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /src/乙级/1040.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string s; 6 | cin >> s; 7 | int nump = 0, numt = 0, result = 0; 8 | for (auto c : s) numt += (c == 'T'); 9 | for (auto c : s) { 10 | switch(c) { 11 | case 'P' : nump++; break; 12 | case 'T' : numt--; break; 13 | case 'A' : result = (result + nump * numt) % 1000000007; 14 | } 15 | } 16 | cout << result; 17 | } -------------------------------------------------------------------------------- /src/甲级/1093.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string s; 6 | cin >> s; 7 | int nump = 0, numt = 0, result = 0; 8 | for (auto c : s) numt += (c == 'T'); 9 | for (auto c : s) { 10 | switch(c) { 11 | case 'P' : nump++; break; 12 | case 'T' : numt--; break; 13 | case 'A' : result = (result + nump * numt) % 1000000007; 14 | } 15 | } 16 | cout << result; 17 | } -------------------------------------------------------------------------------- /src/甲级/1001.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int a, b; 6 | cin >> a >> b; 7 | int sum = a + b; 8 | if (sum < 0) { 9 | cout << '-'; 10 | sum *= -1; 11 | } 12 | string str = to_string(sum); 13 | int n = str.length(); 14 | for (int i = 0; i < n; i++) { 15 | cout << str[i]; 16 | if (i != n - 1 && (n - 1 - i) % 3 == 0) cout << ','; 17 | } 18 | return 0; 19 | } -------------------------------------------------------------------------------- /src/甲级/1058.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int g2k = 17 * 29; 5 | const int s2k = 29; 6 | 7 | int main() { 8 | int g1, s1, k1, g2, s2, k2; 9 | scanf("%d.%d.%d %d.%d.%d", &g1, &s1, &k1, &g2, &s2, &k2); 10 | long long n1 = g1 * g2k + s1 * s2k + k1; 11 | long long n2 = g2 * g2k + s2 * s2k + k2; 12 | long long sum = n1 + n2; 13 | printf("%lld.%lld.%lld\n", sum / g2k, sum % g2k / s2k, sum % s2k); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /src/甲级/1027.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int BASE = 13; 5 | const char num2char[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C'}; 6 | 7 | int main() { 8 | int r, g, b; 9 | cin >> r >> g >> b; 10 | printf("#%c%c", num2char[r / BASE], num2char[r % BASE]); 11 | printf("%c%c", num2char[g / BASE], num2char[g % BASE]); 12 | printf("%c%c\n", num2char[b / BASE], num2char[b % BASE]); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /src/甲级/1031.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string s; 6 | cin >> s; 7 | int n = s.size(); 8 | int n1 = (n + 2) / 3, n2 = n + 2 - 2 * n1; 9 | for (int i = 0; i < n1 - 1; i++) { 10 | cout << s[i]; 11 | for (int j = 0; j < n2 - 2; j++) 12 | cout << ' '; 13 | cout << s[n - i - 1] << endl; 14 | } 15 | for (int i = 0; i < n2; i++) 16 | cout << s[i + n1 - 1]; 17 | return 0; 18 | } -------------------------------------------------------------------------------- /src/乙级/1008.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int n, m, count = 0; 5 | scanf("%d%d", &n, &m); 6 | m %= n; 7 | int nums[n]; 8 | for (int i = 0; i < n; i++) 9 | scanf("%d", &nums[i]); 10 | for (int i = n - m; i < n; i++) { 11 | printf("%d", nums[i]); 12 | if (++count < n) printf(" "); 13 | } 14 | for (int i = 0; i < n - m; i++) { 15 | printf("%d", nums[i]); 16 | if (++count < n) printf(" "); 17 | } 18 | return 0; 19 | } -------------------------------------------------------------------------------- /src/乙级/1037.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define g2k (17 * 29) 4 | #define s2k 29 5 | 6 | int main() { 7 | int g1, s1, k1, g2, s2, k2; 8 | scanf("%d.%d.%d %d.%d.%d", &g1, &s1, &k1, &g2, &s2, &k2); 9 | int money = g1 * g2k + s1 * s2k + k1; 10 | int price = g2 * g2k + s2 * s2k + k2; 11 | int change = price - money; 12 | if (change < 0) { 13 | printf("-"); 14 | change *= -1; 15 | } 16 | printf("%d.%d.%d\n", change / g2k, change % g2k / s2k, change % s2k); 17 | } -------------------------------------------------------------------------------- /src/甲级/1038.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | string nums[n], ans; 9 | for (int i = 0; i < n; i++) cin >> nums[i]; 10 | sort(nums, nums + n, [](string a, string b) { 11 | return a + b < b + a; 12 | }); 13 | for (auto num : nums) ans += num; 14 | while (ans.front() == '0') 15 | ans.erase(ans.begin()); 16 | cout << (ans.empty() ? "0" : ans) << endl; 17 | return 0; 18 | } -------------------------------------------------------------------------------- /src/甲级/1049.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n, m = 1, ans = 0; 6 | cin >> n; 7 | while (n / m) { 8 | int left = n / m / 10; 9 | int digit = n / m % 10; 10 | int right = n % m; 11 | if (digit == 0) ans += left * m; 12 | else if (digit == 1) ans += left * m + right + 1; 13 | else ans += left * m + m; 14 | m *= 10; 15 | } 16 | cout << ans << endl; 17 | return 0; 18 | } -------------------------------------------------------------------------------- /src/甲级/1132.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool judge(int num) { 6 | string tmp = to_string(num); 7 | int a = stoi(tmp.substr(0, tmp.size() / 2)); 8 | int b = stoi(tmp.substr(tmp.size() / 2)); 9 | return a * b != 0 && num % (a * b) == 0; 10 | } 11 | 12 | int main() { 13 | int n, num; 14 | cin >> n; 15 | while (n--) { 16 | cin >> num; 17 | cout << (judge(num) ? "Yes" : "No") << endl; 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /src/乙级/1042.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define ALPHA_NUM 26 5 | 6 | int main() { 7 | char c; 8 | int count[ALPHA_NUM] = {}; 9 | while ((c = getchar()) != EOF) 10 | if (isalpha(c)) count[tolower(c) - 'a']++; 11 | int max = 0; 12 | for (int i = 0; i < ALPHA_NUM; i++) 13 | max = count[i] > max ? count[i] : max; 14 | for (int i = 0; i < ALPHA_NUM; i++) 15 | if (count[i] == max) { printf("%c %d\n", i + 'a', count[i]); break; } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /src/甲级/1005.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string spells[] = { 5 | "zero", "one", "two", "three", "four", 6 | "five", "six", "seven", "eight", "nine" 7 | }; 8 | 9 | int main() { 10 | int sum = 0; 11 | string num; 12 | cin >> num; 13 | for (auto c : num) sum += (c - '0'); 14 | string digits = to_string(sum); 15 | for (int i = 0; i < digits.size(); i++) 16 | cout << spells[digits[i] - '0'] << (i < digits.size() - 1 ? ' ' : '\n'); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /src/甲级/1120.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | set s; 9 | while (n--) { 10 | string num; 11 | int sum = 0; 12 | cin >> num; 13 | for (auto c : num) sum += c - '0'; 14 | s.insert(sum); 15 | } 16 | cout << s.size() << endl; 17 | for (auto it = s.begin(); it != s.end(); it++) { 18 | if (it != s.begin()) cout << ' '; 19 | cout << *it; 20 | } 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/乙级/1069.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, start; 7 | cin >> n >> m >> start; 8 | string v[n + 1]; 9 | set s; 10 | for (int i = 1; i <= n; i++) 11 | cin >> v[i]; 12 | for (int i = start; i <= n; i += m) { 13 | while (i <= n && s.count(v[i])) i++; 14 | if (i > n) break; 15 | cout << v[i] << endl; 16 | s.insert(v[i]); 17 | } 18 | if (start > n) cout << "Keep going..." << endl; 19 | return 0; 20 | } -------------------------------------------------------------------------------- /src/甲级/1041.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | int nums[n]; 9 | map count; 10 | for (int i = 0; i < n; i++) { 11 | cin >> nums[i]; 12 | count[nums[i]]++; 13 | } 14 | bool found = false; 15 | for (auto num : nums) { 16 | if (count[num] == 1) { 17 | cout << num; 18 | found = true; 19 | break; 20 | } 21 | } 22 | if (!found) cout << "None"; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/乙级/1004.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | struct Student { 4 | char name[11]; 5 | char id[11]; 6 | int score; 7 | } tmp, max, min; 8 | 9 | int main() { 10 | int n; 11 | scanf("%d", &n); 12 | max.score = -1; 13 | min.score = 101; 14 | while (n--) { 15 | scanf("%s%s%d", tmp.name, tmp.id, &tmp.score); 16 | if (tmp.score > max.score) max = tmp; 17 | if (tmp.score < min.score) min = tmp; 18 | } 19 | printf("%s %s\n", max.name, max.id); 20 | printf("%s %s\n", min.name, min.id); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/乙级/1043.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define LEN 6 4 | 5 | int main() { 6 | char c, str[] = "PATest"; 7 | int count[LEN] = {}; 8 | while ((c = getchar()) != '\n') 9 | for (int i = 0; i < LEN; i++) 10 | if (str[i] == c) count[i]++; 11 | int flag = 1; 12 | while (flag) { 13 | flag = 0; 14 | for (int i = 0; i < LEN; i++) { 15 | if (count[i] <= 0) continue; 16 | putchar(str[i]); 17 | count[i]--; 18 | flag = 1; 19 | } 20 | } 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/甲级/1040.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int expand(int c1, int c2, const string &str) { 5 | int l = c1, r = c2; 6 | while (l >= 0 && r < str.size() && str[l] == str[r]) 7 | l--, r++; 8 | return r - l - 1; 9 | } 10 | 11 | int main() { 12 | string str; 13 | getline(cin, str); 14 | int ans = 1; 15 | for (int i = 0; i < str.size() - 1; i++) { 16 | ans = max(expand(i, i, str), ans); 17 | ans = max(expand(i, i + 1, str), ans); 18 | } 19 | cout << ans << endl; 20 | return 0; 21 | } -------------------------------------------------------------------------------- /src/甲级/1065.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int t, kase = 0; 6 | cin >> t; 7 | while (t--) { 8 | bool greater; 9 | long long a, b, c; 10 | cin >> a >> b >> c; 11 | if (a > 0 && b > 0 && a + b < 0) 12 | greater = true; 13 | else if (a < 0 && b < 0 && a + b >= 0) 14 | greater = false; 15 | else 16 | greater = a + b > c; 17 | printf("Case #%d: %s\n", ++kase, (greater ? "true" : "false")); 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /src/乙级/1039.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | string str1, str2; 7 | cin >> str1 >> str2; 8 | multiset set1, set2; 9 | for (auto c : str2) set2.insert(c); 10 | for (auto c : str1) { 11 | if (set2.count(c)) { 12 | set1.insert(c); 13 | set2.erase(set2.find(c)); // 仅删去第一个元素 14 | } 15 | } 16 | if (set2.empty()) 17 | printf("Yes %lu\n", str1.size() - str2.size()); 18 | else 19 | printf("No %lu\n", set2.size()); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /src/甲级/1092.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | string str1, str2; 7 | cin >> str1 >> str2; 8 | multiset set1, set2; 9 | for (auto c : str2) set2.insert(c); 10 | for (auto c : str1) { 11 | if (set2.count(c)) { 12 | set1.insert(c); 13 | set2.erase(set2.find(c)); // 仅删去第一个元素 14 | } 15 | } 16 | if (set2.empty()) 17 | printf("Yes %lu\n", str1.size() - str2.size()); 18 | else 19 | printf("No %lu\n", set2.size()); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /src/乙级/1030.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, p; 8 | cin >> n >> p; 9 | vector nums(n); 10 | for (int i = 0; i < n; i++) 11 | cin >> nums[i]; 12 | sort(nums.begin(), nums.end()); 13 | 14 | int ans = 0; 15 | for (auto i = nums.begin(); i != nums.end(); i++) { 16 | auto j = upper_bound(nums.begin(), nums.end(), (long long)*i * p); 17 | ans = max((int)(j - i), ans); 18 | } 19 | 20 | cout << ans << endl; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/甲级/1085.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, p; 8 | cin >> n >> p; 9 | vector nums(n); 10 | for (int i = 0; i < n; i++) 11 | cin >> nums[i]; 12 | sort(nums.begin(), nums.end()); 13 | 14 | int ans = 0; 15 | for (auto i = nums.begin(); i != nums.end(); i++) { 16 | auto j = upper_bound(nums.begin(), nums.end(), (long long)*i * p); 17 | ans = max((int)(j - i), ans); 18 | } 19 | 20 | cout << ans << endl; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/甲级/1124.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, start; 7 | cin >> n >> m >> start; 8 | string names[n + 1]; 9 | set marked; 10 | for (int i = 1; i <= n; i++) 11 | cin >> names[i]; 12 | for (int i = start; i <= n; i += m) { 13 | while (i <= n && marked.count(names[i])) i++; 14 | if (i > n) break; 15 | cout << names[i] << endl; 16 | marked.insert(names[i]); 17 | } 18 | if (start > n) cout << "Keep going..." << endl; 19 | return 0; 20 | } -------------------------------------------------------------------------------- /src/乙级/1007.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n, is_prime[100005]; 6 | scanf("%d", &n); 7 | for (int i = 2; i < n + 1; i++) 8 | is_prime[i] = 1; 9 | 10 | int limit = sqrt(n); 11 | for (int i = 2; i <= limit; i++) { 12 | if (!is_prime[i]) continue; 13 | for (int j = i * i; j <= n; j += i) 14 | is_prime[j] = 0; 15 | } 16 | int count = 0; 17 | for (int i = 3; i <= n - 2; i += 2) 18 | count += (is_prime[i] && is_prime[i + 2]); 19 | printf("%d", count); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /src/甲级/1002.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int E = 1005; 5 | double res[E]; 6 | 7 | int main() { 8 | int k, e, count = 0; 9 | double c; 10 | cin >> k; 11 | while (k--) { 12 | cin >> e >> c; 13 | res[e] += c; 14 | } 15 | cin >> k; 16 | while (k--) { 17 | cin >> e >> c; 18 | res[e] += c; 19 | } 20 | for (auto c : res) count += (c != 0.0); 21 | printf("%d", count); 22 | for (int i = E; i >= 0; i--) 23 | if (res[i] != 0.0) printf(" %d %.1f", i, res[i]); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/乙级/1002.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | char spells[][5] = { "ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu", "shi" }; 6 | char nums[105]; 7 | scanf("%s", nums); 8 | int sum = 0, len = strlen(nums); 9 | for (int i = 0; i < len; i++) 10 | sum += nums[i] - '0'; 11 | int idx = 0, res[5]; 12 | while (sum) { 13 | res[idx++] = sum % 10; 14 | sum /= 10; 15 | } 16 | for (int i = idx - 1; i >= 0; i--) 17 | printf("%s%c", spells[res[i]], i > 0 ? ' ' : '\n'); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /src/乙级/1013.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAXN 1000005 4 | 5 | int primes[MAXN]; 6 | int not_prime[MAXN]; 7 | 8 | int main() { 9 | int m, n, count = 0; 10 | scanf("%d%d", &m, &n); 11 | 12 | while (count < n) { 13 | for (int i = 2; count < n; i++) { 14 | if (not_prime[i]) continue; 15 | for (int j = i * i; j < MAXN; j += i) 16 | not_prime[j] = 1; 17 | primes[++count] = i; 18 | } 19 | } 20 | for (int i = m; i <= n; i++) 21 | printf("%d%c", primes[i], (i - m + 1) % 10 && i != n ? ' ' : '\n'); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /src/乙级/1019.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int num; 8 | cin >> num; 9 | do { 10 | string tmp = to_string(num); 11 | tmp.insert(0, 4 - tmp.size(), '0'); 12 | sort(tmp.begin(), tmp.end(), greater()); 13 | int num1 = stoi(tmp); 14 | sort(tmp.begin(), tmp.end(), less()); 15 | int num2 = stoi(tmp); 16 | printf("%04d - %04d = %04d\n", num1, num2, num = num1 - num2); 17 | } while (num != 6174 && num != 0); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /src/乙级/1027.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int total_char(int row) { return (row * row + 2 * row - 1) / 2; } 5 | 6 | int main() { 7 | char c; 8 | int n, row; 9 | scanf("%d %c", &n, &c); 10 | for (row = 1; total_char(row + 2) <= n; row += 2); 11 | for (int i = 0; i < row; i++) { 12 | for (int j = 0; j < row / 2 - abs(i - row / 2); j++) 13 | putchar(' '); 14 | for (int j = 0; j < abs(row - 1 - 2 * i) + 1; j++) 15 | putchar(c); 16 | putchar('\n'); 17 | } 18 | printf("%d\n", n - total_char(row)); 19 | } -------------------------------------------------------------------------------- /src/甲级/1069.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int num; 8 | cin >> num; 9 | do { 10 | string tmp = to_string(num); 11 | tmp.insert(0, 4 - tmp.size(), '0'); 12 | sort(tmp.begin(), tmp.end(), greater()); 13 | int num1 = stoi(tmp); 14 | sort(tmp.begin(), tmp.end(), less()); 15 | int num2 = stoi(tmp); 16 | printf("%04d - %04d = %04d\n", num1, num2, num = num1 - num2); 17 | } while (num != 6174 && num != 0); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /src/乙级/1084.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string describe(const string &num) { 5 | string res; 6 | for (int i = 0; i < num.size();) { 7 | char c = num[i]; 8 | int count = 0; 9 | while (i < num.size() && num[i] == c) { 10 | i++; 11 | count++; 12 | } 13 | res += c + to_string(count); 14 | } 15 | return res; 16 | } 17 | 18 | int main() { 19 | int n; 20 | string ans; 21 | cin >> ans >> n; 22 | while (--n) ans = describe(ans); 23 | cout << ans << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/甲级/1140.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string describe(const string &num) { 5 | string res; 6 | for (int i = 0; i < num.size();) { 7 | char c = num[i]; 8 | int count = 0; 9 | while (i < num.size() && num[i] == c) { 10 | i++; 11 | count++; 12 | } 13 | res += c + to_string(count); 14 | } 15 | return res; 16 | } 17 | 18 | int main() { 19 | int n; 20 | string ans; 21 | cin >> ans >> n; 22 | while (--n) ans = describe(ans); 23 | cout << ans << endl; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/乙级/1032.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int n; 6 | scanf("%d", &n); 7 | int total_score[n + 1]; 8 | memset(total_score, 0, sizeof(total_score)); 9 | for (int i = 0; i < n; i++) { 10 | int id, score; 11 | scanf("%d%d", &id, &score); 12 | total_score[id] += score; 13 | } 14 | int top = 0, top_id; 15 | for (int i = 1; i <= n; i++) { 16 | if (total_score[i] > top) { 17 | top_id = i; 18 | top = total_score[i]; 19 | } 20 | } 21 | printf("%d %d\n", top_id, top); 22 | } -------------------------------------------------------------------------------- /src/甲级/1045.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int N = 205, L = 10005; 5 | int s1[N], s2[L], dp[N][L]; 6 | 7 | int main() { 8 | int n, m, l; 9 | cin >> n >> m; 10 | for (int i = 1; i <= m; i++) cin >> s1[i]; 11 | cin >> l; 12 | for (int i = 1; i <= l; i++) cin >> s2[i]; 13 | 14 | for (int i = 1; i <= m; i++) { 15 | for (int j = 1; j <= l; j++) { 16 | int tmp = max(dp[i-1][j], dp[i][j-1]); 17 | dp[i][j] = s1[i] == s2[j] ? tmp + 1 : tmp; 18 | } 19 | } 20 | cout << dp[m][l] << endl; 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/甲级/1071.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | char c; 8 | string word; 9 | map count; 10 | while ((c = getchar()) != EOF) { 11 | if (isalnum(c)) { 12 | word += tolower(c); 13 | } else if (!word.empty()) { 14 | count[word]++; 15 | word.clear(); 16 | } 17 | } 18 | string max; 19 | for (auto pair : count) 20 | max = pair.second > count[max] ? pair.first : max; 21 | cout << max << " " << count[max]; 22 | return 0; 23 | } -------------------------------------------------------------------------------- /src/乙级/1060.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int compare(const void* a, const void* b) { 5 | int arg1 = *(const int*)a; 6 | int arg2 = *(const int*)b; 7 | if (arg1 > arg2) return -1; 8 | if (arg1 < arg2) return +1; 9 | return 0; 10 | } 11 | 12 | int main() { 13 | int n; 14 | scanf("%d", &n); 15 | int miles[n]; 16 | for (int i = 0; i < n; i++) 17 | scanf("%d", &miles[i]); 18 | qsort(miles, n, sizeof(int), compare); 19 | int res = 1; 20 | while (res <= n && res < miles[res - 1]) res++; 21 | printf("%d\n", --res); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /src/甲级/1006.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int m; 6 | cin >> m; 7 | string first_id, first_time = "23:59:59"; 8 | string last_id, last_time = "00:00:00"; 9 | while (m--) { 10 | string id, in, out; 11 | cin >> id >> in >> out; 12 | if (in < first_time) { 13 | first_id = id; 14 | first_time = in; 15 | } 16 | if (out > last_time) { 17 | last_id = id; 18 | last_time = out; 19 | } 20 | } 21 | cout << first_id << " " << last_id << endl; 22 | return 0; 23 | } -------------------------------------------------------------------------------- /src/甲级/1138.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int flag, ans; 5 | 6 | void dfs(int *pre, int *in, int n) { 7 | if (n <= 0) return; 8 | int i = 0; 9 | while (i < n && in[i] != *pre) i++; 10 | dfs(pre + 1, in, i); 11 | dfs(pre + i + 1, in + i + 1, n - i - 1); 12 | if (!flag) { flag = 1; ans = *pre; } 13 | } 14 | 15 | int main() { 16 | int n; 17 | cin >> n; 18 | int pre[n], in[n]; 19 | for (int i = 0; i < n; i++) cin >> pre[i]; 20 | for (int i = 0; i < n; i++) cin >> in[i]; 21 | dfs(pre, in, n); 22 | cout << ans << endl; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/乙级/1064.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int digit_sum(int num) { 6 | int res = 0; 7 | while (num) { 8 | res += num % 10; 9 | num /= 10; 10 | } 11 | return res; 12 | } 13 | 14 | int main() { 15 | set s; 16 | int n, num; 17 | cin >> n; 18 | while (n--) { 19 | cin >> num; 20 | s.insert(digit_sum(num)); 21 | } 22 | cout << s.size() << endl; 23 | for (auto it = s.begin(); it != s.end(); it++) { 24 | if (it != s.begin()) cout << ' '; 25 | cout << *it; 26 | } 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/甲级/1011.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | char num2char[] = {'W', 'T', 'L'}; 6 | double total_odd = 1.0; 7 | for (int i = 0; i < 3; i++) { 8 | int index = -1; 9 | double odd, max_odd = 0.0; 10 | for (int j = 0; j < 3; j++) { 11 | cin >> odd; 12 | if (odd > max_odd) { 13 | max_odd = odd; 14 | index = j; 15 | } 16 | } 17 | total_odd *= max_odd; 18 | printf("%c ", num2char[index]); 19 | } 20 | printf("%.2f\n", (total_odd * 0.65 - 1) * 2); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/甲级/1064.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int MAX_N = 1005; 6 | 7 | int n, cnt = 0; 8 | int tree[MAX_N], keys[MAX_N]; 9 | 10 | void in_order(int idx) { 11 | if (idx >= n) return; 12 | in_order(idx * 2 + 1); 13 | tree[idx] = keys[cnt++]; 14 | in_order(idx * 2 + 2); 15 | } 16 | 17 | int main() { 18 | cin >> n; 19 | for (int i = 0; i < n; i++) 20 | cin >> keys[i]; 21 | 22 | sort(keys, keys + n); 23 | in_order(0); 24 | 25 | for (int i = 0; i < n; i++) 26 | cout << tree[i] << (i < n - 1 ? ' ' : '\n'); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/乙级/1041.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | struct Student { 4 | long long id; 5 | int exam_num; 6 | }; 7 | 8 | int main() { 9 | long long id; 10 | int n, m, test_num, exam_num; 11 | scanf("%d", &n); 12 | struct Student students[n + 1]; 13 | while (n--) { 14 | scanf("%lld%d%d", &id, &test_num, &exam_num); 15 | students[test_num].id = id; 16 | students[test_num].exam_num = exam_num; 17 | } 18 | scanf("%d", &m); 19 | while (m--) { 20 | scanf("%d", &test_num); 21 | printf("%lld %d\n", students[test_num].id, students[test_num].exam_num); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/乙级/1094.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_prime(int num) { 6 | if (num < 3) return num == 2; 7 | if (num % 2 == 0) return false; 8 | for (int i = 3; i <= num / i; i += 2) 9 | if (num % i == 0) return false; 10 | return true; 11 | } 12 | 13 | int main() { 14 | bool found = false; 15 | int l, k; 16 | string num, ans; 17 | cin >> l >> k >> num; 18 | for (int i = 0; i <= l - k && !found; i++) { 19 | ans = num.substr(i, k); 20 | if (is_prime(stoi(ans))) found = true; 21 | } 22 | cout << (found ? ans : "404") << endl; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/甲级/1128.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool judge(const vector &pos) { 6 | for (int i = 0; i < pos.size(); i++) 7 | for (int j = i + 1; j < pos.size(); j++) 8 | if (pos[i] == pos[j] || abs(pos[j] - pos[i]) == j - i) 9 | return false; 10 | return true; 11 | } 12 | 13 | int main() { 14 | int k, n; 15 | cin >> k; 16 | while (k--) { 17 | cin >> n; 18 | vector pos(n); 19 | for (int i = 0; i < n; i++) 20 | cin >> pos[i]; 21 | cout << (judge(pos) ? "YES" : "NO") << endl; 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/甲级/1152.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_prime(int num) { 6 | if (num < 3) return num == 2; 7 | if (num % 2 == 0) return false; 8 | for (int i = 3; i <= num / i; i += 2) 9 | if (num % i == 0) return false; 10 | return true; 11 | } 12 | 13 | int main() { 14 | bool found = false; 15 | int l, k; 16 | string num, ans; 17 | cin >> l >> k >> num; 18 | for (int i = 0; i <= l - k && !found; i++) { 19 | ans = num.substr(i, k); 20 | if (is_prime(stoi(ans))) found = true; 21 | } 22 | cout << (found ? ans : "404") << endl; 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/甲级/1015.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_prime(int n) { 6 | if (n < 3) return n == 2; 7 | if (n % 2 == 0) return false; 8 | for (int i = 3; i <= n / i; i += 2) 9 | if (n % i == 0) return false; 10 | return true; 11 | } 12 | 13 | int inverse(int n, int d) { 14 | int res = 0; 15 | while (n) { 16 | res = res * d + n % d; 17 | n /= d; 18 | } 19 | return res; 20 | } 21 | 22 | int main() { 23 | int n, d; 24 | while (cin >> n >> d && n > 0) 25 | cout << (is_prime(n) && is_prime(inverse(n, d)) ? "Yes" : "No") << endl; 26 | return 0; 27 | } -------------------------------------------------------------------------------- /src/甲级/1048.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, coin; 7 | cin >> n >> m; 8 | map count; 9 | while (n--) { 10 | cin >> coin; 11 | count[coin]++; 12 | } 13 | bool found = false; 14 | for (auto pair : count) { 15 | coin = pair.first; 16 | if (count.count(m - coin)) { 17 | if (coin == m - coin && count[coin] == 1) continue; 18 | cout << coin << " " << m - coin; 19 | found = true; 20 | break; 21 | } 22 | } 23 | if (!found) cout << "No Solution"; 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/甲级/1032.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct Node { 5 | bool flag; 6 | char data; 7 | int next; 8 | } nodes[100005]; 9 | 10 | int main() { 11 | int head1, head2, n, addr; 12 | cin >> head1 >> head2 >> n; 13 | while (n--) cin >> addr >> nodes[addr].data >> nodes[addr].next; 14 | while (head1 != -1) { 15 | nodes[head1].flag = true; 16 | head1 = nodes[head1].next; 17 | } 18 | while (head2 != -1) { 19 | if (nodes[head2].flag) break; 20 | head2 = nodes[head2].next; 21 | } 22 | if (head2 != -1) printf("%05d\n", head2); 23 | else printf("-1\n"); 24 | } -------------------------------------------------------------------------------- /src/甲级/1051.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int m, n, k; 7 | cin >> m >> n >> k; 8 | while (k--) { 9 | stack s; 10 | bool valid = true; 11 | int push_val = 1, pop_val; 12 | for (int i = 0; i < n; i++) { 13 | cin >> pop_val; 14 | while (push_val <= n && (s.empty() || s.top() != pop_val)) 15 | s.push(push_val++); 16 | if (s.size() > m) valid = false; 17 | if (!s.empty() && s.top() == pop_val) s.pop(); 18 | } 19 | cout << (valid && s.empty() ? "YES" : "NO") << endl; 20 | } 21 | return 0; 22 | } -------------------------------------------------------------------------------- /src/甲级/1063.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m, k, num; 8 | cin >> n; 9 | vector> sets(n+1); 10 | for (int i = 1; i <= n; i++) { 11 | cin >> m; 12 | while (m--) { 13 | cin >> num; 14 | sets[i].insert(num); 15 | } 16 | } 17 | cin >> k; 18 | while (k--) { 19 | int i, j, count = 0; 20 | cin >> i >> j; 21 | for (auto num : sets[i]) 22 | count += sets[j].count(num); 23 | printf("%.1f%%\n", 100.0 * count / (sets[i].size() + sets[j].size() - count)); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /src/乙级/1090.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, k, a, b; 7 | cin >> n >> m; 8 | set> pairs; 9 | while (n--) { 10 | cin >> a >> b; 11 | pairs.insert({a, b}); 12 | } 13 | while (m--) { 14 | bool flag = true; 15 | set s; 16 | cin >> k; 17 | while (k--) { 18 | cin >> a; 19 | s.insert(a); 20 | } 21 | for (auto pair : pairs) 22 | if (s.count(pair.first) && s.count(pair.second)) 23 | flag = false; 24 | cout << (flag ? "Yes" : "No") << endl; 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /src/甲级/1149.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, k, a, b; 7 | cin >> n >> m; 8 | set> pairs; 9 | while (n--) { 10 | cin >> a >> b; 11 | pairs.insert({a, b}); 12 | } 13 | while (m--) { 14 | bool flag = true; 15 | set s; 16 | cin >> k; 17 | while (k--) { 18 | cin >> a; 19 | s.insert(a); 20 | } 21 | for (auto pair : pairs) 22 | if (s.count(pair.first) && s.count(pair.second)) 23 | flag = false; 24 | cout << (flag ? "Yes" : "No") << endl; 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /src/甲级/1029.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n, m; 6 | scanf("%d", &n); 7 | int nums[n]; 8 | for (int i = 0; i < n; i++) scanf("%d", &nums[i]); 9 | scanf("%d", &m); 10 | int j = 0, count = 0, median = (n + m + 1) / 2; 11 | for (int i = 0; i < m; i++) { 12 | int temp; 13 | scanf("%d", &temp); 14 | while (j < n && temp > nums[j]) { 15 | if (++count == median) cout << nums[j]; 16 | j++; 17 | } 18 | if (++count == median) cout << temp; 19 | } 20 | while (count < median) { 21 | if (++count == median) cout << nums[j]; 22 | j++; 23 | } 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/甲级/1046.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m, dist; 8 | scanf("%d", &n); 9 | vector accumulate_dist(n + 2); 10 | for (int i = 1; i <= n; i++) { 11 | scanf("%d", &dist); 12 | // accumulate_dist[n + 1] 为圆环总距离 13 | accumulate_dist[i + 1] = accumulate_dist[i] + dist; 14 | } 15 | scanf("%d", &m); 16 | while (m--) { 17 | int a, b; 18 | scanf("%d%d", &a, &b); 19 | if (a > b) swap(a, b); 20 | dist = accumulate_dist[b] - accumulate_dist[a]; 21 | printf("%d\n", min(accumulate_dist[n + 1] - dist, dist)); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /src/甲级/1019.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_palindromic(const vector &digits) { 6 | int n = digits.size(); 7 | for (int i = 0; i <= n / 2; i++) 8 | if (digits[i] != digits[n - i - 1]) 9 | return false; 10 | return true; 11 | } 12 | 13 | int main() { 14 | int num, base; 15 | cin >> num >> base; 16 | vector digits; 17 | do { 18 | digits.push_back(num % base); 19 | num /= base; 20 | } while (num); 21 | cout << (is_palindromic(digits) ? "Yes" : "No") << endl; 22 | for (int i = digits.size() - 1; i >= 0; i--) 23 | cout << digits[i] << (i > 0 ? ' ' : '\n'); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/甲级/1112.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int ASCII = 128; 6 | vector stuck(ASCII, true); 7 | vector marked(ASCII, false); 8 | 9 | int main() { 10 | int k; 11 | string str; 12 | cin >> k >> str; 13 | for (int i = 0, j; i < str.size(); i = j) { 14 | j = i + 1; 15 | while (str[j] == str[i] && j - i < k) j++; 16 | if (j - i != k) stuck[str[i]] = false; 17 | } 18 | for (auto c : str) { 19 | if (stuck[c] && !marked[c]) cout << c; 20 | marked[c] = true; 21 | } 22 | cout << endl; 23 | for (int i = 0; i < str.size(); i += stuck[str[i]] ? k : 1) 24 | cout << str[i]; 25 | return 0; 26 | } -------------------------------------------------------------------------------- /src/甲级/1067.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, left = 0; 8 | cin >> n; 9 | vector nums(n), pos(n); 10 | for (int i = 0; i < n; i++) { 11 | cin >> nums[i]; 12 | pos[nums[i]] = i; 13 | if (nums[i] != i && nums[i] != 0) left++; 14 | } 15 | 16 | int ans = 0, i = 1; 17 | while (left > 0) { 18 | if (pos[0] == 0) { 19 | while (i < n && pos[i] == i) i++; 20 | swap(pos[0], pos[i]); 21 | } else { 22 | swap(pos[0], pos[pos[0]]); 23 | left--; 24 | } 25 | ans++; 26 | } 27 | cout << ans << endl; 28 | return 0; 29 | } -------------------------------------------------------------------------------- /src/甲级/1009.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int E = 1005; 5 | double p1[E], p2[E], res[2 * E]; 6 | 7 | int main() { 8 | int k, e, count = 0; 9 | double c; 10 | cin >> k; 11 | while (k--) { 12 | cin >> e >> c; 13 | p1[e] = c; 14 | } 15 | cin >> k; 16 | while (k--) { 17 | cin >> e >> c; 18 | p2[e] = c; 19 | } 20 | for (int i = 0; i < E; i++) 21 | for (int j = 0; j < E; j++) 22 | res[i + j] += p1[i] * p2[j]; 23 | for (auto c : res) 24 | count += (c != 0.0); 25 | printf("%d", count); 26 | for (int i = 2 * E - 1; i >= 0; i--) 27 | if (res[i] != 0.0) printf(" %d %.1f", i, res[i]); 28 | return 0; 29 | } -------------------------------------------------------------------------------- /src/乙级/1031.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int weights[] = {7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2}; 5 | char check_num[] = {'1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'}; 6 | 7 | int main() { 8 | char id[20]; 9 | int n, flag = 1; 10 | scanf("%d", &n); 11 | while (n--) { 12 | int i, sum = 0; 13 | scanf("%s", id); 14 | for (i = 0; i < 17; i++) { 15 | if (!isdigit(id[i])) break; 16 | sum += weights[i] * (id[i] - '0'); 17 | } 18 | if (check_num[sum % 11] != id[17] || i != 17) { 19 | printf("%s\n", id); 20 | flag = 0; 21 | } 22 | } 23 | if (flag) printf("All passed\n"); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /src/甲级/1121.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, v, w; 7 | set ans; 8 | set> edges; 9 | cin >> n; 10 | while (n--) { cin >> v >> w; edges.insert({v, w}); } 11 | cin >> m; 12 | while (m--) { cin >> v; ans.insert(v); } 13 | for (auto edge : edges) { 14 | int v = edge.first, w = edge.second; 15 | if (ans.count(v) && ans.count(w)) { 16 | ans.erase(v); 17 | ans.erase(w); 18 | } 19 | } 20 | printf("%lu\n", ans.size()); 21 | for (auto it = ans.begin(); it != ans.end(); it++) { 22 | if (it != ans.begin()) printf(" "); 23 | printf("%05d", *it); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /src/甲级/1007.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | cin >> n; 7 | int nums[n]; 8 | for (int i = 0; i < n; i++) cin >> nums[i]; 9 | 10 | int tmp_sum = 0, max_sum = -1; 11 | int tmp_begin = 0, max_begin = 0, max_end = n - 1; 12 | for (int i = 0; i < n; i++) { 13 | if (tmp_sum < 0) { 14 | tmp_sum = nums[i]; 15 | tmp_begin = i; 16 | } else { 17 | tmp_sum += nums[i]; 18 | } 19 | if (tmp_sum > max_sum) { 20 | max_sum = tmp_sum; 21 | max_begin = tmp_begin; 22 | max_end = i; 23 | } 24 | } 25 | printf("%d %d %d\n", max_sum > 0 ? max_sum : 0, nums[max_begin], nums[max_end]); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /src/乙级/1028.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct Person { 5 | string name; 6 | string birth; 7 | } tmp, max_ans, min_ans; 8 | 9 | int main() { 10 | string upper = "2014/09/06", lower = "1814/09/06"; 11 | max_ans.birth = upper; min_ans.birth = lower; 12 | int n, count = 0; 13 | cin >> n; 14 | while (n--) { 15 | cin >> tmp.name >> tmp.birth; 16 | if (tmp.birth < lower || tmp.birth > upper) continue; 17 | if (tmp.birth < max_ans.birth) max_ans = tmp; 18 | if (tmp.birth > min_ans.birth) min_ans = tmp; 19 | count++; 20 | } 21 | if (!count) 22 | cout << count << endl; 23 | else 24 | cout << count << ' ' << max_ans.name << ' ' << min_ans.name << endl; 25 | return 0; 26 | } -------------------------------------------------------------------------------- /src/乙级/1045.cpp: -------------------------------------------------------------------------------- 1 | // 注意题目中的输出要求：分两行输出 2 | 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int main() { 9 | int n; 10 | scanf("%d", &n); 11 | vector nums(n); 12 | for (int i = 0; i < n; i++) 13 | scanf("%d", &nums[i]); 14 | vector sorted(nums); 15 | sort(sorted.begin(), sorted.end()); 16 | vector ans; 17 | int max_num = 0; 18 | for (int i = 0; i < n; i++) { 19 | if (nums[i] == sorted[i] && nums[i] > max_num) 20 | ans.push_back(nums[i]); 21 | max_num = max(nums[i], max_num); 22 | } 23 | cout << ans.size() << endl; 24 | for (int i = 0; i < ans.size(); i++) 25 | cout << (i != 0 ? " " : "") << ans[i]; 26 | cout << endl; 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/甲级/1101.cpp: -------------------------------------------------------------------------------- 1 | // 注意题目中的输出要求：分两行输出 2 | 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int main() { 9 | int n; 10 | scanf("%d", &n); 11 | vector nums(n); 12 | for (int i = 0; i < n; i++) 13 | scanf("%d", &nums[i]); 14 | vector sorted(nums); 15 | sort(sorted.begin(), sorted.end()); 16 | vector ans; 17 | int max_num = 0; 18 | for (int i = 0; i < n; i++) { 19 | if (nums[i] == sorted[i] && nums[i] > max_num) 20 | ans.push_back(nums[i]); 21 | max_num = max(nums[i], max_num); 22 | } 23 | cout << ans.size() << endl; 24 | for (int i = 0; i < ans.size(); i++) 25 | cout << (i != 0 ? " " : "") << ans[i]; 26 | cout << endl; 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/甲级/1134.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | vector> edges; 7 | 8 | bool judge(set &vertices) { 9 | for (auto edge : edges) 10 | if (!vertices.count(edge.first) && !vertices.count(edge.second)) 11 | return false; 12 | return true; 13 | } 14 | 15 | int main() { 16 | int n, m, k; 17 | scanf("%d%d", &n, &m); 18 | while (m--) { int v, w; scanf("%d%d", &v, &w); edges.push_back({v, w}); } 19 | scanf("%d", &k); 20 | while (k--) { 21 | int l, v; 22 | set vertices; 23 | scanf("%d", &l); 24 | while (l--) { scanf("%d", &v); vertices.insert(v); } 25 | cout << (judge(vertices) ? "Yes" : "No") << endl; 26 | } 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/甲级/1157.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | string find_min(const unordered_set &s) { 6 | string res = *s.begin(); 7 | for (auto id : s) 8 | if (id.substr(6, 8) < res.substr(6, 8)) 9 | res = id; 10 | return res; 11 | } 12 | 13 | int main() { 14 | int n, m; 15 | string id; 16 | unordered_set s1, s2; 17 | 18 | cin >> n; 19 | while (n--) { 20 | cin >> id; 21 | s1.insert(id); 22 | } 23 | cin >> m; 24 | while (m--) { 25 | cin >> id; 26 | s2.insert(id); 27 | } 28 | 29 | int count = 0; 30 | for (auto id : s2) count += s1.count(id); 31 | cout << count << endl; 32 | cout << (count ? find_min(s1) : find_min(s2)) << endl; 33 | return 0; 34 | } -------------------------------------------------------------------------------- /src/乙级/1005.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | int n; 9 | cin >> n; 10 | vector nums(n); 11 | map checked; 12 | for (int i = 0; i < n; i++) cin >> nums[i]; 13 | for (auto num : nums) { 14 | while (num != 1) { 15 | if (num % 2 == 0) num = num / 2; 16 | else num = (3 * num + 1) / 2; 17 | checked[num] = true; 18 | } 19 | } 20 | vector ans; 21 | for (auto num : nums) 22 | if (!checked[num]) ans.push_back(num); 23 | sort(ans.begin(), ans.end(), greater()); 24 | for (int i = 0; i < ans.size(); i++) 25 | cout << ans[i] << (i < ans.size() - 1 ? ' ' : '\n'); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /src/甲级/1042.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int NUM_CARDS = 54; 6 | const int NUM_SUITS = 13; 7 | const string suits[] = {"S", "H", "C", "D", "J"}; 8 | 9 | int main() { 10 | int k, order[NUM_CARDS]; 11 | cin >> k; 12 | for (int i = 0; i < NUM_CARDS; i++) 13 | cin >> order[i]; 14 | vector deck(NUM_CARDS); 15 | for (int i = 0; i < NUM_CARDS; i++) 16 | deck[i] = suits[i / NUM_SUITS] + to_string(i % NUM_SUITS + 1); 17 | 18 | while (k--) { 19 | vector temp(deck); 20 | for (int i = 0; i < NUM_CARDS; i++) 21 | deck[order[i] - 1] = temp[i]; 22 | } 23 | 24 | for (int i = 0; i < NUM_CARDS; i++) 25 | cout << deck[i] << (i < NUM_CARDS - 1 ? ' ' : '\n'); 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/甲级/1156.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool is_prime(int num) { 5 | if (num < 3) return num == 2; 6 | if (num % 2 == 0) return false; 7 | for (int i = 3; i <= num / i; i += 2) 8 | if (num % i == 0) return false; 9 | return true; 10 | } 11 | 12 | int main() { 13 | int num; 14 | cin >> num; 15 | if (is_prime(num) && is_prime(num - 6)) { 16 | cout << "Yes" << endl << num - 6 << endl; 17 | } else if (is_prime(num) && is_prime(num + 6)) { 18 | cout << "Yes" << endl << num + 6 << endl; 19 | } else { 20 | int ans = num & 1 ? num + 2 : num + 1; 21 | while (!(is_prime(ans) && (is_prime(ans - 6) || is_prime(ans + 6)))) 22 | ans += 2; 23 | cout << "No" << endl << ans << endl; 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /src/甲级/1096.cpp: -------------------------------------------------------------------------------- 1 | // 注意乘积会超出 int 的表示范围 2 | // 注意 n 是质数的特殊情况 3 | 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | int n, max_len = 0; 9 | long long product = 1; 10 | cin >> n; 11 | for (int i = 2; product <= n; product *= i, i++) max_len++; 12 | for (int len = max_len - 1; len >= 1; len--) { 13 | for (int begin = 2; begin <= n / begin; begin++) { 14 | product = 1; 15 | for (int i = begin; i < begin + len; i++) product *= i; 16 | if (n % product) continue; 17 | 18 | cout << len << endl; 19 | for (int i = begin; i < begin + len; i++) 20 | cout << i << (i < begin + len - 1 ? '*' : '\n'); 21 | return 0; 22 | } 23 | } 24 | cout << 1 << endl << n << endl; 25 | return 0; 26 | } -------------------------------------------------------------------------------- /src/甲级/1004.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int N = 105, ROOT = 1; 6 | int ans[N]; 7 | vector nodes[N]; 8 | 9 | int max_level; 10 | 11 | void dfs(int id, int level = 1) { 12 | if (nodes[id].empty()) { 13 | ans[level]++; 14 | max_level = max(level, max_level); 15 | } 16 | for (auto child : nodes[id]) 17 | dfs(child, level + 1); 18 | } 19 | 20 | int main() { 21 | int n, m; 22 | cin >> n >> m; 23 | while (m--) { 24 | int id, k, child; 25 | cin >> id >> k; 26 | while (k--) { 27 | cin >> child; 28 | nodes[id].push_back(child); 29 | } 30 | } 31 | dfs(ROOT); 32 | for (int i = 1; i <= max_level; i++) 33 | cout << ans[i] << (i < max_level ? ' ' : '\n'); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/乙级/1065.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, x, y; 7 | set guests; 8 | set> couple; 9 | cin >> n; 10 | while (n--) { cin >> x >> y; couple.insert({x, y}); } 11 | cin >> m; 12 | while (m--) { cin >> x; guests.insert(x); } 13 | 14 | for (auto pair : couple) { 15 | x = pair.first; y = pair.second; 16 | if (guests.count(x) && guests.count(y)) { 17 | guests.erase(x); 18 | guests.erase(y); 19 | } 20 | } 21 | 22 | if (guests.empty()) { printf("0\n"); return 0; } 23 | printf("%lu\n", guests.size()); 24 | for (auto it = guests.begin(); it != guests.end(); it++) { 25 | if (it != guests.begin()) printf(" "); 26 | printf("%05d", *it); 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /src/甲级/1077.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int MAXLEN = 260; 6 | 7 | int main() { 8 | int n; 9 | size_t min_len = MAXLEN; 10 | cin >> n; getchar(); 11 | string lines[n]; 12 | for (int i = 0; i < n; i++) { 13 | getline(cin, lines[i]); 14 | reverse(lines[i].begin(), lines[i].end()); 15 | min_len = min(lines[i].length(), min_len); 16 | } 17 | string answer; 18 | for (int i = 0; i < min_len; i++) { 19 | bool flag = true; 20 | char c = lines[0][i]; 21 | for (int j = 1; j < n && flag; j++) 22 | if (lines[j][i] != c) flag = false; 23 | if (!flag) break; 24 | answer += c; 25 | } 26 | reverse(answer.begin(), answer.end()); 27 | cout << (answer.empty() ? "nai" : answer) << endl; 28 | return 0; 29 | } -------------------------------------------------------------------------------- /src/甲级/1047.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | char names[40005][5]; 8 | 9 | int main() { 10 | int n, k; 11 | scanf("%d%d", &n, &k); 12 | vector> courses(k+1); 13 | for (int i = 0; i < n; i++) { 14 | int m, id; 15 | scanf("%s %d", &names[i], &m); 16 | while (m--) { 17 | scanf("%d", &id); 18 | courses[id].push_back(i); 19 | } 20 | } 21 | for (int i = 1; i <= k; i++) { 22 | sort(courses[i].begin(), courses[i].end(), [](int a, int b) { 23 | return strcmp(names[a], names[b]) < 0; 24 | }); 25 | printf("%d %lu\n", i, courses[i].size()); 26 | for (auto student : courses[i]) 27 | printf("%s\n", names[student]); 28 | } 29 | return 0; 30 | } -------------------------------------------------------------------------------- /src/甲级/1073.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | string str; 6 | cin >> str; 7 | int pos = str.find('E'), exp = stoi(str.substr(pos + 1)); 8 | if (str[0] == '-') cout << '-'; 9 | if (exp > 0) { 10 | int i, count = 0; 11 | cout << str[1]; 12 | for (i = 3; count < exp && i < pos; i++) { 13 | cout << str[i]; 14 | count++; 15 | } 16 | if (count == exp && str[i] != 'E') 17 | cout << '.' << str.substr(i, pos - i); 18 | else 19 | while (count++ < exp) cout << 0; 20 | } else { 21 | int count = 0; 22 | exp *= -1; 23 | cout << "0."; 24 | while (count++ < exp - 1) cout << 0; 25 | for (int i = 1; i < pos; i++) 26 | if (str[i] != '.') cout << str[i]; 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /src/甲级/1146.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m, k; 7 | cin >> n >> m; 8 | vector> edges; 9 | while (m--) { 10 | int v, w; 11 | cin >> v >> w; 12 | edges.push_back({v, w}); 13 | } 14 | vector ans, pos(n + 1); 15 | cin >> k; 16 | for (int i = 0; i < k; i++) { 17 | bool flag = true; 18 | for (int j = 0; j < n; j++) { 19 | int v; 20 | cin >> v; 21 | pos[v] = j; 22 | } 23 | for (auto edge : edges) 24 | if (pos[edge.first] > pos[edge.second]) 25 | flag = false; 26 | if (!flag) ans.push_back(i); 27 | } 28 | for (int i = 0; i < ans.size(); i++) 29 | cout << ans[i] << (i < ans.size() - 1 ? ' ' : '\n'); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/甲级/1154.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m, k; 8 | scanf("%d%d", &n, &m); 9 | vector> edges; 10 | while (m--) { 11 | int v, w; 12 | scanf("%d%d", &v, &w); 13 | edges.push_back({v, w}); 14 | } 15 | scanf("%d", &k); 16 | while (k--) { 17 | bool flag = true; 18 | vector colors(n); 19 | set count; 20 | for (int i = 0; i < n; i++) { 21 | cin >> colors[i]; 22 | count.insert(colors[i]); 23 | } 24 | for (auto edge : edges) 25 | if (colors[edge.first] == colors[edge.second]) 26 | flag = false; 27 | if (flag) printf("%lu-coloring\n", count.size()); 28 | else printf("No\n"); 29 | } 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/甲级/1119.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool flag = true; 6 | vector ans; 7 | 8 | void build(int *pre, int *post, int n) { 9 | if (n <= 0) return; 10 | if (n == 1) { ans.push_back(pre[0]); return; } 11 | 12 | int i = 0; 13 | while (i < n && post[i] != pre[1]) i++; 14 | if (i == n - 2) flag = false; 15 | build(pre + 1, post, i + 1); 16 | ans.push_back(pre[0]); 17 | build(pre + i + 2, post + i + 1, n - i - 2); 18 | } 19 | 20 | int main() { 21 | int n; 22 | cin >> n; 23 | int pre[n], post[n]; 24 | for (int i = 0; i < n; i++) cin >> pre[i]; 25 | for (int i = 0; i < n; i++) cin >> post[i]; 26 | build(pre, post, n); 27 | cout << (flag ? "Yes" : "No") << endl; 28 | for (int i = 0; i < n; i++) 29 | cout << ans[i] << (i < n - 1 ? ' ' : '\n'); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/甲级/1083.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Student { 7 | char name[11]; 8 | char id[11]; 9 | int score; 10 | }; 11 | 12 | int main() { 13 | int n, lower, upper; 14 | scanf("%d", &n); 15 | vector students(n); 16 | for (int i = 0; i < n; i++) 17 | scanf("%s%s%d", students[i].name, students[i].id, &students[i].score); 18 | scanf("%d%d", &lower, &upper); 19 | sort(students.begin(), students.end(), [](Student a, Student b) { 20 | return a.score > b.score; 21 | }); 22 | bool found = false; 23 | for (auto student : students) { 24 | if (student.score < lower || student.score > upper) continue; 25 | printf("%s %s\n", student.name, student.id); 26 | found = true; 27 | } 28 | if (!found) printf("NONE\n"); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /src/甲级/1044.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m; 8 | cin >> n >> m; 9 | vector nums(n), sums(n + 1); 10 | for (int i = 0; i < n; i++) 11 | cin >> nums[i]; 12 | for (int i = 1; i <= n; i++) 13 | sums[i] = sums[i-1] + nums[i-1]; 14 | 15 | int near_sum = sums.back(); 16 | for (auto i = sums.begin(); i != sums.end(); i++) { 17 | auto j = lower_bound(i + 1, sums.end(), *i + m); 18 | if (j != sums.end()) 19 | near_sum = min(*j - *i, near_sum); 20 | } 21 | for (auto i = sums.begin(); i != sums.end(); i++) { 22 | auto j = lower_bound(i + 1, sums.end(), *i + near_sum); 23 | if (j != sums.end() && *j - *i == near_sum) 24 | printf("%d-%d\n", i - sums.begin() + 1, j - sums.begin()); 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /src/甲级/1079.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int MAX_N = 100005; 7 | 8 | struct TreeNode { 9 | int amount; 10 | vector children; 11 | }; 12 | TreeNode nodes[MAX_N]; 13 | 14 | double p, r, total; 15 | 16 | void dfs(int id, int depth) { 17 | if (nodes[id].children.empty()) 18 | total += nodes[id].amount * p * pow(1 + r / 100, depth); 19 | for (auto child : nodes[id].children) 20 | dfs(child, depth + 1); 21 | } 22 | 23 | int main() { 24 | int n; 25 | cin >> n >> p >> r; 26 | for (int i = 0; i < n; i++) { 27 | int k, id; 28 | cin >> k; 29 | if (k == 0) cin >> nodes[i].amount; 30 | while (k--) { 31 | cin >> id; 32 | nodes[i].children.push_back(id); 33 | } 34 | } 35 | dfs(0, 0); 36 | printf("%.1f\n", total); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1060.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string transfer(string num, int n) { 5 | int i = 0, exp = 0, count = 0; 6 | string res = "0."; 7 | while (num[i] == '0') i++; 8 | if (num[i] == '.') 9 | while (num[++i] == '0') exp--; 10 | else 11 | exp = num.find('.') == string::npos ? num.size() - i : num.find('.') - i; 12 | for (; count < n; i++) { 13 | if (num[i] == '.') continue; 14 | res += i < num.size() ? num[i] : '0'; 15 | count++; 16 | } 17 | if (stof(res) == 0.0) exp = 0; 18 | res += "*10^" + to_string(exp); 19 | return res; 20 | } 21 | 22 | int main() { 23 | int n; 24 | string num1, num2; 25 | cin >> n >> num1 >> num2; 26 | string s1 = transfer(num1, n), s2 = transfer(num2, n); 27 | if (s1 == s2) cout << "YES " << s1; 28 | else cout << "NO " << s1 << " " << s2; 29 | return 0; 30 | } -------------------------------------------------------------------------------- /src/甲级/1052.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Node { 7 | int data, next; 8 | } nodes[100005]; 9 | 10 | int main() { 11 | int n, head, addr; 12 | cin >> n >> head; 13 | while (n--) cin >> addr >> nodes[addr].data >> nodes[addr].next; 14 | vector list; 15 | while (head != -1) { 16 | list.push_back(head); 17 | head = nodes[head].next; 18 | } 19 | sort(list.begin(), list.end(), [](int a, int b) { 20 | return nodes[a].data < nodes[b].data; 21 | }); 22 | 23 | if (list.empty()) { printf("0 -1\n"); return 0; } 24 | 25 | printf("%lu %05d\n", list.size(), list.front()); 26 | for (int i = 0; i < list.size() - 1; i++) 27 | printf("%05d %d %05d\n", list[i], nodes[list[i]].data, list[i+1]); 28 | printf("%05d %d -1\n", list.back(), nodes[list.back()].data); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /src/乙级/1054.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool is_legal(string s) { 5 | char temp[100]; 6 | double num; 7 | sscanf(s.c_str(), "%lf", &num); 8 | sprintf(temp, "%.2lf", num); 9 | for (int i = 0; i < s.size(); i++) 10 | if (temp[i] != s[i]) return false; 11 | return num <= 1000 && num >= -1000; 12 | } 13 | 14 | int main() { 15 | int n, count = 0; 16 | double sum = 0.0; 17 | cin >> n; 18 | while (n--) { 19 | string s; 20 | cin >> s; 21 | if (is_legal(s)) { sum += stod(s); count++; } 22 | else printf("ERROR: %s is not a legal number\n", s.c_str()); 23 | } 24 | if (count == 0) printf("The average of 0 numbers is Undefined\n"); 25 | else if (count == 1) printf("The average of 1 number is %.2lf\n", sum); 26 | else printf("The average of %d numbers is %.2lf\n", count, sum / count); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/甲级/1108.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool is_legal(string s) { 5 | char temp[100]; 6 | double num; 7 | sscanf(s.c_str(), "%lf", &num); 8 | sprintf(temp, "%.2lf", num); 9 | for (int i = 0; i < s.size(); i++) 10 | if (temp[i] != s[i]) return false; 11 | return num <= 1000 && num >= -1000; 12 | } 13 | 14 | int main() { 15 | int n, count = 0; 16 | double sum = 0.0; 17 | cin >> n; 18 | while (n--) { 19 | string s; 20 | cin >> s; 21 | if (is_legal(s)) { sum += stod(s); count++; } 22 | else printf("ERROR: %s is not a legal number\n", s.c_str()); 23 | } 24 | if (count == 0) printf("The average of 0 numbers is Undefined\n"); 25 | else if (count == 1) printf("The average of 1 number is %.2lf\n", sum); 26 | else printf("The average of %d numbers is %.2lf\n", count, sum / count); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/乙级/1024.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define MAXLEN 10000 5 | 6 | int main() { 7 | int i = 0; 8 | char str[MAXLEN]; 9 | scanf("%s", str); 10 | while (str[i] != 'E') i++; 11 | int count = 0, exp = atoi(str + i + 1); 12 | if (str[0] == '-') putchar('-'); 13 | if (exp > 0) { 14 | putchar(str[1]); 15 | for (i = 3; count < exp && str[i] != 'E'; i++) { 16 | putchar(str[i]); 17 | count++; 18 | } 19 | if (count == exp && str[i] != 'E') { 20 | putchar('.'); 21 | while (str[i] != 'E') putchar(str[i++]); 22 | } 23 | while (count++ < exp) putchar('0'); 24 | } else { 25 | exp *= -1; 26 | printf("0."); 27 | while (count++ < exp - 1) putchar('0'); 28 | for (i = 1; str[i] != 'E'; i++) 29 | if (str[i] != '.') putchar(str[i]); 30 | } 31 | return 0; 32 | } -------------------------------------------------------------------------------- /src/甲级/1090.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int MAX_N = 100005; 7 | vector nodes[MAX_N]; 8 | int max_depth, max_count; 9 | 10 | void dfs(int id, int depth) { 11 | if (nodes[id].empty()) { 12 | if (depth > max_depth) { 13 | max_depth = depth; 14 | max_count = 1; 15 | } else if (depth == max_depth) { 16 | max_count++; 17 | } 18 | } 19 | for (auto child : nodes[id]) 20 | dfs(child, depth + 1); 21 | } 22 | 23 | int main() { 24 | int n, root, parent; 25 | double p, r; 26 | cin >> n >> p >> r; 27 | for (int i = 0; i < n; i++) { 28 | cin >> parent; 29 | if (parent == -1) { root = i; continue; } 30 | nodes[parent].push_back(i); 31 | } 32 | dfs(root, 0); 33 | printf("%.2f %d\n", p * pow(1 + r / 100, max_depth), max_count); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/甲级/1129.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Node { 7 | int val, cnt; 8 | 9 | bool operator<(const Node &b) const { 10 | return cnt != b.cnt ? cnt > b.cnt : val < b.val; 11 | } 12 | }; 13 | 14 | int main() { 15 | int n, k; 16 | cin >> n >> k; 17 | vector counts(n + 1); 18 | set nodes; 19 | for (int i = 0; i < n; i++) { 20 | int val; 21 | cin >> val; 22 | if (i != 0) { 23 | int j = 0; 24 | printf("%d:", val); 25 | for (auto it = nodes.begin(); it != nodes.end() && j++ < k; it++) 26 | printf(" %d", it->val); 27 | printf("\n"); 28 | } 29 | auto it = nodes.find(Node{val, counts[val]}); 30 | if (it != nodes.end()) nodes.erase(it); 31 | nodes.insert(Node{val, ++counts[val]}); 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /src/甲级/1162.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int N = 25; 5 | bool marked[N]; 6 | struct TreeNode { 7 | string data; 8 | int lchild, rchild; 9 | } nodes[N]; 10 | 11 | void dfs(int id) { 12 | if (id == -1) return; 13 | int count = (nodes[id].lchild == -1) + (nodes[id].rchild == -1); 14 | cout << "("; 15 | if (count == 1) cout << nodes[id].data; 16 | dfs(nodes[id].lchild); 17 | dfs(nodes[id].rchild); 18 | if (count != 1) cout << nodes[id].data; 19 | cout << ")"; 20 | } 21 | 22 | int main() { 23 | int n; 24 | cin >> n; 25 | for (int i = 1; i <= n; i++) { 26 | cin >> nodes[i].data >> nodes[i].lchild >> nodes[i].rchild; 27 | if (nodes[i].lchild != -1) marked[nodes[i].lchild] = true; 28 | if (nodes[i].rchild != -1) marked[nodes[i].rchild] = true; 29 | } 30 | for (int i = 1; i <= n; i++) 31 | if (!marked[i]) dfs(i); 32 | return 0; 33 | } -------------------------------------------------------------------------------- /src/甲级/1103.cpp: -------------------------------------------------------------------------------- 1 | // 从大往小递归，免去比较序列的麻烦 2 | 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int N, K, P, max_sum; 9 | vector tmp, ans, cache; 10 | 11 | void dfs(int n, int k, int sum, int num) { 12 | if (n == N && k == K && sum > max_sum) { 13 | max_sum = sum; 14 | ans = tmp; 15 | } 16 | if (n > N || k > K || num < 1) return; 17 | 18 | tmp.push_back(num); 19 | dfs(n + cache[num], k + 1, sum + num, num); 20 | tmp.pop_back(); 21 | dfs(n, k, sum, num - 1); 22 | } 23 | 24 | int main() { 25 | cin >> N >> K >> P; 26 | for (int i = 0; pow(i, P) <= N; i++) 27 | cache.push_back(pow(i, P)); 28 | dfs(0, 0, 0, cache.size() - 1); 29 | if (ans.empty()) { printf("Impossible\n"); return 0; } 30 | printf("%d = %d^%d", N, ans.front(), P); 31 | for (int i = 1; i < K; i++) 32 | printf(" + %d^%d", ans[i], P); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /src/甲级/1122.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int N = 205; 7 | bool graph[N][N]; 8 | int n, m; 9 | 10 | bool judge(const vector &path) { 11 | if (path.size() != n + 1 || path.front() != path.back()) return false; 12 | for (int i = 0; i < path.size() - 1; i++) 13 | if (!graph[path[i]][path[i+1]]) return false; 14 | set s(path.begin(), path.end()); 15 | return s.size() == n; 16 | } 17 | 18 | int main() { 19 | cin >> n >> m; 20 | for (int i = 0; i < m; i++) { 21 | int v, w; 22 | cin >> v >> w; 23 | graph[v][w] = graph[w][v] = true; 24 | } 25 | int k; 26 | cin >> k; 27 | while (k--) { 28 | int l; 29 | cin >> l; 30 | vector path(l); 31 | for (int i = 0; i < l; i++) cin >> path[i]; 32 | cout << (judge(path) ? "YES" : "NO") << endl; 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/甲级/1155.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | vector tree, path; 6 | bool is_max_heap = true, is_min_heap = true; 7 | 8 | void dfs(int id) { 9 | path.push_back(tree[id]); 10 | if (2 * id + 1 >= tree.size()) { 11 | for (int i = 0; i < path.size() - 1; i++) { 12 | if (path[i] < path[i+1]) is_max_heap = false; 13 | if (path[i] > path[i+1]) is_min_heap = false; 14 | cout << path[i] << " "; 15 | } 16 | cout << path.back() << endl; 17 | } else { 18 | if (2 * id + 2 < tree.size()) dfs(2 * id + 2); 19 | dfs(2 * id + 1); 20 | } 21 | path.pop_back(); 22 | } 23 | 24 | int main() { 25 | int n; 26 | cin >> n; 27 | tree.resize(n); 28 | for (int i = 0; i < n; i++) cin >> tree[i]; 29 | dfs(0); 30 | cout << (is_max_heap ? "Max Heap" : is_min_heap ? "Min Heap" : "Not Heap") << endl; 31 | return 0; 32 | } -------------------------------------------------------------------------------- /src/甲级/1094.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct TreeNode { 6 | vector children; 7 | }; 8 | 9 | #define MAX_N 105 10 | vector nodes(MAX_N); 11 | vector count(MAX_N); 12 | 13 | void dfs(TreeNode *node, int level) { 14 | if (node == nullptr) return; 15 | count[level]++; 16 | for (auto child : node->children) 17 | dfs(child, level + 1); 18 | } 19 | 20 | int main() { 21 | int n, m; 22 | cin >> n >> m; 23 | while (m--) { 24 | int id, k, child; 25 | cin >> id >> k; 26 | while (k--) { 27 | cin >> child; 28 | nodes[id].children.push_back(&nodes[child]); 29 | } 30 | } 31 | TreeNode *root = &nodes[1]; 32 | dfs(root, 1); 33 | int max = 1; 34 | for (int i = 1; i <= n; i++) 35 | if (count[i] > count[max]) max = i; 36 | printf("%d %d\n", count[max], max); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/乙级/1075.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int INF = 100005, N = 100005; 6 | 7 | struct ListNode { int data, next; }; 8 | int head; 9 | ListNode nodes[N]; 10 | 11 | vector ans; 12 | void range_search(int lower, int upper) { 13 | int temp = head; 14 | while (temp != -1) { 15 | if (nodes[temp].data >= lower && nodes[temp].data < upper) 16 | ans.push_back(temp); 17 | temp = nodes[temp].next; 18 | } 19 | } 20 | 21 | int main() { 22 | int n, k, addr; 23 | cin >> head >> n >> k; 24 | while (n--) cin >> addr >> nodes[addr].data >> nodes[addr].next; 25 | range_search(-INF, 0); 26 | range_search(0, k + 1); 27 | range_search(k + 1, INF); 28 | for (int i = 0; i < ans.size() - 1; i++) 29 | printf("%05d %d %05d\n", ans[i], nodes[ans[i]].data, ans[i+1]); 30 | printf("%05d %d -1\n", ans.back(), nodes[ans.back()].data); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /src/甲级/1013.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int n, m, k; 6 | const int N = 1005; 7 | bool marked[N], graph[N][N]; 8 | 9 | void dfs(int v, int occupied) { 10 | marked[v] = true; 11 | for (int w = 1; w <= n; w++) 12 | if (graph[v][w] && w != occupied && !marked[w]) 13 | dfs(w, occupied); 14 | } 15 | 16 | int main() { 17 | scanf("%d%d%d", &n, &m, &k); 18 | for (int i = 0; i < m; i++) { 19 | int v, w; 20 | scanf("%d%d", &v, &w); 21 | graph[v][w] = graph[w][v] = true; 22 | } 23 | while (k--) { 24 | int occupied, count = 0; 25 | scanf("%d", &occupied); 26 | memset(marked, 0, n + 1); 27 | for (int v = 1; v <= n; v++) { 28 | if (marked[v] || v == occupied) continue; 29 | dfs(v, occupied); 30 | count++; 31 | } 32 | printf("%d\n", count - 1); 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/甲级/1133.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int INF = 100005, N = 100005; 6 | 7 | struct ListNode { int data, next; }; 8 | int head; 9 | ListNode nodes[N]; 10 | 11 | vector ans; 12 | void range_search(int lower, int upper) { 13 | int temp = head; 14 | while (temp != -1) { 15 | if (nodes[temp].data >= lower && nodes[temp].data < upper) 16 | ans.push_back(temp); 17 | temp = nodes[temp].next; 18 | } 19 | } 20 | 21 | int main() { 22 | int n, k, addr; 23 | cin >> head >> n >> k; 24 | while (n--) cin >> addr >> nodes[addr].data >> nodes[addr].next; 25 | range_search(-INF, 0); 26 | range_search(0, k + 1); 27 | range_search(k + 1, INF); 28 | for (int i = 0; i < ans.size() - 1; i++) 29 | printf("%05d %d %05d\n", ans[i], nodes[ans[i]].data, ans[i+1]); 30 | printf("%05d %d -1\n", ans.back(), nodes[ans.back()].data); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /src/甲级/1106.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int MAX_N = 100005; 7 | int min_depth = MAX_N, min_count; 8 | vector nodes[MAX_N]; 9 | 10 | void dfs(int id, int depth) { 11 | if (nodes[id].empty()) { 12 | if (depth < min_depth) { 13 | min_depth = depth; 14 | min_count = 1; 15 | } else if (depth == min_depth) { 16 | min_count++; 17 | } 18 | } 19 | for (auto child : nodes[id]) 20 | dfs(child, depth + 1); 21 | }; 22 | 23 | int main() { 24 | int n; 25 | double p, r; 26 | cin >> n >> p >> r; 27 | for (int i = 0; i < n; i++) { 28 | int k, id; 29 | cin >> k; 30 | while (k--) { 31 | cin >> id; 32 | nodes[i].push_back(id); 33 | } 34 | } 35 | dfs(0, 0); 36 | printf("%.4f %d\n", p * pow(1 + r / 100, min_depth), min_count); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1037.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m; 8 | cin >> n; 9 | int coupons[n]; 10 | for (int i = 0; i < n; i++) cin >> coupons[i]; 11 | cin >> m; 12 | deque products(m); 13 | for (int i = 0; i < m; i++) cin >> products[i]; 14 | sort(products.begin(), products.end()); 15 | 16 | long long ans = 0; 17 | sort(coupons, coupons + n, less()); 18 | for (auto coupon : coupons) { 19 | if (coupon >= 0 || products.empty() || products.front() >= 0) break; 20 | ans += coupon * products.front(); 21 | products.pop_front(); 22 | } 23 | sort(coupons, coupons + n, greater()); 24 | for (auto coupon : coupons) { 25 | if (coupon <= 0 || products.empty() || products.back() <= 0) break; 26 | ans += coupon * products.back(); 27 | products.pop_back(); 28 | } 29 | cout << ans << endl; 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/甲级/1068.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int N = 10005, M = 105; 7 | bool mark[N][M]; 8 | int w[N], dp[M]; 9 | 10 | int main() { 11 | int n, m; 12 | cin >> n >> m; 13 | for (int i = 1; i <= n; i++) 14 | cin >> w[i]; 15 | sort(w + 1, w + n + 1, greater()); 16 | for (int i = 1; i <= n; i++) { 17 | for (int v = m; v >= w[i]; v--) { 18 | if (dp[v] <= dp[v - w[i]] + w[i]) { 19 | dp[v] = dp[v - w[i]] + w[i]; 20 | mark[i][v] = true; 21 | } 22 | } 23 | } 24 | if (dp[m] != m) { cout << "No Solution"; return 0; } 25 | vector ans; 26 | for (int i = n, v = m; i >= 0; i--) { 27 | if (mark[i][v]) { 28 | v -= w[i]; 29 | ans.push_back(w[i]); 30 | } 31 | } 32 | for (int i = 0; i < ans.size(); i++) 33 | cout << ans[i] << (i < ans.size() - 1 ? ' ' : '\n'); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/乙级/1089.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | cin >> n; 7 | int stat[n + 1]; 8 | for (int i = 1; i <= n; i++) 9 | cin >> stat[i]; 10 | for (int i = 1; i <= n; i++) { 11 | for (int j = i + 1; j <= n; j++) { 12 | int good = 0, evil = 0; 13 | for (int k = 1; k <= n; k++) { 14 | if (stat[k] > 0 && (stat[k] == i || stat[k] == j)) { 15 | if (k == i || k == j) evil++; 16 | else good++; 17 | } 18 | if (stat[k] < 0 && -stat[k] != i && -stat[k] != j) { 19 | if (k == i || k == j) evil++; 20 | else good++; 21 | } 22 | } 23 | if (good == 1 && evil == 1) { 24 | printf("%d %d\n", i, j); 25 | return 0; 26 | } 27 | } 28 | } 29 | printf("No Solution\n"); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/甲级/1061.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | string week[] = {"MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"}; 6 | 7 | int main() { 8 | string s1, s2, s3, s4; 9 | cin >> s1 >> s2 >> s3 >> s4; 10 | int i; 11 | for (i = 0; s1[i] && s2[i]; i++) { 12 | if (s1[i] == s2[i] && s1[i] >= 'A' && s1[i] <= 'G') { 13 | printf("%s ", week[s1[i] - 'A'].c_str()); 14 | break; 15 | } 16 | } 17 | for (i++; s1[i] && s2[i]; i++) { 18 | if (s1[i] != s2[i]) continue; 19 | if (isdigit(s1[i])) { 20 | printf("%02d:", s1[i] - '0'); 21 | break; 22 | } else if (s1[i] >= 'A' && s1[i] <= 'N') { 23 | printf("%02d:", s1[i] - 'A' + 10); 24 | break; 25 | } 26 | } 27 | for (i = 0; s3[i] && s4[i]; i++) { 28 | if (s3[i] == s4[i] && isalpha(s3[i])) { 29 | printf("%02d\n", i); 30 | break; 31 | } 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /src/甲级/1135.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int INF = 0x3f3f3f3f; 5 | 6 | bool flag; 7 | int black_height; 8 | int dfs(int *pre, int n, int count) { 9 | if (n <= 0) { 10 | if (black_height == 0) black_height = count; 11 | if (count != black_height) flag = false; 12 | return INF; 13 | } 14 | int root = pre[0], i = 1; 15 | while (i < n && abs(pre[i]) < abs(root)) i++; 16 | int lchild = dfs(pre + 1, i - 1, count + (root > 0)); 17 | int rchild = dfs(pre + i, n - i, count + (root > 0)); 18 | if (root < 0 && (lchild < 0 || rchild < 0)) flag = false; 19 | return root; 20 | } 21 | 22 | int main() { 23 | int k, n; 24 | cin >> k; 25 | while (k--) { 26 | cin >> n; 27 | int pre[n]; 28 | for (int i = 0; i < n; i++) cin >> pre[i]; 29 | flag = true; 30 | black_height = 0; 31 | dfs(pre, n, 0); 32 | cout << (flag && pre[0] > 0 ? "Yes" : "No") << endl; 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/甲级/1148.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int n; 6 | cin >> n; 7 | int stat[n + 1]; 8 | for (int i = 1; i <= n; i++) 9 | cin >> stat[i]; 10 | for (int i = 1; i <= n; i++) { 11 | for (int j = i + 1; j <= n; j++) { 12 | int good = 0, evil = 0; 13 | for (int k = 1; k <= n; k++) { 14 | if (stat[k] > 0 && (stat[k] == i || stat[k] == j)) { 15 | if (k == i || k == j) evil++; 16 | else good++; 17 | } 18 | if (stat[k] < 0 && -stat[k] != i && -stat[k] != j) { 19 | if (k == i || k == j) evil++; 20 | else good++; 21 | } 22 | } 23 | if (good == 1 && evil == 1) { 24 | printf("%d %d\n", i, j); 25 | return 0; 26 | } 27 | } 28 | } 29 | printf("No Solution\n"); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/甲级/1116.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int N = 10005; 6 | int ranks[N], checked[N]; 7 | 8 | bool is_prime(int num) { 9 | if (num < 3) return num == 2; 10 | if (num % 2 == 0) return false; 11 | for (int i = 3; i <= num / i; i += 2) 12 | if (num % i == 0) return false; 13 | return true; 14 | } 15 | 16 | int main() { 17 | int n, k, id; 18 | cin >> n; 19 | for (int i = 1; i <= n; i++) { 20 | cin >> id; 21 | ranks[id] = i; 22 | } 23 | cin >> k; 24 | while (k--) { 25 | cin >> id; 26 | printf("%04d: ", id); 27 | if (ranks[id] == 0) printf("Are you kidding?\n"); 28 | else if (checked[id]) printf("Checked\n"); 29 | else if (ranks[id] == 1) printf("Mystery Award\n"); 30 | else if (is_prime(ranks[id])) printf("Minion\n"); 31 | else printf("Chocolate\n"); 32 | checked[id] = 1; 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/乙级/1003.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | bool accept(string s) { 5 | int n = s.length(), p = -1, t = -1; 6 | for (int i = 0; i < n; i++) { 7 | switch(s[i]) { 8 | case 'P': 9 | if (p == -1) p = i; 10 | else return false; 11 | break; 12 | case 'T': 13 | if (t == -1) t = i; 14 | else return false; 15 | break; 16 | case 'A': 17 | break; 18 | default: 19 | return false; 20 | } 21 | } 22 | if (p + 2 == t && 2 * p + 3 == n && s[p + 1] == 'A') return true; 23 | string a = s.substr(0, p); 24 | string b = s.substr(p + 1, t - p - 2); 25 | string c = s.substr(t + 1, n - 1 - p - t); 26 | return accept(a + "P" + b + "T" + c); 27 | } 28 | 29 | int main() { 30 | int n; 31 | cin >> n; 32 | while (n--) { 33 | string s; 34 | cin >> s; 35 | cout << (accept(s) ? "YES" : "NO") << endl; 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1028.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Student { 7 | int id, score; 8 | string name; 9 | }; 10 | 11 | int main() { 12 | int n, c; 13 | cin >> n >> c; 14 | vector students(n); 15 | for (int i = 0; i < n; i++) 16 | cin >> students[i].id >> students[i].name >> students[i].score; 17 | switch(c) { 18 | case 1: 19 | sort(students.begin(), students.end(), [](Student a, Student b) { return a.id < b.id; }); 20 | break; 21 | case 2: 22 | sort(students.begin(), students.end(), [](Student a, Student b) { return a.name <= b.name; }); 23 | break; 24 | case 3: 25 | sort(students.begin(), students.end(), [](Student a, Student b) { return a.score != b.score ? a.score <= b.score : a.id < b.id; }); 26 | break; 27 | } 28 | for (auto student : students) 29 | printf("%06d %s %d\n", student.id, student.name.c_str(), student.score); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /src/乙级/1059.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAXN 10005 4 | 5 | int visited[MAXN], rank[MAXN]; 6 | 7 | int is_prime(int num) { 8 | if (num < 3) return num == 2; 9 | if (num % 2 == 0) return 0; 10 | for (int i = 3; i <= num / i; i += 2) 11 | if (num % i == 0) return 0; 12 | return 1; 13 | } 14 | 15 | int main() { 16 | int n, k, id; 17 | scanf("%d", &n); 18 | for (int i = 0; i < n; i++) { 19 | scanf("%d", &id); 20 | rank[id] = i + 1; 21 | } 22 | scanf("%d", &k); 23 | while (k--) { 24 | scanf("%d", &id); 25 | printf("%04d: ", id); 26 | if (rank[id] == 0) 27 | printf("Are you kidding?\n"); 28 | else if (visited[id]) 29 | printf("Checked\n"); 30 | else if (rank[id] == 1) 31 | printf("Mystery Award\n"); 32 | else if (is_prime(rank[id])) 33 | printf("Minion\n"); 34 | else 35 | printf("Chocolate\n"); 36 | visited[id] = 1; 37 | } 38 | return 0; 39 | } -------------------------------------------------------------------------------- /src/乙级/1014.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | char week[][4] = {"MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"}; 5 | #define MAX_LEN 65 6 | 7 | int main() { 8 | char s1[MAX_LEN], s2[MAX_LEN], s3[MAX_LEN], s4[MAX_LEN]; 9 | scanf("%s%s%s%s", s1, s2, s3, s4); 10 | int i; 11 | for (i = 0; s1[i] && s2[i]; i++) { 12 | if (s1[i] == s2[i] && s1[i] >= 'A' && s1[i] <= 'G') { 13 | printf("%s ", week[s1[i] - 'A']); 14 | break; 15 | } 16 | } 17 | for (i++; s1[i] && s2[i]; i++) { 18 | if (s1[i] != s2[i]) continue; 19 | if (isdigit(s1[i])) { 20 | printf("%02d:", s1[i] - '0'); 21 | break; 22 | } else if (s1[i] >= 'A' && s1[i] <= 'N') { 23 | printf("%02d:", s1[i] - 'A' + 10); 24 | break; 25 | } 26 | } 27 | for (i = 0; s3[i] && s4[i]; i++) { 28 | if (s3[i] == s4[i] && isalpha(s3[i])) { 29 | printf("%02d\n", i); 30 | break; 31 | } 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /src/乙级/1025.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int MAXN = 100005; 6 | 7 | struct Node { 8 | int data, next; 9 | } nodes[MAXN]; 10 | 11 | int main() { 12 | int n, k, head, addr; 13 | cin >> head >> n >> k; 14 | while (n--) cin >> addr >> nodes[addr].data >> nodes[addr].next; 15 | int ptr = head; 16 | deque list, temp; 17 | while (ptr != -1) { 18 | for (int i = 0; i < k && ptr != -1; i++) { 19 | temp.push_back(ptr); 20 | ptr = nodes[ptr].next; 21 | } 22 | if (temp.size() != k) break; 23 | while (!temp.empty()) { 24 | list.push_back(temp.back()); 25 | temp.pop_back(); 26 | } 27 | } 28 | while (!temp.empty()) { 29 | list.push_back(temp.front()); 30 | temp.pop_front(); 31 | } 32 | for (int i = 0; i < list.size() - 1; i++) 33 | printf("%05d %d %05d\n", list[i], nodes[list[i]].data, list[i+1]); 34 | printf("%05d %d -1\n", list.back(), nodes[list.back()].data); 35 | return 0; 36 | } -------------------------------------------------------------------------------- /src/甲级/1074.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int MAXN = 100005; 6 | 7 | struct Node { 8 | int data, next; 9 | } nodes[MAXN]; 10 | 11 | int main() { 12 | int n, k, head, addr; 13 | cin >> head >> n >> k; 14 | while (n--) cin >> addr >> nodes[addr].data >> nodes[addr].next; 15 | int ptr = head; 16 | deque list, temp; 17 | while (ptr != -1) { 18 | for (int i = 0; i < k && ptr != -1; i++) { 19 | temp.push_back(ptr); 20 | ptr = nodes[ptr].next; 21 | } 22 | if (temp.size() != k) break; 23 | while (!temp.empty()) { 24 | list.push_back(temp.back()); 25 | temp.pop_back(); 26 | } 27 | } 28 | while (!temp.empty()) { 29 | list.push_back(temp.front()); 30 | temp.pop_front(); 31 | } 32 | for (int i = 0; i < list.size() - 1; i++) 33 | printf("%05d %d %05d\n", list[i], nodes[list[i]].data, list[i+1]); 34 | printf("%05d %d -1\n", list.back(), nodes[list.back()].data); 35 | return 0; 36 | } -------------------------------------------------------------------------------- /src/甲级/1115.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct TreeNode { 5 | int key; 6 | TreeNode *lchild = nullptr; 7 | TreeNode *rchild = nullptr; 8 | 9 | TreeNode(int key) : key(key) {} 10 | }; 11 | 12 | void insert(TreeNode *&node, int key) { 13 | if (node == nullptr) node = new TreeNode(key); 14 | else if (key <= node->key) insert(node->lchild, key); 15 | else insert(node->rchild, key); 16 | } 17 | 18 | const int N = 1005; 19 | int max_level, cnt[N]; 20 | void dfs(TreeNode *node, int level) { 21 | if (node == nullptr) return; 22 | max_level = max(level, max_level); 23 | cnt[level]++; 24 | dfs(node->lchild, level + 1); 25 | dfs(node->rchild, level + 1); 26 | } 27 | 28 | int main() { 29 | int n, key; 30 | TreeNode *root = nullptr; 31 | cin >> n; 32 | while (n--) { 33 | cin >> key; 34 | insert(root, key); 35 | } 36 | dfs(root, 0); 37 | int n1 = cnt[max_level], n2 = cnt[max_level - 1]; 38 | printf("%d + %d = %d\n", n1, n2, n1 + n2); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /src/甲级/1039.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | typedef char Name[5]; 7 | 8 | int hash_value(Name name) { 9 | int res = 0; 10 | for (int i = 0; i < 3; i++) 11 | res = res * 26 + name[i] - 'A'; 12 | res = res * 10 + name[3] - '0'; 13 | return res; 14 | } 15 | 16 | vector students[26 * 26 * 26 * 10 + 1]; 17 | 18 | int main() { 19 | int n, k; 20 | scanf("%d%d", &n, &k); 21 | while (k--) { 22 | int id, m; 23 | scanf("%d%d", &id, &m); 24 | while (m--) { 25 | Name name; 26 | scanf("%s", name); 27 | students[hash_value(name)].push_back(id); 28 | } 29 | } 30 | while (n--) { 31 | Name name; 32 | scanf("%s", name); 33 | vector courses = students[hash_value(name)]; 34 | sort(courses.begin(), courses.end()); 35 | printf("%s %lu", name, courses.size()); 36 | for (auto course : courses) 37 | printf(" %d", course); 38 | printf("\n"); 39 | } 40 | return 0; 41 | } -------------------------------------------------------------------------------- /src/甲级/1126.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int N = 505; 6 | vector graph[N]; 7 | 8 | bool mark[N]; 9 | void dfs(int v) { 10 | mark[v] = true; 11 | for (auto w : graph[v]) 12 | if (!mark[w]) dfs(w); 13 | } 14 | 15 | bool is_connected(int n) { 16 | dfs(1); 17 | for (int v = 1; v <= n; v++) 18 | if (!mark[v]) return false; 19 | return true; 20 | } 21 | 22 | int main() { 23 | int n, m; 24 | cin >> n >> m; 25 | while (m--) { 26 | int v, w; 27 | cin >> v >> w; 28 | graph[v].push_back(w); 29 | graph[w].push_back(v); 30 | } 31 | int count = 0; 32 | for (int v = 1; v <= n; v++) { 33 | count += graph[v].size() & 1; 34 | cout << graph[v].size() << (v < n ? ' ' : '\n'); 35 | } 36 | if (!is_connected(n)) cout << "Non-Eulerian" << endl; 37 | else if (count == 0) cout << "Eulerian" << endl; 38 | else if (count == 2) cout << "Semi-Eulerian" << endl; 39 | else cout << "Non-Eulerian" << endl; 40 | return 0; 41 | } -------------------------------------------------------------------------------- /src/甲级/1097.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct ListNode { 6 | int val, next; 7 | }; 8 | 9 | const int N = 100005; 10 | const int K = 10005; 11 | 12 | vector nodes(N); 13 | vector exist(K); 14 | 15 | void print_list(vector list) { 16 | if (list.empty()) return; 17 | for (int i = 0; i < list.size() - 1; i++) 18 | printf("%05d %d %05d\n", list[i], nodes[list[i]].val, list[i+1]); 19 | printf("%05d %d -1\n", list.back(), nodes[list.back()].val); 20 | } 21 | 22 | int main() { 23 | int addr, head, n; 24 | cin >> head >> n; 25 | while (n--) 26 | cin >> addr >> nodes[addr].val >> nodes[addr].next; 27 | vector list1, list2; 28 | int temp = head; 29 | while (temp != -1) { 30 | if (!exist[abs(nodes[temp].val)]) 31 | list1.push_back(temp); 32 | else 33 | list2.push_back(temp); 34 | exist[abs(nodes[temp].val)] = true; 35 | temp = nodes[temp].next; 36 | } 37 | print_list(list1); 38 | print_list(list2); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /src/乙级/1020.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Mooncake { 7 | double stock; 8 | double total_price; 9 | double unit_price; 10 | }; 11 | 12 | int main() { 13 | int n; 14 | double demand; 15 | cin >> n >> demand; 16 | vector mooncakes(n); 17 | for (int i = 0; i < n; i++) 18 | cin >> mooncakes[i].stock; 19 | for (int i = 0; i < n; i++) { 20 | cin >> mooncakes[i].total_price; 21 | mooncakes[i].unit_price = mooncakes[i].total_price / mooncakes[i].stock; 22 | } 23 | sort(mooncakes.begin(), mooncakes.end(), [](Mooncake a, Mooncake b) { 24 | return a.unit_price > b.unit_price; 25 | }); 26 | double answer = 0.0; 27 | for (auto mooncake : mooncakes) { 28 | if (mooncake.stock <= demand) { 29 | demand -= mooncake.stock; 30 | answer += mooncake.total_price; 31 | } else { 32 | answer += mooncake.unit_price * demand; 33 | break; 34 | } 35 | } 36 | printf("%.2f", answer); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1010.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | using LL = long long; 7 | 8 | LL str2num(const string &str, LL base) { 9 | LL ans = 0; 10 | for (auto c : str) { 11 | LL digit; 12 | if (isdigit(c)) digit = c - '0'; 13 | if (islower(c)) digit = c - 'a' + 10; 14 | if (digit >= base) return -1; 15 | ans = ans * base + digit; 16 | } 17 | return ans >= 0 ? ans : __LONG_LONG_MAX__; 18 | } 19 | 20 | int main() { 21 | string str1, str2; 22 | int tag, radix; 23 | cin >> str1 >> str2 >> tag >> radix; 24 | if (tag == 2) swap(str1, str2); 25 | LL num = str2num(str1, radix); 26 | 27 | LL left = 2, right = num + 1, mid; 28 | while (left <= right) { 29 | mid = left + (right - left) / 2; 30 | LL tmp = str2num(str2, mid); 31 | if (tmp < num) left = mid + 1; 32 | else if (tmp > num) right = mid - 1; 33 | else break; 34 | } 35 | if (left <= right) cout << mid; 36 | else cout << "Impossible"; 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1070.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Mooncake { 7 | double stock; 8 | double total_price; 9 | double unit_price; 10 | }; 11 | 12 | int main() { 13 | int n; 14 | double demand; 15 | cin >> n >> demand; 16 | vector mooncakes(n); 17 | for (int i = 0; i < n; i++) 18 | cin >> mooncakes[i].stock; 19 | for (int i = 0; i < n; i++) { 20 | cin >> mooncakes[i].total_price; 21 | mooncakes[i].unit_price = mooncakes[i].total_price / mooncakes[i].stock; 22 | } 23 | sort(mooncakes.begin(), mooncakes.end(), [](Mooncake a, Mooncake b) { 24 | return a.unit_price > b.unit_price; 25 | }); 26 | double answer = 0.0; 27 | for (auto mooncake : mooncakes) { 28 | if (mooncake.stock <= demand) { 29 | demand -= mooncake.stock; 30 | answer += mooncake.total_price; 31 | } else { 32 | answer += mooncake.unit_price * demand; 33 | break; 34 | } 35 | } 36 | printf("%.2f", answer); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/乙级/1048.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define MAXLEN 105 5 | 6 | char num2char(int num) { 7 | if (num < 10) return num + '0'; 8 | switch(num) { 9 | case 10: return 'J'; 10 | case 11: return 'Q'; 11 | case 12: return 'K'; 12 | default: return '\0'; 13 | } 14 | } 15 | 16 | int main() { 17 | char a[MAXLEN], b[MAXLEN], res[MAXLEN]; 18 | scanf("%s%s", a, b); 19 | int n1 = strlen(a), n2 = strlen(b), n = n1 > n2 ? n1 : n2; 20 | if (n2 > n1) { 21 | for (int i = n - 1; i >= 0; i--) 22 | a[i] = a[i + n1 - n]; 23 | memset(a, '0', n - n1); 24 | } else if (n1 > n2) { 25 | for (int i = n - 1; i >= 0; i--) 26 | b[i] = b[i + n2 - n]; 27 | memset(b, '0', n - n2); 28 | } 29 | a[n] = b[n] = res[n] = '\0'; 30 | for (int i = n - 1; i >= 0; i--) { 31 | int code; 32 | if ((n - i) % 2) code = (a[i] - '0' + b[i] - '0') % 13; 33 | else code = (b[i] - a[i] + 10) % 10; 34 | res[i] = num2char(code); 35 | } 36 | printf("%s\n", res); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1036.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct Student { 5 | char gender; 6 | int score; 7 | string name, id; 8 | } best_girl, worst_boy; 9 | 10 | int main() { 11 | int n; 12 | cin >> n; 13 | best_girl.score = -1; 14 | worst_boy.score = 101; 15 | while (n--) { 16 | Student student; 17 | cin >> student.name >> student.gender >> student.id >> student.score; 18 | if (student.gender == 'F' && student.score > best_girl.score) best_girl = student; 19 | if (student.gender == 'M' && student.score < worst_boy.score) worst_boy = student; 20 | } 21 | if (best_girl.score == -1) cout << "Absent" << endl; 22 | else cout << best_girl.name << " " << best_girl.id << endl; 23 | if (worst_boy.score == 101) cout << "Absent" << endl; 24 | else cout << worst_boy.name << " " << worst_boy.id << endl; 25 | if (best_girl.score == -1 || worst_boy.score == 101) cout << "NA" << endl; 26 | else cout << best_girl.score - worst_boy.score << endl; 27 | return 0; 28 | } -------------------------------------------------------------------------------- /src/乙级/1050.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | int n, m, k; 9 | cin >> n; 10 | vector nums(n); 11 | for (int i = 0; i < n; i++) cin >> nums[i]; 12 | sort(nums.begin(), nums.end(), greater()); 13 | for (k = sqrt(n); n % k != 0; k--); 14 | m = n / k; 15 | 16 | vector> ans(m, vector(k, 0)); 17 | int i = 0, row = 0, col = 0; 18 | while (i < n) { 19 | while (i < n && col < k && !ans[row][col]) ans[row][col++] = nums[i++]; 20 | row++; col--; // 向右填充 21 | while (i < n && row < m && !ans[row][col]) ans[row++][col] = nums[i++]; 22 | row--; col--; // 向下填充 23 | while (i < n && col >= 0 && !ans[row][col]) ans[row][col--] = nums[i++]; 24 | row--; col++; // 向左填充 25 | while (i < n && row >= 0 && !ans[row][col]) ans[row--][col] = nums[i++]; 26 | row++; col++; // 向上填充 27 | } 28 | for (int i = 0; i < m; i++) 29 | for (int j = 0; j < k; j++) 30 | cout << ans[i][j] << (j < k - 1 ? ' ' : '\n'); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /src/甲级/1020.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct TreeNode { 6 | int key; 7 | TreeNode *left; 8 | TreeNode *right; 9 | }; 10 | 11 | TreeNode *create_tree(int *post, int *in, int len) { 12 | if (len <= 0) return nullptr; 13 | int i = 0; 14 | TreeNode *root = new TreeNode{post[len - 1], nullptr, nullptr}; 15 | while (i < len && in[i] != root->key) i++; 16 | root->left = create_tree(post, in, i); 17 | root->right = create_tree(post + i, in + i + 1, len - i - 1); 18 | return root; 19 | } 20 | 21 | void bfs(TreeNode *root) { 22 | queue q; 23 | q.push(root); 24 | while (!q.empty()) { 25 | TreeNode *temp = q.front(); q.pop(); 26 | if (temp->left) q.push(temp->left); 27 | if (temp->right) q.push(temp->right); 28 | cout << temp->key << (!q.empty() ? ' ' : '\n'); 29 | } 30 | } 31 | 32 | int main() { 33 | int n; 34 | cin >> n; 35 | int post[n], in[n]; 36 | for (int i = 0; i < n; i++) cin >> post[i]; 37 | for (int i = 0; i < n; i++) cin >> in[i]; 38 | bfs(create_tree(post, in, n)); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /src/甲级/1056.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | int n, m, order; 9 | cin >> n >> m; 10 | vector weight(n), rank(n); 11 | for (int i = 0; i < n; i++) 12 | cin >> weight[i]; 13 | queue q; 14 | for (int i = 0; i < n; i++) { 15 | cin >> order; 16 | q.push(order); 17 | } 18 | while (q.size() != 1) { 19 | queue tmp; 20 | set winners; 21 | while (!q.empty()) { 22 | int winner = q.front(); 23 | for (int i = 0; i < m && !q.empty(); i++, q.pop()) 24 | if (weight[q.front()] > weight[winner]) 25 | winner = q.front(); 26 | winners.insert(winner); 27 | tmp.push(winner); 28 | } 29 | for (int i = 0; i < n; i++) 30 | if (!winners.count(i) && !rank[i]) 31 | rank[i] = winners.size() + 1; 32 | q = tmp; 33 | } 34 | rank[q.front()] = 1; 35 | for (int i = 0; i < n; i++) 36 | cout << rank[i] << (i < n - 1 ? ' ' : '\n'); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1105.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | int n, m, k; 9 | cin >> n; 10 | vector nums(n); 11 | for (int i = 0; i < n; i++) cin >> nums[i]; 12 | sort(nums.begin(), nums.end(), greater()); 13 | for (k = sqrt(n); n % k != 0; k--); 14 | m = n / k; 15 | 16 | vector> ans(m, vector(k, 0)); 17 | int i = 0, row = 0, col = 0; 18 | while (i < n) { 19 | while (i < n && col < k && !ans[row][col]) ans[row][col++] = nums[i++]; 20 | row++; col--; // 向右填充 21 | while (i < n && row < m && !ans[row][col]) ans[row++][col] = nums[i++]; 22 | row--; col--; // 向下填充 23 | while (i < n && col >= 0 && !ans[row][col]) ans[row][col--] = nums[i++]; 24 | row--; col++; // 向左填充 25 | while (i < n && row >= 0 && !ans[row][col]) ans[row--][col] = nums[i++]; 26 | row++; col++; // 向上填充 27 | } 28 | for (int i = 0; i < m; i++) 29 | for (int j = 0; j < k; j++) 30 | cout << ans[i][j] << (j < k - 1 ? ' ' : '\n'); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /src/乙级/1055.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct Person { 8 | string name; 9 | int height; 10 | }; 11 | 12 | vector people; 13 | 14 | void formate(int &i, int num, deque &q) { 15 | q.push_back(people[i++].name); 16 | while (q.size() < num) { 17 | if (q.size() % 2) q.push_front(people[i++].name); 18 | else q.push_back (people[i++].name); 19 | } 20 | } 21 | 22 | int main() { 23 | int n, k; 24 | cin >> n >> k; 25 | people.resize(n); 26 | for (int i = 0; i < n; i++) 27 | cin >> people[i].name >> people[i].height; 28 | sort(people.begin(), people.end(), [](Person a, Person b) { 29 | return a.height != b.height ? a.height > b.height : a.name < b.name; 30 | }); 31 | int i = 0; 32 | while (i < n) { 33 | deque q; 34 | if (i == 0) formate(i, n / k + n % k, q); 35 | else formate(i, n / k, q); 36 | for (int j = 0; j < q.size(); j++) 37 | cout << q[j] << (j < q.size() - 1 ? ' ' : '\n'); 38 | } 39 | return 0; 40 | } -------------------------------------------------------------------------------- /src/甲级/1109.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct Person { 8 | string name; 9 | int height; 10 | }; 11 | 12 | vector people; 13 | 14 | void formate(int &i, int num, deque &q) { 15 | q.push_back(people[i++].name); 16 | while (q.size() < num) { 17 | if (q.size() % 2) q.push_front(people[i++].name); 18 | else q.push_back (people[i++].name); 19 | } 20 | } 21 | 22 | int main() { 23 | int n, k; 24 | cin >> n >> k; 25 | people.resize(n); 26 | for (int i = 0; i < n; i++) 27 | cin >> people[i].name >> people[i].height; 28 | sort(people.begin(), people.end(), [](Person a, Person b) { 29 | return a.height != b.height ? a.height > b.height : a.name < b.name; 30 | }); 31 | int i = 0; 32 | while (i < n) { 33 | deque q; 34 | if (i == 0) formate(i, n / k + n % k, q); 35 | else formate(i, n / k, q); 36 | for (int j = 0; j < q.size(); j++) 37 | cout << q[j] << (j < q.size() - 1 ? ' ' : '\n'); 38 | } 39 | return 0; 40 | } -------------------------------------------------------------------------------- /src/甲级/1163.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int INF = 0x3f3f3f3f; 6 | const int N = 1005; 7 | int graph[N][N]; 8 | 9 | bool judge(vector order) { 10 | int n = order.size(); 11 | vector mark(n + 1); 12 | vector dist(n + 2, INF); 13 | dist[order.front()] = 0; 14 | for (auto v : order) { 15 | for (int w = 1; w <= n; w++) 16 | if (!mark[w] && dist[w] < dist[v]) 17 | return false; 18 | mark[v] = true; 19 | for (int w = 1; w <= n; w++) 20 | if (graph[v][w] != 0) 21 | dist[w] = min(dist[v] + graph[v][w], dist[w]); 22 | } 23 | return true; 24 | } 25 | 26 | int main() { 27 | int n, m, k; 28 | cin >> n >> m; 29 | for (int i = 0; i < m; i++) { 30 | int v, w; 31 | cin >> v >> w >> graph[v][w]; 32 | graph[w][v] = graph[v][w]; 33 | } 34 | cin >> k; 35 | while (k--) { 36 | vector order(n); 37 | for (int i = 0; i < n; i++) 38 | cin >> order[i]; 39 | cout << (judge(order) ? "Yes" : "No") << endl; 40 | } 41 | return 0; 42 | } -------------------------------------------------------------------------------- /src/甲级/1082.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | string digits[] = { "ling", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu" }; 5 | string measure_words[] = { "Ge", "Shi", "Bai", "Qian", "", " Wan", " Yi"}; 6 | 7 | int main() { 8 | int n; 9 | cin >> n; 10 | if (n == 0) { 11 | cout << "ling" << endl; 12 | return 0; 13 | } else if (n < 0) { 14 | cout << "Fu "; 15 | n = -n; 16 | } 17 | string str = to_string(n); 18 | int len = str.size(); 19 | for (int left = 0, right = (len + 3) % 4; right < len; right += 4) { 20 | bool zero_flag = false; 21 | for (; left <= right; left++) { 22 | if (str[left] == '0') { 23 | zero_flag = true; 24 | } else { 25 | if (zero_flag) cout << " ling"; 26 | if (left != 0) cout << ' '; 27 | cout << digits[str[left] - '0']; 28 | if (left < right) cout << ' ' << measure_words[right - left]; 29 | zero_flag = false; 30 | } 31 | } 32 | cout << measure_words[(len - right) / 4 + 4]; 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /src/甲级/1076.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Vertex { int id, level; }; 7 | 8 | const int MAX_N = 1005; 9 | vector graph[MAX_N]; 10 | 11 | int bfs(int id, int l) { 12 | int res = 0; 13 | queue q; 14 | vector marked(MAX_N); 15 | q.push(Vertex{id, 0}); 16 | marked[id] = true; 17 | 18 | while (!q.empty()) { 19 | Vertex v = q.front(); q.pop(); 20 | if (v.level > l) break; 21 | for (auto w : graph[v.id]) { 22 | if (marked[w.id]) continue; 23 | w.level = v.level + 1; 24 | q.push(w); 25 | marked[w.id] = true; 26 | } 27 | res++; 28 | } 29 | return res - 1; // 转发自己的微博不算数 30 | } 31 | 32 | int main() { 33 | int n, l, m, k, id; 34 | cin >> n >> l; 35 | for (int i = 1; i <= n; i++) { 36 | cin >> m; 37 | while (m--) { 38 | cin >> id; 39 | graph[id].push_back(Vertex{i, 0}); 40 | } 41 | } 42 | cin >> k; 43 | while (k--) { 44 | cin >> id; 45 | cout << bfs(id, l) << endl; 46 | } 47 | return 0; 48 | } -------------------------------------------------------------------------------- /src/甲级/1139.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | const int N = 10000; 9 | set graph[N]; 10 | 11 | int main() { 12 | int n, m, k, a, b; 13 | cin >> n >> m; 14 | while (m--) { 15 | cin >> a >> b; 16 | graph[abs(a)].insert(b); 17 | graph[abs(b)].insert(a); 18 | } 19 | cin >> k; 20 | while (k--) { 21 | vector> ans; 22 | cin >> a >> b; 23 | for (auto c : graph[abs(a)]) { 24 | if (c * a < 0 || c == b) continue; 25 | for (auto d : graph[abs(c)]) { 26 | if (d * b < 0 || d == a) continue; 27 | if (graph[abs(d)].count(b)) ans.push_back({abs(c), abs(d)}); 28 | } 29 | } 30 | sort(ans.begin(), ans.end(), [](pair p1, pair p2) { 31 | return p1.first != p2.first ? p1.first < p2.first : p1.second < p2.second; 32 | }); 33 | printf("%lu\n", ans.size()); 34 | for (auto pair : ans) 35 | printf("%04d %04d\n", pair.first, pair.second); 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /src/甲级/1147.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_max_heap, is_min_heap; 6 | 7 | void test_heap(vector &heap, int id, int child) { 8 | if (child >= heap.size()) return; 9 | if (heap[child] > heap[id]) is_max_heap = false; 10 | if (heap[child] < heap[id]) is_min_heap = false; 11 | } 12 | 13 | void dfs(int id, vector &heap, vector &ans) { 14 | if (id >= heap.size()) return; 15 | int lchild = id * 2 + 1, rchild = id * 2 + 2; 16 | test_heap(heap, id, lchild); 17 | test_heap(heap, id, rchild); 18 | dfs(lchild, heap, ans); 19 | dfs(rchild, heap, ans); 20 | ans.push_back(heap[id]); 21 | } 22 | 23 | int main() { 24 | int m, n; 25 | cin >> m >> n; 26 | while (m--) { 27 | vector heap(n), ans; 28 | for (int i = 0; i < n; i++) 29 | cin >> heap[i]; 30 | is_max_heap = is_min_heap = true; 31 | dfs(0, heap, ans); 32 | cout << (is_max_heap ? "Max Heap" : is_min_heap ? "Min Heap" : "Not Heap") << endl; 33 | for (int i = 0; i < n; i++) 34 | cout << ans[i] << (i < n - 1 ? ' ' : '\n'); 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /src/甲级/1130.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct Node { 6 | string data; 7 | int lchild, rchild; 8 | }; 9 | 10 | int n; 11 | const int N = 25; 12 | Node nodes[N]; 13 | 14 | void dfs(int id) { 15 | if (id == -1) return; 16 | if (nodes[id].lchild == -1 && nodes[id].rchild == -1) { 17 | cout << nodes[id].data; 18 | return; 19 | } 20 | cout << "("; 21 | dfs(nodes[id].lchild); 22 | cout << nodes[id].data; 23 | dfs(nodes[id].rchild); 24 | cout << ")"; 25 | } 26 | 27 | void dfs() { 28 | vector is_root(n + 1, true); 29 | for (int i = 1; i <= n; i++) { 30 | if (nodes[i].lchild != -1) is_root[nodes[i].lchild] = false; 31 | if (nodes[i].rchild != -1) is_root[nodes[i].rchild] = false; 32 | } 33 | int root; 34 | for (int i = 1; i <= n; i++) 35 | if (is_root[i]) root = i; 36 | dfs(nodes[root].lchild); 37 | cout << nodes[root].data; 38 | dfs(nodes[root].rchild); 39 | } 40 | 41 | int main() { 42 | cin >> n; 43 | for (int i = 1; i <= n; i++) 44 | cin >> nodes[i].data >> nodes[i].lchild >> nodes[i].rchild; 45 | dfs(); 46 | return 0; 47 | } -------------------------------------------------------------------------------- /src/甲级/1035.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Account { string name, password; }; 7 | 8 | map transfer { {'1', '@'}, {'0', '%'}, {'l', 'L'}, {'O', 'o'} }; 9 | 10 | int main() { 11 | int n; 12 | cin >> n; 13 | vector accounts(n), modified; 14 | for (int i = 0; i < n; i++) 15 | cin >> accounts[i].name >> accounts[i].password; 16 | for (auto account : accounts) { 17 | bool flag = false; 18 | for (auto &c : account.password) { 19 | if (transfer.count(c)) { 20 | flag = true; 21 | c = transfer[c]; 22 | } 23 | } 24 | if (flag) modified.push_back(account); 25 | } 26 | if (modified.empty()) { 27 | if (accounts.size() == 1) 28 | cout << "There is 1 account and no account is modified" << endl; 29 | else 30 | cout << "There are " << n << " accounts and no account is modified" << endl; 31 | } else { 32 | cout << modified.size() << endl; 33 | for (auto account : modified) 34 | cout << account.name << ' ' << account.password << endl; 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /src/甲级/1161.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int N = 100005; 7 | struct Node { int addr, data, next; } nodes[N]; 8 | 9 | int main() { 10 | int head1, head2, n, addr; 11 | cin >> head1 >> head2 >> n; 12 | for (int i = 0; i < n; i++) 13 | cin >> addr >> nodes[addr].data >> nodes[addr].next; 14 | vector list1, list2, ans; 15 | while (head1 != -1) { 16 | list1.push_back(head1); 17 | head1 = nodes[head1].next; 18 | } 19 | while (head2 != -1) { 20 | list2.push_back(head2); 21 | head2 = nodes[head2].next; 22 | } 23 | if (list1.size() < list2.size()) swap(list1, list2); 24 | reverse(list2.begin(), list2.end()); 25 | 26 | int i = 0, j = 0; 27 | while (j < list2.size()) { 28 | ans.push_back(list1[i++]); 29 | ans.push_back(list1[i++]); 30 | ans.push_back(list2[j++]); 31 | } 32 | while (i < list1.size()) 33 | ans.push_back(list1[i++]); 34 | 35 | for (int i = 0; i < ans.size() - 1; i++) 36 | printf("%05d %d %05d\n", ans[i], nodes[ans[i]].data, ans[i+1]); 37 | printf("%05d %d -1\n", ans.back(), nodes[ans.back()].data); 38 | return 0; 39 | } -------------------------------------------------------------------------------- /src/甲级/1081.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int gcd(int a, int b) { 5 | if (b == 0) return a; 6 | return gcd(b, a % b); 7 | } 8 | 9 | struct Rational { 10 | int n, d; 11 | 12 | Rational(int n, int d) { 13 | int sign1 = n > 0 ? +1 : -1; 14 | int sign2 = d > 0 ? +1 : -1; 15 | int sign = sign1 * sign2; 16 | int factor = gcd(abs(n), abs(d)); 17 | this->n = abs(n) / factor * sign; 18 | this->d = abs(d) / factor; 19 | } 20 | 21 | friend void operator+=(Rational &a, const Rational &b) { 22 | a = Rational(a.n * b.d + a.d * b.n, a.d * b.d); 23 | } 24 | 25 | friend ostream& operator<<(ostream& out, Rational r) { 26 | if (r.n == 0) { out << "0"; return out; } 27 | 28 | int integer = r.n / r.d; 29 | int fraction = r.n % r.d; 30 | if (integer) out << integer << (fraction ? " " : ""); 31 | if (fraction) out << fraction << "/" << r.d; 32 | return out; 33 | } 34 | }; 35 | 36 | int main() { 37 | int m, n, d; 38 | scanf("%d", &m); 39 | Rational ans(0, 1); 40 | while (m--) { 41 | scanf("%d/%d", &n, &d); 42 | ans += Rational(n, d); 43 | } 44 | cout << ans << endl; 45 | } -------------------------------------------------------------------------------- /src/甲级/1057.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int N = 100005; 6 | const int M = 316; 7 | 8 | stack s; 9 | int table[N]; 10 | int block[M]; 11 | 12 | void push(int x) { 13 | s.push(x); 14 | block[x / M]++; 15 | table[x]++; 16 | } 17 | 18 | void pop() { 19 | int x = s.top(); 20 | s.pop(); 21 | block[x / M]--; 22 | table[x]--; 23 | printf("%d\n", x); 24 | } 25 | 26 | void peek_median() { 27 | int cnt = 0, idx = 0, k = (s.size() + 1) / 2; 28 | while (cnt + block[idx] < k) 29 | cnt += block[idx++]; 30 | int num = idx * M; 31 | while (cnt + table[num] < k) 32 | cnt += table[num++]; 33 | printf("%d\n", num); 34 | } 35 | 36 | int main() { 37 | int n, key; 38 | cin >> n; 39 | while (n--) { 40 | string op; 41 | cin >> op; 42 | if (op == "Push") { 43 | cin >> key; 44 | push(key); 45 | } else if (op == "Pop") { 46 | if (s.empty()) printf("Invalid\n"); 47 | else pop(); 48 | } else if (op == "PeekMedian") { 49 | if (s.empty()) printf("Invalid\n"); 50 | else peek_median(); 51 | } 52 | } 53 | return 0; 54 | } -------------------------------------------------------------------------------- /src/甲级/1078.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_prime(int n) { 6 | if (n < 3) return n == 2; 7 | if (n % 2 == 0) return false; 8 | for (int i = 3; i <= n / i; i++) 9 | if (n % i == 0) return false; 10 | return true; 11 | } 12 | 13 | int next_prime(int n) { 14 | if (n < 2) return 2; 15 | int res = n & 1 ? n : n + 1; 16 | while (!is_prime(res)) res += 2; 17 | return res; 18 | } 19 | 20 | int main() { 21 | int m, n; 22 | cin >> m >> n; 23 | int capacity = next_prime(m); 24 | vector ans(n, -1), hash_table(capacity); 25 | 26 | for (int i = 0; i < n; i++) { 27 | int key; 28 | cin >> key; 29 | int hash_value = key % capacity; 30 | for (int j = 0; j < capacity; j++) { 31 | int pos = (hash_value + j * j) % capacity; 32 | if (hash_table[pos] == 0) { 33 | hash_table[pos] = key; 34 | ans[i] = pos; 35 | break; 36 | } 37 | } 38 | } 39 | 40 | for (int i = 0; i < n; i++) { 41 | if (ans[i] == -1) cout << "-"; 42 | else cout << ans[i]; 43 | cout << (i < n - 1 ? ' ' : '\n'); 44 | } 45 | return 0; 46 | } -------------------------------------------------------------------------------- /src/甲级/1022.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | map> maps[6]; 7 | 8 | int main() { 9 | int n, m; 10 | cin >> n; 11 | while (n--) { 12 | int id; 13 | string title, author, key, publisher, year; 14 | cin >> id; getchar(); // skip '\n' 15 | getline(cin, title); 16 | maps[1][title].insert(id); 17 | getline(cin, author); 18 | maps[2][author].insert(id); 19 | while (true) { 20 | char c; 21 | cin >> key; 22 | maps[3][key].insert(id); 23 | if ((c = getchar()) == '\n') break; 24 | } 25 | getline(cin, publisher); 26 | maps[4][publisher].insert(id); 27 | getline(cin, year); 28 | maps[5][year].insert(id); 29 | } 30 | cin >> m; 31 | while (m--) { 32 | int type; 33 | string key; 34 | scanf("%d: ", &type); 35 | getline(cin, key); 36 | printf("%d: %s\n", type, key.c_str()); 37 | if (maps[type][key].empty()) { 38 | printf("Not Found\n"); 39 | continue; 40 | } 41 | for (auto id : maps[type][key]) 42 | printf("%07d\n", id); 43 | } 44 | return 0; 45 | } -------------------------------------------------------------------------------- /src/乙级/1017.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct BigInt { 7 | vector digits; 8 | 9 | friend istream& operator>>(istream &in, BigInt &num) { 10 | string str; 11 | in >> str; 12 | for (auto it = str.rbegin(); it != str.rend(); it++) 13 | num.digits.push_back(*it - '0'); 14 | return in; 15 | } 16 | 17 | friend ostream& operator<<(ostream &out, const BigInt &num) { 18 | for (auto it = num.digits.rbegin(); it != num.digits.rend(); it++) 19 | cout << *it; 20 | return out; 21 | } 22 | 23 | friend BigInt divide(BigInt a, int b, int &r) { 24 | r = 0; 25 | BigInt c; 26 | const int n = a.digits.size(); 27 | c.digits.resize(n); 28 | for (int i = n - 1; i >= 0; i--) { 29 | r = r * 10 + a.digits[i]; 30 | c.digits[i] = r / b; 31 | r %= b; 32 | } 33 | while (c.digits.size() > 1 && c.digits.back() == 0) 34 | c.digits.pop_back(); 35 | return c; 36 | } 37 | }; 38 | 39 | int main() { 40 | BigInt a; 41 | int b, r; 42 | cin >> a >> b; 43 | BigInt c = divide(a, b, r); 44 | cout << c << " " << r << endl; 45 | } -------------------------------------------------------------------------------- /src/甲级/1118.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct UnionFindSet { 6 | vector id; 7 | 8 | UnionFindSet(int size) : id(size + 1) { 9 | for (int i = 1; i <= size; i++) 10 | id[i] = i; 11 | } 12 | 13 | int find(int x) { 14 | if (id[x] == x) return x; 15 | return id[x] = find(id[x]); 16 | } 17 | 18 | void union_sets(int x, int y) { 19 | int a = find(x), b = find(y); 20 | id[a] = b; 21 | } 22 | 23 | bool connected(int x, int y) { 24 | return find(x) == find(y); 25 | } 26 | }; 27 | 28 | const int N = 10005; 29 | UnionFindSet s(N); 30 | 31 | int main() { 32 | int n, m, k, x, y; 33 | int num = 0, cnt = 0; 34 | cin >> n; 35 | while (n--) { 36 | cin >> m >> x; 37 | num = max(x, num); 38 | while (--m) { 39 | cin >> y; 40 | s.union_sets(x, y); 41 | num = max(y, num); 42 | } 43 | } 44 | for (int i = 1; i <= num; i++) 45 | cnt += s.id[i] == i; 46 | cout << cnt << " " << num << endl; 47 | cin >> k; 48 | while (k--) { 49 | cin >> x >> y; 50 | cout << (s.connected(x, y) ? "Yes" : "No") << endl; 51 | } 52 | return 0; 53 | } -------------------------------------------------------------------------------- /src/甲级/1142.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int n, m; 7 | const int N = 205; 8 | bool graph[N][N]; 9 | 10 | bool is_clique(const vector &clique) { 11 | for (int i = 0; i < clique.size(); i++) 12 | for (int j = i + 1; j < clique.size(); j++) 13 | if (!graph[clique[i]][clique[j]]) return false; 14 | return true; 15 | } 16 | 17 | bool is_max(const vector &clique) { 18 | set vetices(clique.begin(), clique.end()); 19 | for (int v = 1; v <= n; v++) { 20 | if (vetices.count(v)) continue; 21 | bool flag = true; 22 | for (auto w : clique) 23 | if (!graph[v][w]) flag = false; 24 | if (flag) return false; 25 | } 26 | return true; 27 | } 28 | 29 | int main() { 30 | int k, l; 31 | cin >> n >> m; 32 | for (int i = 0; i < m; i++) { 33 | int v, w; 34 | cin >> v >> w; 35 | graph[v][w] = graph[w][v] = true; 36 | } 37 | cin >> k; 38 | while (k--) { 39 | cin >> l; 40 | vector clique(l); 41 | for (int i = 0; i < l; i++) 42 | cin >> clique[i]; 43 | cout << (!is_clique(clique) ? "Not a Clique" : !is_max(clique) ? "Not Maximal" : "Yes") << endl; 44 | } 45 | return 0; 46 | } -------------------------------------------------------------------------------- /src/乙级/1080.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct Student { 8 | string name; 9 | int assign = -1, mid = -1, final = -1, total = -1; 10 | }; 11 | 12 | int main() { 13 | int n, m, k; 14 | cin >> n >> m >> k; 15 | int score; 16 | string name; 17 | map students; 18 | while (n--) { 19 | cin >> name >> score; 20 | students[name].assign = score; 21 | } 22 | while (m--) { 23 | cin >> name >> score; 24 | students[name].mid = score; 25 | } 26 | while (k--) { 27 | cin >> name >> score; 28 | students[name].final = score; 29 | } 30 | vector ans; 31 | for (auto entry : students) { 32 | Student s = entry.second; 33 | s.name = entry.first; 34 | s.total = ((s.mid > s.final ? s.mid * 0.4 + s.final * 0.6 : s.final) + 0.5); 35 | if (s.assign >= 200 && s.total >= 60) ans.push_back(s); 36 | } 37 | sort(ans.begin(), ans.end(), [](Student a, Student b) { 38 | return a.total != b.total ? a.total > b.total : a.name < b.name; 39 | }); 40 | for (auto s : ans) 41 | printf("%s %d %d %d %d\n", s.name.c_str(), s.assign, s.mid, s.final, s.total); 42 | return 0; 43 | } -------------------------------------------------------------------------------- /src/甲级/1137.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct Student { 8 | string name; 9 | int assign = -1, mid = -1, final = -1, total = -1; 10 | }; 11 | 12 | int main() { 13 | int n, m, k; 14 | cin >> n >> m >> k; 15 | int score; 16 | string name; 17 | map students; 18 | while (n--) { 19 | cin >> name >> score; 20 | students[name].assign = score; 21 | } 22 | while (m--) { 23 | cin >> name >> score; 24 | students[name].mid = score; 25 | } 26 | while (k--) { 27 | cin >> name >> score; 28 | students[name].final = score; 29 | } 30 | vector ans; 31 | for (auto entry : students) { 32 | Student s = entry.second; 33 | s.name = entry.first; 34 | s.total = ((s.mid > s.final ? s.mid * 0.4 + s.final * 0.6 : s.final) + 0.5); 35 | if (s.assign >= 200 && s.total >= 60) ans.push_back(s); 36 | } 37 | sort(ans.begin(), ans.end(), [](Student a, Student b) { 38 | return a.total != b.total ? a.total > b.total : a.name < b.name; 39 | }); 40 | for (auto s : ans) 41 | printf("%s %d %d %d %d\n", s.name.c_str(), s.assign, s.mid, s.final, s.total); 42 | return 0; 43 | } -------------------------------------------------------------------------------- /src/甲级/1059.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct Factor { 6 | int factor; 7 | int count; 8 | }; 9 | 10 | const int MAXF = 10005; 11 | 12 | int main() { 13 | int n; 14 | cin >> n; 15 | if (n == 1) { cout << "1=1" << endl; return 0; } 16 | 17 | vector primes; 18 | vector is_prime(MAXF, true); 19 | for (int i = 2; i < MAXF; i++) { 20 | if (!is_prime[i]) continue; 21 | primes.push_back(i); 22 | for (int j = i * i; j < MAXF; j += i) 23 | is_prime[j] = false; 24 | } 25 | 26 | int tmp = n; 27 | vector ans; 28 | for (int i = 0; i < MAXF; i++) { 29 | if (primes[i] > tmp / primes[i]) break; 30 | if (tmp % primes[i]) continue; 31 | 32 | int count = 0; 33 | while (tmp % primes[i] == 0) { 34 | count++; 35 | tmp /= primes[i]; 36 | } 37 | ans.push_back(Factor{primes[i], count}); 38 | } 39 | if (tmp != 1) ans.push_back(Factor{tmp, 1}); 40 | 41 | cout << n << "="; 42 | for (int i = 0; i < ans.size(); i++) { 43 | cout << ans[i].factor; 44 | if (ans[i].count > 1) cout << "^" << ans[i].count; 45 | cout << (i < ans.size() - 1 ? '*' : '\n'); 46 | } 47 | return 0; 48 | } -------------------------------------------------------------------------------- /src/乙级/1012.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | int n, num, sum; 8 | vector nums[5]; 9 | cin >> n; 10 | while (n--) { 11 | cin >> num; 12 | if (num % 5) 13 | nums[num % 5].push_back(num); 14 | else if (num % 2 == 0) 15 | nums[0].push_back(num); 16 | } 17 | // A1 18 | sum = 0; 19 | for (auto num : nums[0]) 20 | sum += num & 1 ? 0 : num; 21 | if (nums[0].empty()) printf("N "); 22 | else printf("%d ", sum); 23 | // A2 24 | sum = 0; 25 | int sign = 1; 26 | for (auto num : nums[1]) { 27 | sum += sign * num; 28 | sign *= -1; 29 | } 30 | if (nums[1].empty()) printf("N "); 31 | else printf("%d ", sum); 32 | // A3 33 | if (nums[2].empty()) printf("N "); 34 | else printf("%d ", (int)nums[2].size()); 35 | // A4 36 | sum = 0; 37 | for (auto num : nums[3]) 38 | sum += num; 39 | if (nums[3].empty()) printf("N "); 40 | else printf("%.1f ", (double)sum / nums[3].size()); 41 | // A5 42 | if (nums[4].empty()) printf("N\n"); 43 | else printf("%d\n", *max_element(nums[4].begin(), nums[4].end())); 44 | return 0; 45 | } -------------------------------------------------------------------------------- /src/乙级/1018.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int to_number(char c) { 4 | switch(c) { 5 | case 'B': return 0; 6 | case 'C': return 1; 7 | case 'J': return 2; 8 | default: return -1; 9 | } 10 | } 11 | 12 | int win(int n1, int n2) { 13 | return (n1 + 1) % 3 == n2; 14 | } 15 | 16 | int main() { 17 | int n, count[3] = {}, win_count1[3] = {}, win_count2[3] = {}; 18 | scanf("%d", &n); 19 | while (n--) { 20 | char c1, c2; 21 | getchar(); 22 | scanf("%c %c", &c1, &c2); 23 | int n1 = to_number(c1), n2 = to_number(c2); 24 | if (win(n1, n2)) { 25 | count[0]++; 26 | win_count1[n1]++; 27 | } else if (win(n2, n1)) { 28 | count[2]++; 29 | win_count2[n2]++; 30 | } else { 31 | count[1]++; 32 | } 33 | } 34 | int idx1 = 0, idx2 = 0; 35 | for (int i = 0; i < 3; i++) { 36 | if (win_count1[i] > win_count1[idx1]) 37 | idx1 = i; 38 | if (win_count2[i] > win_count2[idx2]) 39 | idx2 = i; 40 | } 41 | char to_character[3] = {'B', 'C', 'J'}; 42 | printf("%d %d %d\n", count[0], count[1], count[2]); 43 | printf("%d %d %d\n", count[2], count[1], count[0]); 44 | printf("%c %c\n", to_character[idx1], to_character[idx2]); 45 | return 0; 46 | } -------------------------------------------------------------------------------- /src/甲级/1053.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int MAX_N = 105, ROOT = 0; 7 | 8 | struct TreeNode { 9 | int weight; 10 | vector children; 11 | }; 12 | TreeNode nodes[MAX_N]; 13 | 14 | vector path; 15 | 16 | void dfs(int id, int sum, int s) { 17 | if (sum > s) return; 18 | 19 | if (nodes[id].children.empty() && sum == s) 20 | for (int i = 0; i < path.size(); i++) 21 | cout << nodes[path[i]].weight << (i < path.size() - 1 ? ' ' : '\n'); 22 | 23 | for (auto child : nodes[id].children) { 24 | path.push_back(child); 25 | dfs(child, sum + nodes[child].weight, s); 26 | path.pop_back(); 27 | } 28 | } 29 | 30 | int main() { 31 | int n, m, s; 32 | cin >> n >> m >> s; 33 | for (int i = 0; i < n; i++) 34 | cin >> nodes[i].weight; 35 | while (m--) { 36 | int id, k, child; 37 | cin >> id >> k; 38 | while (k--) { 39 | cin >> child; 40 | nodes[id].children.push_back(child); 41 | } 42 | sort(nodes[id].children.begin(), nodes[id].children.end(), [](int a, int b) { 43 | return nodes[a].weight > nodes[b].weight; 44 | }); 45 | } 46 | path.push_back(ROOT); 47 | dfs(ROOT, nodes[ROOT].weight, s); 48 | return 0; 49 | } -------------------------------------------------------------------------------- /src/甲级/1014.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int START = 8 * 60, END = 17 * 60; 6 | 7 | struct Window { 8 | queue q; 9 | int end, free; 10 | }; 11 | 12 | int main() { 13 | int n, m, k, q; 14 | cin >> n >> m >> k >> q; 15 | Window windows[n]; 16 | int serve_time[k], ans[k]; 17 | for (int i = 0; i < k; i++) cin >> serve_time[i]; 18 | for (int i = 0; i < n; i++) windows[i].end = START; 19 | 20 | int idx = 0; 21 | while (idx < k) { 22 | Window &w = windows[idx % n]; 23 | if (w.q.size() >= m) break; 24 | w.q.push(idx); 25 | w.end += serve_time[idx]; 26 | w.free = START + serve_time[w.q.front()]; 27 | ans[idx++] = w.end; 28 | } 29 | while (idx < k) { 30 | int min = 0; 31 | for (int i = 0; i < n; i++) 32 | if (windows[i].free < windows[min].free) 33 | min = i; 34 | Window &w = windows[min]; 35 | w.q.pop(); 36 | w.end += serve_time[idx]; 37 | w.free += serve_time[w.q.front()]; 38 | ans[idx++] = w.end; 39 | } 40 | while (q--) { 41 | cin >> idx; 42 | if (ans[idx - 1] - serve_time[idx - 1] >= END) printf("Sorry\n"); 43 | else printf("%02d:%02d\n", ans[idx - 1] / 60, ans[idx - 1] % 60); 44 | } 45 | return 0; 46 | } -------------------------------------------------------------------------------- /src/乙级/1085.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct School { 8 | int rank, count; 9 | string name; 10 | double total; 11 | }; 12 | 13 | int main() { 14 | int n; 15 | cin >> n; 16 | map tmp; 17 | while (n--) { 18 | double score; 19 | string id, name; 20 | cin >> id >> score >> name; 21 | for (auto &c : name) c = tolower(c); 22 | double weight = id[0] == 'B' ? 1.0 / 1.5 : id[0] == 'A' ? 1.0 : 1.5; 23 | tmp[name].count++; 24 | tmp[name].name = name; 25 | tmp[name].total += weight * score; 26 | } 27 | vector ans; 28 | for (auto entry : tmp) { 29 | entry.second.total = (int)entry.second.total; 30 | ans.push_back(entry.second); 31 | } 32 | sort(ans.begin(), ans.end(), [](School a, School b) { 33 | if (a.total != b.total) return a.total > b.total; 34 | if (a.count != b.count) return a.count < b.count; 35 | return a.name < b.name; 36 | }); 37 | ans[0].rank = 1; 38 | for (int i = 1; i < ans.size(); i++) 39 | ans[i].rank = ans[i].total == ans[i-1].total ? ans[i-1].rank : i + 1; 40 | printf("%lu\n", ans.size()); 41 | for (auto x : ans) 42 | printf("%d %s %d %d\n", x.rank, x.name.c_str(), (int)x.total, x.count); 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/甲级/1141.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct School { 8 | int rank, count; 9 | string name; 10 | double total; 11 | }; 12 | 13 | int main() { 14 | int n; 15 | cin >> n; 16 | map tmp; 17 | while (n--) { 18 | double score; 19 | string id, name; 20 | cin >> id >> score >> name; 21 | for (auto &c : name) c = tolower(c); 22 | double weight = id[0] == 'B' ? 1.0 / 1.5 : id[0] == 'A' ? 1.0 : 1.5; 23 | tmp[name].count++; 24 | tmp[name].name = name; 25 | tmp[name].total += weight * score; 26 | } 27 | vector ans; 28 | for (auto entry : tmp) { 29 | entry.second.total = (int)entry.second.total; 30 | ans.push_back(entry.second); 31 | } 32 | sort(ans.begin(), ans.end(), [](School a, School b) { 33 | if (a.total != b.total) return a.total > b.total; 34 | if (a.count != b.count) return a.count < b.count; 35 | return a.name < b.name; 36 | }); 37 | ans[0].rank = 1; 38 | for (int i = 1; i < ans.size(); i++) 39 | ans[i].rank = ans[i].total == ans[i-1].total ? ans[i-1].rank : i + 1; 40 | printf("%lu\n", ans.size()); 41 | for (auto x : ans) 42 | printf("%d %s %d %d\n", x.rank, x.name.c_str(), (int)x.total, x.count); 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/甲级/1023.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct BigInt { 7 | vector digits; 8 | 9 | friend istream& operator>>(istream &in, BigInt &num) { 10 | string str; 11 | cin >> str; 12 | for (auto it = str.rbegin(); it != str.rend(); it++) 13 | num.digits.push_back(*it - '0'); 14 | return in; 15 | } 16 | 17 | friend ostream& operator<<(ostream &out, const BigInt &num) { 18 | for (auto it = num.digits.rbegin(); it != num.digits.rend(); it++) 19 | cout << *it; 20 | return out; 21 | } 22 | 23 | friend BigInt multiply(const BigInt &a, int b) { 24 | BigInt c; 25 | int carry = 0; 26 | for (auto d : a.digits) { 27 | int temp = d * b + carry; 28 | c.digits.push_back(temp % 10); 29 | carry = temp / 10; 30 | } 31 | if (carry) c.digits.push_back(carry % 10); 32 | return c; 33 | } 34 | }; 35 | 36 | int main() { 37 | BigInt num; 38 | cin >> num; 39 | vector counts(10); 40 | for (auto d : num.digits) counts[d]++; 41 | num = multiply(num, 2); 42 | for (auto d : num.digits) counts[d]--; 43 | bool flag = true; 44 | for (auto cnt : counts) 45 | if (cnt != 0) flag = false; 46 | cout << (flag ? "Yes" : "No") << endl << num << endl; 47 | return 0; 48 | } -------------------------------------------------------------------------------- /src/乙级/1015.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | enum Type { SAGE, NOBLE, FOOL, SMALL }; 7 | 8 | struct Person { 9 | int id; 10 | int virtue, talent, total; 11 | Type type; 12 | }; 13 | 14 | int main() { 15 | int n, lower, upper; 16 | cin >> n >> lower >> upper; 17 | vector people; 18 | while (n--) { 19 | Person tmp; 20 | cin >> tmp.id >> tmp.virtue >> tmp.talent; 21 | if (tmp.virtue < lower || tmp.talent < lower) 22 | continue; 23 | else if (tmp.virtue >= upper && tmp.talent >= upper) 24 | tmp.type = SAGE; 25 | else if (tmp.virtue >= upper) 26 | tmp.type = NOBLE; 27 | else if (tmp.talent > tmp.virtue) 28 | tmp.type = SMALL; 29 | else 30 | tmp.type = FOOL; 31 | tmp.total = tmp.virtue + tmp.talent; 32 | people.push_back(tmp); 33 | } 34 | sort(people.begin(), people.end(), [](Person a, Person b) { 35 | if (a.type != b.type) return a.type < b.type; 36 | if (a.total != b.total) return a.total > b.total; 37 | if (a.virtue != b.virtue) return a.virtue > b.virtue; 38 | return a.id < b.id; 39 | }); 40 | printf("%lu\n", people.size()); 41 | for (auto person : people) 42 | printf("%08d %d %d\n", person.id, person.virtue, person.talent); 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/甲级/1062.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | enum Type { SAGE, NOBLE, FOOL, SMALL }; 7 | 8 | struct Person { 9 | int id; 10 | int virtue, talent, total; 11 | Type type; 12 | }; 13 | 14 | int main() { 15 | int n, lower, upper; 16 | cin >> n >> lower >> upper; 17 | vector people; 18 | while (n--) { 19 | Person tmp; 20 | cin >> tmp.id >> tmp.virtue >> tmp.talent; 21 | if (tmp.virtue < lower || tmp.talent < lower) 22 | continue; 23 | else if (tmp.virtue >= upper && tmp.talent >= upper) 24 | tmp.type = SAGE; 25 | else if (tmp.virtue >= upper) 26 | tmp.type = NOBLE; 27 | else if (tmp.talent > tmp.virtue) 28 | tmp.type = SMALL; 29 | else 30 | tmp.type = FOOL; 31 | tmp.total = tmp.virtue + tmp.talent; 32 | people.push_back(tmp); 33 | } 34 | sort(people.begin(), people.end(), [](Person a, Person b) { 35 | if (a.type != b.type) return a.type < b.type; 36 | if (a.total != b.total) return a.total > b.total; 37 | if (a.virtue != b.virtue) return a.virtue > b.virtue; 38 | return a.id < b.id; 39 | }); 40 | printf("%lu\n", people.size()); 41 | for (auto person : people) 42 | printf("%08d %d %d\n", person.id, person.virtue, person.talent); 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/甲级/1110.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct TreeNode { 8 | int left = -1; 9 | int right = -1; 10 | }; 11 | vector nodes; 12 | 13 | int find_root() { 14 | set children; 15 | for (auto node : nodes) { 16 | children.insert(node.left); 17 | children.insert(node.right); 18 | } 19 | for (int i = 0; i < nodes.size(); i++) 20 | if (!children.count(i)) return i; 21 | return -1; 22 | } 23 | 24 | int last; 25 | bool is_complete(int root) { 26 | queue q; 27 | q.push(root); 28 | while (true) { 29 | int temp = q.front(); q.pop(); 30 | if (temp == -1) break; 31 | q.push(nodes[temp].left); 32 | q.push(nodes[temp].right); 33 | last = temp; 34 | } 35 | while (!q.empty()) { 36 | if (q.front() != -1) return false; 37 | q.pop(); 38 | } 39 | return true; 40 | } 41 | 42 | int main() { 43 | int n; 44 | scanf("%d", &n); 45 | nodes.resize(n); 46 | for (int i = 0; i < n; i++) { 47 | string left, right; 48 | cin >> left >> right; 49 | if (left != "-") nodes[i].left = stoi(left); 50 | if (right != "-") nodes[i].right = stoi(right); 51 | } 52 | int root = find_root(); 53 | if (is_complete(root)) printf("YES %d\n", last); 54 | else printf("NO %d\n" , root); 55 | return 0; 56 | } -------------------------------------------------------------------------------- /src/甲级/1012.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int COURSE_NUM = 4; 6 | char course_symbol[] = {'A', 'C', 'M', 'E'}; 7 | 8 | struct Student { 9 | int id; 10 | int scores[COURSE_NUM]; 11 | } students[2005]; 12 | int ranks[1000005][COURSE_NUM]; 13 | 14 | int main() { 15 | int n, m; 16 | cin >> n >> m; 17 | for (int i = 0; i < n; i++) { 18 | cin >> students[i].id; 19 | for (int j = 1; j < COURSE_NUM; j++) { 20 | cin >> students[i].scores[j]; 21 | students[i].scores[0] += students[i].scores[j]; 22 | } 23 | } 24 | for (int course = 0; course < COURSE_NUM; course++) { 25 | sort(students, students + n, [course](Student a, Student b) { 26 | return a.scores[course] > b.scores[course]; 27 | }); 28 | ranks[students[0].id][course] = 1; 29 | for (int i = 1; i < n; i++) { 30 | int cur = students[i].id, pre = students[i - 1].id; 31 | ranks[cur][course] = students[i].scores[course] < students[i - 1].scores[course] ? i + 1 : ranks[pre][course]; 32 | } 33 | } 34 | while (m--) { 35 | int id, best = 0; 36 | cin >> id; 37 | if (ranks[id][0] == 0) { printf("N/A\n"); continue; } 38 | for (int i = 1; i < COURSE_NUM; i++) 39 | if (ranks[id][i] < ranks[id][best]) best = i; 40 | printf("%d %c\n", ranks[id][best], course_symbol[best]); 41 | } 42 | return 0; 43 | } -------------------------------------------------------------------------------- /src/甲级/1017.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Client { int arrive, served; }; 7 | 8 | int convert(int hour, int minute, int second) { 9 | return hour * 3600 + minute * 60 + second; 10 | } 11 | 12 | int main() { 13 | int n, k, begin = convert(8, 0, 0), end = convert(17, 0, 0); 14 | scanf("%d%d", &n, &k); 15 | vector clients(n); 16 | vector windows(k, begin); 17 | for (int i = 0; i < n; i++) { 18 | int hour, minute, second, served; 19 | scanf("%d:%d:%d %d", &hour, &minute, &second, &served); 20 | clients[i].arrive = convert(hour, minute, second); 21 | clients[i].served = served > 60 ? 3600 : served * 60; 22 | } 23 | sort(clients.begin(), clients.end(), [](Client a, Client b) { 24 | return a.arrive < b.arrive; 25 | }); 26 | int count = 0, total = 0; 27 | for (int i = 0; i < n; i++) { 28 | if (clients[i].arrive > end) break; 29 | int free = 0; 30 | for (int j = 0; j < k; j++) 31 | if (windows[j] < windows[free]) free = j; 32 | if (windows[free] < clients[i].arrive) { 33 | windows[free] = clients[i].arrive + clients[i].served; 34 | } else { 35 | total += windows[free] - clients[i].arrive; 36 | windows[free] += clients[i].served; 37 | } 38 | count++; 39 | } 40 | printf("%.1f\n", (double)total / 60 / count); 41 | return 0; 42 | } -------------------------------------------------------------------------------- /src/甲级/1160.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int digit_sum(int num) { 8 | int sum = 0; 9 | while (num) { 10 | sum += num % 10; 11 | num /= 10; 12 | } 13 | return sum; 14 | } 15 | 16 | bool is_prime(int num) { 17 | if (num < 3) return num == 2; 18 | if (num % 2 == 0) return false; 19 | for (int i = 3; i <= num / i; i += 2) 20 | if (num % i == 0) return false; 21 | return true; 22 | } 23 | 24 | int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } 25 | 26 | int main() { 27 | int t; 28 | cin >> t; 29 | for (int i = 1; i <= t; i++) { 30 | int k, m; 31 | cin >> k >> m; 32 | vector> ans; 33 | int begin = pow(10, k - 1), end = pow(10, k); 34 | for (int i = begin + 9; i < end; i += 10) { 35 | if (digit_sum(i) != m) continue; 36 | int n = digit_sum(i + 1), d = gcd(m, n); 37 | if (is_prime(d) && d > 2) 38 | ans.push_back({n, i}); 39 | } 40 | sort(ans.begin(), ans.end(), [](pair a, pair b) { 41 | return a.first != b.first ? a.first < b.first : a.second < b.second; 42 | }); 43 | printf("Case %d\n", i); 44 | if (ans.empty()) printf("No Solution\n"); 45 | for (auto entry : ans) 46 | printf("%d %d\n", entry.first, entry.second); 47 | } 48 | return 0; 49 | } -------------------------------------------------------------------------------- /src/甲级/1086.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct TreeNode { 6 | int key; 7 | TreeNode *left; 8 | TreeNode *right; 9 | 10 | TreeNode(int key) : key(key), left(nullptr), right(nullptr) {} 11 | }; 12 | 13 | using Iterator = vector::iterator; 14 | 15 | TreeNode* create_tree(Iterator pre, Iterator in, int len) { 16 | if (len <= 0) return nullptr; 17 | 18 | int i = 0; 19 | TreeNode *root = new TreeNode(*pre); 20 | while (i < len && in[i] != root->key) i++; 21 | root->left = create_tree(pre + 1, in, i); 22 | root->right = create_tree(pre + i + 1, in + i + 1, len - i - 1); 23 | return root; 24 | } 25 | 26 | void post_order(TreeNode *root) { 27 | if (root == nullptr) return; 28 | 29 | post_order(root->left); 30 | post_order(root->right); 31 | cout << root->key << ' '; 32 | } 33 | 34 | int main() { 35 | int n; 36 | cin >> n; 37 | vector s, pre, in; 38 | for (int i = 0; i < 2 * n; i++) { 39 | string op; 40 | cin >> op; 41 | if (op == "Push") { 42 | int key; 43 | cin >> key; 44 | s.push_back(key); 45 | pre.push_back(key); 46 | } else { 47 | in.push_back(s.back()); 48 | s.pop_back(); 49 | } 50 | } 51 | TreeNode *root = create_tree(pre.begin(), in.begin(), n); 52 | post_order(root->left); 53 | post_order(root->right); 54 | cout << root->key << endl; 55 | return 0; 56 | } -------------------------------------------------------------------------------- /src/甲级/1003.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int N = 505, INF = 0x3f3f3f3f; 6 | int n, m, cnt[N], num[N], weight[N], graph[N][N]; 7 | 8 | void shortest_path(int src, int dest) { 9 | vector marked(n); 10 | vector dist(n + 1, INF); 11 | 12 | dist[src] = 0; 13 | cnt[src] = 1; 14 | num[src] = weight[src]; 15 | 16 | while (true) { 17 | int v = n; 18 | for (int w = 0; w < n; w++) 19 | if (!marked[w] && dist[w] < dist[v]) 20 | v = w; 21 | if (v == dest) break; 22 | 23 | marked[v] = true; 24 | for (int w = 0; w < n; w++) { 25 | if (!graph[v][w] || marked[w]) continue; 26 | if (dist[w] > dist[v] + graph[v][w]) { 27 | dist[w] = dist[v] + graph[v][w]; 28 | cnt[w] = cnt[v]; 29 | num[w] = num[v] + weight[w]; 30 | } else if (dist[w] == dist[v] + graph[v][w]) { 31 | cnt[w] += cnt[v]; 32 | num[w] = max(num[v] + weight[w], num[w]); 33 | } 34 | } 35 | } 36 | } 37 | 38 | int main() { 39 | int src, dest; 40 | cin >> n >> m >> src >> dest; 41 | for (int i = 0; i < n; i++) cin >> weight[i]; 42 | for (int i = 0; i < m; i++) { 43 | int v, w; 44 | cin >> v >> w >> graph[v][w]; 45 | graph[w][v] = graph[v][w]; 46 | } 47 | shortest_path(src, dest); 48 | cout << cnt[dest] << " " << num[dest] << endl; 49 | return 0; 50 | } -------------------------------------------------------------------------------- /src/甲级/1021.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | const int N = 10005; 8 | vector graph[N]; 9 | vector marked(N); 10 | 11 | void dfs(int v) { 12 | marked[v] = true; 13 | for (auto w : graph[v]) 14 | if (!marked[w]) dfs(w); 15 | } 16 | 17 | int max_depth; 18 | void dfs(int v, set &s, int depth = 0) { 19 | if (depth > max_depth) { 20 | max_depth = depth; 21 | s.clear(); 22 | s.insert(v); 23 | } else if (depth == max_depth) { 24 | s.insert(v); 25 | } 26 | 27 | marked[v] = true; 28 | for (auto w : graph[v]) 29 | if (!marked[w]) dfs(w, s, depth + 1); 30 | } 31 | 32 | int main() { 33 | int n; 34 | cin >> n; 35 | for (int i = 0; i < n - 1; i++) { 36 | int v, w; 37 | cin >> v >> w; 38 | graph[v].push_back(w); 39 | graph[w].push_back(v); 40 | } 41 | 42 | int count = 0; 43 | fill(marked.begin(), marked.end(), false); 44 | for (int v = 1; v <= n; v++) { 45 | if (marked[v]) continue; 46 | dfs(v); 47 | count++; 48 | } 49 | if (count != 1) { 50 | printf("Error: %d components\n", count); 51 | return 0; 52 | } 53 | 54 | set tmp; 55 | fill(marked.begin(), marked.end(), false); 56 | dfs(1, tmp); 57 | set ans(tmp); 58 | fill(marked.begin(), marked.end(), false); 59 | dfs(*ans.begin(), tmp); 60 | for (auto v : tmp) ans.insert(v); 61 | 62 | for (auto v : ans) printf("%d\n", v); 63 | return 0; 64 | } -------------------------------------------------------------------------------- /src/甲级/1100.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | const int BASE = 13; 9 | 10 | string num2str(int num) { 11 | static string digits1[BASE] {"tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov", "dec"}; 12 | static string digits2[BASE] {" ", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer", "jou"}; 13 | string result; 14 | if (num / BASE) { 15 | result = digits2[num / BASE]; 16 | if (num % BASE) result += " " + digits1[num % BASE]; 17 | } else { 18 | result = digits1[num % BASE]; 19 | } 20 | return result; 21 | } 22 | 23 | int str2num(string str) { 24 | static map nums1 {{"jan", 1}, {"feb", 2}, {"mar", 3}, {"apr", 4}, {"may", 5}, {"jun", 6}, {"jly", 7}, {"aug", 8}, {"sep", 9}, {"oct", 10}, {"nov", 11}, {"dec", 12}, {"tret", 0}}; 25 | static map nums2 {{"tam", 1}, {"hel", 2}, {"maa", 3}, {"huh", 4}, {"tou", 5}, {"kes", 6}, {"hei", 7}, {"elo", 8}, {"syy", 9}, {"lok", 10}, {"mer", 11}, {"jou", 12}}; 26 | int result = 0; 27 | string num; 28 | stringstream sin(str); 29 | while (sin >> num) 30 | result += nums2[num] * BASE + nums1[num]; 31 | return result; 32 | } 33 | 34 | int main() { 35 | int n; 36 | scanf("%d\n", &n); 37 | while (n--) { 38 | string s; 39 | getline(cin, s); 40 | if (isdigit(s[0])) cout << num2str(stoi(s)) << endl; 41 | else cout << str2num(s) << endl; 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/乙级/1044.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | const int BASE = 13; 9 | 10 | string num2str(int num) { 11 | static const string digits1[BASE] {"tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov", "dec"}; 12 | static const string digits2[BASE] {" ", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer", "jou"}; 13 | string result; 14 | if (num / BASE) { 15 | result = digits2[num / BASE]; 16 | if (num % BASE) result += " " + digits1[num % BASE]; 17 | } else { 18 | result = digits1[num % BASE]; 19 | } 20 | return result; 21 | } 22 | 23 | int str2num(string str) { 24 | static map nums1 {{"jan", 1}, {"feb", 2}, {"mar", 3}, {"apr", 4}, {"may", 5}, {"jun", 6}, {"jly", 7}, {"aug", 8}, {"sep", 9}, {"oct", 10}, {"nov", 11}, {"dec", 12}, {"tret", 0}}; 25 | static map nums2 {{"tam", 1}, {"hel", 2}, {"maa", 3}, {"huh", 4}, {"tou", 5}, {"kes", 6}, {"hei", 7}, {"elo", 8}, {"syy", 9}, {"lok", 10}, {"mer", 11}, {"jou", 12}}; 26 | int result = 0; 27 | string num; 28 | stringstream sin(str); 29 | while (sin >> num) 30 | result += nums2[num] * BASE + nums1[num]; 31 | return result; 32 | } 33 | 34 | int main() { 35 | int n; 36 | scanf("%d\n", &n); 37 | while (n--) { 38 | string s; 39 | getline(cin, s); 40 | if (isdigit(s[0])) cout << num2str(stoi(s)) << endl; 41 | else cout << str2num(s) << endl; 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /src/甲级/1034.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct Gang { int num, val, max; }; 6 | 7 | const int N = 2005; 8 | bool marked[N]; 9 | int weights[N]; 10 | int graph[N][N]; 11 | map ans; 12 | 13 | map name2id; 14 | map id2name; 15 | int id(string name) { 16 | if (name2id.count(name)) return name2id[name]; 17 | int new_id = name2id[name] = name2id.size(); 18 | id2name[new_id] = name; 19 | return new_id; 20 | } 21 | 22 | void dfs(int v, Gang &gang) { 23 | marked[v] = true; 24 | gang.num++; 25 | gang.val += weights[v]; 26 | gang.max = weights[v] > weights[gang.max] ? v : gang.max; 27 | 28 | for (int w = 0; w < name2id.size(); w++) 29 | if (!marked[w] && graph[v][w]) dfs(w, gang); 30 | } 31 | 32 | void dfs(int k) { 33 | for (int v = 0; v < name2id.size(); v++) { 34 | if (marked[v]) continue; 35 | Gang gang{0, 0, v}; 36 | dfs(v, gang); 37 | if (gang.num > 2 && gang.val > 2 * k) 38 | ans[id2name[gang.max]] = gang; 39 | } 40 | } 41 | 42 | int main() { 43 | int n, k; 44 | cin >> n >> k; 45 | for (int i = 0; i < n; i++) { 46 | int weight; 47 | string name1, name2; 48 | cin >> name1 >> name2 >> weight; 49 | int v = id(name1), w = id(name2); 50 | weights[v] += weight, weights[w] += weight; 51 | graph[v][w] = graph[w][v] = weight; 52 | } 53 | dfs(k); 54 | 55 | cout << ans.size() << endl; 56 | for (auto pair : ans) 57 | cout << pair.first << " " << pair.second.num << endl; 58 | return 0; 59 | } -------------------------------------------------------------------------------- /src/甲级/1107.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct UnionFind { 7 | vector id, sz; 8 | 9 | UnionFind(int n) : id(n), sz(n, 1) { 10 | for (int i = 0; i < n; i++) 11 | id[i] = i; 12 | } 13 | 14 | int find(int x) { 15 | if (id[x] == x) return x; 16 | return id[x] = find(id[x]); 17 | } 18 | 19 | void union_sets(int x, int y) { 20 | int i = find(x), j = find(y); 21 | if (i == j) return; 22 | if (sz[i] >= sz[j]) { id[j] = i; sz[i] += sz[j]; } 23 | else { id[i] = j; sz[j] += sz[i]; } 24 | } 25 | 26 | void print() { 27 | vector ans; 28 | for (int i = 0; i < id.size(); i++) 29 | if (id[i] == i) ans.push_back(sz[i]); 30 | sort(ans.begin(), ans.end(), greater()); 31 | cout << ans.size() << endl; 32 | for (int i = 0; i < ans.size(); i++) 33 | cout << ans[i] << (i < ans.size() - 1 ? ' ' : '\n'); 34 | } 35 | }; 36 | 37 | const int MAX_H = 1005; 38 | 39 | int main() { 40 | int n, k, h; 41 | scanf("%d", &n); 42 | vector hobbies[MAX_H]; 43 | UnionFind uf(n); 44 | for (int i = 0; i < n; i++) { 45 | scanf("%d:", &k); 46 | while (k--) { 47 | scanf("%d", &h); 48 | hobbies[h].push_back(i); 49 | } 50 | } 51 | for (auto hobby : hobbies) { 52 | if (hobby.empty()) continue; 53 | for (auto person : hobby) 54 | uf.union_sets(person, hobby.front()); 55 | } 56 | uf.print(); 57 | return 0; 58 | } -------------------------------------------------------------------------------- /src/甲级/1055.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | struct Person { 9 | char name[10]; 10 | int age; 11 | int worth; 12 | }; 13 | 14 | const int MAXM = 100; 15 | 16 | int main() { 17 | int n, k; 18 | scanf("%d%d", &n, &k); 19 | vector people(n); 20 | for (int i = 0; i < n; i++) 21 | scanf("%s%d%d", people[i].name, &people[i].age, &people[i].worth); 22 | sort(people.begin(), people.end(), [](Person a, Person b) { 23 | if (a.worth != b.worth) return a.worth > b.worth; 24 | if (a.age != b.age) return a.age < b.age; 25 | return strcmp(a.name, b.name) < 0; 26 | }); 27 | // 过滤数据，防止超时 28 | map age_count; 29 | vector valid; 30 | for (auto person : people) { 31 | if (age_count[person.age] > MAXM) continue; 32 | valid.push_back(person); 33 | age_count[person.age]++; 34 | } 35 | int kase = 0; 36 | while (k--) { 37 | int m, lower, upper; 38 | scanf("%d%d%d", &m, &lower, &upper); 39 | vector result; 40 | for (auto person : valid) { 41 | if (result.size() >= m) break; 42 | if (person.age >= lower && person.age <= upper) 43 | result.push_back(person); 44 | } 45 | printf("Case #%d:\n", ++kase); 46 | if (result.empty()) { 47 | printf("None\n"); 48 | continue; 49 | } 50 | for (auto person : result) 51 | printf("%s %d %d\n", person.name, person.age, person.worth); 52 | } 53 | return 0; 54 | } -------------------------------------------------------------------------------- /src/甲级/1030.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | const int N = 505, INF = 0x3f3f3f3f; 6 | int dist_graph[N][N], cost_graph[N][N]; 7 | 8 | int main() { 9 | int n, m, src, dest; 10 | cin >> n >> m >> src >> dest; 11 | while (m--) { 12 | int v, w; 13 | cin >> v >> w >> dist_graph[v][w] >> cost_graph[v][w]; 14 | dist_graph[w][v] = dist_graph[v][w]; 15 | cost_graph[w][v] = cost_graph[v][w]; 16 | } 17 | 18 | vector marked(N); 19 | vector dist(N, INF), cost(N, INF), from(N, -1); 20 | dist[src] = cost[src] = 0; 21 | while (true) { 22 | int v = n; 23 | for (int w = 0; w < n; w++) 24 | if (!marked[w] && dist[w] < dist[v]) 25 | v = w; 26 | if (v == dest) break; 27 | 28 | marked[v] = true; 29 | for (int w = 0; w < n; w++) { 30 | if (!dist_graph[v][w] || marked[w]) continue; 31 | if (dist[v] + dist_graph[v][w] < dist[w] || 32 | (dist[v] + dist_graph[v][w] == dist[w] && 33 | cost[v] + cost_graph[v][w] < cost[w])) { 34 | dist[w] = dist[v] + dist_graph[v][w]; 35 | cost[w] = cost[v] + cost_graph[v][w]; 36 | from[w] = v; 37 | } 38 | } 39 | } 40 | 41 | vector path; 42 | int temp = dest; 43 | while (temp != -1) { 44 | path.push_back(temp); 45 | temp = from[temp]; 46 | } 47 | 48 | for (auto it = path.rbegin(); it != path.rend(); it++) 49 | printf("%d ", *it); 50 | printf("%d %d\n", dist[dest], cost[dest]); 51 | return 0; 52 | } -------------------------------------------------------------------------------- /src/甲级/1099.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | const int ROOT = 0; 8 | 9 | struct TreeNode { 10 | int key; 11 | TreeNode *left = nullptr; 12 | TreeNode *right = nullptr; 13 | }; 14 | 15 | int size(TreeNode *node) { 16 | if (node == nullptr) return 0; 17 | return 1 + size(node->left) + size(node->right); 18 | } 19 | 20 | typedef vector::iterator Iterator; 21 | 22 | void fill_keys(TreeNode *node, Iterator begin, Iterator end) { 23 | if (node == nullptr) return; 24 | int n = size(node->left); 25 | node->key = begin[n]; 26 | fill_keys(node->left, begin, begin + n - 1); 27 | fill_keys(node->right, begin + n + 1, end); 28 | } 29 | 30 | void build(vector &nodes, vector &keys) { 31 | sort(keys.begin(), keys.end()); 32 | fill_keys(&nodes[ROOT], keys.begin(), keys.end()); 33 | } 34 | 35 | void bfs(TreeNode *root) { 36 | queue q; 37 | q.push(root); 38 | while (!q.empty()) { 39 | TreeNode *temp = q.front(); q.pop(); 40 | if (temp->left != nullptr) q.push(temp->left ); 41 | if (temp->right != nullptr) q.push(temp->right); 42 | cout << temp->key << (!q.empty() ? ' ' : '\n'); 43 | } 44 | } 45 | 46 | int main() { 47 | int n; 48 | cin >> n; 49 | vector nodes(n); 50 | for (int i = 0; i < n; i++) { 51 | int l, r; 52 | cin >> l >> r; 53 | if (l != -1) nodes[i].left = &nodes[l]; 54 | if (r != -1) nodes[i].right = &nodes[r]; 55 | } 56 | vector keys(n); 57 | for (int i = 0; i < n; i++) 58 | cin >> keys[i]; 59 | build(nodes, keys); 60 | bfs(&nodes[ROOT]); 61 | return 0; 62 | } -------------------------------------------------------------------------------- /src/甲级/1127.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | struct TreeNode { 8 | int key, level; 9 | TreeNode *lchild = nullptr; 10 | TreeNode *rchild = nullptr; 11 | 12 | TreeNode(int key) : key(key) {} 13 | }; 14 | 15 | TreeNode* build(int *in, int *post, int n) { 16 | if (n <= 0) return nullptr; 17 | TreeNode *node = new TreeNode(post[n - 1]); 18 | int i = 0; 19 | while (i < n && in[i] != node->key) i++; 20 | node->lchild = build(in, post, i); 21 | node->rchild = build(in + i + 1, post + i, n - i - 1); 22 | return node; 23 | } 24 | 25 | void zigzag(TreeNode *root, int n) { 26 | vector order[n]; 27 | queue q; 28 | root->level = 0; 29 | q.push(root); 30 | while (!q.empty()) { 31 | TreeNode *node = q.front(); q.pop(); 32 | if (!node) continue; 33 | order[node->level].push_back(node->key); 34 | if (node->lchild) node->lchild->level = node->level + 1; 35 | if (node->rchild) node->rchild->level = node->level + 1; 36 | q.push(node->lchild); 37 | q.push(node->rchild); 38 | } 39 | printf("%d", root->key); 40 | for (int i = 1; i < n; i++) { 41 | auto print = [](int x) { printf(" %d", x); }; 42 | if (i & 1) for_each(order[i].begin(), order[i].end(), print); 43 | else for_each(order[i].rbegin(), order[i].rend(), print); 44 | } 45 | } 46 | 47 | int main() { 48 | int n; 49 | cin >> n; 50 | int in[n], post[n]; 51 | for (int i = 0; i < n; i++) cin >> in[i]; 52 | for (int i = 0; i < n; i++) cin >> post[i]; 53 | TreeNode *root = build(in, post, n); 54 | zigzag(root, n); 55 | return 0; 56 | } -------------------------------------------------------------------------------- /src/甲级/1024.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct BigInt { 7 | vector digits; 8 | 9 | friend istream& operator>>(istream &in, BigInt &num) { 10 | string str; 11 | in >> str; 12 | for (auto it = str.rbegin(); it != str.rend(); it++) 13 | num.digits.push_back(*it - '0'); 14 | return in; 15 | } 16 | 17 | friend ostream& operator<<(ostream &out, const BigInt &num) { 18 | for (auto it = num.digits.rbegin(); it != num.digits.rend(); it++) 19 | cout << *it; 20 | return out; 21 | } 22 | 23 | bool is_palindromic() { 24 | int i = 0, j = digits.size() - 1; 25 | while (i < j) 26 | if (digits[i++] != digits[j--]) return false; 27 | return true; 28 | } 29 | 30 | BigInt reversed() { 31 | BigInt res; 32 | res.digits.assign(digits.rbegin(), digits.rend()); 33 | return res; 34 | } 35 | 36 | friend BigInt operator+(BigInt a, BigInt b) { 37 | BigInt c; 38 | int carry = 0, m = a.digits.size(), n = b.digits.size(); 39 | for (int i = 0; i < m || i < n; i++) { 40 | int temp = carry; 41 | temp += i < m ? a.digits[i] : 0; 42 | temp += i < n ? b.digits[i] : 0; 43 | c.digits.push_back(temp % 10); 44 | carry = temp / 10; 45 | } 46 | if (carry) c.digits.push_back(carry); 47 | return c; 48 | } 49 | }; 50 | 51 | int main() { 52 | BigInt num; 53 | int k, count = 0; 54 | cin >> num >> k; 55 | while (!num.is_palindromic() && count < k) { 56 | num = num + num.reversed(); 57 | count++; 58 | } 59 | cout << num << endl << count << endl; 60 | return 0; 61 | } -------------------------------------------------------------------------------- /src/甲级/1145.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | bool is_prime(int num) { 6 | if (num < 3) return num == 2; 7 | if (num % 2 == 0) return false; 8 | for (int i = 3; i <= num / i; i += 2) 9 | if (num % i == 0) return false; 10 | return true; 11 | } 12 | 13 | int next_prime(int num) { 14 | num = num % 2 ? num : num + 1; 15 | while (!is_prime(num)) num += 2; 16 | return num; 17 | } 18 | 19 | struct HashTable { 20 | vector table; 21 | 22 | HashTable(int size) : table(next_prime(size)) {} 23 | 24 | int hash(int key) { return key % table.size(); } 25 | 26 | bool insert(int key) { 27 | int hash_val = hash(key); 28 | for (int i = 0; i < table.size(); i++) { 29 | int pos = (hash_val + i * i) % table.size(); 30 | if (table[pos] == 0) { 31 | table[pos] = key; 32 | return true; 33 | } 34 | } 35 | return false; 36 | } 37 | 38 | int search(int key) { 39 | int hash_val = hash(key), count = 0; 40 | for (int i = 0; i <= table.size(); i++) { 41 | count++; 42 | int val = table[(hash_val + i * i) % table.size()]; 43 | if (val == 0 || val == key) break; 44 | } 45 | return count; 46 | } 47 | }; 48 | 49 | int main() { 50 | int size, n, m, key, count = 0; 51 | cin >> size >> n >> m; 52 | HashTable hash_table(size); 53 | while (n--) { 54 | cin >> key; 55 | if (!hash_table.insert(key)) 56 | printf("%d cannot be inserted.\n", key); 57 | } 58 | for (int i = 0; i < m; i++) { 59 | cin >> key; 60 | count += hash_table.search(key); 61 | } 62 | printf("%.1f\n", (double)count / m); 63 | return 0; 64 | } -------------------------------------------------------------------------------- /src/甲级/1136.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct BigInt { 7 | vector digits; 8 | 9 | BigInt(vector digits) : digits(digits) {} 10 | 11 | BigInt reversed() { 12 | vector tmp(digits.rbegin(), digits.rend()); 13 | return BigInt(tmp); 14 | } 15 | 16 | bool is_palindromic() { 17 | for (int i = 0, j = digits.size() - 1; i < j; i++, j--) 18 | if (digits[i] != digits[j]) 19 | return false; 20 | return true; 21 | } 22 | 23 | friend BigInt operator+(BigInt a, BigInt b) { 24 | const int n = a.digits.size(), m = b.digits.size(); 25 | vector tmp(max(n, m)); 26 | int carry = 0; 27 | for (int i = 0; i < tmp.size(); i++) { 28 | int sum = carry; 29 | sum += i < n ? a.digits[i] : 0; 30 | sum += i < m ? b.digits[i] : 0; 31 | tmp[i] = sum % 10; 32 | carry = sum / 10; 33 | } 34 | if (carry) tmp.push_back(carry); 35 | return BigInt(tmp); 36 | } 37 | 38 | friend ostream& operator<<(ostream &out, const BigInt &x) { 39 | for (auto it = x.digits.rbegin(); it != x.digits.rend(); it++) 40 | out << *it; 41 | return out; 42 | } 43 | }; 44 | 45 | int main() { 46 | char c; 47 | int count = 0; 48 | vector tmp; 49 | while (cin >> c) tmp.push_back(c - '0'); 50 | reverse(tmp.begin(), tmp.end()); 51 | BigInt a(tmp); 52 | while (count < 10 && !a.is_palindromic()) { 53 | BigInt b = a.reversed(); 54 | cout << a << " + " << b << " = " << (a = a + b) << endl; 55 | count++; 56 | } 57 | if (count < 10) cout << a << " is a palindromic number." << endl; 58 | else cout << "Not found in 10 iterations." << endl; 59 | return 0; 60 | } -------------------------------------------------------------------------------- /src/甲级/1025.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Testee { 7 | string id; 8 | int score; 9 | int location; 10 | int local_rank; 11 | int final_rank; 12 | 13 | friend bool operator<(Testee a, Testee b) { 14 | return a.score != b.score ? a.score > b.score : a.id < b.id; 15 | } 16 | }; 17 | 18 | int main() { 19 | int n; 20 | cin >> n; 21 | vector local_testees[n]; 22 | vector global_testees; 23 | 24 | for (int i = 0; i < n; i++) { 25 | int k; 26 | cin >> k; 27 | local_testees[i].resize(k); 28 | for (int j = 0; j < k; j++) { 29 | cin >> local_testees[i][j].id >> local_testees[i][j].score; 30 | local_testees[i][j].location = i + 1; 31 | } 32 | 33 | sort(local_testees[i].begin(), local_testees[i].end()); 34 | local_testees[i].front().local_rank = 1; 35 | for (int j = 1; j < k; j++) 36 | local_testees[i][j].local_rank = 37 | local_testees[i][j].score < local_testees[i][j - 1].score ? 38 | j + 1 : local_testees[i][j - 1].local_rank; 39 | 40 | for (auto testee : local_testees[i]) 41 | global_testees.push_back(testee); 42 | } 43 | 44 | sort(global_testees.begin(), global_testees.end()); 45 | global_testees.front().final_rank = 1; 46 | for (int i = 1; i < global_testees.size(); i++) 47 | global_testees[i].final_rank = 48 | global_testees[i].score < global_testees[i - 1].score ? 49 | i + 1 : global_testees[i - 1].final_rank; 50 | 51 | printf("%lu\n", global_testees.size()); 52 | for (auto testee : global_testees) 53 | printf("%s %d %d %d\n", testee.id.c_str(), testee.final_rank, testee.location, testee.local_rank); 54 | return 0; 55 | } -------------------------------------------------------------------------------- /src/甲级/1033.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct GasStation { double price, pos; }; 7 | 8 | int main() { 9 | int n; 10 | double cap, dest, dist; 11 | cin >> cap >> dest >> dist >> n; 12 | vector st(n + 1); 13 | for (int i = 0; i < n; i++) 14 | cin >> st[i].price >> st[i].pos; 15 | st[n].price = 0.0; st[n].pos = dest; 16 | sort(st.begin(), st.end(), [](GasStation a, GasStation b) { 17 | return a.pos < b.pos; 18 | }); 19 | 20 | if (st.front().pos != 0.0) { 21 | printf("The maximum travel distance = 0.00\n"); 22 | return 0; 23 | } 24 | 25 | int idx = 0; 26 | double ans = 0.0, pos = 0.0, tank = 0.0, limit = cap * dist; 27 | while (true) { 28 | bool found = false; 29 | int next = idx + 1; 30 | 31 | for (int i = idx + 1; i <= n && st[i].pos <= pos + limit; i++) { 32 | found = true; 33 | if (st[i].price < st[idx].price) { 34 | next = i; 35 | break; 36 | } 37 | if (st[i].price < st[next].price) 38 | next = i; 39 | } 40 | if (!found) break; 41 | 42 | double need = (st[next].pos - pos) / dist; 43 | if (st[next].price < st[idx].price) { 44 | if (tank < need) { 45 | ans += (need - tank) * st[idx].price; 46 | tank = 0.0; 47 | } else { 48 | tank -= need; 49 | } 50 | } else { 51 | ans += (cap - tank) * st[idx].price; 52 | tank = cap - need; 53 | } 54 | idx = next; 55 | pos = st[idx].pos; 56 | } 57 | 58 | if (pos + limit >= dest) printf("%.2f\n", ans); 59 | else printf("The maximum travel distance = %.2f\n", pos + limit); 60 | return 0; 61 | } -------------------------------------------------------------------------------- /src/乙级/1079.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct BigInt { 7 | vector digits; 8 | 9 | BigInt(vector digits) : digits(digits) {} 10 | 11 | BigInt reversed() { 12 | vector tmp(digits); 13 | reverse(tmp.begin(), tmp.end()); 14 | return BigInt(tmp); 15 | } 16 | 17 | bool is_palindromic() { 18 | for (int i = 0, j = digits.size() - 1; i < j; i++, j--) 19 | if (digits[i] != digits[j]) 20 | return false; 21 | return true; 22 | } 23 | 24 | friend BigInt operator+(BigInt a, BigInt b) { 25 | const int n = a.digits.size(), m = b.digits.size(); 26 | vector tmp(max(n, m)); 27 | int carry = 0; 28 | for (int i = 0; i < tmp.size(); i++) { 29 | int sum = carry; 30 | sum += i < n ? a.digits[i] : 0; 31 | sum += i < m ? b.digits[i] : 0; 32 | tmp[i] = sum % 10; 33 | carry = sum / 10; 34 | } 35 | if (carry) tmp.push_back(carry); 36 | return BigInt(tmp); 37 | } 38 | 39 | friend ostream& operator<<(ostream &out, const BigInt &x) { 40 | for (auto it = x.digits.rbegin(); it != x.digits.rend(); it++) 41 | out << *it; 42 | return out; 43 | } 44 | }; 45 | 46 | int main() { 47 | char c; 48 | int count = 0; 49 | vector tmp; 50 | while (cin >> c) tmp.push_back(c - '0'); 51 | reverse(tmp.begin(), tmp.end()); 52 | BigInt a(tmp); 53 | while (count < 10 && !a.is_palindromic()) { 54 | BigInt b = a.reversed(); 55 | cout << a << " + " << b << " = " << (a = a + b) << endl; 56 | count++; 57 | } 58 | if (count < 10) cout << a << " is a palindromic number." << endl; 59 | else cout << "Not found in 10 iterations." << endl; 60 | return 0; 61 | } -------------------------------------------------------------------------------- /src/甲级/1088.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } 5 | 6 | struct Rational { 7 | long long n, d; 8 | 9 | Rational(long long n, long long d) { 10 | int sign1 = n > 0 ? +1 : -1; 11 | int sign2 = d > 0 ? +1 : -1; 12 | int sign = sign1 * sign2; // 注意判断符号不要直接用两数相乘 13 | n = abs(n); d = abs(d); 14 | long long factor = gcd(n, d); 15 | this->n = sign * n / factor; 16 | this->d = d / factor; 17 | } 18 | 19 | friend ostream& operator<<(ostream &out, const Rational &num) { 20 | if (num.n == 0) { out << "0"; return out; } 21 | if (num.d == 0) { out << "Inf"; return out; } 22 | 23 | int integer = abs(num.n / num.d); 24 | int fraction = abs(num.n % num.d); 25 | if (num.n < 0) out << "(-"; 26 | if (integer) out << integer << (fraction ? " " : ""); 27 | if (fraction) out << fraction << "/" << num.d; 28 | if (num.n < 0) out << ")"; 29 | return out; 30 | } 31 | 32 | friend Rational operator+(Rational a, Rational b) { return Rational(a.n * b.d + a.d * b.n, a.d * b.d); } 33 | friend Rational operator-(Rational a, Rational b) { return Rational(a.n * b.d - a.d * b.n, a.d * b.d); } 34 | friend Rational operator*(Rational a, Rational b) { return Rational(a.n * b.n, a.d * b.d); } 35 | friend Rational operator/(Rational a, Rational b) { return Rational(a.n * b.d, a.d * b.n); } 36 | }; 37 | 38 | int main() { 39 | long long na, da, nb, db; 40 | scanf("%lld/%lld %lld/%lld", &na, &da, &nb, &db); 41 | Rational a(na, da), b(nb, db); 42 | cout << a << " + " << b << " = " << a + b << endl; 43 | cout << a << " - " << b << " = " << a - b << endl; 44 | cout << a << " * " << b << " = " << a * b << endl; 45 | cout << a << " / " << b << " = " << a / b << endl; 46 | return 0; 47 | } -------------------------------------------------------------------------------- /src/甲级/1091.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int m, n, l, t; 6 | int pixels[1300][130][65]; 7 | bool marked[1300][130][65]; 8 | 9 | struct Position { 10 | int x, y, z; 11 | 12 | friend Position operator+(const Position &a, const Position &b) { 13 | return Position{a.x + b.x, a.y + b.y, a.z + b.z}; 14 | } 15 | 16 | bool is_legal() { 17 | if (x >= m || x < 0) return false; 18 | if (y >= n || y < 0) return false; 19 | if (z >= l || z < 0) return false; 20 | if (!pixels[x][y][z]) return false; 21 | if (marked[x][y][z]) return false; 22 | return true; 23 | } 24 | 25 | void mark() { marked[x][y][z] = true; } 26 | }; 27 | 28 | Position moves[] { 29 | Position{+1, 0, 0}, Position{-1, 0, 0}, 30 | Position{0, +1, 0}, Position{0, -1, 0}, 31 | Position{0, 0, +1}, Position{0, 0, -1}, 32 | }; 33 | 34 | int bfs(Position pos) { 35 | if (!pos.is_legal()) return 0; 36 | int count = 0; 37 | queue q; 38 | q.push(pos); 39 | pos.mark(); 40 | while (!q.empty()) { 41 | Position tmp = q.front(); q.pop(); 42 | count++; 43 | for (auto move : moves) { 44 | Position next = tmp + move; 45 | if (next.is_legal()) { 46 | q.push(next); 47 | next.mark(); 48 | } 49 | } 50 | } 51 | return count >= t ? count : 0; 52 | } 53 | 54 | int main() { 55 | cin >> m >> n >> l >> t; 56 | for (int k = 0; k < l; k++) 57 | for (int i = 0; i < m; i++) 58 | for (int j = 0; j < n; j++) 59 | cin >> pixels[i][j][k]; 60 | 61 | int ans = 0; 62 | for (int k = 0; k < l; k++) 63 | for (int i = 0; i < m; i++) 64 | for (int j = 0; j < n; j++) 65 | ans += bfs(Position{i, j, k}); 66 | cout << ans << endl; 67 | return 0; 68 | } -------------------------------------------------------------------------------- /src/乙级/1034.cpp: -------------------------------------------------------------------------------- 1 | // 注意判断符号不要直接用两数相乘 2 | 3 | #include 4 | using namespace std; 5 | 6 | int gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } 7 | 8 | struct Rational { 9 | long long n, d; 10 | 11 | Rational(long long n, long long d) { 12 | int sign1 = n > 0 ? +1 : -1; 13 | int sign2 = d > 0 ? +1 : -1; 14 | int sign = sign1 * sign2; 15 | n = abs(n); d = abs(d); 16 | long long factor = gcd(n, d); 17 | this->n = sign * n / factor; 18 | this->d = d / factor; 19 | } 20 | 21 | friend ostream& operator<<(ostream &out, const Rational &num) { 22 | if (num.n == 0) { out << "0"; return out; } 23 | if (num.d == 0) { out << "Inf"; return out; } 24 | 25 | int integer = abs(num.n / num.d); 26 | int fraction = abs(num.n % num.d); 27 | if (num.n < 0) out << "(-"; 28 | if (integer) out << integer << (fraction ? " " : ""); 29 | if (fraction) out << fraction << "/" << num.d; 30 | if (num.n < 0) out << ")"; 31 | return out; 32 | } 33 | 34 | friend Rational operator+(Rational a, Rational b) { return Rational(a.n * b.d + a.d * b.n, a.d * b.d); } 35 | friend Rational operator-(Rational a, Rational b) { return Rational(a.n * b.d - a.d * b.n, a.d * b.d); } 36 | friend Rational operator*(Rational a, Rational b) { return Rational(a.n * b.n, a.d * b.d); } 37 | friend Rational operator/(Rational a, Rational b) { return Rational(a.n * b.d, a.d * b.n); } 38 | }; 39 | 40 | int main() { 41 | long long na, da, nb, db; 42 | scanf("%lld/%lld %lld/%lld", &na, &da, &nb, &db); 43 | Rational a(na, da), b(nb, db); 44 | cout << a << " + " << b << " = " << a + b << endl; 45 | cout << a << " - " << b << " = " << a - b << endl; 46 | cout << a << " * " << b << " = " << a * b << endl; 47 | cout << a << " / " << b << " = " << a / b << endl; 48 | return 0; 49 | } -------------------------------------------------------------------------------- /src/甲级/1102.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct TreeNode { 7 | int key; 8 | TreeNode *left = nullptr; 9 | TreeNode *right = nullptr; 10 | }; 11 | 12 | void invert(TreeNode *node) { 13 | if (node == nullptr) return; 14 | invert(node->left); 15 | invert(node->right); 16 | swap(node->left, node->right); 17 | } 18 | 19 | void bfs(TreeNode *root) { 20 | queue q; 21 | q.push(root); 22 | while (!q.empty()) { 23 | TreeNode *temp = q.front(); q.pop(); 24 | if (temp->left) q.push(temp->left); 25 | if (temp->right) q.push(temp->right); 26 | cout << temp->key << (!q.empty() ? ' ' : '\n'); 27 | } 28 | } 29 | 30 | void print(TreeNode *node) { 31 | static bool flag = false; 32 | if (flag) cout << ' '; 33 | cout << node->key; 34 | flag = true; 35 | } 36 | 37 | void in_order(TreeNode *node) { 38 | if (node == nullptr) return; 39 | 40 | in_order(node->left); 41 | print(node); 42 | in_order(node->right); 43 | } 44 | 45 | TreeNode* find_root(vector &nodes) { 46 | const int n = nodes.size(); 47 | vector is_root(n, true); 48 | for (auto node : nodes) { 49 | if (node.left ) is_root[node.left ->key] = false; 50 | if (node.right) is_root[node.right->key] = false; 51 | } 52 | for (int i = 0; i < n; i++) 53 | if (is_root[i]) return &nodes[i]; 54 | return nullptr; 55 | } 56 | 57 | int main() { 58 | int n; 59 | cin >> n; 60 | vector nodes(n); 61 | for (int i = 0; i < n; i++) { 62 | nodes[i].key = i; 63 | string l, r; 64 | cin >> l >> r; 65 | if (l != "-") nodes[i].left = &nodes[stoi(l)]; 66 | if (r != "-") nodes[i].right = &nodes[stoi(r)]; 67 | } 68 | TreeNode *root = find_root(nodes); 69 | invert(root); 70 | bfs(root); 71 | in_order(root); 72 | return 0; 73 | } -------------------------------------------------------------------------------- /src/甲级/1158.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct UnionFindSet { 7 | vector id; 8 | 9 | UnionFindSet(int n) : id(n) { 10 | for (int i = 0; i < n; i++) 11 | id[i] = i; 12 | } 13 | 14 | int find(int x) { 15 | if (id[x] == x) return x; 16 | return id[x] = find(id[x]); 17 | } 18 | 19 | void union_set(int a, int b) { 20 | int x = find(a), y = find(b); 21 | if (x != y) id[x] = y; 22 | } 23 | }; 24 | 25 | const int N = 1005; 26 | int graph[N][N]; 27 | 28 | int main() { 29 | int k, n, m; 30 | cin >> k >> n >> m; 31 | while (m--) { 32 | int v, w, t; 33 | cin >> v >> w >> t; 34 | graph[v][w] += t; 35 | } 36 | vector evil; 37 | for (int v = 1; v <= n; v++) { 38 | int call = 0, back = 0; 39 | for (int w = 1; w <= n; w++) { 40 | if (graph[v][w] > 0 && graph[v][w] <= 5) { 41 | call++; 42 | back += graph[w][v] > 0; 43 | } 44 | } 45 | if (call > k && back <= 0.2 * call) 46 | evil.push_back(v); 47 | } 48 | UnionFindSet uf(n + 1); 49 | for (int i = 0; i < evil.size(); i++) 50 | for (int j = i + 1; j < evil.size(); j++) 51 | if (graph[evil[i]][evil[j]] && graph[evil[j]][evil[i]]) 52 | uf.union_set(evil[i], evil[j]); 53 | vector> tmp(n), ans; 54 | for (auto v : evil) 55 | tmp[uf.find(v)].push_back(v); 56 | for (auto gang : tmp) 57 | if (!gang.empty()) ans.push_back(gang); 58 | sort(ans.begin(), ans.end(), [](vector a, vector b) { 59 | return a.front() < b.front(); 60 | }); 61 | for (auto gang : ans) 62 | for (int i = 0; i < gang.size(); i++) 63 | cout << gang[i] << (i < gang.size() - 1 ? ' ' : '\n'); 64 | if (ans.empty()) cout << "None" << endl; 65 | return 0; 66 | } -------------------------------------------------------------------------------- /src/甲级/1080.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Student { 7 | int number; 8 | int score1; 9 | int score2; 10 | int total; 11 | int rank; 12 | vector choices; 13 | }; 14 | 15 | struct School { 16 | int quota; 17 | int last; 18 | vector result; 19 | }; 20 | 21 | bool cmp(Student a, Student b) { 22 | return a.total != b.total ? a.total > b.total : a.score1 > b.score1; 23 | } 24 | 25 | int main() { 26 | int n, m, k; 27 | cin >> n >> m >> k; 28 | vector schools(m); 29 | vector students(n); 30 | for (int i = 0; i < m; i++) 31 | cin >> schools[i].quota; 32 | for (int i = 0; i < n; i++) { 33 | students[i].number = i; 34 | cin >> students[i].score1 >> students[i].score2; 35 | students[i].total = students[i].score1 + students[i].score2; 36 | students[i].choices.resize(k); 37 | for (int j = 0; j < k; j++) 38 | cin >> students[i].choices[j]; 39 | } 40 | 41 | sort(students.begin(), students.end(), cmp); 42 | for (int i = 0; i < n; i++) 43 | students[i].rank = i == 0 ? 1 : 44 | cmp(students[i-1], students[i]) ? i + 1 : students[i-1].rank; 45 | for (auto student : students) { 46 | for (auto i : student.choices) { 47 | if (schools[i].result.size() < schools[i].quota || student.rank == schools[i].last) { 48 | schools[i].result.push_back(student.number); 49 | schools[i].last = student.rank; 50 | break; 51 | } 52 | } 53 | } 54 | 55 | for (auto school : schools) { 56 | sort(school.result.begin(), school.result.end()); 57 | for (int i = 0; i < school.result.size(); i++) { 58 | cout << school.result[i]; 59 | if (i != school.result.size() - 1) cout << " "; 60 | } 61 | cout << endl; 62 | } 63 | return 0; 64 | } -------------------------------------------------------------------------------- /src/甲级/1075.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int MAXK = 5; 7 | 8 | struct User { 9 | bool valid; 10 | int id; 11 | int total; 12 | int count; 13 | int rank; 14 | vector scores; 15 | }; 16 | 17 | int main() { 18 | int n, k, m; 19 | scanf("%d%d%d", &n, &k, &m); 20 | vector users(n); 21 | for (int i = 0; i < n; i++) { 22 | users[i].id = i + 1; 23 | users[i].scores.resize(k, -2); 24 | } 25 | int full_marks[k]; 26 | for (int i = 0; i < k; i++) 27 | scanf("%d", &full_marks[i]); 28 | while (m--) { 29 | int uid, pid, score; 30 | scanf("%d%d%d", &uid, &pid, &score); 31 | if (score == full_marks[pid-1] && users[uid-1].scores[pid-1] != full_marks[pid-1]) 32 | users[uid-1].count++; 33 | if (score > users[uid-1].scores[pid-1]) 34 | users[uid-1].scores[pid-1] = score; 35 | } 36 | for (auto& user : users) { 37 | for (auto score : user.scores) { 38 | if (score >= 0) { 39 | user.valid = true; 40 | user.total += score; 41 | } 42 | } 43 | } 44 | sort(users.begin(), users.end(), [](User a, User b) { 45 | if (a.total != b.total) return a.total > b.total; 46 | if (a.count != b.count) return a.count > b.count; 47 | return a.id < b.id; 48 | }); 49 | for (int i = 0; i < n; i++) { 50 | if (!users[i].valid) break; 51 | users[i].rank = i == 0 ? 1 : users[i].total < users[i-1].total ? i + 1 : users[i-1].rank; 52 | printf("%d %05d %d", users[i].rank, users[i].id, users[i].total); 53 | for (auto score : users[i].scores) { 54 | if (score == -2) printf(" -"); // 没有提交 55 | else if (score == -1) printf(" 0"); // 有提交，但未能通过编译 56 | else printf(" %d", score); 57 | } 58 | printf("\n"); 59 | } 60 | return 0; 61 | } -------------------------------------------------------------------------------- /src/甲级/1150.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | const int INF = 0x3f3f3f3f; 7 | 8 | int n, m; 9 | const int N = 205; 10 | int graph[N][N]; 11 | 12 | vector descriptions { 13 | "Not a TS cycle", 14 | "Not a TS cycle", 15 | "TS cycle", 16 | "TS simple cycle", 17 | }; 18 | 19 | int get_dist(const vector &path) { 20 | int res = 0; 21 | for (int i = 0; i < path.size() - 1; i++) { 22 | int len = graph[path[i]][path[i+1]]; 23 | if (!len) return INF; 24 | res += len; 25 | } 26 | return res; 27 | } 28 | 29 | bool is_ts_cycle(const vector &path) { 30 | for (int i = 0; i < path.size() - 1; i++) 31 | if (!graph[path[i]][path[i+1]]) 32 | return false; 33 | set visited(path.begin(), path.end()); 34 | return visited.size() == n && path.front() == path.back(); 35 | } 36 | 37 | bool is_simple(const vector &path) { 38 | set visited(path.begin(), path.end()); 39 | return path.size() == visited.size() + 1 && path.front() == path.back(); 40 | } 41 | 42 | int main() { 43 | cin >> n >> m; 44 | while (m--) { 45 | int v, w; 46 | cin >> v >> w >> graph[v][w]; 47 | graph[w][v] = graph[v][w]; 48 | } 49 | int min_dist = INF, min_idx, k; 50 | cin >> k; 51 | for (int i = 1; i <= k; i++) { 52 | int l; 53 | cin >> l; 54 | vector path(l); 55 | for (int j = 0; j < l; j++) 56 | cin >> path[j]; 57 | int dist = get_dist(path); 58 | string dist_str = dist == INF ? "NA" : to_string(dist); 59 | int idx = is_ts_cycle(path) * 2 + is_simple(path); 60 | string description = descriptions[idx]; 61 | printf("Path %d: %s (%s)\n", i, dist_str.c_str(), description.c_str()); 62 | if (idx >= 2 && dist < min_dist) { 63 | min_dist = dist; 64 | min_idx = i; 65 | } 66 | } 67 | printf("Shortest Dist(%d) = %d\n", min_idx, min_dist); 68 | return 0; 69 | } -------------------------------------------------------------------------------- /src/甲级/1143.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | struct TreeNode { 6 | int key, level; 7 | TreeNode *lchild = nullptr; 8 | TreeNode *rchild = nullptr; 9 | TreeNode *parent = nullptr; 10 | 11 | TreeNode(int key, int level) : key(key), level(level) {} 12 | }; 13 | 14 | map nodes; 15 | 16 | TreeNode* build(int *pre, int n, int level) { 17 | if (n <= 0) return nullptr; 18 | TreeNode *node = new TreeNode(*pre, level); 19 | int i = 1; 20 | while (i < n && pre[i] < node->key) i++; 21 | node->lchild = build(pre + 1, i - 1, level + 1); 22 | node->rchild = build(pre + i, n - i, level + 1); 23 | if (node->lchild) node->lchild->parent = node; 24 | if (node->rchild) node->rchild->parent = node; 25 | return nodes[node->key] = node; 26 | } 27 | 28 | int main() { 29 | int m, n; 30 | cin >> m >> n; 31 | int pre[n]; 32 | for (int i = 0; i < n; i++) cin >> pre[i]; 33 | build(pre, n, 0); 34 | while (m--) { 35 | int v, w; 36 | cin >> v >> w; 37 | TreeNode *node1 = nodes[v], *node2 = nodes[w]; 38 | if (!node1 && !node2) { 39 | printf("ERROR: %d and %d are not found.\n", v, w); 40 | } else if (!node1) { 41 | printf("ERROR: %d is not found.\n", v); 42 | } else if (!node2) { 43 | printf("ERROR: %d is not found.\n", w); 44 | } else { 45 | bool flag = node1->level > node2->level; 46 | if (flag) swap(node1, node2); 47 | while (node1->level < node2->level) 48 | node2 = node2->parent; 49 | if (node1 == node2) { 50 | printf("%d is an ancestor of %d.\n", node1->key, flag ? v : w); 51 | } else { 52 | while (node1 != node2) { 53 | node1 = node1->parent; 54 | node2 = node2->parent; 55 | } 56 | printf("LCA of %d and %d is %d.\n", v, w, node1->key); 57 | } 58 | } 59 | } 60 | return 0; 61 | } -------------------------------------------------------------------------------- /src/甲级/1066.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct TreeNode { 5 | int key; 6 | TreeNode *left; 7 | TreeNode *right; 8 | 9 | TreeNode(int key) : key(key), left(nullptr), right(nullptr) {} 10 | }; 11 | 12 | struct AVLTree { 13 | TreeNode *root = nullptr; 14 | 15 | int height(TreeNode *node) { 16 | if (node == nullptr) return 0; 17 | return max(height(node->left), height(node->right)) + 1; 18 | } 19 | 20 | void left_rotate(TreeNode *&node) { 21 | TreeNode *temp = node->right; 22 | node->right = temp->left; 23 | temp->left = node; 24 | node = temp; 25 | } 26 | 27 | void right_rotate(TreeNode *&node) { 28 | TreeNode *temp = node->left; 29 | node->left = temp->right; 30 | temp->right = node; 31 | node = temp; 32 | } 33 | 34 | void insert(int key, TreeNode *&node) { 35 | if (node == nullptr) { 36 | node = new TreeNode(key); 37 | } else if (key < node->key) { 38 | insert(key, node->left); 39 | if (height(node->left) - height(node->right) == 2) { 40 | if (key < node->left->key) { 41 | right_rotate(node); 42 | } else { 43 | left_rotate(node->left); 44 | right_rotate(node); 45 | } 46 | } 47 | } else { 48 | insert(key, node->right); 49 | if (height(node->right) - height(node->left) == 2) { 50 | if (key > node->right->key) { 51 | left_rotate(node); 52 | } else { 53 | right_rotate(node->right); 54 | left_rotate(node); 55 | } 56 | } 57 | } 58 | } 59 | 60 | void insert(int key) { insert(key, root); } 61 | }; 62 | 63 | int main() { 64 | int n, key; 65 | AVLTree tree; 66 | cin >> n; 67 | while (n--) { 68 | cin >> key; 69 | tree.insert(key); 70 | } 71 | cout << tree.root->key << endl; 72 | return 0; 73 | } -------------------------------------------------------------------------------- /src/甲级/1114.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | struct Family { 7 | int id, count; 8 | double sets, area; 9 | }; 10 | 11 | const int N = 10005; 12 | int sets[N], area[N]; 13 | Family families[N]; 14 | 15 | struct UnionFindSet { 16 | vector id; 17 | 18 | UnionFindSet(int size) : id(size + 1) { 19 | for (int i = 0; i <= size; i++) 20 | id[i] = i; 21 | } 22 | 23 | int find(int f) { 24 | if (id[f] == f) return f; 25 | return id[f] = find(id[f]); 26 | } 27 | 28 | bool connected(int f, int y) { 29 | return find(f) == find(y); 30 | } 31 | 32 | void union_sets(int f, int y) { 33 | int i = find(f), j = find(y); 34 | if (i < j) id[j] = i; 35 | else id[i] = j; 36 | } 37 | }; 38 | 39 | int main() { 40 | int n; 41 | cin >> n; 42 | UnionFindSet uf(N); 43 | while (n--) { 44 | int id, father, mather, child, k; 45 | cin >> id >> father >> mather >> k; 46 | if (father != -1) uf.union_sets(id, father); 47 | if (mather != -1) uf.union_sets(id, mather); 48 | while (k--) { 49 | cin >> child; 50 | uf.union_sets(id, child); 51 | } 52 | cin >> sets[id] >> area[id]; 53 | } 54 | for (int i = 0; i < N; i++) { 55 | int id = uf.find(i); 56 | families[id].id = id; 57 | families[id].count++; 58 | families[id].sets += sets[i]; 59 | families[id].area += area[i]; 60 | } 61 | vector ans; 62 | for (auto family : families) { 63 | if (!family.sets) continue; 64 | family.sets /= family.count; 65 | family.area /= family.count; 66 | ans.push_back(family); 67 | } 68 | sort(ans.begin(), ans.end(), [](Family a, Family b) { 69 | return a.area != b.area ? a.area > b.area : a.id < b.id; 70 | }); 71 | printf("%lu\n", ans.size()); 72 | for (auto f : ans) 73 | printf("%04d %d %.3f %.3f\n", f.id, f.count, f.sets, f.area); 74 | return 0; 75 | } -------------------------------------------------------------------------------- /src/甲级/1098.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | void print(const vector v) { 7 | for (int i = 0; i < v.size(); i++) 8 | printf("%d%c", v[i], i < v.size() - 1 ? ' ' : '\n'); 9 | } 10 | 11 | void insertion_sort_pass(vector &v, int &pos) { 12 | for (int i = pos++; i > 0 && v[i] < v[i-1]; i--) 13 | swap(v[i], v[i-1]); 14 | } 15 | 16 | bool insertion_sort(const vector &init, const vector &part) { 17 | int pos = 1; 18 | vector temp(init); 19 | while (pos < init.size()) { 20 | insertion_sort_pass(temp, pos); 21 | if (temp == part) { 22 | insertion_sort_pass(temp, pos); 23 | printf("Insertion Sort\n"); 24 | print(temp); 25 | return true; 26 | } 27 | } 28 | return false; 29 | } 30 | 31 | struct BinaryHeap { 32 | int n; 33 | vector heap; 34 | 35 | BinaryHeap(const vector &init) : heap(init) { 36 | n = heap.size(); 37 | for (int i = n / 2; i >= 0; i--) sink(i); 38 | } 39 | 40 | bool empty() { return n == 0; } 41 | 42 | void sink(int i) { 43 | while (2 * i + 1 < n) { 44 | int j = 2 * i + 1; 45 | if (j + 1 < n && heap[j+1] > heap[j]) j++; 46 | if (heap[i] > heap[j]) break; 47 | swap(heap[i], heap[j]); 48 | i = j; 49 | } 50 | } 51 | 52 | void heap_sort_pass() { 53 | swap(heap[0], heap[--n]); 54 | sink(0); 55 | } 56 | }; 57 | 58 | 59 | bool heap_sort(const vector &init, const vector &part) { 60 | BinaryHeap pq(init); 61 | while (!pq.empty()) { 62 | pq.heap_sort_pass(); 63 | if (part == pq.heap) { 64 | pq.heap_sort_pass(); 65 | printf("Heap Sort\n"); 66 | print(pq.heap); 67 | return true; 68 | } 69 | } 70 | return false; 71 | } 72 | 73 | int main() { 74 | int n; 75 | cin >> n; 76 | vector init(n), part(n); 77 | for (int i = 0; i < n; i++) cin >> init[i]; 78 | for (int i = 0; i < n; i++) cin >> part[i]; 79 | if (!insertion_sort(init, part)) heap_sort(init, part); 80 | return 0; 81 | } --------------------------------------------------------------------------------