├── .DS_Store ├── Code ├── 1003.cpp ├── 1006.cpp ├── 1010.cpp ├── 1016.cpp ├── 1017.cpp ├── 1020.cpp ├── 1021.cpp ├── 1026.cpp ├── 1027.cpp ├── 1034.cpp ├── 1036.cpp ├── 1037.cpp ├── 1039.cpp ├── 1043.cpp ├── 1049.cpp ├── 1051.cpp ├── 1053.cpp ├── 1056.cpp ├── 1111.cpp ├── 1112.cpp ├── 1117.cpp ├── 1202.cpp ├── 1203.cpp ├── 1204.cpp ├── 1206.cpp ├── 1207.cpp ├── 1209.cpp ├── 1211.cpp ├── 1212.cpp ├── 1214.cpp ├── 1215.cpp ├── 1216.cpp ├── 1218.cpp ├── 1221.cpp ├── 1231.cpp ├── 1232.cpp ├── 1233.cpp ├── 1234.cpp ├── 1235.cpp ├── 1249.cpp ├── 1257.cpp ├── 1282.cpp ├── 1338.cpp ├── 1348.cpp ├── 1360.cpp ├── 1367.cpp ├── 1509.cpp ├── 1518.cpp ├── 1530.cpp ├── 1533.cpp ├── 1550.cpp ├── 1560.cpp ├── 1564.cpp ├── 1570.cpp ├── 1571.cpp ├── 1574.cpp ├── 1577.cpp ├── 1579.cpp ├── 1580.cpp ├── 1593.cpp ├── 1596.cpp ├── 1605.cpp ├── 1606.cpp ├── 1991.cpp ├── 1992.cpp ├── 2104.cpp ├── 3034.cpp ├── 4003.cpp ├── 4008.cpp ├── 4009.cpp ├── 4011.cpp ├── 4012.cpp ├── 4028.cpp ├── 4039.cpp ├── 4040.cpp ├── 4042.cpp ├── 4048.cpp ├── 4053.cpp ├── 4065.cpp ├── 4072.cpp ├── 4073.cpp ├── 4074.cpp ├── 4075.cpp ├── 4078.cpp ├── 4083.cpp ├── 4088.cpp ├── 4092.cpp ├── 4095.cpp ├── 4096.cpp ├── 4097.cpp ├── 4116.cpp ├── 4151.cpp ├── 4152.cpp ├── 4153.cpp ├── 4154.cpp ├── 4155.cpp ├── 4158.cpp ├── 4171.cpp ├── 4174.cpp ├── 4183.cpp ├── 4186.cpp ├── 4192.cpp ├── 4200.cpp ├── 4201.cpp ├── 4203.cpp ├── 4206.cpp ├── 4207.cpp ├── 4231.cpp ├── 4070.cpp ├── CMakeLists.txt ├── 1000.cpp ├── 1501.cpp ├── 1018.cpp ├── 2000.cpp ├── 4268.cpp ├── 1205.cpp ├── 4257.cpp ├── 1001.cpp ├── 1503.cpp ├── 4022.cpp ├── 4024.cpp ├── 4026.cpp ├── 4258.cpp ├── 4187.cpp ├── 4318.cpp ├── 1208.cpp ├── 1998.cpp ├── 4254.cpp ├── 4062.cpp ├── 4023.cpp ├── 4319.cpp ├── 4047.cpp ├── 3044.cpp ├── 4255.cpp ├── 4110.cpp ├── 1024.cpp ├── 3002.cpp ├── 1038.cpp ├── 4378.cpp ├── 1598.cpp ├── 3016.cpp ├── 1013.cpp ├── 1217.cpp ├── 4147.cpp ├── 1004.cpp ├── 4223.cpp ├── 1567.cpp ├── 4208.cpp ├── 4149.cpp ├── 4102.cpp ├── 4221.cpp ├── 4093.cpp ├── 4219.cpp ├── 1541.cpp ├── 4211.cpp ├── 4256.cpp ├── 4222.cpp ├── 4354.cpp ├── 1019.cpp ├── 4229.cpp ├── 1107.cpp ├── 3030.cpp ├── 4045.cpp ├── 1272.cpp ├── 1002.cpp ├── 1994.cpp ├── 2111.cpp ├── 4242.cpp ├── 1239.cpp ├── 4089.cpp ├── 4377.cpp ├── 1594.cpp ├── 2109.cpp ├── 1320.cpp ├── 4132.cpp ├── 1007.cpp ├── 1040.cpp ├── 4269.cpp ├── 1128.cpp ├── 4320.cpp ├── 1241.cpp ├── 4090.cpp ├── 1023.cpp ├── 1025.cpp ├── 1047.cpp ├── 1549.cpp ├── 4117.cpp ├── 4163.cpp ├── 1525.cpp ├── 1041.cpp ├── 1048.cpp ├── 1088.cpp ├── 1224.cpp ├── 1074.cpp ├── 4027.cpp ├── 4239.cpp ├── 1633.cpp ├── 1634.cpp ├── 1243.cpp ├── 4025.cpp ├── 1629.cpp ├── 4054.cpp ├── 1032.cpp ├── 1237.cpp ├── 4369.cpp ├── 3026.cpp ├── 4379.cpp ├── 1028.cpp ├── 4189.cpp ├── 4138.cpp ├── 1012.cpp ├── 4322.cpp ├── 1075.cpp ├── 1052.cpp ├── 1545.cpp ├── 1123.cpp ├── 4071.cpp ├── 1358.cpp ├── 1029.cpp ├── 1045.cpp ├── 4244.cpp ├── 1635.cpp ├── 1521.cpp ├── 1005.cpp ├── 1009.cpp ├── 4370.cpp ├── 1515.cpp ├── 1258.cpp ├── 1046.cpp ├── 1329.cpp ├── 1031.cpp ├── 1565.cpp ├── 1247.cpp ├── 4232.cpp ├── 1011.cpp ├── 4321.cpp ├── 4091.cpp ├── 4284.cpp ├── 4243.cpp ├── 1281.cpp ├── 1008.cpp ├── 4237.cpp ├── 4119.cpp ├── 4127.cpp └── 1999.cpp ├── DataStructure ├── 图.cpp ├── 栈.cpp ├── 二叉树.cpp ├── 向量.cpp ├── 并查集.cpp ├── 排序.cpp ├── 红黑树.cpp ├── 队列.cpp ├── 优先队列.cpp └── 列表.cpp ├── .gitignore └── README.md /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/.DS_Store -------------------------------------------------------------------------------- /Code/1003.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1003.cpp -------------------------------------------------------------------------------- /Code/1006.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1006.cpp -------------------------------------------------------------------------------- /Code/1010.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1010.cpp -------------------------------------------------------------------------------- /Code/1016.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1016.cpp -------------------------------------------------------------------------------- /Code/1017.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1017.cpp -------------------------------------------------------------------------------- /Code/1020.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1020.cpp -------------------------------------------------------------------------------- /Code/1021.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1021.cpp -------------------------------------------------------------------------------- /Code/1026.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1026.cpp -------------------------------------------------------------------------------- /Code/1027.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1027.cpp -------------------------------------------------------------------------------- /Code/1034.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1034.cpp -------------------------------------------------------------------------------- /Code/1036.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1036.cpp -------------------------------------------------------------------------------- /Code/1037.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1037.cpp -------------------------------------------------------------------------------- /Code/1039.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1039.cpp -------------------------------------------------------------------------------- /Code/1043.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1043.cpp -------------------------------------------------------------------------------- /Code/1049.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1049.cpp -------------------------------------------------------------------------------- /Code/1051.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1051.cpp -------------------------------------------------------------------------------- /Code/1053.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1053.cpp -------------------------------------------------------------------------------- /Code/1056.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1056.cpp -------------------------------------------------------------------------------- /Code/1111.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1111.cpp -------------------------------------------------------------------------------- /Code/1112.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1112.cpp -------------------------------------------------------------------------------- /Code/1117.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1117.cpp -------------------------------------------------------------------------------- /Code/1202.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1202.cpp -------------------------------------------------------------------------------- /Code/1203.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1203.cpp -------------------------------------------------------------------------------- /Code/1204.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1204.cpp -------------------------------------------------------------------------------- /Code/1206.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1206.cpp -------------------------------------------------------------------------------- /Code/1207.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1207.cpp -------------------------------------------------------------------------------- /Code/1209.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1209.cpp -------------------------------------------------------------------------------- /Code/1211.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1211.cpp -------------------------------------------------------------------------------- /Code/1212.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1212.cpp -------------------------------------------------------------------------------- /Code/1214.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1214.cpp -------------------------------------------------------------------------------- /Code/1215.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1215.cpp -------------------------------------------------------------------------------- /Code/1216.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1216.cpp -------------------------------------------------------------------------------- /Code/1218.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1218.cpp -------------------------------------------------------------------------------- /Code/1221.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1221.cpp -------------------------------------------------------------------------------- /Code/1231.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1231.cpp -------------------------------------------------------------------------------- /Code/1232.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1232.cpp -------------------------------------------------------------------------------- /Code/1233.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1233.cpp -------------------------------------------------------------------------------- /Code/1234.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1234.cpp -------------------------------------------------------------------------------- /Code/1235.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1235.cpp -------------------------------------------------------------------------------- /Code/1249.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1249.cpp -------------------------------------------------------------------------------- /Code/1257.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1257.cpp -------------------------------------------------------------------------------- /Code/1282.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1282.cpp -------------------------------------------------------------------------------- /Code/1338.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1338.cpp -------------------------------------------------------------------------------- /Code/1348.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1348.cpp -------------------------------------------------------------------------------- /Code/1360.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1360.cpp -------------------------------------------------------------------------------- /Code/1367.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1367.cpp -------------------------------------------------------------------------------- /Code/1509.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1509.cpp -------------------------------------------------------------------------------- /Code/1518.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1518.cpp -------------------------------------------------------------------------------- /Code/1530.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1530.cpp -------------------------------------------------------------------------------- /Code/1533.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1533.cpp -------------------------------------------------------------------------------- /Code/1550.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1550.cpp -------------------------------------------------------------------------------- /Code/1560.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1560.cpp -------------------------------------------------------------------------------- /Code/1564.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1564.cpp -------------------------------------------------------------------------------- /Code/1570.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1570.cpp -------------------------------------------------------------------------------- /Code/1571.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1571.cpp -------------------------------------------------------------------------------- /Code/1574.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1574.cpp -------------------------------------------------------------------------------- /Code/1577.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1577.cpp -------------------------------------------------------------------------------- /Code/1579.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1579.cpp -------------------------------------------------------------------------------- /Code/1580.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1580.cpp -------------------------------------------------------------------------------- /Code/1593.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1593.cpp -------------------------------------------------------------------------------- /Code/1596.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1596.cpp -------------------------------------------------------------------------------- /Code/1605.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1605.cpp -------------------------------------------------------------------------------- /Code/1606.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1606.cpp -------------------------------------------------------------------------------- /Code/1991.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1991.cpp -------------------------------------------------------------------------------- /Code/1992.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/1992.cpp -------------------------------------------------------------------------------- /Code/2104.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/2104.cpp -------------------------------------------------------------------------------- /Code/3034.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/3034.cpp -------------------------------------------------------------------------------- /Code/4003.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4003.cpp -------------------------------------------------------------------------------- /Code/4008.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4008.cpp -------------------------------------------------------------------------------- /Code/4009.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4009.cpp -------------------------------------------------------------------------------- /Code/4011.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4011.cpp -------------------------------------------------------------------------------- /Code/4012.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4012.cpp -------------------------------------------------------------------------------- /Code/4028.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4028.cpp -------------------------------------------------------------------------------- /Code/4039.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4039.cpp -------------------------------------------------------------------------------- /Code/4040.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4040.cpp -------------------------------------------------------------------------------- /Code/4042.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4042.cpp -------------------------------------------------------------------------------- /Code/4048.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4048.cpp -------------------------------------------------------------------------------- /Code/4053.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4053.cpp -------------------------------------------------------------------------------- /Code/4065.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4065.cpp -------------------------------------------------------------------------------- /Code/4072.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4072.cpp -------------------------------------------------------------------------------- /Code/4073.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4073.cpp -------------------------------------------------------------------------------- /Code/4074.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4074.cpp -------------------------------------------------------------------------------- /Code/4075.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4075.cpp -------------------------------------------------------------------------------- /Code/4078.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4078.cpp -------------------------------------------------------------------------------- /Code/4083.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4083.cpp -------------------------------------------------------------------------------- /Code/4088.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4088.cpp -------------------------------------------------------------------------------- /Code/4092.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4092.cpp -------------------------------------------------------------------------------- /Code/4095.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4095.cpp -------------------------------------------------------------------------------- /Code/4096.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4096.cpp -------------------------------------------------------------------------------- /Code/4097.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4097.cpp -------------------------------------------------------------------------------- /Code/4116.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4116.cpp -------------------------------------------------------------------------------- /Code/4151.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4151.cpp -------------------------------------------------------------------------------- /Code/4152.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4152.cpp -------------------------------------------------------------------------------- /Code/4153.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4153.cpp -------------------------------------------------------------------------------- /Code/4154.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4154.cpp -------------------------------------------------------------------------------- /Code/4155.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4155.cpp -------------------------------------------------------------------------------- /Code/4158.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4158.cpp -------------------------------------------------------------------------------- /Code/4171.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4171.cpp -------------------------------------------------------------------------------- /Code/4174.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4174.cpp -------------------------------------------------------------------------------- /Code/4183.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4183.cpp -------------------------------------------------------------------------------- /Code/4186.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4186.cpp -------------------------------------------------------------------------------- /Code/4192.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4192.cpp -------------------------------------------------------------------------------- /Code/4200.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4200.cpp -------------------------------------------------------------------------------- /Code/4201.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4201.cpp -------------------------------------------------------------------------------- /Code/4203.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4203.cpp -------------------------------------------------------------------------------- /Code/4206.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4206.cpp -------------------------------------------------------------------------------- /Code/4207.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4207.cpp -------------------------------------------------------------------------------- /Code/4231.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/Code/4231.cpp -------------------------------------------------------------------------------- /DataStructure/图.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/图.cpp -------------------------------------------------------------------------------- /DataStructure/栈.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/栈.cpp -------------------------------------------------------------------------------- /DataStructure/二叉树.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/二叉树.cpp -------------------------------------------------------------------------------- /DataStructure/向量.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/向量.cpp -------------------------------------------------------------------------------- /DataStructure/并查集.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/并查集.cpp -------------------------------------------------------------------------------- /DataStructure/排序.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/排序.cpp -------------------------------------------------------------------------------- /DataStructure/红黑树.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/红黑树.cpp -------------------------------------------------------------------------------- /DataStructure/队列.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/队列.cpp -------------------------------------------------------------------------------- /DataStructure/优先队列.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiez22/SJTU-OJ/HEAD/DataStructure/优先队列.cpp -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | DS Template/ 2 | ProjectDeque/ 3 | VJudge1/ 4 | VJudge2/ 5 | service.py 6 | Code/cmake-build-debug/ 7 | Code/.idea/ 8 | -------------------------------------------------------------------------------- /Code/4070.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | int main() { 7 | 8 | 9 | } -------------------------------------------------------------------------------- /Code/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.17) 2 | project(Code) 3 | 4 | set(CMAKE_CXX_STANDARD 20) 5 | 6 | add_executable(Code 7 | 4379.cpp) 8 | -------------------------------------------------------------------------------- /Code/1000.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | int a, b; 6 | cin >> a >> b; 7 | cout << a + b; 8 | 9 | return 0; 10 | } -------------------------------------------------------------------------------- /Code/1501.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | double a, b; 6 | cin >> a >> b; 7 | cout << a * b << " " << a * b * 0.9; 8 | return 0; 9 | } -------------------------------------------------------------------------------- /Code/1018.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int main() { 5 | int a, b; 6 | while (cin >> a >> b) { 7 | cout << a + b << "\n"; 8 | } 9 | 10 | return 0; 11 | } -------------------------------------------------------------------------------- /Code/2000.cpp: -------------------------------------------------------------------------------- 1 | #include "cstdio" 2 | using namespace std; 3 | 4 | int main() { 5 | int num,n; 6 | long long ans=0; 7 | scanf("%d", &num); 8 | for (int i = 0; i < num; i++) { 9 | scanf("%d", &n); 10 | ans += n; 11 | } 12 | 13 | printf("%lld", ans); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Code/4268.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int f(int n, int m) { 6 | if (n == 1) 7 | return 0; 8 | return (f(n - 1, m) + m) % n; 9 | } 10 | 11 | int main() { 12 | int n, m; 13 | cin >> n >> m; 14 | 15 | cout << f(n, m) + 1; 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /Code/1205.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int A(int m, int n) { 5 | if (m == 0) return n + 1; 6 | else if (n == 0) return A(m - 1, 1); 7 | else return A(m - 1, A(m, n - 1)); 8 | } 9 | 10 | int main() { 11 | int m, n; 12 | cin >> m >> n; 13 | cout << A(m, n); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Code/4257.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | uint64_t n, k, A, B, ans = 0; 6 | cin >> n >> k >> A >> B; 7 | 8 | for (; n >= k && (n / k * k - n / k) * A >= B; n /= k) { 9 | ans += B + (n - n / k * k) * A; 10 | } 11 | ans += (n - 1ull) * A; 12 | cout << ans; 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Code/1001.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int H, h, n, num = 0; 6 | cin >> H >> h >> n; 7 | for (int i = 0; i < n; i++) { 8 | int t; 9 | cin >> t; 10 | if (H + h >= t) { 11 | num++; 12 | } 13 | } 14 | cout << num << endl; 15 | } 16 | -------------------------------------------------------------------------------- /Code/1503.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | double x1, x2, y1, y2; 8 | cin >> x1 >> y1 >> x2 >> y2; 9 | 10 | auto c = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); 11 | c = int64_t(c * 100000.0 + 0.5) / 100000.0; 12 | cout << c; 13 | 14 | return 0; 15 | } -------------------------------------------------------------------------------- /Code/4022.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int main() { 6 | long long x, n; 7 | cin >> x >> n; 8 | 9 | long long ans = 0; 10 | ans += n / 7 * (250 * 5); 11 | 12 | for (long long i = 0; i < n % 7; ++i) { 13 | if (x + i != 6 && x + i != 7) 14 | ans += 250; 15 | } 16 | 17 | cout << ans; 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Code/4024.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int a = 0, b = 0; 7 | cin >> a; 8 | cin >> b; 9 | 10 | cout << a << "+" << b << "=" << a + b << endl; 11 | cout << a << "*" << b << "=" << a * b << endl; 12 | cout << a << "/" << b << "=" << a / b << endl; 13 | cout << a << "%" << b << "=" << a % b << endl; 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /Code/4026.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | char a, b, c, d; 7 | int input; 8 | cin >> input; 9 | a = input / 1000; 10 | b = (input % 1000) / 100; 11 | c = (input % 100) / 10; 12 | d = (input % 10); 13 | a = a + 77; 14 | b = b + 77; 15 | c = c + 77; 16 | d = d + 77; 17 | cout<< a << b << c << d << endl; 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Code/4258.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int fast_pow(int a, int n) { 5 | int ans = 1, base = a; 6 | for (; n; n >>= 1) { 7 | if (n & 1) 8 | ans = (ans * base) % 2019; 9 | base = (base * base) % 2019; 10 | } 11 | return ans; 12 | } 13 | 14 | int main() { 15 | int a, n; 16 | cin >> a >> n; 17 | cout << fast_pow(a, n); 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Code/4187.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int main() { 5 | int n = 0; 6 | unsigned int ans[100] = { 0 }; 7 | cin >> n; 8 | if (n <= 0 || n > 50) { 9 | cout << "error!"; 10 | return 0; 11 | } 12 | ans[1] = 0; 13 | ans[2] = 1; 14 | for (int i = 3; i <= n; i++) { 15 | ans[i] = ans[i - 2] + ans[i - 1]; 16 | } 17 | cout << ans[n]; 18 | 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Code/4318.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(0); 8 | cout.tie(0); 9 | 10 | int n; 11 | cin >> n; 12 | 13 | int max_n = 0; 14 | for (int i = 0; i < n; ++i) { 15 | int temp; 16 | cin >> temp; 17 | max_n = max(temp, max_n); 18 | } 19 | cout << max_n; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /Code/1208.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstring" 3 | #include "cstdio" 4 | #include "cmath" 5 | using namespace std; 6 | 7 | int main() { 8 | double r, d; 9 | double ans = 0.0; 10 | while (cin >> r >> d) { 11 | double cur_ans = r * r * acos(d / r) - d * sqrt(r * r - d * d); 12 | ans = cur_ans > ans ? cur_ans : ans; 13 | } 14 | 15 | printf("%.2f", ans); 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /Code/1998.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cmath" 3 | #include "algorithm" 4 | using namespace std; 5 | 6 | int main() { 7 | int num; 8 | cin >> num; 9 | int *data = new int[num]; 10 | for (int i = 0; i < num; i++) 11 | cin >> data[i]; 12 | 13 | sort(data, data + num); 14 | int dis = 0; 15 | for (int i = 0; i < num;i++) { 16 | dis += abs(data[i] - data[num / 2]); 17 | } 18 | cout << dis; 19 | return 0; 20 | } -------------------------------------------------------------------------------- /Code/4254.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | using ull = unsigned long long; 4 | 5 | int main() { 6 | ull n, a = 0, b = 0, c = 0; 7 | cin >> n; 8 | 9 | for (; n % 5ull == 0; n /= 5ull, ++c); 10 | for (; n % 3ull == 0; n /= 3ull, ++b); 11 | for (; n % 2ull == 0; n /= 2ull, ++a); 12 | 13 | if (n != 1) 14 | cout << -1; 15 | else 16 | cout << a + 2ull * b + 3ull * c; 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /Code/4062.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | long long cal(long long x, long long y) { 6 | if (y == 0 || x == 0) 7 | return 0; 8 | if (y >= x) { 9 | return cal(x, y % x) + y / x * x * 4; 10 | } 11 | else { 12 | return cal(x % y, y) + x / y * y * 4; 13 | } 14 | } 15 | 16 | int main() { 17 | long long x, y; 18 | cin >> x >> y; 19 | 20 | cout << cal(x, y); 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # SJTU-OJ Code 2 | 本人编写的上海交通大学OJ系统部分题目的C++版本代码。 3 | - [上海交通大学Online Judge](https://acm.sjtu.edu.cn/OnlineJudge/) 4 | - [使用本仓库代码的OJ-APP](https://github.com/ligongzzz/OJ-APP) 5 | ## 特别说明 6 | - **（2019年9月更新特别说明）** 本次更新去除了原有的Code目录下的子文件夹，全部代码以题号命名文件形式保存，存储结构更为清晰。 7 | - 代码在Code文件夹中的子文件夹中，其中的代码为相应的"题目编号.cpp"。 8 | - 作者邮箱：xiezhe20001128@sjtu.edu.cn 9 | - 部分代码可能无法通过OJ测试，请及时通过Issues或者Pull Request反馈！ 10 | - __请注意，本项目中的代码和OJ-APP仅供参考使用！请各位独立完成作业。__ -------------------------------------------------------------------------------- /Code/4023.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(0); 8 | cout.tie(0); 9 | 10 | int n; 11 | cin >> n; 12 | 13 | vector val(n); 14 | 15 | for (int i = 0; i < n; ++i) { 16 | cin >> val[i]; 17 | int cnt = 0; 18 | for (int j = 0; j < i; ++j) 19 | if (val[j] < val[i]) 20 | ++cnt; 21 | cout << cnt << " "; 22 | } 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Code/4319.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | int n; 9 | cin >> n; 10 | 11 | vector xval(n + 1, 0); 12 | for (int i = 1; i <= n; ++i) 13 | xval[i] = xval[i - 1] ^ i; 14 | 15 | int ans = 0; 16 | for (int i = 1; i <= n; ++i) { 17 | int k = n / i, r = n % i; 18 | if (k % 2) 19 | ans ^= xval[i - 1]; 20 | ans ^= xval[r]; 21 | } 22 | 23 | cout << ans; 24 | 25 | return 0; 26 | } -------------------------------------------------------------------------------- /Code/4047.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int main() { 5 | bool a[2000001]; 6 | int num; 7 | cin >> num; 8 | 9 | for (int i = 0; i <= num; i++) 10 | a[i] = true; 11 | 12 | for (int i = 2; i <= num; i++) { 13 | if (a[i]) { 14 | for (int j = 2; i*j <= num; j++) 15 | a[i*j] = false; 16 | } 17 | } 18 | 19 | cout << "2"; 20 | 21 | for (int i = 3; i <= num; i++) { 22 | if (a[i]) 23 | cout << " " << i; 24 | } 25 | 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /Code/3044.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | constexpr long long mod = (long long)(1e9 + 7); 6 | 7 | long long ans_data[1009] = { 0 }; 8 | 9 | int main() { 10 | ans_data[0] = 1; 11 | ans_data[1] = 1; 12 | long long num; 13 | cin >> num; 14 | for (long long i = 2; i <= num; ++i) { 15 | for (long long j = i; j >= 0; j -= 2) 16 | ans_data[i] = (ans_data[i] + ans_data[(i - j) / 2]) % mod; 17 | } 18 | cout << ans_data[num]; 19 | 20 | return 0; 21 | } -------------------------------------------------------------------------------- /Code/4255.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | int n; 12 | cin >> n; 13 | vector vdata(n - 1); 14 | 15 | for (int i = 0; i < n - 1; ++i) 16 | cin >> vdata[i]; 17 | 18 | int ans = vdata[0] + vdata[n - 2]; 19 | for (int i = 0; i < n - 2; ++i) 20 | ans += min(vdata[i], vdata[i + 1]); 21 | 22 | cout << ans; 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Code/4110.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | int n; 13 | cin >> n; 14 | cin.get(); 15 | 16 | vector val_data(n); 17 | for (int i = 0; i < n; ++i) { 18 | getline(cin, val_data[i]); 19 | } 20 | 21 | sort(val_data.begin(), val_data.end()); 22 | 23 | for (auto& p : val_data) 24 | cout << p << "\n"; 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /Code/1024.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "vector" 3 | #include "algorithm" 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | vector vector_data; 12 | 13 | int n; 14 | cin >> n; 15 | 16 | for (int i = 0; i < n; ++i) { 17 | int temp; 18 | cin >> temp; 19 | vector_data.push_back(temp); 20 | } 21 | 22 | sort(vector_data.begin(), vector_data.end()); 23 | 24 | for (auto p : vector_data) 25 | cout << p << " "; 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /Code/3002.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | bool val_num[1009] = { 0 }; 7 | 8 | int main() { 9 | int n; 10 | scanf("%d", &n); 11 | 12 | int cnt = 0; 13 | for (int i = 0; i < n; ++i) { 14 | int temp; 15 | scanf("%d", &temp); 16 | if (!val_num[temp]) { 17 | ++cnt; 18 | val_num[temp] = true; 19 | } 20 | } 21 | 22 | printf("%d\n", cnt); 23 | for (int i = 0; i < 1005; ++i) { 24 | if (val_num[i]) 25 | printf("%d ", i); 26 | } 27 | 28 | return 0; 29 | } -------------------------------------------------------------------------------- /Code/1038.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "vector" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int M, data[20000]; 8 | vector monkeyList; 9 | cin >> M; 10 | for (int i = 0; i < M-1; i++) 11 | cin >> data[i]; 12 | for (int i = 0; i < M; i++) 13 | monkeyList.push_back(i+1); 14 | 15 | for (int i = 0,current=0,len=M; i < M - 1; i++,len--) { 16 | int temp = (data[i]+current-1) % len; 17 | monkeyList.erase(monkeyList.begin()+temp); 18 | current = temp; 19 | } 20 | 21 | cout << monkeyList.back(); 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /Code/4378.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by 谢哲 on 2021/4/22. 3 | // 4 | 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | int main(){ 10 | ios::sync_with_stdio(false); 11 | cin.tie(0); 12 | cout.tie(0); 13 | 14 | int cur_min = 999999999; 15 | int result = 0; 16 | 17 | int n; 18 | cin >> n; 19 | 20 | for(;n;--n) { 21 | int a; 22 | cin >> a; 23 | result = max(result, a - cur_min); 24 | cur_min = min(cur_min, a); 25 | } 26 | 27 | cout << result; 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /Code/1598.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | int n; 12 | cin >> n; 13 | vector vdata(2 * n); 14 | 15 | for (int i = 0; i < 2 * n; ++i) 16 | cin >> vdata[i]; 17 | sort(vdata.begin(), vdata.end()); 18 | 19 | int ans = 0; 20 | for (int i = 0; i < n; ++i) { 21 | ans -= vdata[i]; 22 | } 23 | for (int i = n; i < 2 * n; ++i) { 24 | ans += vdata[i]; 25 | } 26 | 27 | cout << ans; 28 | 29 | return 0; 30 | } -------------------------------------------------------------------------------- /Code/3016.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int ai[109] = { 0 }; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(NULL); 9 | 10 | int num; 11 | cin >> num; 12 | int average = 0; 13 | 14 | for (int i = 0; i < num; ++i) { 15 | cin >> ai[i]; 16 | average += ai[i]; 17 | } 18 | average /= num; 19 | 20 | int ans = 0; 21 | for (int i = 0; i < num - 1; ++i) { 22 | if (ai[i] != average) { 23 | ai[i + 1] -= average - ai[i]; 24 | ai[i] = average; 25 | ++ans; 26 | } 27 | } 28 | 29 | cout << ans; 30 | 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Code/1013.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | int weight[1009] = { 0 }, value[1009] = { 0 },dp_data[10009] = { 0 }; 4 | int dp(int v, int n) { 5 | if (dp_data[v] > 0) return dp_data[v]; 6 | int ans = 0; 7 | for (int i = 0; i < n; ++i) 8 | if (weight[i] <= v) { 9 | auto temp = dp(v - weight[i], n) + value[i]; 10 | ans = temp > ans ? temp : ans; 11 | } 12 | dp_data[v] = ans; 13 | return ans; 14 | } 15 | int main() { 16 | int v, n; 17 | cin >> v >> n; 18 | for (int i = 0; i < n; ++i) 19 | cin >> weight[i] >> value[i]; 20 | cout << dp(v, n); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /Code/1217.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(0); 8 | cout.tie(0); 9 | 10 | int n; 11 | cin >> n; 12 | 13 | unordered_map mdata; 14 | for (; n; --n) { 15 | int temp; 16 | cin >> temp; 17 | mdata.insert(make_pair(temp, true)); 18 | } 19 | 20 | int m; 21 | cin >> m; 22 | for (; m; --m) { 23 | int temp; 24 | cin >> temp; 25 | if (mdata.find(temp) != mdata.end()) 26 | cout << "Y\n"; 27 | else 28 | cout << "N\n"; 29 | } 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Code/4147.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | constexpr int inf = (int)(1e9 + 7); 6 | 7 | int main() { 8 | int n; 9 | scanf("%d", &n); 10 | 11 | for (int i = 0, last = inf; i < n; ++i) { 12 | int wi, hi; 13 | scanf("%d %d", &wi, &hi); 14 | if (wi <= last && hi <= last) { 15 | last = wi > hi ? wi : hi; 16 | } 17 | else if (wi <= last) { 18 | last = wi; 19 | } 20 | else if (hi <= last) { 21 | last = hi; 22 | } 23 | else { 24 | cout << "NO"; 25 | return 0; 26 | } 27 | } 28 | cout << "YES"; 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /Code/1004.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(NULL); 8 | cout.tie(NULL); 9 | 10 | int M, T, U, F, D; 11 | cin >> M >> T >> U >> F >> D; 12 | 13 | int ans = 0; 14 | for (int i = 0, cur_time = 0; i < T; ++i) { 15 | char c; 16 | cin >> c; 17 | if (c == 'u'||c=='d') { 18 | if (cur_time + U + D <= M) 19 | ++ans; 20 | cur_time += U + D; 21 | } 22 | else { 23 | if (cur_time + 2 * F <= M) 24 | ++ans; 25 | cur_time += 2 * F; 26 | } 27 | } 28 | cout << ans; 29 | return 0; 30 | } -------------------------------------------------------------------------------- /Code/4223.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class node { 6 | public: 7 | int parent = 0; 8 | vector child; 9 | vector isbad; 10 | bool good = false; 11 | }; 12 | 13 | int n; 14 | vector tdata; 15 | 16 | int main() { 17 | ios::sync_with_stdio(false); 18 | cin.tie(0); 19 | cout.tie(0); 20 | 21 | cin >> n; 22 | tdata.resize(n + 1); 23 | 24 | for (int a = 0; a < n; ++a) { 25 | int i, j, k; 26 | cin >> i >> j >> k; 27 | 28 | tdata[i].child.emplace_back(j); 29 | tdata[j].child.emplace_back(i); 30 | 31 | } 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Code/1567.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int main() { 5 | ios::sync_with_stdio(false); 6 | cin.tie(NULL); 7 | 8 | char c; 9 | int num; 10 | cin >> c >> num; 11 | 12 | for (int i = 0; i <= num / 2; ++i) { 13 | for (int j = 0; j < num / 2 - i; ++j) 14 | cout << " "; 15 | for (int j = 0; j < 2 * i + 1; ++j) 16 | cout << c; 17 | cout << endl; 18 | } 19 | for (int i = num / 2 - 1; i >= 0; --i) { 20 | for (int j = 0; j < num / 2 - i; ++j) 21 | cout << " "; 22 | for (int j = 0; j < 2 * i + 1; ++j) 23 | cout << c; 24 | cout << endl; 25 | } 26 | 27 | return 0; 28 | } -------------------------------------------------------------------------------- /Code/4208.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cmath" 4 | using namespace std; 5 | 6 | int main() { 7 | int n; 8 | cin >> n; 9 | 10 | for (; n > 0; --n) { 11 | int a, b, x1, y1, x2, y2; 12 | scanf("%d %d %d %d %d %d", &b, &a, &x1, &y1, &x2, &y2); 13 | a *= 2, b *= 2; 14 | int m1 = floor(double(x1 - y1) / a), n1 = floor(double(x1 + y1) / b), 15 | m2 = floor(double(x2 - y2) / a), n2 = floor(double(x2 + y2) / b); 16 | if (abs(m1 - m2) > abs(n1 - n2)) { 17 | printf("%d\n", abs(m1 - m2)); 18 | } 19 | else { 20 | printf("%d\n", abs(n1 - n2)); 21 | } 22 | } 23 | 24 | return 0; 25 | } -------------------------------------------------------------------------------- /Code/4149.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | constexpr int max_num = 20000000; 6 | 7 | bool remain[max_num] = { 0 }; 8 | 9 | int main() { 10 | long long n, m, k; 11 | cin >> n >> m >> k; 12 | 13 | long long cnt = n, cur_pos = 0; 14 | for (; k > 0; --k) { 15 | long long dis = m % cnt; 16 | if (dis == 0) 17 | dis = cnt; 18 | for (long long i = 0; i < dis;) { 19 | ++cur_pos; 20 | if (cur_pos > n) 21 | cur_pos = 1; 22 | if (!remain[cur_pos]) { 23 | ++i; 24 | } 25 | } 26 | remain[cur_pos] = true; 27 | } 28 | 29 | cout << cur_pos; 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /Code/4102.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | uint32_t n, k; 12 | cin >> k >> n; 13 | 14 | multiset sdata; 15 | vector vdata(n); 16 | uint32_t cur_ans = 0u; 17 | for (uint32_t i = 0u, cur_left = 0u; i < n; ++i) { 18 | cin >> vdata[i]; 19 | sdata.insert(vdata[i]); 20 | for (; *sdata.rbegin() - *sdata.begin() > k; sdata.erase(sdata.find(vdata[cur_left++]))); 21 | cur_ans = i - cur_left + 1u > cur_ans ? i - cur_left + 1u : cur_ans; 22 | } 23 | 24 | cout << cur_ans; 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /Code/4221.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "stack" 3 | #include "cstdio" 4 | using namespace std; 5 | 6 | stack stack_data; 7 | 8 | int main() { 9 | int n; 10 | scanf("%d", &n); 11 | 12 | 13 | int ans = 0; 14 | for (int i = 0; i < n; ++i) { 15 | int val, direction; 16 | scanf("%d %d", &val, &direction); 17 | if (direction) { 18 | stack_data.push(val); 19 | } 20 | else { 21 | while (!stack_data.empty()) { 22 | if (val >= stack_data.top()) 23 | stack_data.pop(); 24 | else { 25 | --ans; 26 | break; 27 | } 28 | } 29 | ++ans; 30 | } 31 | } 32 | printf("%d", (int)stack_data.size() + ans); 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Code/4093.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | const int MAX = 200001; 5 | int n, m; 6 | struct candy { 7 | int ai = 0; 8 | int bi = 0; 9 | }c[MAX]; 10 | 11 | long long nums[MAX] = { 0 }; 12 | 13 | int main() { 14 | ios::sync_with_stdio(false); 15 | cin.tie(0); 16 | cin >> n >> m; 17 | for (int i = 0; i < m; ++i) { 18 | cin >> c[i].ai; 19 | cin >> c[i].bi; 20 | nums[c[i].bi] += c[i].ai; 21 | } 22 | long long ans = 0; 23 | 24 | for (long long i = MAX - 1; i >= 0; --i) { 25 | if (n > nums[i]) { 26 | ans += nums[i] * i; 27 | n -= nums[i]; 28 | } 29 | else { 30 | ans += n * i; 31 | break; 32 | } 33 | } 34 | cout << ans; 35 | return 0; 36 | } -------------------------------------------------------------------------------- /Code/4219.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "vector" 3 | #include "algorithm" 4 | using namespace std; 5 | 6 | const int mod = int(1e9 + 7); 7 | vector value; 8 | 9 | int main() { 10 | ios::sync_with_stdio(false); 11 | cin.tie(0); 12 | cout.tie(0); 13 | 14 | int T, n; 15 | cin >> T >> n; 16 | 17 | for (int i = 0; i < n; ++i) { 18 | int temp; 19 | cin >> temp; 20 | value.push_back(temp); 21 | } 22 | 23 | sort(value.begin(), value.end(), [](int a, int b) {return a > b; }); 24 | 25 | for (int i = 1; i < n; ++i) 26 | value[i] = (value[i - 1] + value[i]) % int(1e9 + 7); 27 | 28 | for (; T > 0; --T) { 29 | int temp; 30 | cin >> temp; 31 | cout << value[temp - 1] << "\n"; 32 | } 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Code/1541.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "set" 4 | using namespace std; 5 | 6 | 7 | int main() { 8 | int k, n; 9 | cin >> k >> n; 10 | 11 | multiset> mySet; 12 | 13 | int currentNum,*numData=new int[n]; 14 | for (int i = 0; i < k; i++) { 15 | int tempNum; 16 | scanf("%d", &tempNum); 17 | numData[i] = tempNum; 18 | } 19 | 20 | mySet.insert(numData, numData + k); 21 | cout << *mySet.begin(); 22 | for (int startNum = 0; startNum + k < n; startNum++) { 23 | int tempNum; 24 | scanf("%d", &tempNum); 25 | numData[startNum + k] = tempNum; 26 | mySet.erase(mySet.find(numData[startNum])); 27 | mySet.insert(tempNum); 28 | printf(" %d", *mySet.begin()); 29 | } 30 | return 0; 31 | } -------------------------------------------------------------------------------- /Code/4211.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | int n; 13 | cin >> n; 14 | 15 | vector ans(n, "-1"); 16 | stack>> sdata; 17 | 18 | for (int i = 0; i < n; ++i) { 19 | int val; 20 | string name; 21 | cin >> val; 22 | cin.get(); 23 | getline(cin, name); 24 | 25 | for (; !sdata.empty() && val > sdata.top().second.first;) { 26 | ans[sdata.top().first] = name; 27 | sdata.pop(); 28 | } 29 | sdata.push(make_pair(i, make_pair(val, name))); 30 | } 31 | 32 | for (auto& p : ans) 33 | cout << p << "\n"; 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Code/4256.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(0); 8 | cout.tie(0); 9 | 10 | int n; 11 | cin >> n; 12 | vector up(n + 1), down(n + 1), ups(n + 1, 0), downs(n + 1, 0); 13 | 14 | for (int i = 1; i <= n; ++i) { 15 | cin >> up[i]; 16 | ups[i] = ups[i - 1] + up[i]; 17 | } 18 | for (int i = 1; i <= n; ++i) 19 | cin >> down[i]; 20 | 21 | downs[n] = down[n]; 22 | for (int i = n - 1; i >= 1; --i) 23 | downs[i] = downs[i + 1] + down[i]; 24 | 25 | int ans = 0; 26 | for (int i = 1; i <= n; ++i) { 27 | int cur_ans = ups[i] + downs[i]; 28 | ans = cur_ans > ans ? cur_ans : ans; 29 | } 30 | 31 | cout << ans; 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Code/4222.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(0); 8 | cout.tie(0); 9 | 10 | int t; 11 | cin >> t; 12 | 13 | for (; t; --t) { 14 | int n, m; 15 | cin >> n >> m; 16 | 17 | vector mdata(m, false); 18 | mdata[0] = true; 19 | 20 | int cur_sum = 0; 21 | bool flag = false; 22 | for (int i = 0; i < n; ++i) { 23 | int temp; 24 | cin >> temp; 25 | if (flag) 26 | continue; 27 | cur_sum = (cur_sum + temp) % m; 28 | if (mdata[cur_sum]) { 29 | flag = true; 30 | } 31 | else 32 | mdata[cur_sum] = true; 33 | } 34 | if (flag) 35 | cout << "YES\n"; 36 | else 37 | cout << "NO\n"; 38 | } 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Code/4354.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | string s; 13 | cin >> s; 14 | 15 | string output = ""; 16 | vector sp; 17 | 18 | auto length = s.length(); 19 | for (size_t i = 0; i < length; ++i) { 20 | if (s[i] >= '0' && s[i] <= '9') 21 | continue; 22 | else if (s[i] == '(') { 23 | sp.emplace_back(output.length()); 24 | } 25 | else if (s[i] == ')') { 26 | reverse(output.begin() + sp.back(), output.end()); 27 | sp.pop_back(); 28 | } 29 | else 30 | { 31 | output += s[i]; 32 | } 33 | } 34 | 35 | cout << output; 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Code/1019.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "stack" 5 | using namespace std; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | int n; 13 | cin >> n; 14 | for (int i = 0; i < n; ++i) { 15 | stack stack_data; 16 | char temp[109]; 17 | cin >> temp; 18 | int length = strlen(temp); 19 | for (int j = 0; j < length; ++j) { 20 | if (temp[j] == '(') 21 | stack_data.push('('); 22 | else if (!stack_data.empty() && stack_data.top() == '(') 23 | stack_data.pop(); 24 | else 25 | stack_data.push(')'); 26 | } 27 | if (stack_data.empty()) 28 | cout << "YES" << "\n"; 29 | else 30 | cout << "NO" << "\n"; 31 | } 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Code/4229.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | int val_num[50009] = { 0 }; 7 | 8 | int main() { 9 | int n; 10 | scanf("%d", &n); 11 | 12 | int cur_max = 0, max_n = 0; 13 | while (true) { 14 | char op[10]; 15 | scanf("%s", op); 16 | if (strcmp(op, "add") == 0) { 17 | int a, b; 18 | scanf("%d %d", &a, &b); 19 | ++val_num[b]; 20 | if (val_num[b] == max_n) { 21 | if (b < cur_max) { 22 | cur_max = b; 23 | } 24 | } 25 | if (val_num[b] > max_n) { 26 | cur_max = b; 27 | max_n = val_num[b]; 28 | } 29 | } 30 | else if (strcmp(op, "query") == 0) { 31 | printf("%d %d\n", cur_max, max_n); 32 | } 33 | else { 34 | break; 35 | } 36 | } 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Code/1107.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | int m; 12 | cin >> m; 13 | 14 | vector mdata(m); 15 | 16 | int maxn = 0; 17 | for (int i = 0; i < m; ++i) { 18 | cin >> mdata[i]; 19 | maxn = mdata[i] > maxn ? mdata[i] : maxn; 20 | } 21 | 22 | vector isNum(maxn + 1, true); 23 | vector cnt(maxn + 1, 0); 24 | for (int i = 2; i <= maxn; ++i) { 25 | if (!isNum[i]) { 26 | cnt[i] = cnt[i - 1]; 27 | continue; 28 | } 29 | for (int j = 2 * i; j <= maxn; j += i) 30 | isNum[i] = false; 31 | cnt[i] = cnt[i - 1] + 1; 32 | } 33 | 34 | for (auto p : mdata) { 35 | 36 | } 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Code/3030.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int time_val[109], val[109]; 6 | int dp_data[109][1009] = { 0 }; 7 | 8 | int dp(int num, int v) { 9 | if (num == 0) 10 | return 0; 11 | if (dp_data[num][v] > 0) 12 | return dp_data[num][v]; 13 | if (time_val[num - 1] > v) { 14 | dp_data[num][v] = dp(num - 1, v); 15 | return dp_data[num][v]; 16 | } 17 | else { 18 | int ans1 = dp(num - 1, v), ans2 = dp(num - 1, v - time_val[num - 1]) + val[num - 1]; 19 | dp_data[num][v] = ans1 > ans2 ? ans1 : ans2; 20 | return dp_data[num][v]; 21 | } 22 | } 23 | 24 | int main() { 25 | int T, M; 26 | cin >> T >> M; 27 | 28 | for (int i = 0; i < M; ++i) 29 | scanf("%d %d", &time_val[i], &val[i]); 30 | 31 | cout << dp(M, T); 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Code/4045.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int origin[10009] = { 0 }; 6 | int num_data[10009] = { 0 }; 7 | 8 | int main() { 9 | int n, m; 10 | scanf("%d %d", &n, &m); 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | scanf("%d", &origin[i]); 14 | //num_data[i] = origin[i]; 15 | } 16 | 17 | for (int i = 0; i < m; ++i) { 18 | int l, r, x; 19 | scanf("%d %d %d", &l, &r, &x); 20 | if (xr) { 21 | printf("Yes\n"); 22 | } 23 | else { 24 | int cnt = 0; 25 | for (int j = l; j <= r; ++j) { 26 | if (j == x) 27 | continue; 28 | if (origin[j] < origin[x]) 29 | ++cnt; 30 | } 31 | if (cnt == x - l) 32 | printf("Yes\n"); 33 | else 34 | printf("No\n"); 35 | } 36 | } 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Code/1272.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | int n; 12 | cin >> n; 13 | 14 | vector vdata(n); 15 | unordered_map mdata; 16 | 17 | for (int i = 0; i < n; ++i) { 18 | cin >> vdata[i]; 19 | mdata.insert(make_pair(vdata[i], true)); 20 | } 21 | 22 | for (int i = 0; i < vdata.size(); ++i) { 23 | for (int j = 0; j < i; ++j) { 24 | int ans = vdata[i] > vdata[j] ? vdata[i] / vdata[j] : vdata[j] / vdata[i]; 25 | if (mdata.find(ans) == mdata.end()) { 26 | vdata.emplace_back(ans); 27 | mdata.insert(make_pair(ans, true)); 28 | } 29 | } 30 | } 31 | 32 | cout << vdata.size(); 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Code/1002.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int hs[1009][1009] = { 0 }; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | int L, W; 13 | cin >> L >> W; 14 | 15 | for (int i = 1; i <= L; ++i) { 16 | for (int j = 1; j <= W; ++j) { 17 | int temp; 18 | cin >> temp; 19 | hs[i][j] = hs[i][j - 1] + hs[i - 1][j] - hs[i - 1][j - 1] + temp; 20 | } 21 | } 22 | int cur_ans = 0; 23 | int a, b; 24 | cin >> a >> b; 25 | for (int i = 0; i + a <= L; ++i) { 26 | for (int j = 0; j + b <= W; ++j) { 27 | if (hs[i + a][j + b] - hs[i][j + b] - hs[i + a][j] + hs[i][j] > cur_ans) 28 | cur_ans = hs[i + a][j + b] - hs[i][j + b] - hs[i + a][j] + hs[i][j]; 29 | } 30 | } 31 | 32 | cout << cur_ans; 33 | 34 | return 0; 35 | } -------------------------------------------------------------------------------- /Code/1994.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | bool map[509][509] = { 0 }; 6 | int dx[] = { 0,1,0,-1 }, 7 | dy[] = { 1,0,-1,0 }; 8 | int n, m; 9 | void dfs(int x, int y) { 10 | map[x][y] = false; 11 | for (int i = 0; i < 4; ++i) { 12 | if (x + dx[i] >= 0 && x + dx[i] < n && y + dy[i] >= 0 && y + dy[i] < m && map[x + dx[i]][y + dy[i]]) 13 | dfs(x + dx[i], y + dy[i]); 14 | } 15 | } 16 | 17 | int main() { 18 | scanf("%d %d", &n, &m); 19 | 20 | for(int i=0;i setdata; 10 | int M; 11 | cin >> M; 12 | 13 | for (; M > 0; --M) { 14 | int op, x; 15 | scanf("%d %d", &op, &x); 16 | 17 | if (op == 0) { 18 | auto p=setdata.lower_bound(x); 19 | if (p == setdata.end()) 20 | printf("%d\n", (int)abs(*setdata.rbegin() - x)); 21 | else if (p == setdata.begin()) 22 | printf("%d\n", (int)abs(*setdata.begin() - x)); 23 | else { 24 | int x1 = (int)abs(*p - x), 25 | x2 = (int)abs(*(--p) - x); 26 | printf("%d\n", min(x1, x2)); 27 | } 28 | 29 | } 30 | else if (op == 1) { 31 | setdata.insert(x); 32 | } 33 | else { 34 | setdata.erase(setdata.find(x)); 35 | } 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Code/4242.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | using ull = unsigned long long; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | string A, B; 13 | cin >> A >> B; 14 | 15 | if (A.length() < B.length()) { 16 | cout << 0; 17 | return 0; 18 | } 19 | int al = A.length(), bl = B.length(); 20 | 21 | ull hasha = 0, hashb = 0, pnum = 1ull; 22 | for (int i = 0; i < bl; ++i) { 23 | hasha = hasha * 131ull + ull(A[i]); 24 | hashb = hashb * 131ull + ull(B[i]); 25 | pnum *= 131ull; 26 | } 27 | 28 | int cnt = 0; 29 | for (int i = 0;; ++i) { 30 | if (hasha == hashb) 31 | ++cnt; 32 | if (i + bl >= al) 33 | break; 34 | 35 | hasha = hasha * 131ull + ull(A[i + bl]) - pnum * ull(A[i]); 36 | } 37 | 38 | cout << cnt; 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Code/1239.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int main() { 5 | int salary; 6 | cin >> salary; 7 | salary -= 3500; 8 | 9 | double ans = 0.0; 10 | if (salary > 80000) { 11 | ans += (salary - 80000) * 0.45; 12 | salary = 80000; 13 | } 14 | if (salary > 55000) { 15 | ans += (salary - 55000) * 0.35; 16 | salary = 55000; 17 | } 18 | if (salary > 35000) { 19 | ans += (salary - 35000) * 0.30; 20 | salary = 35000; 21 | } 22 | if (salary > 9000) { 23 | ans += (salary - 9000) * 0.25; 24 | salary = 9000; 25 | } 26 | if (salary > 4500) { 27 | ans += (salary - 4500) * 0.20; 28 | salary = 4500; 29 | } 30 | if (salary > 1500) { 31 | ans += (salary - 1500) * 0.10; 32 | salary = 1500; 33 | } 34 | if (salary > 0) { 35 | ans += (salary - 0) * 0.03; 36 | } 37 | 38 | cout << (int)ans; 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Code/4089.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | constexpr auto maxNum = 1000; 5 | 6 | class Joseph { 7 | bool exi[maxNum]; 8 | public: 9 | int n, m; 10 | Joseph(int n,int m):n(n),m(m){ 11 | for (int i = 0; i <= n; i++) exi[i] = true; 12 | } 13 | 14 | void simulate() { 15 | int num = n; 16 | int cal = 0, sci = 1; 17 | while (num > 0) { 18 | if (!exi[sci]) { 19 | sci++; 20 | if (sci> n) 21 | sci = 1; 22 | continue; 23 | } 24 | if (cal == m) { 25 | cout << sci; 26 | cal = 0; 27 | exi[sci] = false; 28 | num--; 29 | if (num > 0) 30 | cout << " "; 31 | } 32 | sci++; 33 | cal++; 34 | if (sci>n) 35 | sci = 1; 36 | } 37 | } 38 | }; 39 | 40 | int main() { 41 | int m, n; 42 | cin >> m >> n; 43 | Joseph j(m, n); 44 | 45 | j.simulate(); 46 | 47 | return 0; 48 | } -------------------------------------------------------------------------------- /Code/4377.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by 谢哲 on 2021/4/13. 3 | // 4 | 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | constexpr long long mod = 1e9+7; 10 | 11 | vector dp_data; 12 | 13 | 14 | long long dp(int l, int r) { 15 | if (dp_data[r-l]>=0) return dp_data[r-l]; 16 | 17 | if (r-l==1) return 1; 18 | if (r==l) return 1; 19 | 20 | long long ans = 0; 21 | for (int i=l;i>n; 37 | 38 | dp_data.resize(n+1, -1); 39 | 40 | cout< 0; --Q) { 28 | int x1, y1, x2, y2; 29 | scanf("%d %d %d %d", &x1, &y1, &x2, &y2); 30 | printf("%lld\n", f(x2, y2) - f(x2, y1 - 1) - f(x1 - 1, y2) + f(x1 - 1, y1 - 1)); 31 | } 32 | 33 | return 0; 34 | } -------------------------------------------------------------------------------- /Code/2109.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cmath" 3 | #include "cstdio" 4 | using namespace std; 5 | 6 | int ai[100009] = { 0 }; 7 | 8 | int mid_find(int left, int right, int val) { 9 | if (left == right) { 10 | if (ai[left] <= val) 11 | return left; 12 | else return left - 1; 13 | } 14 | int mid = (left + right) >> 1; 15 | if (ai[mid] == val) 16 | return mid; 17 | else if (ai[mid] < val) { 18 | return mid_find(mid + 1, right, val); 19 | } 20 | else { 21 | return mid_find(left, mid - 1, val); 22 | } 23 | } 24 | 25 | int main() { 26 | int N; 27 | scanf("%d", &N); 28 | for (int i = 0; i < N; ++i) 29 | scanf("%d", &ai[i]); 30 | 31 | int K; 32 | scanf("%d", &K); 33 | for (int i = 0; i < K; ++i) { 34 | int b, c; 35 | scanf("%d %d", &b, &c); 36 | 37 | printf("%d\n", mid_find(0, N - 1, b * b / (4 * c)) + 1); 38 | } 39 | 40 | return 0; 41 | } -------------------------------------------------------------------------------- /Code/1320.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int val_data[1009][1009] = { 0 }; 7 | int n; 8 | 9 | int dp_data[1009][1009] = { 0 }; 10 | 11 | int dp(int posi, int posj) { 12 | if (dp_data[posi][posj] >= 0) 13 | return dp_data[posi][posj]; 14 | if (posi >= n) 15 | return 0; 16 | 17 | int ans1 = val_data[posi][posj] + dp(posi + 1, posj), 18 | ans2 = val_data[posi][posj] + dp(posi + 1, posj + 1); 19 | 20 | dp_data[posi][posj] = max(ans1, ans2); 21 | return dp_data[posi][posj]; 22 | } 23 | 24 | int main() { 25 | ios::sync_with_stdio(false); 26 | cin.tie(0); 27 | cout.tie(0); 28 | 29 | cin >> n; 30 | 31 | memset(dp_data, -1, sizeof(dp_data)); 32 | 33 | for (int i = 0; i < n; ++i) { 34 | for (int j = 0; j <= i; ++j) { 35 | cin >> val_data[i][j]; 36 | } 37 | } 38 | 39 | cout << dp(0, 0); 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /Code/4132.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | int n, m; 13 | cin >> n >> m; 14 | int len = min(n, m); 15 | 16 | vector lcp(len, 0); 17 | string A, B; 18 | cin >> A >> B; 19 | 20 | int cur_pos = 0; 21 | for (; cur_pos < len && A[cur_pos] == B[cur_pos]; ++cur_pos); 22 | lcp[0] = cur_pos; 23 | 24 | int q; 25 | cin >> q; 26 | 27 | for (; q > 0; --q) { 28 | int a, b; 29 | char c; 30 | cin >> a >> b; 31 | cin.get(); 32 | cin >> c; 33 | if (b > len) 34 | continue; 35 | if (a == 0) 36 | A[b - 1] = c; 37 | else 38 | B[b - 1] = c; 39 | 40 | --b; 41 | for (cur_pos = 0; lcp[cur_pos] <= b; cur_pos = lcp[cur_pos]); 42 | if (A[b] != B[b]) { 43 | 44 | } 45 | } 46 | 47 | return 0; 48 | } -------------------------------------------------------------------------------- /Code/1007.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | string ch1, ch2; 8 | cin >> ch1 >> ch2; 9 | auto pos1 = ch1.find('.'), pos2 = ch2.find('.'); 10 | 11 | auto ch10 = ch1.substr(0, pos1), ch11 = ch1.substr(pos1 + 1); 12 | auto ch20 = ch2.substr(0, pos2), ch21 = ch2.substr(pos2 + 1); 13 | 14 | string ans; 15 | 16 | auto l1=ch10.length(),l2=ch20.length(); 17 | for(int i=0,jw=(atoi(ch11.c_str())+atoi(ch21.c_str())>=100);i=10){ 20 | ans.push_back(a+b+jw-10+'0'); 21 | jw=1; 22 | }else{ 23 | ans.push_back(a+b+jw+'0'); 24 | jw = 0; 25 | } 26 | } 27 | 28 | reverse(ans.begin(),ans.end()); 29 | cout< 2 | #include 3 | #include 4 | using namespace std; 5 | using pii = pair; 6 | 7 | vector tdata; 8 | 9 | void bfs() { 10 | queue qdata; 11 | qdata.push(0); 12 | 13 | while (!qdata.empty()) { 14 | auto tmp = qdata.front(); 15 | qdata.pop(); 16 | 17 | cout << tmp << " "; 18 | if (tdata[tmp].first) { 19 | qdata.push(tdata[tmp].first); 20 | } 21 | if (tdata[tmp].second) { 22 | qdata.push(tdata[tmp].second); 23 | } 24 | } 25 | } 26 | 27 | int main() { 28 | ios::sync_with_stdio(false); 29 | cin.tie(0); 30 | cout.tie(0); 31 | 32 | int n; 33 | cin >> n; 34 | 35 | tdata.resize(n + 1, pii(0, 0)); 36 | for (int i = 1; i <= n - 1; ++i) { 37 | int tmp; 38 | cin >> tmp; 39 | if (!tdata[tmp].first) { 40 | tdata[tmp].first = i; 41 | } 42 | else { 43 | tdata[tmp].second = i; 44 | } 45 | } 46 | 47 | bfs(); 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /Code/4269.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | bool is_ans(int input) { 8 | string a = to_string(input); 9 | int length = a.length(); 10 | for (int i = 0; i < length; ++i) { 11 | if (a[i] != a[length - i - 1]) 12 | return false; 13 | } 14 | return true; 15 | } 16 | 17 | int next_n(int input) { 18 | string a = to_string(input); 19 | reverse(a.begin(), a.end()); 20 | return stoi(a) + input; 21 | } 22 | 23 | int main() { 24 | ios::sync_with_stdio(false); 25 | cin.tie(0); 26 | cout.tie(0); 27 | 28 | int n; 29 | 30 | while (cin >> n) { 31 | int o_n = n; 32 | vector nxt_ans; 33 | while (!is_ans(n)) { 34 | n = next_n(n); 35 | nxt_ans.emplace_back(n); 36 | } 37 | 38 | cout << nxt_ans.size() << endl << o_n; 39 | for (auto p : nxt_ans) 40 | cout << "--->" << p; 41 | cout << endl; 42 | } 43 | 44 | return 0; 45 | } -------------------------------------------------------------------------------- /Code/1128.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main() { 8 | ios::sync_with_stdio(false); 9 | cin.tie(0); 10 | cout.tie(0); 11 | 12 | int n; 13 | cin >> n; 14 | 15 | vector> vector_data(n); 16 | 17 | for (int i = 0; i < n; ++i) { 18 | cin >> vector_data[i].first >> vector_data[i].second; 19 | } 20 | 21 | sort(vector_data.begin(), vector_data.end(), [](pair& a, pair& b) {return a.second > b.second; }); 22 | 23 | int ans = 0; 24 | priority_queue queue_data; 25 | for (int t = vector_data.front().second, i = 0; t > 0; --t) { 26 | for (; i < vector_data.size() && vector_data[i].second >= t; ++i) 27 | queue_data.push(vector_data[i].first); 28 | if (!queue_data.empty()) { 29 | ans += queue_data.top(); 30 | queue_data.pop(); 31 | } 32 | } 33 | 34 | cout << ans; 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /Code/4320.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | long long sol(vector num) { 7 | int n = num.size(); 8 | vector dp_data(n + 1, 0); 9 | 10 | long long ans = -1e9; 11 | for (int i = 0; i < n; ++i) { 12 | dp_data[i + 1] = max(dp_data[i] + num[i], num[i]); 13 | ans = max(ans, dp_data[i + 1]); 14 | } 15 | return ans; 16 | } 17 | 18 | int main() { 19 | ios::sync_with_stdio(false); 20 | cin.tie(0); 21 | cout.tie(0); 22 | 23 | int n; 24 | cin >> n; 25 | 26 | vector num(n); 27 | for (int i = 0; i < n; ++i) { 28 | cin >> num[i]; 29 | } 30 | 31 | vector num1, num2; 32 | for (int i = 0; i + 1 < n; i += 2) { 33 | num1.emplace_back(num[i] + num[i + 1]); 34 | } 35 | for (int i = 1; i + 1 < n; i += 2) { 36 | num2.emplace_back(num[i] + num[i + 1]); 37 | } 38 | 39 | cout << max(sol(num1), sol(num2)); 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /Code/1241.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int main() { 6 | int N; 7 | scanf("%d", &N); 8 | 9 | double TotalGPA = 0.0; 10 | 11 | for (int i = 0; i < N; ++i) { 12 | int temp; 13 | scanf("%d",&temp); 14 | 15 | if (temp >= 95) { 16 | TotalGPA += 4.3; 17 | } 18 | else if (temp >= 90) { 19 | TotalGPA += 4.0; 20 | } 21 | else if (temp >= 85) { 22 | TotalGPA += 3.7; 23 | } 24 | else if (temp >= 80) { 25 | TotalGPA += 3.3; 26 | } 27 | else if (temp >= 75) { 28 | TotalGPA += 3.0; 29 | } 30 | else if (temp >= 70) { 31 | TotalGPA += 2.7; 32 | } 33 | else if (temp >= 67) { 34 | TotalGPA += 2.3; 35 | } 36 | else if (temp >= 65) { 37 | TotalGPA += 2.0; 38 | } 39 | else if (temp >= 62) { 40 | TotalGPA += 1.7; 41 | } 42 | else if (temp >= 60) { 43 | TotalGPA += 1.0; 44 | } 45 | } 46 | 47 | printf("%.2f", TotalGPA / N); 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /Code/4090.cpp: -------------------------------------------------------------------------------- 1 | #include "cstdio" 2 | #include "iostream" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int year, month, day; 8 | int n; 9 | int months[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 }; 10 | 11 | scanf("%4d%2d%2d %d", &year, &month, &day, &n); 12 | if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 13 | months[2] = 29; 14 | else 15 | months[2] = 28; 16 | 17 | for (; n > 0; n--) { 18 | if (day + 1 > months[month]) { 19 | day = 1; 20 | if (month + 1 > 12) { 21 | month = 1; 22 | if (year + 1 > 9999) { 23 | cout << "out of limitation!"; 24 | return 0; 25 | } 26 | else 27 | year++; 28 | if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 29 | months[2] = 29; 30 | else 31 | months[2] = 28; 32 | 33 | } 34 | else 35 | month++; 36 | } 37 | else 38 | day++; 39 | } 40 | 41 | printf("%04d%02d%02d", year, month, day); 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /Code/1023.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | ios::sync_with_stdio(false); 7 | cin.tie(0); 8 | cout.tie(0); 9 | 10 | int n; 11 | cin >> n; 12 | 13 | for (; n > 0; --n) { 14 | int a, b; 15 | cin >> a >> b; 16 | 17 | vector> mat(a,vector(a,0)); 18 | 19 | if (b == 0) { 20 | for (int i = 0; i < a; ++i) { 21 | for (int j = 0; j < a; ++j) { 22 | cin >> mat[i][a - j - 1]; 23 | } 24 | } 25 | } 26 | else if (b == 1) { 27 | for (int i = 0; i < a; ++i) { 28 | for (int j = 0; j < a; ++j) { 29 | cin >> mat[a - i - 1][j]; 30 | } 31 | } 32 | } 33 | else { 34 | for (int i = 0; i < a; ++i) { 35 | for (int j = 0; j < a; ++j) { 36 | cin >> mat[j][i]; 37 | } 38 | } 39 | } 40 | 41 | for (auto& p : mat) { 42 | for (auto q : p) { 43 | cout << q << " "; 44 | } 45 | cout << "\n"; 46 | } 47 | } 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /Code/1025.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | int n; 12 | cin >> n; 13 | 14 | vector> val_data(n); 15 | 16 | for (int i = 0; i < n; ++i) { 17 | cin >> val_data[i].first >> val_data[i].second; 18 | } 19 | 20 | sort(val_data.begin(), val_data.end(), [](pair& a, pair& b) {return a.first < b.first; }); 21 | 22 | long long ans = 0; 23 | int cur_start = val_data[0].first, cur_end = val_data[0].second; 24 | for (auto p : val_data) { 25 | if (p.first > cur_end) { 26 | ans += (long long)cur_end - (long long)cur_start; 27 | cur_start = p.first; 28 | cur_end = p.second; 29 | } 30 | else { 31 | cur_end = p.second > cur_end ? p.second : cur_end; 32 | } 33 | } 34 | ans += (long long)cur_end - (long long)cur_start; 35 | 36 | cout << ans; 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /Code/1047.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | vector> mdata = { 7 | {1,2,4,5}, 8 | {1,2,3}, 9 | {2,3,5,6}, 10 | {1,4,7}, 11 | {2,4,5,6,8}, 12 | {3,6,9}, 13 | {4,5,7,8}, 14 | {7,8,9}, 15 | {5,6,8,9} 16 | }; 17 | 18 | vector vdata(10); 19 | 20 | class clock { 21 | public: 22 | int ttime[10] = { 0 }; 23 | int last = 0; 24 | }; 25 | 26 | queue qdata; 27 | 28 | bool check(const clock& cur_time) { 29 | for (int i = 1; i <= 9; ++i) { 30 | if (i != 12) 31 | return false; 32 | } 33 | 34 | return true; 35 | } 36 | 37 | void bfs(const clock& cur_time) { 38 | for (int i = 1; i <= 9; ++i) { 39 | qdata.push(cur_time); 40 | } 41 | 42 | while (!qdata.empty()) { 43 | 44 | } 45 | } 46 | 47 | 48 | int main() { 49 | ios::sync_with_stdio(false); 50 | cin.tie(0); 51 | cout.tie(0); 52 | 53 | for (int i = 1; i <= 9; ++i) 54 | cin >> vdata[i]; 55 | 56 | 57 | 58 | return 0; 59 | } -------------------------------------------------------------------------------- /Code/1549.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | using pic = pair; 7 | 8 | int main() { 9 | ios::sync_with_stdio(false); 10 | cin.tie(0); 11 | cout.tie(0); 12 | 13 | string ch; 14 | while (cin >> ch) { 15 | stack sdata; 16 | auto length = ch.length(); 17 | vector vdata(length, ' '); 18 | 19 | for (int i = 0; i < length; ++i) { 20 | if (ch[i] == '(') { 21 | sdata.push(make_pair(i, '(')); 22 | } 23 | else if (ch[i] == ')') { 24 | if (!sdata.empty() && sdata.top().second == '(') { 25 | sdata.pop(); 26 | } 27 | else{ 28 | sdata.push(make_pair(i,')')); 29 | } 30 | } 31 | } 32 | 33 | while (!sdata.empty()) { 34 | vdata[sdata.top().first] = sdata.top().second == '(' ? '$' : '?'; 35 | sdata.pop(); 36 | } 37 | cout << ch << "\n"; 38 | for (auto p : vdata) 39 | cout << p; 40 | cout << "\n"; 41 | } 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /Code/4117.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int numData[100009] = { 0 }; 6 | long long numAns[100009] = { 0 }; 7 | 8 | int main() { 9 | int N, M; 10 | scanf("%d %d", &N, &M); 11 | 12 | for (int i = 1; i <= N; i++) { 13 | scanf("%d", &numData[i]); 14 | numAns[i] = numAns[i - 1] + numData[i]; 15 | } 16 | 17 | for (; M > 0; M--) { 18 | char op; 19 | scanf("\n%c", &op); 20 | 21 | if (op == 'Q') { 22 | int a, b; 23 | scanf("%d %d", &a, &b); 24 | printf("%lld\n", numAns[b] - numAns[a - 1]); 25 | } 26 | else { 27 | int a, b, c; 28 | scanf("%d %d %d", &a, &b, &c); 29 | if (a - 1 > N - b) { 30 | int ans = c; 31 | for (; a < b; a++,ans+=c) 32 | numAns[a] += ans; 33 | for (; a <= N; a++) 34 | numAns[a] += ans; 35 | } 36 | else { 37 | int ans = c; 38 | for (b=b-1;b>=a;b--, ans += c) 39 | numAns[b] -= ans; 40 | for (; b>=0; b--) 41 | numAns[b] -= ans; 42 | } 43 | } 44 | } 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /Code/4163.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | int val_data[100009] = { 0 }; 7 | 8 | int main() { 9 | int n, m; 10 | scanf("%d %d", &n, &m); 11 | 12 | int left = 0, right = 0; 13 | 14 | for (int i = 0; i < n; ++i) { 15 | scanf("%d", &val_data[i]); 16 | right += val_data[i]; 17 | left = val_data[i] > left ? val_data[i] : left; 18 | } 19 | 20 | int right_ans = 0; 21 | 22 | while (left <= right) { 23 | auto mid = (left + right) >> 1; 24 | int cnt = 0; 25 | for (int i = 0; i < n; ) { 26 | int cur_ans = 0; 27 | ++cnt; 28 | for (int j = i;; ++j) { 29 | cur_ans += val_data[j]; 30 | if (cur_ans > mid) { 31 | i = j; 32 | break; 33 | } 34 | if (j == n - 1) { 35 | i = j + 1; 36 | break; 37 | } 38 | } 39 | } 40 | if (cnt <= m) { 41 | right_ans = mid; 42 | right = mid - 1; 43 | } 44 | else { 45 | left = mid + 1; 46 | } 47 | } 48 | 49 | cout << right_ans; 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Code/1525.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | vector vdata; 6 | int n; 7 | 8 | int find_k(int start, int end, int k) { 9 | int key = vdata[start], l = start, r = end - 1; 10 | bool status = true; 11 | while (l < r) { 12 | if (status) 13 | if (key > vdata[r]) { 14 | vdata[l] = vdata[r]; 15 | status = false; 16 | ++l; 17 | } 18 | else 19 | --r; 20 | else 21 | if (key < vdata[l]) { 22 | vdata[r] = vdata[l]; 23 | status = true; 24 | --r; 25 | } 26 | else 27 | ++l; 28 | } 29 | vdata[l] = key; 30 | if (k > l - start) 31 | return find_k(l + 1, end, k - l + start - 1); 32 | else if (k < l - start) 33 | return find_k(start, l, k); 34 | else 35 | return vdata[l]; 36 | } 37 | 38 | int main() { 39 | ios::sync_with_stdio(false); 40 | cin.tie(0); 41 | cout.tie(0); 42 | 43 | int k; 44 | cin >> n >> k; 45 | vdata.resize(n); 46 | 47 | for (int i = 0; i < n; ++i) 48 | cin >> vdata[i]; 49 | 50 | cout << find_k(0, n, k - 1); 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /Code/1041.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int main() { 9 | ios::sync_with_stdio(false); 10 | cin.tie(0); 11 | cout.tie(0); 12 | 13 | int n; 14 | cin >> n; 15 | 16 | map> mdata; 17 | vector vdata(n + 1); 18 | 19 | for (int i = 1; i <= n; ++i) { 20 | int temp; 21 | cin >> temp; 22 | 23 | if (mdata.find(temp) == mdata.end()) { 24 | set stmp; 25 | stmp.insert(i); 26 | mdata.insert(make_pair(temp, stmp)); 27 | } 28 | else { 29 | mdata[temp].insert(i); 30 | } 31 | vdata[i] = temp; 32 | } 33 | 34 | string op; 35 | while (cin >> op) { 36 | if (op == "findmin") { 37 | int val; 38 | cin >> val; 39 | 40 | auto p = mdata.upper_bound(val); 41 | cout << *(p->second.begin()) << "\n"; 42 | } 43 | else if (op == "decrease") { 44 | int i, j; 45 | cin >> i >> j; 46 | mdata[vdata[i]].erase(i); 47 | vdata[i] -= j; 48 | mdata[vdata[i]].insert(i); 49 | } 50 | } 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /Code/1048.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | using pii = pair; 7 | 8 | vector tdata; 9 | 10 | void bfs(int root) { 11 | queue qdata; 12 | qdata.push(root); 13 | 14 | while (!qdata.empty()) { 15 | auto temp = qdata.front(); 16 | qdata.pop(); 17 | 18 | cout << temp << "\n"; 19 | 20 | if (tdata[temp].first) { 21 | qdata.push(tdata[temp].first); 22 | qdata.push(tdata[temp].second); 23 | } 24 | } 25 | } 26 | 27 | int main() { 28 | ios::sync_with_stdio(false); 29 | cin.tie(0); 30 | cout.tie(0); 31 | 32 | int n; 33 | cin >> n; 34 | 35 | tdata.resize(n + 1, pii(0, 0)); 36 | vector isroot(n + 1, true); 37 | 38 | int a, b, c; 39 | while (cin >> a) { 40 | cin >> b >> c; 41 | 42 | tdata[a].first = b; 43 | tdata[a].second = c; 44 | 45 | isroot[b] = isroot[c] = false; 46 | } 47 | 48 | int root = 0; 49 | 50 | for (int i = 1; i <= n; ++i) { 51 | if (isroot[i]) { 52 | root = i; 53 | break; 54 | } 55 | } 56 | 57 | bfs(root); 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /Code/1088.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int map_data[20][20] = { 0 }; 5 | 6 | int mmin(int a, int b) { 7 | return a < b ? a : b; 8 | } 9 | 10 | bool visited[20] = { 0 }; 11 | int n; 12 | 13 | int dfs(int pos, int m) { 14 | if (m == n - 1) { 15 | return map_data[pos][0]; 16 | } 17 | visited[pos] = true; 18 | int ans = 999999999; 19 | for (int i = 0; i < n; ++i) { 20 | if (i != pos && !visited[i]) { 21 | auto cur_ans = dfs(i, m + 1) + map_data[pos][i]; 22 | ans = cur_ans < ans ? cur_ans : ans; 23 | } 24 | } 25 | visited[pos] = false; 26 | return ans; 27 | } 28 | 29 | int main() { 30 | ios::sync_with_stdio(false); 31 | cin.tie(0); 32 | cout.tie(0); 33 | 34 | cin >> n; 35 | 36 | for (int i = 0; i < n; ++i) 37 | for (int j = 0; j < n; ++j) 38 | cin >> map_data[i][j]; 39 | 40 | /* 41 | for (int k = 0; k < n; ++k) { 42 | for (int i = 0; i < n; ++i) { 43 | for (int j = 0; j < n; ++j) { 44 | map_data[i][j] = mmin(map_data[i][j], map_data[i][k] + map_data[k][j]); 45 | } 46 | } 47 | }*/ 48 | 49 | cout << dfs(0, 0); 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Code/1224.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstring" 3 | using namespace std; 4 | 5 | constexpr int mod = 1000009; 6 | 7 | class type { 8 | public: 9 | int key = -99999999; 10 | int val = 0; 11 | }; 12 | 13 | int val_data[509][4] = { 0 }; 14 | type hash_map[mod]; 15 | 16 | int get_pos(int key) { 17 | int ans = (key + 2000009) % mod; 18 | for (; hash_map[ans].key != key; ans = (ans + 1) % mod) { 19 | if (hash_map[ans].key <= -99999999) { 20 | hash_map[ans].key = key; 21 | break; 22 | } 23 | } 24 | return ans; 25 | } 26 | 27 | int main() { 28 | int n; 29 | scanf("%d", &n); 30 | 31 | for (int i = 0; i < n; ++i) { 32 | for (int j = 0; j < 4; ++j) 33 | scanf("%d", &val_data[i][j]); 34 | } 35 | 36 | for (int i = 0; i < n; ++i) { 37 | for (int j = 0; j < n; ++j) { 38 | ++hash_map[get_pos(val_data[i][0] + val_data[j][1])].val; 39 | } 40 | } 41 | 42 | int ans = 0; 43 | 44 | for (int i = 0; i < n; ++i) { 45 | for (int j = 0; j < n; ++j) { 46 | ans += hash_map[get_pos(-val_data[i][2] - val_data[j][3])].val; 47 | } 48 | } 49 | 50 | cout << ans; 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /Code/1074.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | bool ground[1240][1240] = { 0 }; 6 | int sum[1240][1240] = { 0 }; 7 | 8 | int main() { 9 | int N, M; 10 | cin >> N >> M; 11 | 12 | for (int i = 1; i <= N; ++i) { 13 | sum[i][0] = sum[i - 1][1]; 14 | for (int j = 1; j <= M; ++j) { 15 | while (true) { 16 | char c; 17 | scanf("%c", &c); 18 | if (c == 'X') { 19 | ground[i][j] = true; 20 | sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + 1; 21 | break; 22 | } 23 | else if (c == '-') { 24 | sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1]; 25 | break; 26 | } 27 | } 28 | } 29 | } 30 | 31 | int cur_max = 0; 32 | for (int i = 1; i <= N; ++i) { 33 | for (int j = cur_max * 2; j <= M; ++j) { 34 | for (int k = cur_max; j >= k * 2 && i >= k; ++k) { 35 | if (sum[i][j] - sum[i][j - k * 2] - sum[i - k][j] + sum[i - k][j - k * 2] == 0) { 36 | cur_max = k; 37 | } 38 | else 39 | break; 40 | } 41 | } 42 | } 43 | 44 | cout << cur_max * cur_max * 2; 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /Code/4027.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int n; 8 | int a1[100009] = { 0 }, a2[100009] = { 0 }; 9 | int belong[100009] = { 0 }; 10 | int f[100009], b[100009], len; 11 | 12 | int mid_find(int left, int right, int val) { 13 | int right_ans = right; 14 | --right; 15 | while (left <= right) { 16 | int mid = (left + right) >> 1; 17 | if (val > b[mid]) { 18 | left = mid + 1; 19 | } 20 | else if (val <= b[mid]) { 21 | right_ans = mid; 22 | right = mid - 1; 23 | } 24 | } 25 | return right_ans; 26 | } 27 | 28 | int main() 29 | { 30 | scanf("%d", &n); 31 | for (int i = 1; i <= n; ++i) 32 | { 33 | scanf("%d", &a1[i]); 34 | belong[a1[i]] = i; 35 | } 36 | for (int i = 1; i <= n; ++i) { 37 | scanf("%d", &a2[i]); 38 | } 39 | 40 | for (int i = 1; i <= n; ++i) 41 | { 42 | if (belong[a2[i]] > b[len]) 43 | { 44 | b[++len] = belong[a2[i]]; 45 | f[i] = len; 46 | continue; 47 | } 48 | int k = mid_find(1, len + 1, belong[a2[i]]); 49 | b[k] = belong[a2[i]]; 50 | f[i] = k; 51 | } 52 | printf("%d\n", len); 53 | return 0; 54 | } -------------------------------------------------------------------------------- /Code/4239.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int stack_data[300009] = { 0 }; 6 | int stack_n = 0; 7 | 8 | int mid_search(int l, int r, int val) { 9 | if (val > stack_data[stack_n - 1]) 10 | return stack_n; 11 | int right_ans = 0; 12 | while (l <= r) { 13 | int mid = (l + r) >> 1; 14 | if (stack_data[mid] >= val) { 15 | right_ans = mid; 16 | r = mid - 1; 17 | } 18 | else { 19 | l = mid + 1; 20 | } 21 | } 22 | return right_ans; 23 | } 24 | 25 | int main() { 26 | ios::sync_with_stdio(false); 27 | cin.tie(0); 28 | cout.tie(0); 29 | 30 | int n; 31 | cin >> n; 32 | 33 | for (int i = 0; i < n; ++i) { 34 | int l, r; 35 | cin >> l >> r; 36 | 37 | int lpos = mid_search(0, stack_n - 1, l), 38 | rpos = mid_search(0, stack_n - 1, r); 39 | 40 | if (lpos == stack_n) { 41 | stack_data[stack_n++] = l; 42 | } 43 | else { 44 | if (rpos == stack_n) 45 | ++stack_n; 46 | for (; rpos > lpos; --rpos) { 47 | stack_data[rpos] = stack_data[rpos - 1] + 1; 48 | } 49 | stack_data[lpos] = l; 50 | } 51 | } 52 | 53 | cout << stack_n; 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Code/1633.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class dset { 6 | public: 7 | int set_data[30009] = { 0 }; 8 | dset() { 9 | memset(set_data, -1, sizeof(set_data)); 10 | } 11 | void set_union(int root1, int root2) { 12 | if (root1 == root2) 13 | return; 14 | if (set_data[root1] < set_data[root2]) { 15 | set_data[root1] += set_data[root2]; 16 | set_data[root2] = root1; 17 | } 18 | else { 19 | set_data[root2] += set_data[root1]; 20 | set_data[root1] = root2; 21 | } 22 | } 23 | int set_find(int pos) { 24 | if (set_data[pos] < 0) 25 | return pos; 26 | return set_data[pos] = set_find(set_data[pos]); 27 | } 28 | }; 29 | 30 | dset set_data; 31 | 32 | int main() { 33 | ios::sync_with_stdio(false); 34 | cin.tie(0); 35 | cout.tie(0); 36 | 37 | int n, m; 38 | cin >> n >> m; 39 | 40 | for (; m > 0; --m) { 41 | int k; 42 | cin >> k; 43 | int temp; 44 | cin >> temp; 45 | for (; k > 1; --k) { 46 | int i; 47 | cin >> i; 48 | set_data.set_union(set_data.set_find(temp), set_data.set_find(i)); 49 | } 50 | } 51 | 52 | cout << -set_data.set_data[set_data.set_find(0)]; 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /Code/1634.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | long long cnt = 0; 6 | 7 | int val_data[1000009] = { 0 }; 8 | 9 | void quick_sort(int* left, int* right) { 10 | if (left >= right - 1) 11 | return; 12 | auto p = left, q = right - 1; 13 | auto key = *p; 14 | bool flag = true; 15 | while (p < q) { 16 | if (flag) { 17 | if (*q < key) { 18 | *p = *q; 19 | flag = false; 20 | ++p; 21 | } 22 | else { 23 | --q; 24 | } 25 | ++cnt; 26 | } 27 | else { 28 | if (*p > key) { 29 | *q = *p; 30 | flag = true; 31 | --p; 32 | } 33 | else { 34 | ++q; 35 | } 36 | ++cnt; 37 | } 38 | } 39 | *p = key; 40 | quick_sort(left, p + 1); 41 | quick_sort(p + 1, right); 42 | } 43 | 44 | int main() { 45 | ios::sync_with_stdio(false); 46 | cin.tie(0); 47 | cout.tie(0); 48 | 49 | int n, k; 50 | cin >> n >> k; 51 | 52 | for (int i = 0; i < n; ++i) 53 | cin >> val_data[i]; 54 | 55 | if (k == 3) { 56 | quick_sort(val_data, val_data + n); 57 | for (int i = 0; i < n; ++i) { 58 | cout << val_data[i] << " "; 59 | } 60 | cout << endl; 61 | cout << cnt; 62 | } 63 | 64 | return 0; 65 | } -------------------------------------------------------------------------------- /Code/1243.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | int val_data[1009] = { 0 }; 6 | 7 | int main() { 8 | int n, m; 9 | scanf("%d %d", &n, &m); 10 | 11 | for (int i = 0; i < n; ++i) { 12 | scanf("%d", &val_data[i]); 13 | } 14 | 15 | for (; m > 0; --m) { 16 | int opt, l, r; 17 | scanf("%d %d %d", &opt, &l, &r); 18 | 19 | if (opt == 0) { 20 | double ans = 0.0; 21 | for (int i = l; i <= r; ++i) 22 | ans += double(val_data[i]); 23 | printf("%.2f\n", ans / (r - l + 1)); 24 | } 25 | else if (opt == 1) { 26 | int cur_max = 0; 27 | for (int i = l; i <= r; ++i) { 28 | cur_max = val_data[i] > cur_max ? val_data[i] : cur_max; 29 | } 30 | printf("%d\n", cur_max); 31 | } 32 | else if (opt == 2) { 33 | for (; l < r; ++l, --r) { 34 | swap(val_data[l], val_data[r]); 35 | } 36 | } 37 | else if (opt == 3) { 38 | printf("%d", val_data[l]); 39 | for (int i = l + 1; i <= r; ++i) 40 | printf(" %d", val_data[i]); 41 | printf("\n"); 42 | } 43 | else if (opt == 4) { 44 | for (int i = l; i <= r; ++i) { 45 | if (val_data[i] > 0) 46 | --val_data[i]; 47 | } 48 | } 49 | } 50 | 51 | return 0; 52 | } -------------------------------------------------------------------------------- /Code/4025.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | constexpr int inf = 1000000009; 6 | constexpr double jd = 1e-4; 7 | 8 | int height[509][509] = { 0 }; 9 | 10 | int main() { 11 | int M, N; 12 | cin >> M >> N; 13 | 14 | int minh = inf, maxh = 0; 15 | 16 | for (int i = 0; i < M; ++i) { 17 | for (int j = 0; j < N; ++j) { 18 | scanf("%d", &height[i][j]); 19 | if (height[i][j] < minh) 20 | minh = height[i][j]; 21 | if (height[i][j] > maxh) 22 | maxh = height[i][j]; 23 | } 24 | } 25 | double V; 26 | cin >> V; 27 | 28 | double left = minh, right = 1e10, mid; 29 | int cnt = 0; 30 | while (right - left > jd) { 31 | mid = (left + right) / 2; 32 | cnt = 0; 33 | double v = 0; 34 | for (int i = 0; i < M; ++i) { 35 | for (int j = 0; j < N; ++j) { 36 | if (height[i][j] + jd < mid) { 37 | ++cnt; 38 | v += (mid - height[i][j]); 39 | } 40 | } 41 | } 42 | if (v < V) { 43 | left = (left + right) / 2; 44 | } 45 | else if (v == V) 46 | break; 47 | else { 48 | right = (left + right) / 2; 49 | } 50 | } 51 | 52 | printf("%.2f\n%.2f", mid, double(cnt) / double(M * N) * 100); 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /Code/1629.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class node { 6 | public: 7 | int parent = 0; 8 | int num = 1; 9 | vector child; 10 | }; 11 | 12 | node tree_data[10009]; 13 | 14 | int dfs(int root) { 15 | for (auto p : tree_data[root].child) { 16 | if (p != tree_data[root].parent) { 17 | tree_data[p].parent = root; 18 | tree_data[root].num += dfs(p); 19 | } 20 | } 21 | return tree_data[root].num; 22 | } 23 | 24 | int main() { 25 | ios::sync_with_stdio(false); 26 | cin.tie(0); 27 | cout.tie(0); 28 | 29 | int n; 30 | cin >> n; 31 | 32 | for (int i = 0; i < n - 1; ++i) { 33 | int u, v; 34 | cin >> u >> v; 35 | tree_data[v].child.push_back(u); 36 | tree_data[u].child.push_back(v); 37 | } 38 | 39 | dfs(1); 40 | 41 | int ans = 999999999, ans_i = 0;; 42 | for (int i = 1; i <= n; ++i) { 43 | int cur_ans = n - tree_data[i].num; 44 | for (auto p : tree_data[i].child) { 45 | if (p != tree_data[i].parent) { 46 | cur_ans = tree_data[p].num > cur_ans ? tree_data[p].num : cur_ans; 47 | } 48 | } 49 | if (cur_ans < ans) { 50 | ans_i = i; 51 | ans = cur_ans; 52 | } 53 | } 54 | 55 | cout << ans_i << " " << ans; 56 | 57 | return 0; 58 | } -------------------------------------------------------------------------------- /Code/4054.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "cmath" 5 | using namespace std; 6 | 7 | long long poww(int i) { 8 | long long ans = 1; 9 | for (int j = 0; j < i; ++j) 10 | ans *= 10; 11 | return ans; 12 | } 13 | 14 | long long cal(char* ch) { 15 | int len = strlen(ch); 16 | if (len == 1) 17 | return ch[0] - '0'; 18 | if (len == 2) { 19 | if (ch[0] > ch[1]) 20 | return ch[0] - '1' + 9; 21 | else 22 | return ch[0] - '0' + 9; 23 | } 24 | int temp = ch[0] > ch[len - 1] ? ch[len - 1] - '0' : ch[0] - '0'; 25 | 26 | long long ans = 9; 27 | for (int i = 0; i < len - 2; ++i) 28 | ans += (long long)9 * poww(i); 29 | long long p = 1; 30 | char ch1[100]; 31 | strcpy(ch1, ch + 1); 32 | ch1[strlen(ch1) - 1] = 0; 33 | sscanf(ch1, "%lld", &p); 34 | if (ch[0] <= ch[len - 1]) 35 | ans += p + 1; 36 | else 37 | ans += p; 38 | ans += (long long)(ch[0] - '1') * poww(len - 2); 39 | return ans; 40 | } 41 | 42 | int main() { 43 | 44 | char L[100], R[100]; 45 | cin >> L >> R; 46 | 47 | long long Lans, Rans; 48 | Lans = cal(L); 49 | Rans = cal(R); 50 | 51 | if (L[0] == L[strlen(L) - 1]) 52 | ++Rans; 53 | 54 | cout << Rans - Lans; 55 | 56 | return 0; 57 | } -------------------------------------------------------------------------------- /Code/1032.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | 5 | 6 | class cur_data { 7 | public: 8 | bool status = false; 9 | int m, n; 10 | cur_data() = default; 11 | cur_data(int m,int n,bool status=false):m(m),n(n),status(status){} 12 | }; 13 | cur_data stack_data[20000]; 14 | int stack_size = 0; 15 | int ackerman(int m, int n) { 16 | int cur_ans; 17 | cur_data data_temp(m, n, false); 18 | stack_data[stack_size++] = data_temp; 19 | 20 | while (stack_size > 0) { 21 | auto temp = stack_data[--stack_size]; 22 | 23 | if (temp.m == 0) { 24 | cur_ans = temp.n + 1; 25 | } 26 | else if (temp.n == 0) { 27 | cur_data data_push(temp.m - 1, 1, false); 28 | stack_data[stack_size++] = data_push; 29 | } 30 | else { 31 | if (!temp.status) { 32 | cur_data data_push(temp.m, temp.n - 1, false); 33 | temp.status = true; 34 | stack_data[stack_size++] = temp; 35 | stack_data[stack_size++] = data_push; 36 | } 37 | else { 38 | cur_data data_push(temp.m - 1, cur_ans, false); 39 | stack_data[stack_size++] = data_push; 40 | } 41 | } 42 | } 43 | 44 | return cur_ans; 45 | } 46 | 47 | int main() { 48 | int m, n; 49 | cin >> m >> n; 50 | cout << ackerman(m, n); 51 | 52 | return 0; 53 | } -------------------------------------------------------------------------------- /Code/1237.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | using pii = pair; 7 | 8 | class node { 9 | public: 10 | int remain = 0; 11 | vector child; 12 | }; 13 | 14 | vector nlist; 15 | 16 | int bfs(const vector rlist) { 17 | queue qdata; 18 | for(auto root:rlist) 19 | qdata.push(make_pair(root, 1)); 20 | 21 | int ans = 0; 22 | while (!qdata.empty()) { 23 | auto temp = qdata.front(); 24 | qdata.pop(); 25 | ans = max(ans, temp.second); 26 | 27 | for (auto& p : nlist[temp.first].child) { 28 | --nlist[p].remain; 29 | if (!nlist[p].remain) { 30 | qdata.push(make_pair(p, temp.second + 1)); 31 | } 32 | } 33 | } 34 | return ans; 35 | } 36 | 37 | int main(){ 38 | ios::sync_with_stdio(false); 39 | cin.tie(0); 40 | cout.tie(0); 41 | 42 | int n, m; 43 | cin >> n >> m; 44 | nlist.resize(n + 1); 45 | 46 | for (; m; --m) { 47 | int a, b; 48 | cin >> a >> b; 49 | ++nlist[a].remain; 50 | nlist[b].child.emplace_back(a); 51 | } 52 | 53 | vector rlist; 54 | for (int i = 1; i <= n; ++i) { 55 | if (nlist[i].remain == 0) 56 | rlist.emplace_back(i); 57 | } 58 | 59 | cout << bfs(rlist); 60 | 61 | return 0; 62 | } -------------------------------------------------------------------------------- /Code/4369.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by ligongzzz on 2021/3/13. 3 | // 4 | // 4369 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | ios::sync_with_stdio(false); 13 | cin.tie(0); 14 | cout.tie(0); 15 | 16 | int a, b; 17 | cin >> a >> b; 18 | 19 | int start_len = min(1, int(to_string(a).length()/2)); 20 | int cnt = 0; 21 | 22 | for (int len=start_len;;++len) { 23 | int nmax = 1; 24 | for (int i=len-1;i;--i, nmax*=10); 25 | 26 | for(int first_num=2;first_num<10;first_num+=2) { 27 | for(int remain=0;remainb) { 34 | if (cnt==0) cout<<0<<'\n'; 35 | return 0; 36 | } 37 | 38 | if (ans>=a) { 39 | ++cnt; 40 | cout< 2 | #include 3 | using namespace std; 4 | 5 | int cal(const vector& vdata, long long total) { 6 | long long base = 0; 7 | for (int pos = 0; pos < vdata.size(); ++pos) { 8 | bool flag = true; 9 | base += vdata[pos]; 10 | 11 | if (total % base) 12 | continue; 13 | 14 | long long temp = 0; 15 | int cnt = 0; 16 | for (int i = 0, j = 0; j < vdata.size(); ++j) { 17 | temp += vdata[j]; 18 | if (j == vdata.size() - 1) { 19 | if (temp != base) { 20 | flag = false; 21 | break; 22 | } 23 | } 24 | 25 | if (temp == base) { 26 | temp = 0; 27 | i = j + 1; 28 | ++cnt; 29 | } 30 | else if (temp > base) { 31 | flag = false; 32 | break; 33 | } 34 | } 35 | if (flag) { 36 | return cnt; 37 | } 38 | } 39 | } 40 | 41 | int main() { 42 | ios::sync_with_stdio(false); 43 | cin.tie(0); 44 | cout.tie(0); 45 | 46 | int p; 47 | cin >> p; 48 | 49 | for (; p; --p) { 50 | int n, m; 51 | cin >> n >> m; 52 | 53 | vector vdata(m); 54 | 55 | long long total = 0; 56 | for (int i = 0; i < m; ++i) { 57 | cin >> vdata[i]; 58 | total += vdata[i]; 59 | } 60 | 61 | cout << n << " " << cal(vdata, total) << "\n"; 62 | } 63 | 64 | return 0; 65 | } -------------------------------------------------------------------------------- /Code/4379.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by 谢哲 on 2021/4/22. 3 | // 4 | // 注意：这道题的输入不包括两侧的双引号 5 | 6 | #include 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | ios::sync_with_stdio(false); 13 | cin.tie(0); 14 | cout.tie(0); 15 | 16 | string s; 17 | cin >> s; 18 | 19 | stack sdata; 20 | 21 | if (s.length()<1 || s.length()>10000) { 22 | cout << 0; 23 | return 0; 24 | } 25 | 26 | for (auto p: s) { 27 | if (p==')') { 28 | if (sdata.empty()||sdata.top()!='(') { 29 | cout<<0; 30 | return 0; 31 | } 32 | else sdata.pop(); 33 | } 34 | else if (p==']') { 35 | if (sdata.empty()||sdata.top()!='[') { 36 | cout<<0; 37 | return 0; 38 | } 39 | else sdata.pop(); 40 | } 41 | else if (p=='}') { 42 | if (sdata.empty()||sdata.top()!='{') { 43 | cout<<0; 44 | return 0; 45 | } 46 | else sdata.pop(); 47 | } 48 | else sdata.push(p); 49 | } 50 | 51 | if (sdata.empty()) {cout<<1;} 52 | else cout<<0; 53 | 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /Code/1028.cpp: -------------------------------------------------------------------------------- 1 | //WA - 90 2 | 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int bucket[5] = { 0 }; 8 | 9 | int cmp(char arr[]) { 10 | if (!strcmp(arr, "begin")) 11 | return 0; 12 | if (!strcmp(arr, "end")) 13 | return 1; 14 | if (!strcmp(arr, "if")) 15 | return 2; 16 | if (!strcmp(arr, "then")) 17 | return 3; 18 | if (!strcmp(arr, "else")) 19 | return 4; 20 | } 21 | 22 | int main() { 23 | int n; 24 | cin >> n; 25 | bool flag = false, isif = false, isbegin = false; 26 | char arr[109][6]; 27 | for (int i = 0; i < n; i++) { 28 | cin >> arr[i]; 29 | bucket[cmp(arr[i])]++; 30 | if (cmp(arr[i]) == 2) 31 | isif = true; 32 | if (cmp(arr[i]) == 3 && isif == true) 33 | isif = false; 34 | if (cmp(arr[i]) == 0 && isif == true) 35 | isbegin = true; 36 | if (cmp(arr[i]) == 1 && isif == true && isbegin == true) { 37 | cout << "NO"; 38 | flag = true; 39 | break; 40 | } 41 | if (bucket[0] < bucket[1] || bucket[2] < bucket[3] || bucket[2] < bucket[4]) { 42 | cout << "NO"; 43 | flag = true; 44 | break; 45 | } 46 | } 47 | if (flag == false) { 48 | if (bucket[0] == bucket[1] && bucket[2] == bucket[3]) { 49 | cout << "YES"; 50 | } 51 | else { 52 | cout << "NO"; 53 | } 54 | } 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Code/4189.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class node { 6 | public: 7 | int parent = 0, child_num = 0; 8 | vector child; 9 | }; 10 | 11 | vector tree_data; 12 | 13 | int dfs(int root) { 14 | tree_data[root].child_num = 1; 15 | for (auto p : tree_data[root].child) { 16 | if (p != tree_data[root].parent) { 17 | tree_data[p].parent = root; 18 | tree_data[root].child_num += dfs(p); 19 | } 20 | } 21 | return tree_data[root].child_num; 22 | } 23 | 24 | int main() { 25 | ios::sync_with_stdio(false); 26 | cin.tie(0); 27 | cout.tie(0); 28 | 29 | int n; 30 | cin >> n; 31 | 32 | tree_data.resize(n + 1); 33 | 34 | for (int i = 0; i < n - 1; ++i) { 35 | int u, v; 36 | cin >> u >> v; 37 | tree_data[u].child.push_back(v); 38 | tree_data[v].child.push_back(u); 39 | } 40 | 41 | dfs(1); 42 | 43 | for (int i = 1; i <= n; ++i) { 44 | if (n - tree_data[i].child_num > n / 2) { 45 | continue; 46 | } 47 | bool flag = true; 48 | for (auto p : tree_data[i].child) { 49 | if (p != tree_data[i].parent) { 50 | if (tree_data[p].child_num > n / 2) { 51 | flag = false; 52 | break; 53 | } 54 | } 55 | } 56 | if (flag) { 57 | cout << i << " "; 58 | } 59 | } 60 | 61 | return 0; 62 | } -------------------------------------------------------------------------------- /Code/4138.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | int n, m; 7 | bool visited[20] = { 0 }; 8 | int groups[109][20] = { 0 }; 9 | int val_data[109] = { 0 }; 10 | int val_num[109] = { 0 }; 11 | 12 | double ans = 0.0; 13 | 14 | void cal_max(int pos) { 15 | if (pos == n) { 16 | double cur_ans = 0.0; 17 | int cnt = 0; 18 | for (int i = 0; i < n; ++i) { 19 | if (visited[i]) { 20 | ++cnt; 21 | } 22 | } 23 | for (int i = 0; i < m; ++i) { 24 | bool flag = true; 25 | for (int j = 0; j < val_num[i]; ++j) { 26 | if (!visited[groups[i][j]]) { 27 | flag = false; 28 | break; 29 | } 30 | } 31 | if (flag) { 32 | cur_ans += double(val_data[i]); 33 | } 34 | } 35 | if (cnt > 0) 36 | cur_ans /= double(cnt); 37 | ans = cur_ans > ans ? cur_ans : ans; 38 | return; 39 | } 40 | visited[pos] = true; 41 | cal_max(pos + 1); 42 | visited[pos] = false; 43 | cal_max(pos + 1); 44 | } 45 | 46 | int main() { 47 | scanf("%d %d", &n, &m); 48 | 49 | for (int i = 0; i < m; ++i) { 50 | scanf("%d %d", &val_num[i], &val_data[i]); 51 | for (int j = 0; j < val_num[i]; ++j) { 52 | scanf("%d", &groups[i][j]); 53 | } 54 | } 55 | 56 | cal_max(0); 57 | printf("%.2f",ans); 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /Code/1012.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstring" 3 | #include "cstdio" 4 | using namespace std; 5 | 6 | long long dp_data[500009] = { 0 }; 7 | long long cal_num[500009] = { 0 }; 8 | 9 | long long dp(long long num, long long T) { 10 | if (dp_data[num] > 0) 11 | return dp_data[num]; 12 | if (num > T) { 13 | return 0; 14 | } 15 | 16 | long long ans = 0; 17 | for (long long i = 1; i <= 100; ++i) { 18 | if (num * i % 100 == 0) { 19 | long long cur_ans = dp(num * i / 100 + num, T) + 1; 20 | ans = cur_ans > ans ? cur_ans : ans; 21 | } 22 | } 23 | for (long long i = 1; i <= 100; ++i) { 24 | if (num * i % 100 == 0) { 25 | if (dp_data[num + num * i / 100] + 1 == ans) { 26 | cal_num[num] += cal_num[num + num * i / 100]; 27 | } 28 | } 29 | } 30 | if (ans == 1) 31 | cal_num[num] = 1; 32 | dp_data[num] = ans; 33 | return ans; 34 | } 35 | 36 | int main() { 37 | long long S, T; 38 | cin >> S >> T; 39 | 40 | long long ans = 0; 41 | for (long long i = S; i <= T; ++i) { 42 | long long cur_ans = dp(i, T); 43 | ans = cur_ans > ans ? cur_ans : ans; 44 | } 45 | 46 | long long cnt = 0; 47 | for (long long i = S; i <= T; ++i) { 48 | if (dp(i, T) == ans) { 49 | cnt += cal_num[i]; 50 | } 51 | } 52 | 53 | cout << ans << endl << cnt; 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Code/4322.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | using ull = unsigned long long; 6 | constexpr auto mod = 203ull; 7 | 8 | int main() { 9 | ios::sync_with_stdio(false); 10 | cin.tie(0); 11 | cout.tie(0); 12 | 13 | int n, k; 14 | cin >> n >> k; 15 | 16 | unordered_map rdata, ldata; 17 | int zero_num = 0; 18 | 19 | for (int i = 0; i < n; ++i) { 20 | ull rcode = 0ull, lcode = 0ull; 21 | int fnum; 22 | cin >> fnum; 23 | for (int j = 1; j < k; ++j) { 24 | int tmp; 25 | cin >> tmp; 26 | rcode = rcode * mod + ull(100 + tmp - fnum); 27 | lcode = lcode * mod + ull(100 + fnum - tmp); 28 | } 29 | if (rcode == lcode) { 30 | zero_num++; 31 | continue; 32 | } 33 | 34 | if (rdata.find(rcode) == rdata.end()) { 35 | rdata[rcode] = 1; 36 | } 37 | else 38 | { 39 | rdata[rcode]++; 40 | } 41 | 42 | if (ldata.find(lcode) == ldata.end()) { 43 | ldata[lcode] = 1; 44 | } 45 | else 46 | { 47 | ldata[lcode]++; 48 | } 49 | } 50 | 51 | int ans = 0; 52 | for (auto p : rdata) { 53 | if (ldata.find(p.first) != ldata.end()) { 54 | ans += p.second * ldata[p.first]; 55 | } 56 | } 57 | ans /= 2; 58 | ans += zero_num * (zero_num - 1) / 2; 59 | 60 | cout << ans; 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /Code/1075.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cmath" 4 | #include "cstring" 5 | using namespace std; 6 | 7 | constexpr long long mod = 19301; 8 | long long tree_num[3350] = { 0 }; 9 | 10 | long long jc[3350] = { 0 }; 11 | 12 | long long fast_pow(long long a, long long b) { 13 | long long ans = 1, base = a; 14 | while (b) { 15 | if (b & 1) 16 | ans = (ans * base) % mod; 17 | base = (base * base) % mod; 18 | b >>= 1; 19 | } 20 | return ans; 21 | } 22 | 23 | long long get_zhs(int n, int m) { 24 | long long temp = (jc[m] * jc[n - m]) % mod; 25 | temp = fast_pow(temp, mod - 2); 26 | temp = (jc[n] * temp) % mod; 27 | return temp; 28 | } 29 | 30 | long long cal_tree(int n) { 31 | if (n == 0) 32 | return 1LL; 33 | if (tree_num[n] > 0) 34 | return tree_num[n]; 35 | long long ans = 0; 36 | for (int i = 0; i < n; ++i) { 37 | ans = (ans + cal_tree(n - i - 1) * cal_tree(i)) % mod; 38 | } 39 | tree_num[n] = ans; 40 | return ans; 41 | } 42 | 43 | int main() { 44 | jc[0] = 1; 45 | for (long long i = 1LL; i <= 3350LL; ++i) { 46 | jc[i] = (jc[i - 1] * i) % mod; 47 | } 48 | long long n; 49 | cin >> n; 50 | 51 | long long ans = 0; 52 | for (int i = 0; i <= n; i += 2) { 53 | ans = (ans + get_zhs(n, i) * cal_tree(i / 2)) % mod; 54 | } 55 | 56 | cout << ans; 57 | 58 | return 0; 59 | } -------------------------------------------------------------------------------- /Code/1052.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main() { 7 | ios::sync_with_stdio(false); 8 | cin.tie(0); 9 | cout.tie(0); 10 | 11 | int n; 12 | cin >> n; 13 | 14 | vector> vdata(n); 15 | vector vsize(n); 16 | 17 | for (int i = 0; i < n; ++i) 18 | cin >> vsize[i]; 19 | 20 | for (int i = 0; i < n; ++i) { 21 | for (int j = 0; j < vsize[i]; ++j) { 22 | int temp; 23 | cin >> temp; 24 | vdata[i].insert(temp); 25 | } 26 | } 27 | 28 | int m; 29 | cin >> m; 30 | for (; m; --m) { 31 | char op; 32 | int a, b; 33 | cin.get(); 34 | cin >> op >> a >> b; 35 | --a; 36 | --b; 37 | if (op == '+') { 38 | vdata[a].insert(vdata[b].begin(), vdata[b].end()); 39 | } 40 | else if (op == '-') { 41 | for (auto p = vdata[a].begin(); p != vdata[a].end();) { 42 | if (vdata[b].find(*p) != vdata[b].end()) { 43 | vdata[a].erase(p++); 44 | } 45 | else 46 | ++p; 47 | } 48 | } 49 | else { 50 | for (auto p = vdata[a].begin(); p != vdata[a].end();) { 51 | if (vdata[b].find(*p) == vdata[b].end()) { 52 | vdata[a].erase(p++); 53 | } 54 | else 55 | ++p; 56 | } 57 | } 58 | } 59 | 60 | for (int i = 0; i < n; ++i) { 61 | for (auto p : vdata[i]) { 62 | cout << p << " "; 63 | } 64 | cout << "\n"; 65 | } 66 | 67 | return 0; 68 | } -------------------------------------------------------------------------------- /Code/1545.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "cmath" 5 | using namespace std; 6 | 7 | int n, m, k; 8 | bool visited[1009][1009] = { 0 }; 9 | int ops[10009][4] = { 0 }; 10 | 11 | int cx, cy, r; 12 | 13 | int dx[] = { 0,1,0,-1 }, 14 | dy[] = { 1,0,-1,0 }; 15 | 16 | bool check_av(int x, int y) { 17 | return (x - cx) * (x - cx) + (y - cy) * (y - cy) <= r * r; 18 | } 19 | 20 | int main() { 21 | ios::sync_with_stdio(false); 22 | cin.tie(0); 23 | cout.tie(0); 24 | 25 | cin >> n >> m >> k; 26 | 27 | for (int i = 0; i < k; ++i) { 28 | cin >> cx >> cy >> r; 29 | --cx; 30 | --cy; 31 | ops[i][0] = cx; 32 | ops[i][1] = cy; 33 | ops[i][2] = r; 34 | char temp[10]; 35 | cin >> temp; 36 | if (temp[0] == 'R') { 37 | ops[i][3] = 1; 38 | } 39 | else if (temp[0] == 'G') { 40 | ops[i][3] = 2; 41 | } 42 | else { 43 | ops[i][3] = 3; 44 | } 45 | } 46 | 47 | int cnt[4] = { 0 }; 48 | for (int i = 0; i < n; ++i) { 49 | for (int j = 0; j < m; ++j) { 50 | int color = 0; 51 | for (int a = k - 1; a >= 0; --a) { 52 | cx = ops[a][0], cy = ops[a][1], r = ops[a][2]; 53 | if (check_av(i, j)) { 54 | color = ops[a][3]; 55 | break; 56 | } 57 | } 58 | ++cnt[color]; 59 | } 60 | } 61 | 62 | cout << "Red:" << cnt[1] << endl << "Green:" << cnt[2] << endl << "Blue:" << cnt[3]; 63 | 64 | return 0; 65 | } -------------------------------------------------------------------------------- /Code/1123.cpp: -------------------------------------------------------------------------------- 1 | //TLE - 30 2 | 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | using pii = pair; 8 | using vi = vector; 9 | constexpr int mod = 100007; 10 | 11 | vector pdata; 12 | vector> dp_data; 13 | 14 | int n; 15 | 16 | int dp(int pos, int k, bool dir, bool isfirst = false) { 17 | if (k < 0) 18 | return 0; 19 | if (dp_data[pos][k][dir]) 20 | return dp_data[pos][k][dir]; 21 | 22 | 23 | int ans = 0; 24 | if (k == 0) 25 | ans = 1; 26 | for (int nxt = pos + 1; nxt < n; ++nxt) { 27 | if (pdata[nxt].second < pdata[pos].second) { 28 | if (dir || isfirst) 29 | ans = (ans + dp(nxt, k - 1, false)) % mod; 30 | else 31 | ans = (ans + dp(nxt, k, false)) % mod; 32 | } 33 | else { 34 | if (!dir || isfirst) 35 | ans = (ans + dp(nxt, k - 1, true)) % mod; 36 | else 37 | ans = (ans + dp(nxt, k, true)) % mod; 38 | } 39 | } 40 | return dp_data[pos][k][dir] = ans; 41 | } 42 | 43 | int main() { 44 | ios::sync_with_stdio(false); 45 | cin.tie(0); 46 | cout.tie(0); 47 | 48 | int k; 49 | cin >> n >> k; 50 | 51 | pdata.resize(n); 52 | dp_data.resize(n, vector(k + 1, vi(2, 0))); 53 | 54 | for (int i = 0; i < n; ++i) 55 | cin >> pdata[i].first >> pdata[i].second; 56 | 57 | sort(pdata.begin(), pdata.end(), [](pii a, pii b) {return a.first < b.first; }); 58 | cout << dp(0, k, false, true); 59 | 60 | return 0; 61 | } -------------------------------------------------------------------------------- /Code/4071.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "cmath" 5 | using namespace std; 6 | 7 | constexpr long long mod = (long long)(1e9 + 7); 8 | 9 | class matrix { 10 | public: 11 | long long a11 = 0, a12 = 0; 12 | long long a21 = 0, a22 = 0; 13 | 14 | matrix() = default; 15 | matrix(long long a11, long long a12, long long a21, long long a22) :a11(a11% mod), a12(a12% mod) 16 | , a21(a21% mod), a22(a22% mod) {} 17 | 18 | matrix(matrix&& other){ 19 | swap(*this, other); 20 | } 21 | 22 | void operator=(matrix&& other) { 23 | swap(*this, other); 24 | } 25 | 26 | matrix&& operator*(const matrix& b) const{ 27 | matrix temp; 28 | temp.a11 = (a11 * b.a11 + a12 * b.a21) % mod; 29 | temp.a12 = (a11 * b.a12 + a12 * b.a22) % mod; 30 | temp.a21 = (a21 * b.a11 + a22 * b.a21) % mod; 31 | temp.a22 = (a21 * b.a12 + a22 * b.a22) % mod; 32 | return std::move(temp); 33 | } 34 | }; 35 | 36 | matrix&& fast_pow(const matrix& a, long long b) { 37 | matrix ans(1, 0, 0, 1), base(a.a11, a.a12, a.a21, a.a22); 38 | for (; b; b >>= 1) { 39 | if (b & 1LL) 40 | ans = ans * base; 41 | base = base * base; 42 | } 43 | return std::move(ans); 44 | } 45 | 46 | int main() { 47 | long long n; 48 | scanf("%lld", &n); 49 | 50 | matrix temp(1, 1, 0, 0); 51 | matrix to(1, 1, 1, 0); 52 | matrix ans; 53 | ans = temp * fast_pow(to, n - 1); 54 | printf("%lld", ans.a11); 55 | 56 | return 0; 57 | } -------------------------------------------------------------------------------- /Code/1358.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | class edge { 7 | public: 8 | int val = 0; 9 | edge* next = nullptr; 10 | }; 11 | 12 | edge* edges_start[10009]; 13 | edge* edges_end[10009]; 14 | 15 | int nums[10009] = { 0 }; 16 | bool visited[10009] = { 0 }; 17 | 18 | int dfs(int pos) { 19 | visited[pos] = true; 20 | nums[pos] = 1; 21 | 22 | for (auto p = edges_start[pos]->next; p; p = p->next) { 23 | if (!visited[p->val]) { 24 | nums[pos] += dfs(p->val); 25 | } 26 | } 27 | 28 | return nums[pos]; 29 | } 30 | 31 | int main() { 32 | int n; 33 | scanf("%d", &n); 34 | 35 | for (int i = 1; i <= n; ++i) { 36 | edges_start[i] = edges_end[i] = new edge; 37 | } 38 | 39 | for (int i = 0; i < n - 1; ++i) { 40 | int a, b; 41 | scanf("%d %d", &a, &b); 42 | 43 | edges_end[a]->next = new edge; 44 | edges_end[a] = edges_end[a]->next; 45 | edges_end[a]->val = b; 46 | 47 | edges_end[b]->next = new edge; 48 | edges_end[b] = edges_end[b]->next; 49 | edges_end[b]->val = a; 50 | } 51 | 52 | dfs(1); 53 | 54 | for (int i = 1; i <= n; ++i) { 55 | if (n - nums[i] > n / 2) 56 | continue; 57 | bool flag = true; 58 | for (auto p = edges_start[i]->next; p; p = p->next) { 59 | if (nums[p->val]val]>n / 2) { 60 | flag = false; 61 | break; 62 | } 63 | } 64 | if (flag) { 65 | printf("%d\n", i); 66 | } 67 | } 68 | 69 | return 0; 70 | } 71 | -------------------------------------------------------------------------------- /Code/1029.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | class node { 7 | public: 8 | int val = 0; 9 | node* next = nullptr; 10 | }; 11 | 12 | node* heads[109] = { nullptr }; 13 | node* rears[109] = { nullptr }; 14 | 15 | char ch[10009] = { 0 }; 16 | 17 | int main() { 18 | int n; 19 | scanf("%d", &n); 20 | 21 | for (int i = 1; i <= n; ++i) { 22 | rears[i] = heads[i] = new node; 23 | } 24 | 25 | cin.getline(ch, 10009); 26 | 27 | for (int i = 1; i <= n; ++i) { 28 | cin.getline(ch, 10000); 29 | int length = strlen(ch); 30 | 31 | int num = 0; 32 | 33 | for (int j = 0; j < length; ++j) { 34 | if (ch[j] == ' ') { 35 | continue; 36 | } 37 | else if (ch[j] == '\n') { 38 | break; 39 | } 40 | else { 41 | num = num * 10 + ch[j] - '0'; 42 | if (ch[j + 1]<'0' || ch[j + 1]>'9') { 43 | rears[i]->next = new node; 44 | rears[i] = rears[i]->next; 45 | rears[i]->val = num; 46 | num = 0; 47 | } 48 | } 49 | } 50 | } 51 | 52 | for (int i = 0; i < n - 1; ++i) { 53 | int a, b; 54 | scanf("%d %d", &a, &b); 55 | 56 | rears[b]->next = heads[a]->next; 57 | heads[a]->next = nullptr; 58 | rears[b] = rears[a]; 59 | rears[a] = heads[a]; 60 | } 61 | 62 | for (int i = n; i > 0; --i) { 63 | if (heads[i]->next == nullptr) 64 | continue; 65 | for (auto p = heads[i]->next; p; p = p->next) 66 | cout << p->val << " "; 67 | } 68 | 69 | return 0; 70 | } -------------------------------------------------------------------------------- /Code/1045.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | class person { 8 | public: 9 | int parent = 0, childnum = 0; 10 | bool status = true; 11 | }; 12 | 13 | int main() { 14 | ios::sync_with_stdio(false); 15 | cin.tie(0); 16 | cout.tie(0); 17 | 18 | int n; 19 | cin >> n; 20 | 21 | unordered_map person_map; 22 | vector vdata; 23 | int total_cnt = 1, ans = 1; 24 | 25 | //Init 26 | person fiperson; 27 | fiperson.status = false; 28 | vdata.emplace_back(fiperson); 29 | fiperson.status = true; 30 | vdata.emplace_back(fiperson); 31 | person_map.insert(make_pair(1, 1)); 32 | 33 | for (; n; --n) { 34 | string ch; 35 | cin >> ch; 36 | 37 | if (ch == "B") { 38 | int x, y; 39 | cin >> x >> y; 40 | person tmp; 41 | tmp.parent = person_map[x]; 42 | vdata[person_map[x]].childnum++; 43 | vdata.emplace_back(tmp); 44 | person_map.insert(make_pair(y, ++total_cnt)); 45 | } 46 | else if (ch == "D") { 47 | int x; 48 | cin >> x; 49 | vdata[person_map[x]].status = false; 50 | if (!vdata[person_map[x]].parent || !vdata[vdata[person_map[x]].parent].status) { 51 | ans += vdata[person_map[x]].childnum - 1; 52 | } 53 | else { 54 | --vdata[vdata[person_map[x]].parent].childnum; 55 | ans += vdata[person_map[x]].childnum; 56 | } 57 | person_map.erase(x); 58 | cout << ans << "\n"; 59 | } 60 | } 61 | 62 | return 0; 63 | } -------------------------------------------------------------------------------- /Code/4244.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "vector" 3 | using namespace std; 4 | 5 | class node { 6 | public: 7 | vector child; 8 | long long s = 0; 9 | long long a = 0; 10 | int parent = 0; 11 | }; 12 | 13 | long long ans = 0; 14 | 15 | void update(int pos, vector& node_list) { 16 | if (pos == 1) { 17 | node_list[pos].a = node_list[pos].s; 18 | ans += node_list[pos].a; 19 | } 20 | else if (node_list[pos].s >= 0) { 21 | node_list[pos].a = node_list[pos].s - node_list[node_list[pos].parent].s; 22 | ans += node_list[pos].a; 23 | } 24 | else { 25 | if (node_list[pos].child.empty()) { 26 | node_list[pos].a = 0; 27 | ans += node_list[pos].a; 28 | return; 29 | } 30 | node_list[pos].s = node_list[node_list[pos].child[0]].s; 31 | for (auto p : node_list[pos].child) { 32 | node_list[pos].s = node_list[p].s < node_list[pos].s ? node_list[p].s : node_list[pos].s; 33 | } 34 | node_list[pos].a = node_list[pos].s - node_list[node_list[pos].parent].s; 35 | ans += node_list[pos].a; 36 | } 37 | for (auto p : node_list[pos].child) { 38 | update(p, node_list); 39 | } 40 | } 41 | 42 | int main() { 43 | ios::sync_with_stdio(false); 44 | cin.tie(0); 45 | cout.tie(0); 46 | 47 | int n; 48 | cin >> n; 49 | vector node_list(n + 1); 50 | 51 | for (int i = 2; i <= n; ++i) { 52 | int temp; 53 | cin >> temp; 54 | node_list[i].parent = temp; 55 | node_list[temp].child.push_back(i); 56 | } 57 | for (int i = 1; i <= n; ++i) { 58 | cin >> node_list[i].s; 59 | } 60 | 61 | update(1, node_list); 62 | cout << ans; 63 | 64 | return 0; 65 | } -------------------------------------------------------------------------------- /Code/1635.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | constexpr int max_size = 2000009; 7 | 8 | class edge { 9 | public: 10 | int to = 0; 11 | long long val = 0; 12 | edge* next = nullptr; 13 | }; 14 | 15 | edge* head[1000009], *rear[1000009]; 16 | int queue_data[max_size] = { 0 }; 17 | int queue_start = 0, queue_size = 0; 18 | 19 | long long dis[1000009] = { 0 }; 20 | 21 | void SPFA(int from) { 22 | queue_data[(queue_start + queue_size) % max_size] = from; 23 | dis[from] = 0; 24 | ++queue_size; 25 | while (queue_size) { 26 | auto temp = queue_data[queue_start % max_size]; 27 | ++queue_start; 28 | --queue_size; 29 | for (auto p = head[temp]->next; p; p = p->next) { 30 | if (dis[temp] + p->val < dis[p->to]) { 31 | dis[p->to] = dis[temp] + p->val; 32 | queue_data[(queue_start + queue_size) % max_size] = p->to; 33 | ++queue_size; 34 | } 35 | } 36 | } 37 | } 38 | 39 | int main() { 40 | ios::sync_with_stdio(false); 41 | cin.tie(0); 42 | cout.tie(0); 43 | 44 | int n, m; 45 | cin >> n >> m; 46 | 47 | for (int i = 1; i <= n; ++i) { 48 | rear[i] = head[i] = new edge; 49 | dis[i] = 999999999999; 50 | } 51 | 52 | for (int i = 0; i < m; ++i) { 53 | int u, v; 54 | long long c; 55 | cin >> u >> v >> c; 56 | rear[u]->next = new edge; 57 | rear[u] = rear[u]->next; 58 | rear[u]->to = v; 59 | rear[u]->val = c; 60 | 61 | rear[v]->next = new edge; 62 | rear[v] = rear[v]->next; 63 | rear[v]->to = u; 64 | rear[v]->val = c; 65 | } 66 | 67 | SPFA(1); 68 | cout << dis[n]; 69 | 70 | return 0; 71 | } -------------------------------------------------------------------------------- /Code/1521.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | class node { 7 | public: 8 | int first_max = 0, second_max = 0; 9 | int depth = 0; 10 | int parent = 0; 11 | }; 12 | 13 | node tree_data[20009]{}; 14 | 15 | int main() { 16 | ios::sync_with_stdio(false); 17 | cin.tie(0); 18 | cout.tie(0); 19 | 20 | int n, m; 21 | cin >> n >> m; 22 | 23 | tree_data[1].depth = 1; 24 | 25 | for (int i = 2; i <= n + m; ++i) { 26 | cin >> tree_data[i].parent; 27 | tree_data[i].depth = tree_data[tree_data[i].parent].depth + 1; 28 | } 29 | 30 | for (int i = n + m; i > 0; --i) { 31 | if (tree_data[i].depth > tree_data[i].first_max) { 32 | tree_data[i].second_max = tree_data[i].first_max; 33 | tree_data[i].first_max = tree_data[i].depth; 34 | } 35 | if (tree_data[i].depth > tree_data[i].second_max) { 36 | tree_data[i].second_max = tree_data[i].depth; 37 | } 38 | if (tree_data[i].first_max > tree_data[tree_data[i].parent].first_max) { 39 | tree_data[tree_data[i].parent].second_max = tree_data[tree_data[i].parent].first_max; 40 | tree_data[tree_data[i].parent].first_max = tree_data[i].first_max; 41 | } 42 | else if (tree_data[i].first_max > tree_data[tree_data[i].parent].second_max) { 43 | tree_data[tree_data[i].parent].second_max = tree_data[i].first_max; 44 | } 45 | } 46 | 47 | int ans = 0; 48 | for (int i = 1; i <= n + m; ++i) { 49 | int cur_ans = tree_data[i].first_max + tree_data[i].second_max - 2 * tree_data[i].depth; 50 | ans = cur_ans > ans ? cur_ans : ans; 51 | } 52 | 53 | cout << ans; 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /Code/1005.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | int main() { 5 | int num; 6 | cin >> num; 7 | 8 | for (; num > 0; num--) { 9 | int data[9][9]; 10 | for (int i = 0; i < 9; i++) 11 | for (int j = 0; j < 9; j++) 12 | cin >> data[i][j]; 13 | 14 | //Check 15 | bool flag = false; 16 | for (int i = 0; i < 9; i++) { 17 | bool check[9] = { 0 }; 18 | for (int j = 0; j < 9; j++) { 19 | if (check[data[i][j] - 1]) { 20 | cout << "Wrong" << endl; 21 | flag = true; 22 | break; 23 | } 24 | check[data[i][j] - 1] = true; 25 | } 26 | if (flag) 27 | break; 28 | } 29 | if (flag) 30 | continue; 31 | 32 | //Check 33 | flag = false; 34 | for (int i = 0; i < 9; i++) { 35 | bool check[9] = { 0 }; 36 | for (int j = 0; j < 9; j++) { 37 | if (check[data[j][i] - 1]) { 38 | cout << "Wrong" << endl; 39 | flag = true; 40 | break; 41 | } 42 | check[data[j][i] - 1] = true; 43 | } 44 | if (flag) 45 | break; 46 | } 47 | if (flag) 48 | continue; 49 | 50 | flag = false; 51 | for (int i = 0; i < 9; i += 3) { 52 | for (int j = 0; j < 9; j += 3) { 53 | //Small Square 54 | bool check[9] = { 0 }; 55 | for (int m = 0; m < 3; m++) { 56 | for (int n = 0; n < 3; n++) { 57 | if (check[data[i + m][j + n] - 1]) { 58 | flag = true; 59 | cout << "Wrong" << endl; 60 | goto outside; 61 | } 62 | check[data[i + m][j + n] - 1] = true; 63 | } 64 | } 65 | } 66 | } 67 | 68 | outside: 69 | if (flag) 70 | continue; 71 | cout << "Right" << endl; 72 | } 73 | 74 | return 0; 75 | } -------------------------------------------------------------------------------- /Code/1009.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | typedef pair pii; 9 | 10 | class type { 11 | public: 12 | int t, a, d; 13 | }; 14 | 15 | int main() { 16 | ios::sync_with_stdio(false); 17 | cin.tie(0); 18 | cout.tie(0); 19 | 20 | int m, n; 21 | cin >> m; 22 | vector buy_data(m); 23 | 24 | for (int i = 0; i < m; ++i) { 25 | cin >> buy_data[i].t >> buy_data[i].a >> buy_data[i].d; 26 | } 27 | 28 | cin >> n; 29 | vector> val_data(n); 30 | for (int i = 0; i < n; ++i) 31 | cin >> val_data[i].first >> val_data[i].second; 32 | 33 | function cmp = [](const pair& a,const pair& b) { 34 | return a.first < b.first; 35 | }; 36 | 37 | sort(buy_data.begin(), buy_data.end(), [](type& a, type& b) {return a.t < b.t; }); 38 | sort(val_data.begin(), val_data.end(), cmp); 39 | 40 | double ans = 0.0; 41 | for (int i = 0, j = 0; i < m; ++i) { 42 | for (; j < n - 1 && buy_data[i].t >= val_data[j + 1].first; ++j); 43 | if (buy_data[i].d == 1) { 44 | double cur_num = 100.0 * buy_data[i].a * val_data[j].second; 45 | ans -= cur_num * 0.002 > 5.0 ? cur_num * 0.002 : 5.0; 46 | ans -= 1.0 * buy_data[i].a / 10; 47 | ans -= 1.0; 48 | ans -= cur_num; 49 | } 50 | else { 51 | double cur_num = 100.0 * buy_data[i].a * val_data[j].second; 52 | ans -= cur_num * 0.002 > 5.0 ? cur_num * 0.002 : 5.0; 53 | ans -= 1.0 * buy_data[i].a / 10; 54 | ans -= 1.0; 55 | ans += cur_num; 56 | ans -= cur_num * 0.001; 57 | } 58 | } 59 | 60 | cout << fixed << setprecision(2) << ans; 61 | 62 | return 0; 63 | } -------------------------------------------------------------------------------- /Code/4370.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class myStack { 6 | stack real_stack; 7 | stack> min_stack; 8 | 9 | public: 10 | void push(unsigned int x) { 11 | real_stack.push(x); 12 | if (min_stack.empty()||min_stack.top().second>x){ 13 | min_stack.push(make_pair(real_stack.size(), x)); 14 | } 15 | } 16 | 17 | void pop() { 18 | if (real_stack.empty()) { 19 | cout << "Empty\n"; 20 | return; 21 | } 22 | if (min_stack.top().first==real_stack.size()) { 23 | min_stack.pop(); 24 | } 25 | real_stack.pop(); 26 | } 27 | 28 | void top() { 29 | if (real_stack.empty()) { 30 | cout << "Empty\n"; 31 | return; 32 | } 33 | cout << real_stack.top() << "\n"; 34 | } 35 | 36 | void getMin() { 37 | if (real_stack.empty()) { 38 | cout << "Empty\n"; 39 | return; 40 | } 41 | cout << min_stack.top().second << "\n"; 42 | } 43 | }; 44 | 45 | int main(){ 46 | ios::sync_with_stdio(false); 47 | cin.tie(0); 48 | cout.tie(0); 49 | 50 | int n = 0; 51 | cin >> n; 52 | 53 | myStack stack1; 54 | 55 | for (;n;--n) { 56 | int a; 57 | cin >> a; 58 | if (a==0) { 59 | unsigned int b; 60 | cin >> b; 61 | stack1.push(b); 62 | } 63 | else if (a==1) { 64 | stack1.pop(); 65 | } 66 | else if (a==2) { 67 | stack1.top(); 68 | } 69 | else { 70 | stack1.getMin(); 71 | } 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /Code/1515.cpp: -------------------------------------------------------------------------------- 1 | //Written by LCK 2 | 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int m, n; 9 | int ans = 1e6; 10 | int map[1000][1000] = { 0 }; 11 | int sx, sy, ex, ey; 12 | int step[1000][1000] = { 0 }; 13 | int a[1000000] = { 0 }, b[1000000] = { 0 }; 14 | int dx[4] = { 1,-1,0,0 }; 15 | int dy[4] = { 0,0,1,-1 }; 16 | int cnt = -1; 17 | class node { 18 | public: 19 | int x; 20 | int y; 21 | }; 22 | class shop { 23 | public: 24 | int x; 25 | int y; 26 | } sh[1000000] = { 0,0 }; 27 | 28 | void bfs(node s) { 29 | queue que; 30 | que.push(s); 31 | node nw, nxt; 32 | while (!que.empty()) { 33 | nw = que.front(); 34 | que.pop(); 35 | for (int i = 0; i < 4; ++i) { 36 | nxt.x = nw.x + dx[i]; 37 | nxt.y = nw.y + dy[i]; 38 | 39 | if (nxt.x >= 0 && nxt.x < m&&nxt.y >= 0 && nxt.y < n&&step[nxt.x][nxt.y] == 0 && map[nxt.x][nxt.y] != 1) { 40 | step[nxt.x][nxt.y] = step[nw.x][nw.y] + 1; 41 | que.push(nxt); 42 | } 43 | } 44 | } 45 | } 46 | 47 | int main() { 48 | cin >> n >> m; 49 | for (int i = 0; i < m; ++i) 50 | for (int j = 0; j < n; ++j) { 51 | cin >> map[i][j]; 52 | if (map[i][j] == 2) { sx = i; sy = j; } 53 | if (map[i][j] == 3) { ex = i; ey = j; } 54 | if (map[i][j] == 4) { 55 | cnt++; 56 | sh[cnt].x = i; 57 | sh[cnt].y = j; 58 | } 59 | } 60 | node s = { sx,sy }; 61 | bfs(s); 62 | for (int i = 0; i <= cnt; ++i) { 63 | a[i] = step[sh[i].x][sh[i].y]; 64 | } 65 | memset(step, 0, sizeof(step)); 66 | node e = { ex,ey }; 67 | bfs(e); 68 | for (int i = 0; i <= cnt; ++i) { 69 | b[i] = step[sh[i].x][sh[i].y]; 70 | } 71 | int tmp; 72 | for (int i = 0; i <= cnt; ++i) { 73 | if (a[i] > 0 && b[i] > 0) { 74 | tmp = a[i] + b[i]; 75 | ans = min(ans, tmp); 76 | } 77 | } 78 | cout << ans; 79 | return 0; 80 | } 81 | -------------------------------------------------------------------------------- /Code/1258.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "cmath" 5 | using namespace std; 6 | 7 | class node { 8 | public: 9 | int val = 0; 10 | int left = 0, right = 0; 11 | }; 12 | 13 | int val_data[100009] = { 0 }; 14 | node smt[400009]; 15 | 16 | void build_tree(int l, int r, int root) { 17 | smt[root].left = l; 18 | smt[root].right = r; 19 | if (l == r - 1) { 20 | smt[root].val = val_data[l]; 21 | return; 22 | } 23 | 24 | int mid = (l + r) >> 1; 25 | build_tree(l, mid, root * 2); 26 | build_tree(mid, r, root * 2 + 1); 27 | 28 | smt[root].val = smt[root * 2].val + smt[root * 2 + 1].val; 29 | } 30 | 31 | int query(int l, int r, int root) { 32 | if (l <= smt[root].left && smt[root].right <= r) { 33 | return smt[root].val; 34 | } 35 | 36 | auto mid = (smt[root].left + smt[root].right) >> 1; 37 | int ans = 0; 38 | if (l < mid) { 39 | ans += query(l, r, root * 2); 40 | } 41 | if (r > mid) { 42 | ans += query(l, r, root * 2 + 1); 43 | } 44 | return ans; 45 | } 46 | 47 | void update(int val,int pos, int root) { 48 | if (smt[root].right - smt[root].left == 1) { 49 | smt[root].val += val; 50 | return; 51 | } 52 | 53 | auto mid = (smt[root].left + smt[root].right) >> 1; 54 | if (pos < mid) { 55 | update(val, pos, root * 2); 56 | } 57 | else { 58 | update(val, pos, root * 2 + 1); 59 | } 60 | smt[root].val = smt[root * 2].val + smt[root * 2 + 1].val; 61 | } 62 | 63 | int main() { 64 | ios::sync_with_stdio(false); 65 | cin.tie(0); 66 | cout.tie(0); 67 | 68 | int n; 69 | cin >> n; 70 | 71 | build_tree(0, 100009, 1); 72 | 73 | long long cnt = 0; 74 | for (int i = 0; i < n; ++i) { 75 | cin >> val_data[i]; 76 | 77 | update(1, val_data[i], 1); 78 | cnt += (long long)query(val_data[i] + 1, 100009, 1); 79 | } 80 | 81 | cout << cnt; 82 | 83 | return 0; 84 | } -------------------------------------------------------------------------------- /Code/1046.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class node { 5 | public: 6 | int lchild = 0, rchild = 0; 7 | int num = 1; 8 | int red_num = 0; 9 | bool is_red = false; 10 | int parent = 0; 11 | }; 12 | 13 | node node_list[100009]; 14 | 15 | int dfs(int root) { 16 | if (node_list[root].lchild) 17 | node_list[root].num += dfs(node_list[root].lchild); 18 | if (node_list[root].rchild) 19 | node_list[root].num += dfs(node_list[root].rchild); 20 | return node_list[root].num; 21 | } 22 | 23 | void paint_red(int root,int pos) { 24 | pos = pos % node_list[root].num; 25 | int this_pos = node_list[root].lchild ? node_list[node_list[root].lchild].num : 0; 26 | if (pos == this_pos) { 27 | if (!node_list[root].is_red) { 28 | node_list[root].is_red = true; 29 | for (auto p = root; p; p = node_list[p].parent) 30 | ++node_list[p].red_num; 31 | } 32 | return; 33 | } 34 | else if (pos < this_pos) { 35 | paint_red(node_list[root].lchild, pos); 36 | } 37 | else { 38 | paint_red(node_list[root].rchild, pos - this_pos - 1); 39 | } 40 | } 41 | 42 | int main() { 43 | ios::sync_with_stdio(false); 44 | cin.tie(0); 45 | cout.tie(0); 46 | 47 | int n, p, q; 48 | cin >> n >> p >> q; 49 | 50 | for (int i = 0; i < n; ++i) { 51 | int x, l, r; 52 | cin >> x >> l >> r; 53 | 54 | node_list[x].lchild = l; 55 | node_list[x].rchild = r; 56 | if (l) 57 | node_list[l].parent = x; 58 | if (r) 59 | node_list[r].parent = x; 60 | } 61 | 62 | int root = 0; 63 | for(int i=1;i<=n;++i) 64 | if (node_list[i].parent == 0) { 65 | root = i; 66 | break; 67 | } 68 | 69 | dfs(root); 70 | 71 | for (int i = 0; i < p; ++i) { 72 | int t, x; 73 | cin >> t >> x; 74 | paint_red(t, x); 75 | } 76 | 77 | for (int i = 0; i < q; ++i) { 78 | int w; 79 | cin >> w; 80 | cout << node_list[w].red_num << "\n"; 81 | } 82 | 83 | return 0; 84 | } -------------------------------------------------------------------------------- /Code/1329.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | int n, m; 7 | bool visited[25] = { 0 }; 8 | int choose[65][25] = { 0 }; 9 | int val_num[65] = { 0 }; 10 | bool fucked = false; 11 | 12 | void fuck(int pos) { 13 | if (pos == n + 1) { 14 | bool flag = true; 15 | for (int i = 0; i < m; ++i) { 16 | int cnt = 0; 17 | for (int j = 0; j < val_num[i]; ++j) { 18 | if (choose[i][j] < 0 && !visited[-choose[i][j]]) { 19 | ++cnt; 20 | } 21 | else if (choose[i][j] > 0 && visited[choose[i][j]]) { 22 | ++cnt; 23 | } 24 | } 25 | if (cnt == 0) { 26 | flag = false; 27 | break; 28 | } 29 | } 30 | if (flag) { 31 | fucked = true; 32 | } 33 | return; 34 | } 35 | visited[pos] = true; 36 | fuck(pos + 1); 37 | visited[pos] = false; 38 | fuck(pos + 1); 39 | } 40 | 41 | int main() { 42 | ios::sync_with_stdio(false); 43 | cin.tie(0); 44 | cout.tie(0); 45 | 46 | int t; 47 | cin >> t; 48 | cin.get(); 49 | 50 | for (; t > 0; --t) { 51 | fucked = false; 52 | memset(visited, 0, sizeof(visited)); 53 | memset(choose, 0, sizeof(choose)); 54 | memset(val_num, 0, sizeof(val_num)); 55 | cin >> n >> m; 56 | /* 57 | cin.get(); 58 | char buff[1000] = { 0 }; 59 | cin.getline(buff, 1000); 60 | int length = strlen(buff); 61 | int cnt = 0; 62 | int cur_num = 0; 63 | for (int i = 0; i < length; ++i) { 64 | if (buff[i] >= '0' && buff[i] <= '9') { 65 | cur_num = cur_num * 10 + buff[i] - '0'; 66 | if () 67 | } 68 | }*/ 69 | cin.get(); 70 | for (int i = 0; i < m; ++i) { 71 | for (int cnt = 0;; ++cnt) { 72 | cin >> choose[i][cnt]; 73 | if (cin.get() == '\n') { 74 | val_num[i] = cnt + 1; 75 | break; 76 | } 77 | } 78 | } 79 | 80 | fuck(1); 81 | 82 | if (fucked) { 83 | cout << "Bingo!\n"; 84 | } 85 | else { 86 | cout << "Sigh...\n"; 87 | } 88 | } 89 | 90 | return 0; 91 | } -------------------------------------------------------------------------------- /Code/1031.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int map_data[109][109] = { 0 }; 6 | 7 | int dx[] = { 0,1,0,-1 }, 8 | dy[] = { 1,0,-1,0 }; 9 | int n; 10 | 11 | bool visited[109][109] = { 0 }; 12 | int max_h = 0; 13 | 14 | bool dfs(int posx, int posy, int cur_max, int cur_min) { 15 | visited[posx][posy] = true; 16 | if (cur_max == -1) { 17 | cur_max = cur_min = map_data[posx][posy]; 18 | } 19 | else { 20 | cur_max = map_data[posx][posy] > cur_max ? map_data[posx][posy] : cur_max; 21 | cur_min = map_data[posx][posy] < cur_min ? map_data[posx][posy] : cur_min; 22 | } 23 | if (cur_max - cur_min > max_h) { 24 | visited[posx][posy] = false; 25 | return false; 26 | } 27 | if (posx == n - 1 && posy == n - 1) 28 | return true; 29 | 30 | for (int i = 0; i < 4; ++i) { 31 | int nx = posx + dx[i], ny = posy + dy[i]; 32 | if (!visited[nx][ny] && nx >= 0 && nx < n && ny >= 0 && ny < n) { 33 | auto flag = dfs(nx, ny, cur_max, cur_min); 34 | if (flag) { 35 | visited[posx][posy] = false; 36 | return true; 37 | } 38 | } 39 | } 40 | visited[posx][posy] = false; 41 | return false; 42 | } 43 | 44 | int main() { 45 | ios::sync_with_stdio(false); 46 | cin.tie(0); 47 | cout.tie(0); 48 | 49 | cin >> n; 50 | 51 | int h_min = 200, h_max = 0; 52 | 53 | for (int i = 0; i < n; ++i) 54 | for (int j = 0; j < n; ++j) { 55 | cin >> map_data[i][j]; 56 | h_min = map_data[i][j] < h_min ? map_data[i][j] : h_min; 57 | h_max = map_data[i][j] > h_max ? map_data[i][j] : h_max; 58 | } 59 | 60 | int left = 0, right = h_max - h_min, right_ans = -1; 61 | 62 | while (left <= right) { 63 | auto mid = (left + right) >> 1; 64 | max_h = mid; 65 | 66 | memset(visited, 0, sizeof(visited)); 67 | if (dfs(0, 0, -1, -1)) { 68 | right_ans = mid; 69 | right = mid - 1; 70 | } 71 | else { 72 | left = mid + 1; 73 | } 74 | } 75 | 76 | cout << right_ans; 77 | 78 | return 0; 79 | } -------------------------------------------------------------------------------- /Code/1565.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | constexpr int max_size = 2000009; 7 | 8 | class edge { 9 | public: 10 | int to = 0; 11 | long long val = 0; 12 | long long money = 0; 13 | edge* next = nullptr; 14 | }; 15 | 16 | edge* head[1009], * rear[1009]; 17 | int queue_data[max_size] = { 0 }; 18 | int queue_start = 0, queue_size = 0; 19 | 20 | long long dis[1009] = { 0 }, cost[1009] = { 0 }; 21 | 22 | void SPFA(int from) { 23 | queue_data[(queue_start + queue_size) % max_size] = from; 24 | dis[from] = 0; 25 | cost[from] = 0; 26 | ++queue_size; 27 | while (queue_size) { 28 | auto temp = queue_data[queue_start % max_size]; 29 | ++queue_start; 30 | --queue_size; 31 | for (auto p = head[temp]->next; p; p = p->next) { 32 | if (dis[temp] + p->val < dis[p->to]|| 33 | (dis[temp] + p->val == dis[p->to] && cost[temp] + p->money < cost[p->to])) { 34 | dis[p->to] = dis[temp] + p->val; 35 | cost[p->to] = cost[temp] + p->money; 36 | queue_data[(queue_start + queue_size) % max_size] = p->to; 37 | ++queue_size; 38 | } 39 | } 40 | } 41 | } 42 | 43 | int main() { 44 | ios::sync_with_stdio(false); 45 | cin.tie(0); 46 | cout.tie(0); 47 | 48 | int n, m; 49 | cin >> n >> m; 50 | 51 | for (int i = 1; i <= 1000; ++i) { 52 | rear[i] = head[i] = new edge; 53 | dis[i] = 999999999999; 54 | cost[i] = 999999999999; 55 | } 56 | for (int i = 0; i < m; ++i) { 57 | int u, v; 58 | long long c, money; 59 | cin >> u >> v >> c >> money; 60 | rear[u]->next = new edge; 61 | rear[u] = rear[u]->next; 62 | rear[u]->to = v; 63 | rear[u]->val = c; 64 | rear[u]->money = money; 65 | 66 | rear[v]->next = new edge; 67 | rear[v] = rear[v]->next; 68 | rear[v]->to = u; 69 | rear[v]->val = c; 70 | rear[v]->money = money; 71 | } 72 | 73 | int s, t; 74 | cin >> s >> t; 75 | 76 | SPFA(s); 77 | cout << dis[t] << " " << cost[t]; 78 | 79 | return 0; 80 | } -------------------------------------------------------------------------------- /Code/1247.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "cmath" 5 | using namespace std; 6 | 7 | class node { 8 | public: 9 | int left = 0, right = 0; 10 | int val = 0; 11 | bool flag = false; 12 | }; 13 | 14 | node smt[100009]; 15 | 16 | void build_tree(int l, int r, int root) { 17 | smt[root].left = l; 18 | smt[root].right = r; 19 | if (l == r - 1) { 20 | smt[root].val = 1; 21 | return; 22 | } 23 | int mid = (l + r) >> 1; 24 | build_tree(l, mid, root * 2); 25 | build_tree(mid, r, root * 2 + 1); 26 | 27 | smt[root].val = smt[root * 2].val + smt[root * 2 + 1].val; 28 | } 29 | 30 | void push_down(int root) { 31 | if (smt[root].flag) { 32 | smt[root].flag = false; 33 | smt[root * 2].val = 0; 34 | smt[root * 2 + 1].val = 0; 35 | smt[root * 2].flag = true; 36 | smt[root * 2 + 1].flag = true; 37 | } 38 | } 39 | 40 | void update(int l, int r, int root) { 41 | if (l <= smt[root].left && smt[root].right <= r) { 42 | smt[root].val = 0; 43 | smt[root].flag = true; 44 | return; 45 | } 46 | int mid = (smt[root].left + smt[root].right) >> 1; 47 | push_down(root); 48 | if (l < mid) 49 | update(l, r, root * 2); 50 | if (r > mid) 51 | update(l, r, root * 2 + 1); 52 | smt[root].val = smt[root * 2].val + smt[root * 2 + 1].val; 53 | } 54 | 55 | int query(int l, int r, int root) { 56 | if (l <= smt[root].val && smt[root].val <= r) { 57 | return smt[root].val; 58 | } 59 | int mid = (smt[root].left + smt[root].right) >> 1; 60 | push_down(root); 61 | int ans = 0; 62 | if (l < mid) { 63 | ans += query(l, r, root * 2); 64 | } 65 | if (r > mid) { 66 | ans += query(l, r, root * 2 + 1); 67 | } 68 | return ans; 69 | } 70 | 71 | int main() { 72 | int M, L; 73 | scanf("%d %d", &L, &M); 74 | 75 | build_tree(0, L + 1, 1); 76 | 77 | for (; M > 0; --M) { 78 | int a, b; 79 | scanf("%d %d", &a, &b); 80 | 81 | update(a, b + 1, 1); 82 | } 83 | 84 | printf("%d", query(0, L + 1, 1)); 85 | 86 | return 0; 87 | } -------------------------------------------------------------------------------- /Code/4232.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cmath" 3 | #include "cstdio" 4 | #include "cstring" 5 | using namespace std; 6 | 7 | class node { 8 | public: 9 | int val = 0; 10 | int left = 0, right = 0; 11 | }; 12 | 13 | int mmax(int a, int b) { 14 | return a > b ? a : b; 15 | } 16 | 17 | node smt[800000]; 18 | int val_data[200009] = { 0 }; 19 | 20 | void build_tree(int l, int r, int pos) { 21 | smt[pos].left = l; 22 | smt[pos].right = r; 23 | if (l == r - 1) { 24 | smt[pos].val = val_data[l]; 25 | return; 26 | } 27 | 28 | int mid = (l + r) >> 1; 29 | build_tree(l, mid, pos * 2); 30 | build_tree(mid, r, pos * 2 + 1); 31 | 32 | smt[pos].val = mmax(smt[pos * 2].val, smt[pos * 2 + 1].val); 33 | } 34 | 35 | void update(int val, int pos, int root) { 36 | if (smt[root].left == smt[root].right - 1) { 37 | smt[root].val = val; 38 | return; 39 | } 40 | int mid = (smt[root].left + smt[root].right) >> 1; 41 | if (pos < mid) 42 | update(val, pos, root * 2); 43 | else 44 | update(val, pos, root * 2 + 1); 45 | smt[root].val = mmax(smt[root * 2].val, smt[root * 2 + 1].val); 46 | } 47 | 48 | int query(int l, int r, int root) { 49 | if (l <= smt[root].left && smt[root].right <= r) { 50 | return smt[root].val; 51 | } 52 | int mid = (smt[root].left + smt[root].right) >> 1; 53 | int ans1 = 0, ans2 = 0; 54 | if (l < mid) { 55 | ans1 = query(l, r, root * 2); 56 | } 57 | if (r > mid) { 58 | ans2 = query(l, r, root * 2 + 1); 59 | } 60 | return ans1 > ans2 ? ans1 : ans2; 61 | } 62 | 63 | int main() { 64 | int n, m; 65 | while (cin >> n >> m) { 66 | memset(smt, 0, sizeof(smt)); 67 | memset(val_data, 0, sizeof(val_data)); 68 | 69 | for (int i = 0; i < n; ++i) { 70 | scanf("%d", &val_data[i]); 71 | } 72 | build_tree(0, n, 1); 73 | for (; m > 0; --m) { 74 | char op; 75 | int a, b; 76 | scanf("\n%c %d %d", &op, &a, &b); 77 | if (op == 'Q') { 78 | printf("%d\n", query(a - 1, b, 1)); 79 | } 80 | else { 81 | update(b, a - 1, 1); 82 | } 83 | } 84 | } 85 | 86 | return 0; 87 | } -------------------------------------------------------------------------------- /Code/1011.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "cstdio" 3 | using namespace std; 4 | 5 | class MyComplex 6 | { 7 | private: 8 | double x, y; 9 | public: 10 | friend istream& operator>>(istream& input, MyComplex &b) { 11 | input >> b.x >> b.y; 12 | return input; 13 | } 14 | friend ostream& operator<<(ostream& output, const MyComplex &b) { 15 | char op[1000]; 16 | sprintf(op, "%.2f %.2f", b.x, b.y); 17 | output << op; 18 | //output << fixed << setprecision(2) << b.x << " " << b.y; 19 | return output; 20 | } 21 | 22 | MyComplex operator+(const MyComplex &b) const{ 23 | MyComplex temp; 24 | temp.x = x + b.x; 25 | temp.y = y + b.y; 26 | return temp; 27 | } 28 | 29 | MyComplex operator-(const MyComplex &b) const { 30 | MyComplex temp; 31 | temp.x = x - b.x; 32 | temp.y = y - b.y; 33 | return temp; 34 | } 35 | 36 | MyComplex operator*(const MyComplex &b) const { 37 | MyComplex temp; 38 | temp.x = x * b.x - y * b.y; 39 | temp.y = x * b.y + y * b.x; 40 | return temp; 41 | } 42 | 43 | MyComplex operator/(const MyComplex &b) const { 44 | MyComplex temp; 45 | double data = b.x*b.x + b.y*b.y; 46 | temp.x = (x*b.x + y * b.y) / data; 47 | temp.y = (y*b.x - x * b.y) / data; 48 | return temp; 49 | } 50 | 51 | MyComplex &operator+=(const MyComplex &b) { 52 | *this = *this + b; 53 | return *this; 54 | } 55 | 56 | MyComplex &operator-=(const MyComplex &b) { 57 | *this = *this - b; 58 | return *this; 59 | } 60 | 61 | MyComplex &operator*=(const MyComplex &b) { 62 | *this = *this * b; 63 | return *this; 64 | } 65 | 66 | MyComplex &operator/=(const MyComplex &b) { 67 | *this = *this / b; 68 | return *this; 69 | } 70 | }; 71 | 72 | int main() 73 | { 74 | MyComplex z1; 75 | MyComplex z2; 76 | 77 | cin >> z1 >> z2; 78 | 79 | cout << z1 + z2 << endl; 80 | cout << z1 - z2 << endl; 81 | cout << z1 * z2 << endl; 82 | cout << z1 / z2 << endl; 83 | cout << (z1 += z2) << endl; 84 | cout << (z1 -= z2) << endl; 85 | cout << (z1 *= z2) << endl; 86 | cout << (z1 /= z2); 87 | 88 | return 0; 89 | } -------------------------------------------------------------------------------- /Code/4321.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | class node { 7 | public: 8 | int code; 9 | vector> edges; 10 | }; 11 | 12 | vector nl, nlf; 13 | vector visited; 14 | vector forest_num; 15 | 16 | int dfs1(int pos, int k, int code) { 17 | nl[pos].code = code; 18 | visited[pos] = true; 19 | int ans = 1; 20 | for (auto edge : nl[pos].edges) { 21 | if (edge.second < k && !visited[edge.first]) { 22 | ans += dfs1(edge.first, k, code); 23 | } 24 | } 25 | return ans; 26 | } 27 | 28 | int dfs2(int pos, int& num) { 29 | visited[pos] = true; 30 | num += forest_num[pos]; 31 | int ans = 0; 32 | for (auto edge : nlf[pos].edges) { 33 | if (!visited[edge.first]) { 34 | ans += forest_num[edge.first] * num; 35 | ans += dfs2(edge.first, num); 36 | } 37 | } 38 | return ans; 39 | } 40 | 41 | int main() { 42 | ios::sync_with_stdio(false); 43 | cin.tie(0); 44 | cout.tie(0); 45 | 46 | int n, m, k; 47 | cin >> n >> m >> k; 48 | 49 | nl.resize(n); 50 | vector> k_edge; 51 | for (int i = 0; i < m; ++i) { 52 | int x, y, v; 53 | cin >> x >> y >> v; 54 | --x, --y; 55 | nl[x].edges.emplace_back(make_pair(y, v)); 56 | nl[y].edges.emplace_back(make_pair(x, v)); 57 | if (v == k) { 58 | k_edge.emplace_back(make_pair(x, y)); 59 | } 60 | } 61 | 62 | int code = 0; 63 | visited.resize(n, false); 64 | for (int i = 0; i < n; ++i) { 65 | if (visited[i]) { 66 | continue; 67 | } 68 | int ans = dfs1(i, k, code); 69 | forest_num.emplace_back(ans); 70 | ++code; 71 | } 72 | 73 | nlf.resize(code); 74 | for (auto p : k_edge) { 75 | nlf[nl[p.first].code].edges.emplace_back(make_pair(nl[p.second].code, k)); 76 | nlf[nl[p.second].code].edges.emplace_back(make_pair(nl[p.first].code, k)); 77 | } 78 | 79 | visited.clear(); 80 | visited.resize(code, false); 81 | int ans = 0; 82 | for (int i = 0; i < code; ++i) { 83 | if (visited[i]) { 84 | continue; 85 | } 86 | int num = 0; 87 | ans += dfs2(i, num); 88 | } 89 | cout << ans; 90 | 91 | return 0; 92 | } -------------------------------------------------------------------------------- /Code/4091.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | using namespace std; 3 | 4 | class Time { 5 | public: 6 | int hour = 0, minute = 0, second = 0; 7 | 8 | Time &operator+=(const Time &t) { 9 | int jw = 0; 10 | second += t.second; 11 | if (second >= 60) { 12 | second -= 60; 13 | jw = 1; 14 | } 15 | minute += t.minute+jw; 16 | if (minute >=60) { 17 | minute -= 60; 18 | jw = 1; 19 | } 20 | else 21 | jw = 0; 22 | hour += t.hour+jw; 23 | if (hour >= 24) { 24 | hour -= 24; 25 | } 26 | return *this; 27 | } 28 | 29 | Time &operator-=(const Time &t) { 30 | int jw = 0; 31 | second -= t.second; 32 | if (second <0) { 33 | second += 60; 34 | jw = 1; 35 | } 36 | minute -= t.minute+ jw; 37 | if (minute <0) { 38 | minute += 60; 39 | jw = 1; 40 | } 41 | else 42 | jw = 0; 43 | hour -= t.hour + jw; 44 | if (hour< 0) { 45 | hour += 24; 46 | } 47 | return *this; 48 | } 49 | 50 | Time &operator++() { 51 | Time temp; 52 | temp.second = 1; 53 | *this += temp; 54 | return *this; 55 | } 56 | Time operator++(int) { 57 | Time temp, tmp; 58 | tmp = *this; 59 | temp.second = 1; 60 | *this += temp; 61 | return tmp; 62 | } 63 | 64 | Time &operator--() { 65 | Time temp; 66 | temp.second = 1; 67 | *this -= temp; 68 | return *this; 69 | } 70 | Time operator--(int) { 71 | Time temp, tmp; 72 | tmp = *this; 73 | temp.second = 1; 74 | *this -= temp; 75 | return tmp; 76 | } 77 | }; 78 | 79 | istream &operator>>(istream &input, Time &t) { 80 | input >> t.hour >> t.minute >> t.second; 81 | return input; 82 | } 83 | ostream &operator<<(ostream &output,const Time &t) { 84 | output << (t.hour<10?"0":"")<> time1 >> time2; 91 | time1 += (time2++); 92 | cout << time1 << endl; 93 | time1 -= time2; 94 | cout << time1 << endl; 95 | ++time2; 96 | cout << time2 << endl; 97 | time2 += (time1--); 98 | cout << time2 << endl; 99 | --time1; 100 | cout << time1 << endl; 101 | time2 -= time1; 102 | cout << time2 << endl; 103 | 104 | return 0; 105 | } -------------------------------------------------------------------------------- /Code/4284.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | vector> map_data; 8 | map>> ele_data; 9 | int n, sx, sy, tx, ty; 10 | 11 | int dx[] = { 0,1,0,-1 }, 12 | dy[] = { 1,0,-1,0 }; 13 | 14 | int bfs() { 15 | queue , int>> qdata; 16 | vector> visited(n, vector(n, false)); 17 | qdata.push(make_pair(make_pair(sx, sy), 0)); 18 | visited[sx][sy] = true; 19 | 20 | while (!qdata.empty()) { 21 | auto temp = qdata.front(); 22 | qdata.pop(); 23 | if (temp.first.first == tx && temp.first.second == ty) { 24 | return temp.second; 25 | } 26 | int cx = temp.first.first, cy = temp.first.second; 27 | for (int i = 0; i < 4; ++i) { 28 | int nx = temp.first.first + dx[i], ny = temp.first.second + dy[i]; 29 | if (nx < n && ny < n && nx >= 0 && ny >= 0 && !visited[nx][ny] && map_data[nx][ny] >= 0) { 30 | qdata.push(make_pair(make_pair(nx, ny), temp.second + 1)); 31 | visited[nx][ny] = true; 32 | } 33 | } 34 | if (map_data[cx][cy] > 0) { 35 | int nx, ny; 36 | if (ele_data[map_data[cx][cy]][0].first == cx && ele_data[map_data[cx][cy]][0].second == cy) { 37 | nx = ele_data[map_data[cx][cy]][1].first; 38 | ny = ele_data[map_data[cx][cy]][1].second; 39 | } 40 | else { 41 | nx = ele_data[map_data[cx][cy]][0].first; 42 | ny = ele_data[map_data[cx][cy]][0].second; 43 | } 44 | if (!visited[nx][ny]) { 45 | qdata.push(make_pair(make_pair(nx, ny), temp.second + 1)); 46 | visited[nx][ny] = true; 47 | } 48 | } 49 | } 50 | } 51 | 52 | int main() { 53 | ios::sync_with_stdio(false); 54 | cin.tie(0); 55 | cout.tie(0); 56 | cin >> n >> sx >> sy >> tx >> ty; 57 | --sx, --sy, --tx, --ty; 58 | 59 | map_data.resize(n, vector(n)); 60 | 61 | for (int i = 0; i < n; ++i) { 62 | for (int j = 0; j < n; ++j) { 63 | cin >> map_data[i][j]; 64 | if (map_data[i][j] > 0) { 65 | if (ele_data.find(map_data[i][j]) == ele_data.end()) { 66 | ele_data.insert(make_pair(map_data[i][j], vector>(1, make_pair(i, j)))); 67 | } 68 | else { 69 | ele_data[map_data[i][j]].emplace_back(make_pair(i, j)); 70 | } 71 | } 72 | } 73 | } 74 | 75 | cout << bfs(); 76 | 77 | return 0; 78 | } -------------------------------------------------------------------------------- /Code/4243.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "vector" 3 | #include "stack" 4 | using namespace std; 5 | 6 | class node { 7 | public: 8 | long long val = 0; 9 | long long parent = 0; 10 | long long num = 0; 11 | long long tag = 0; 12 | vector edges; 13 | }; 14 | 15 | long long n, m, r; 16 | 17 | long long find_parent(long long pos,vector& node_list) { 18 | long long ans = 1; 19 | for (auto p : node_list[pos].edges) { 20 | if (p != node_list[pos].parent) { 21 | node_list[p].parent = pos; 22 | ans += find_parent(p, node_list); 23 | node_list[pos].val += node_list[p].val; 24 | } 25 | } 26 | node_list[pos].num = ans; 27 | return ans; 28 | } 29 | 30 | void push_down(long long pos, vector& node_list) { 31 | stack stack_data; 32 | for (auto p = node_list[pos].parent; p; p = node_list[p].parent) { 33 | stack_data.push(p); 34 | } 35 | while (!stack_data.empty()) { 36 | auto temp = stack_data.top(); 37 | stack_data.pop(); 38 | if (node_list[temp].tag) { 39 | for (auto p : node_list[temp].edges) { 40 | if (p != node_list[temp].parent) { 41 | node_list[p].val += node_list[temp].tag * node_list[p].num; 42 | node_list[p].tag += node_list[temp].tag; 43 | } 44 | } 45 | node_list[temp].tag = 0; 46 | } 47 | } 48 | } 49 | 50 | void push_up(long long pos, long long val, vector& node_list) { 51 | for (pos = node_list[pos].parent; pos; pos = node_list[pos].parent) { 52 | node_list[pos].val += val; 53 | } 54 | } 55 | 56 | void update(long long pos, long long val,vector& node_list) { 57 | push_down(pos, node_list); 58 | node_list[pos].tag += val; 59 | node_list[pos].val += node_list[pos].num * val; 60 | push_up(pos, node_list[pos].num * val, node_list); 61 | } 62 | 63 | long long query(long long pos, vector& node_list) { 64 | push_down(pos, node_list); 65 | return node_list[pos].val; 66 | } 67 | 68 | int main() { 69 | scanf("%lld %lld %lld", &n, &m, &r); 70 | 71 | vector node_list(n + 1); 72 | for (long long i = 1; i <= n; ++i) { 73 | scanf("%lld", &node_list[i].val); 74 | } 75 | 76 | for (long long i = 1; i <= n - 1; ++i) { 77 | long long a, b; 78 | scanf("%lld %lld", &a, &b); 79 | node_list[a].edges.push_back(b); 80 | node_list[b].edges.push_back(a); 81 | } 82 | 83 | find_parent(r, node_list); 84 | 85 | for (; m > 0; --m) { 86 | long long op; 87 | scanf("%lld", &op); 88 | if (op == 1) { 89 | long long a, x; 90 | scanf("%lld %lld", &a, &x); 91 | update(a, x, node_list); 92 | } 93 | else { 94 | long long a; 95 | scanf("%lld", &a); 96 | cout << query(a, node_list) << "\n"; 97 | } 98 | } 99 | 100 | return 0; 101 | } -------------------------------------------------------------------------------- /Code/1281.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | template 7 | class my_queue { 8 | public: 9 | T queue_[50000]; 10 | int start = 0, end = 0; 11 | int mod = 50000; 12 | void clear() { 13 | start = 0; 14 | end = 0; 15 | memset(queue_, 0, sizeof(queue_)); 16 | } 17 | bool empty() const { 18 | return end - start == 0; 19 | } 20 | T front() const { 21 | return queue_[start % mod]; 22 | } 23 | void pop() { 24 | ++start; 25 | } 26 | 27 | void push(const T& val) { 28 | queue_[(end++) % mod] = val; 29 | } 30 | int size() { 31 | return end - start; 32 | } 33 | }; 34 | 35 | class position { 36 | public: 37 | int distance = 0; 38 | int pos_x = 0, pos_y = 0; 39 | 40 | position() = default; 41 | position(int dis, int x, int y) :distance(dis), pos_x(x), pos_y(y) {} 42 | }; 43 | 44 | int map_data[49][49] = { 0 }; 45 | 46 | bool visited[49][49] = { 0 }; 47 | int dx[8], dy[8]; 48 | int n, m; 49 | 50 | my_queue queue_data; 51 | int bfs(int start_x, int start_y, int end_x, int end_y) { 52 | queue_data.clear(); 53 | memset(visited, 0, sizeof(visited)); 54 | position start_point(0, start_x, start_y); 55 | queue_data.push(start_point); 56 | visited[start_x][start_y] = true; 57 | 58 | while (!queue_data.empty()) { 59 | auto temp = queue_data.front(); 60 | queue_data.pop(); 61 | 62 | if (temp.pos_x == end_x && temp.pos_y == end_y) { 63 | return temp.distance; 64 | } 65 | 66 | for (int i = 0; i < 8; ++i) { 67 | if (temp.pos_x + dx[i] >= 0 && temp.pos_x + dx[i] < m && 68 | temp.pos_y + dy[i] >= 0 && temp.pos_y + dy[i] < n && 69 | !visited[temp.pos_x + dx[i]][temp.pos_y + dy[i]] 70 | && map_data[temp.pos_x + dx[i]][temp.pos_y + dy[i]] != 0 71 | && map_data[temp.pos_x + dx[i]][temp.pos_y + dy[i]] != 2) { 72 | position next_point(temp.distance + 1, temp.pos_x + dx[i], temp.pos_y + dy[i]); 73 | queue_data.push(next_point); 74 | visited[next_point.pos_x][next_point.pos_y] = true; 75 | } 76 | } 77 | } 78 | return -1; 79 | } 80 | 81 | 82 | int main() { 83 | int m1, m2; 84 | scanf("%d %d %d %d", &m, &n, &m1, &m2); 85 | 86 | dx[0] = m1, dy[0] = m2; 87 | dx[1] = m1, dy[1] = -m2; 88 | dx[2] = -m1, dy[2] = m2; 89 | dx[3] = -m1, dy[3] = -m2; 90 | dx[4] = m2, dy[4] = m1; 91 | dx[5] = m2, dy[5] = -m1; 92 | dx[6] = -m2, dy[6] = m1; 93 | dx[7] = -m2, dy[7] = -m1; 94 | 95 | int start_x, start_y, end_x, end_y; 96 | 97 | for (int i = 0; i < m; ++i) { 98 | for (int j = 0; j < n; ++j) { 99 | scanf("%d", &map_data[i][j]); 100 | if (map_data[i][j] == 3) { 101 | start_x = i; 102 | start_y = j; 103 | } 104 | else if (map_data[i][j] == 4) { 105 | end_x = i; 106 | end_y = j; 107 | } 108 | } 109 | } 110 | 111 | cout << bfs(start_x, start_y, end_x, end_y); 112 | 113 | return 0; 114 | } -------------------------------------------------------------------------------- /Code/1008.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | using namespace std; 5 | int dayOfMonth[][13] = { {0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31} }; 6 | struct Date 7 | { 8 | int y, m, d; 9 | int leap() 10 | { 11 | return (y % 4 == 0 && y % 100 != 0 || y % 400 == 0 ? 1 : 0); 12 | } 13 | int week() 14 | { 15 | int Y = y, M = m; 16 | if (m == 1 || m == 2) 17 | { 18 | Y--; 19 | M += 12; 20 | } 21 | int W = (d + M * 2 + 3 * (M + 1) / 5 + Y + Y / 4 - Y / 100 + Y / 400) % 7; 22 | return W + 1; 23 | } 24 | Date() {} 25 | Date(int yy, int mm, int dd) { y = yy; m = mm; d = dd; } 26 | Date getNext() 27 | { 28 | Date t(y, m, d); 29 | if (d < dayOfMonth[leap()][m]) 30 | t.d += 1; 31 | else if (m < 12) 32 | { 33 | t.m += 1; 34 | t.d = 1; 35 | } 36 | else 37 | { 38 | t.y += 1; 39 | t.m = 1; 40 | t.d = 1; 41 | } 42 | return t; 43 | } 44 | 45 | bool dealDay() 46 | { 47 | if (week() == 6 || week() == 7) 48 | return false; 49 | if (m == 1 && d == 1 || m == 5 && d >= 1 && d <= 3 || m == 10 && d >= 1 && d <= 7) 50 | return false; 51 | return true; 52 | } 53 | bool isWeekend() 54 | { 55 | return week() == 6 || week() == 7; 56 | } 57 | 58 | }; 59 | bool equals(Date d1, Date d2) 60 | { 61 | return d1.y == d2.y && d1.m == d2.m && d1.d == d2.d; 62 | } 63 | 64 | int ansOfYear(int year) 65 | { 66 | bool isleap = (year % 4 == 0 && year % 100 != 0 || year % 400 == 0); 67 | int res = (isleap ? 366 : 365), t1, t2, t3 = 0, i; 68 | t1 = 104; 69 | if (isleap) 70 | { 71 | if (Date(year, 12, 30).isWeekend()) 72 | t1 += 1; 73 | if (Date(year, 12, 31).isWeekend()) 74 | t1 += 1; 75 | } 76 | else 77 | { 78 | if (Date(year, 12, 31).isWeekend()) 79 | t1 += 1; 80 | } 81 | t2 = 11; 82 | if (Date(year, 1, 1).isWeekend()) 83 | t3 += 1; 84 | for (i = 1; i < 4; i++) 85 | if (Date(year, 5, i).isWeekend()) 86 | t3 += 1; 87 | for (i = 1; i < 8; i++) 88 | if (Date(year, 10, i).isWeekend()) 89 | t3 += 1; 90 | res = res - t1 - t2 + t3; 91 | return res; 92 | } 93 | 94 | int main() 95 | { 96 | int n, res = 0, i; 97 | Date d1, d2, t; 98 | scanf("%d", &n); 99 | while (n--) 100 | { 101 | res = 0; 102 | scanf("%d-%d-%d %d-%d-%d", &d1.y, &d1.m, &d1.d, &d2.y, &d2.m, &d2.d); 103 | if (d2.y - d1.y <= 1) 104 | { 105 | for (t = d1; !equals(t, d2.getNext()); t = t.getNext()) 106 | if (t.dealDay()) 107 | res += 1; 108 | } 109 | else 110 | { 111 | for (t = d1; !equals(t, Date(d1.y + 1, 1, 1)); t = t.getNext()) 112 | if (t.dealDay()) 113 | res += 1; 114 | for (t = Date(d2.y, 1, 1); !equals(t, d2.getNext()); t = t.getNext()) 115 | if (t.dealDay()) 116 | res += 1; 117 | for (i = d1.y + 1; i < d2.y; i++) 118 | res += ansOfYear(i); 119 | } 120 | printf("%d\n", res); 121 | } 122 | return 0; 123 | } 124 | -------------------------------------------------------------------------------- /Code/4237.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | #include "cstdio" 5 | using namespace std; 6 | 7 | class node { 8 | public: 9 | //unsigned long long val=0; 10 | int left = 0, right = 0; 11 | unsigned long long tag = 0, tag_num = 0; 12 | }; 13 | 14 | node smt[800009]; 15 | unsigned long long pnum[200009] = { 0 }; 16 | 17 | void build_tree(int l, int r, int root) { 18 | smt[root].left = l; 19 | smt[root].right = r; 20 | if (l == r - 1) { 21 | return; 22 | } 23 | int mid = (l + r) >> 1; 24 | build_tree(l, mid, root * 2); 25 | build_tree(mid, r, root * 2 + 1); 26 | } 27 | 28 | void push_down(int root) { 29 | smt[root * 2].tag = (smt[root * 2].tag * pnum[smt[root].tag_num] + smt[root].tag); 30 | smt[root * 2].tag_num += smt[root].tag_num; 31 | smt[root * 2 + 1].tag = (smt[root * 2 + 1].tag * pnum[smt[root].tag_num] + smt[root].tag); 32 | smt[root * 2 + 1].tag_num += smt[root].tag_num; 33 | smt[root].tag = 0; 34 | smt[root].tag_num = 0; 35 | } 36 | 37 | void update(int l, int r, unsigned long long val, int root) { 38 | if (l <= smt[root].left && smt[root].right <= r) { 39 | smt[root].tag = smt[root].tag * (unsigned long long)257 + val; 40 | smt[root].tag_num++; 41 | return; 42 | } 43 | int mid = (smt[root].left + smt[root].right) >> 1; 44 | push_down(root); 45 | if (l < mid) { 46 | update(l, r, val, root * 2); 47 | } 48 | if (r > mid) { 49 | update(l, r, val, root * 2 + 1); 50 | } 51 | } 52 | 53 | unsigned long long query(int l, int r, int root) { 54 | if (l <= smt[root].left && smt[root].right <= r) { 55 | return smt[root].tag; 56 | } 57 | int mid = (smt[root].left + smt[root].right) >> 1; 58 | push_down(root); 59 | if (l < mid) { 60 | return query(l, r, root * 2); 61 | } 62 | if (r > mid) { 63 | return query(l, r, root * 2 + 1); 64 | } 65 | } 66 | 67 | int get_pos(int pos, int root) { 68 | if (smt[root].right - smt[root].left == 1) { 69 | return root; 70 | } 71 | int mid = (smt[root].right + smt[root].left) >> 1; 72 | if (pos < mid) 73 | return get_pos(pos, root * 2); 74 | else 75 | return get_pos(pos, root * 2 + 1); 76 | } 77 | 78 | int main() { 79 | pnum[0] = 1; 80 | for (int i = 1; i < 200000; ++i) 81 | pnum[i] = pnum[i - 1] * (unsigned long long)257; 82 | int n, m; 83 | scanf("%d %d", &n, &m); 84 | build_tree(0, n, 1); 85 | 86 | for (; m > 0; --m) { 87 | int op; 88 | scanf("%d", &op); 89 | 90 | if (op == 0) { 91 | int L, R, K; 92 | scanf("%d %d %d", &L, &R, &K); 93 | update(L - 1, R, K, 1); 94 | } 95 | else { 96 | int X, Y; 97 | scanf("%d %d", &X, &Y); 98 | auto a = query(X - 1, X, 1), b = query(Y - 1, Y, 1); 99 | if (a == b) { 100 | printf("YES\n"); 101 | auto pos1 = get_pos(X - 1, 1), pos2 = get_pos(Y - 1, 1); 102 | smt[pos1].tag = 0; 103 | smt[pos2].tag = 0; 104 | smt[pos1].tag_num = 0; 105 | smt[pos2].tag_num = 0; 106 | } 107 | else { 108 | printf("NO\n"); 109 | } 110 | } 111 | } 112 | 113 | return 0; 114 | } -------------------------------------------------------------------------------- /Code/4119.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cmath" 4 | #include "cstring" 5 | using namespace std; 6 | 7 | class edge { 8 | public: 9 | int to = 0; 10 | int length = 0; 11 | edge* next = nullptr; 12 | }; 13 | 14 | class tree_node { 15 | public: 16 | int parent = 0; 17 | int depth = 0; 18 | int dist = 0; 19 | int parent_list[16] = { 0 }; 20 | edge* head = nullptr, * rear = nullptr; 21 | }; 22 | 23 | tree_node tree_data[20009]; 24 | int root_pos = 0; 25 | 26 | void dfs(int pos) { 27 | if (pos == root_pos) { 28 | tree_data[pos].depth = 0; 29 | } 30 | else { 31 | tree_data[pos].depth = tree_data[tree_data[pos].parent].depth + 1; 32 | int k = (int)(log(tree_data[pos].depth) / log(2)); 33 | tree_data[pos].parent_list[0] = tree_data[pos].parent; 34 | for (int i = 1; i <= k; ++i) { 35 | tree_data[pos].parent_list[i] = tree_data[tree_data[pos].parent_list[i - 1]].parent_list[i - 1]; 36 | } 37 | } 38 | for (auto p = tree_data[pos].head->next; p; p = p->next) { 39 | if (p->to != tree_data[pos].parent) { 40 | tree_data[p->to].parent = pos; 41 | tree_data[p->to].dist = tree_data[pos].dist + p->length; 42 | dfs(p->to); 43 | } 44 | } 45 | } 46 | 47 | int LCA(int pos1, int pos2) { 48 | while (tree_data[pos1].depth < tree_data[pos2].depth) { 49 | int k = int(log(tree_data[pos2].depth - tree_data[pos1].depth) / log(2)); 50 | pos2 = tree_data[pos2].parent_list[k]; 51 | } 52 | while (tree_data[pos2].depth < tree_data[pos1].depth) { 53 | int k = int(log(tree_data[pos1].depth - tree_data[pos2].depth) / log(2)); 54 | pos1 = tree_data[pos1].parent_list[k]; 55 | } 56 | while (pos1 != pos2) { 57 | int k = int(log(tree_data[pos1].depth) / log(2)); 58 | for (int i = k; i >= 0; --i) { 59 | if (i == 0 || tree_data[pos1].parent_list[i] != tree_data[pos2].parent_list[i]) { 60 | pos1 = tree_data[pos1].parent_list[i]; 61 | pos2 = tree_data[pos2].parent_list[i]; 62 | } 63 | } 64 | } 65 | return pos1; 66 | } 67 | 68 | int cal_distance(int pos1, int pos2) { 69 | int lca = LCA(pos1, pos2); 70 | return tree_data[pos1].dist + tree_data[pos2].dist - 2 * tree_data[lca].dist; 71 | } 72 | 73 | int main() { 74 | ios::sync_with_stdio(false); 75 | cin.tie(0); 76 | cout.tie(0); 77 | 78 | int n, a, b, c; 79 | cin >> n >> a >> b >> c; 80 | 81 | for (int i = 1; i <= n; ++i) { 82 | tree_data[i].rear = tree_data[i].head = new edge; 83 | } 84 | 85 | for (int i = 0; i < n - 1; ++i) { 86 | int u, v, w; 87 | cin >> u >> v >> w; 88 | 89 | tree_data[u].rear->next = new edge; 90 | tree_data[u].rear = tree_data[u].rear->next; 91 | tree_data[u].rear->to = v; 92 | tree_data[u].rear->length = w; 93 | 94 | tree_data[v].rear->next = new edge; 95 | tree_data[v].rear = tree_data[v].rear->next; 96 | tree_data[v].rear->to = u; 97 | tree_data[v].rear->length = w; 98 | } 99 | 100 | root_pos = a; 101 | dfs(a); 102 | 103 | int ans_pos = LCA(b, c), ans_val = tree_data[b].dist + tree_data[c].dist - tree_data[ans_pos].dist; 104 | 105 | cout << ans_pos << "\n" << ans_val; 106 | 107 | return 0; 108 | } -------------------------------------------------------------------------------- /Code/4127.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cmath" 4 | #include "cstring" 5 | using namespace std; 6 | 7 | class edge { 8 | public: 9 | int to = 0; 10 | edge* next = nullptr; 11 | }; 12 | 13 | class tree_node { 14 | public: 15 | int parent = 0; 16 | int depth = 0; 17 | int parent_list[24] = { 0 }; 18 | edge* head = nullptr, * rear = nullptr; 19 | }; 20 | 21 | tree_node tree_data[100009]; 22 | int root_pos = 0; 23 | 24 | void dfs(int pos) { 25 | if (pos == root_pos) { 26 | tree_data[pos].depth = 0; 27 | } 28 | else { 29 | tree_data[pos].depth = tree_data[tree_data[pos].parent].depth + 1; 30 | int k = (int)(log(tree_data[pos].depth) / log(2)); 31 | tree_data[pos].parent_list[0] = tree_data[pos].parent; 32 | for (int i = 1; i <= k; ++i) { 33 | tree_data[pos].parent_list[i] = tree_data[tree_data[pos].parent_list[i - 1]].parent_list[i - 1]; 34 | } 35 | } 36 | for (auto p = tree_data[pos].head->next; p; p = p->next) { 37 | if (p->to != tree_data[pos].parent) { 38 | tree_data[p->to].parent = pos; 39 | dfs(p->to); 40 | } 41 | } 42 | } 43 | 44 | int LCA(int pos1, int pos2) { 45 | while (tree_data[pos1].depth < tree_data[pos2].depth) { 46 | int k = int(log(tree_data[pos2].depth - tree_data[pos1].depth) / log(2)); 47 | pos2 = tree_data[pos2].parent_list[k]; 48 | } 49 | while (tree_data[pos2].depth < tree_data[pos1].depth) { 50 | int k = int(log(tree_data[pos1].depth - tree_data[pos2].depth) / log(2)); 51 | pos1 = tree_data[pos1].parent_list[k]; 52 | } 53 | while (pos1 != pos2) { 54 | int k = int(log(tree_data[pos1].depth) / log(2)); 55 | for (int i = k; i >= 0; --i) { 56 | if (i == 0 || tree_data[pos1].parent_list[i] != tree_data[pos2].parent_list[i]) { 57 | pos1 = tree_data[pos1].parent_list[i]; 58 | pos2 = tree_data[pos2].parent_list[i]; 59 | } 60 | } 61 | } 62 | return pos1; 63 | } 64 | 65 | 66 | int main() { 67 | ios::sync_with_stdio(false); 68 | cin.tie(0); 69 | cout.tie(0); 70 | 71 | int n; 72 | cin >> n; 73 | 74 | for (int i = 1; i <= n; ++i) { 75 | tree_data[i].rear = tree_data[i].head = new edge; 76 | } 77 | 78 | for (int i = 0; i < n - 1; ++i) { 79 | int u, v; 80 | cin >> u >> v; 81 | 82 | tree_data[u].rear->next = new edge; 83 | tree_data[u].rear = tree_data[u].rear->next; 84 | tree_data[u].rear->to = v; 85 | 86 | tree_data[v].rear->next = new edge; 87 | tree_data[v].rear = tree_data[v].rear->next; 88 | tree_data[v].rear->to = u; 89 | } 90 | 91 | root_pos = 1; 92 | dfs(1); 93 | 94 | int q; 95 | cin >> q; 96 | 97 | for (; q > 0; --q) { 98 | int u, v, w; 99 | cin >> u >> v >> w; 100 | int lca1 = LCA(u, v), lca2 = LCA(u, w), lca3 = LCA(v, w); 101 | if (tree_data[lca1].depth < tree_data[lca2].depth) { 102 | if (tree_data[lca3].depth > tree_data[lca2].depth) { 103 | cout << lca3 << "\n"; 104 | } 105 | else { 106 | cout << lca2 << "\n"; 107 | } 108 | } 109 | else { 110 | if (tree_data[lca3].depth > tree_data[lca1].depth) { 111 | cout << lca3 << "\n"; 112 | } 113 | else { 114 | cout << lca1 << "\n"; 115 | } 116 | } 117 | } 118 | 119 | return 0; 120 | } -------------------------------------------------------------------------------- /Code/1999.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | #include "cstdio" 3 | #include "cstring" 4 | using namespace std; 5 | 6 | template 7 | class my_queue { 8 | public: 9 | T queue_[50000]; 10 | int start = 0, end = 0; 11 | int mod = 50000; 12 | void clear() { 13 | start = 0; 14 | end = 0; 15 | memset(queue_, 0, sizeof(queue_)); 16 | } 17 | bool empty() const { 18 | return end - start == 0; 19 | } 20 | T front() const { 21 | return queue_[start % mod]; 22 | } 23 | void pop() { 24 | ++start; 25 | } 26 | 27 | void push(const T& val) { 28 | queue_[(end++) % mod] = val; 29 | } 30 | int size() { 31 | return end - start; 32 | } 33 | }; 34 | 35 | class position { 36 | public: 37 | int distance = 0; 38 | int pos_x = 0, pos_y = 0; 39 | 40 | position() = default; 41 | position(int dis,int x,int y):distance(dis),pos_x(x),pos_y(y){} 42 | }; 43 | 44 | int map_data[109][109] = { 0 }; 45 | 46 | bool visited[109][109] = { 0 }; 47 | int distance_data[8][109][109] = { 0 }; 48 | 49 | int dx[] = { 0,1,0,-1 }, 50 | dy[] = { 1,0,-1,0 }; 51 | 52 | int n, m; 53 | 54 | my_queue queue_data; 55 | void bfs(int start_x, int start_y, int step) { 56 | queue_data.clear(); 57 | memset(visited, 0, sizeof(visited)); 58 | position start_point(0, start_x, start_y); 59 | queue_data.push(start_point); 60 | visited[start_x][start_y] = true; 61 | 62 | while (!queue_data.empty()) { 63 | auto temp = queue_data.front(); 64 | queue_data.pop(); 65 | distance_data[step][temp.pos_x][temp.pos_y] = temp.distance; 66 | for (int i = 0; i < 4; ++i) { 67 | if (temp.pos_x + dx[i] >= 0 && temp.pos_x + dx[i] < n && 68 | temp.pos_y + dy[i] >= 0 && temp.pos_y + dy[i] < m && 69 | !visited[temp.pos_x + dx[i]][temp.pos_y + dy[i]] 70 | && map_data[temp.pos_x + dx[i]][temp.pos_y + dy[i]] != -1) { 71 | position next_point(temp.distance + 1, temp.pos_x + dx[i], temp.pos_y + dy[i]); 72 | queue_data.push(next_point); 73 | visited[next_point.pos_x][next_point.pos_y] = true; 74 | } 75 | } 76 | } 77 | } 78 | 79 | bool dfs_visited[10] = { 0 }; 80 | int box[8][2] = { 0 }; 81 | int box_num = 0; 82 | int dfs(int step, int cur_num) { 83 | if (cur_num == box_num) 84 | return 0; 85 | dfs_visited[step] = true; 86 | int ans = 10000009; 87 | for (int i = 1; i <= box_num; ++i) { 88 | if (!dfs_visited[i]) { 89 | if (distance_data[step][box[i][0]][box[i][1]] == 0) { 90 | return -1; 91 | } 92 | int cur_ans = dfs(i, cur_num + 1); 93 | if (cur_ans < 0) 94 | return -1; 95 | cur_ans += distance_data[step][box[i][0]][box[i][1]]; 96 | ans = cur_ans < ans ? cur_ans : ans; 97 | } 98 | } 99 | dfs_visited[step] = false; 100 | return ans; 101 | } 102 | 103 | int main() { 104 | scanf("%d %d", &n, &m); 105 | 106 | int start_x = 0, start_y = 0; 107 | 108 | 109 | for (int i = 0; i < n; ++i) { 110 | for (int j = 0; j < m; ++j) { 111 | scanf("%d", &map_data[i][j]); 112 | if (map_data[i][j] == 2) { 113 | start_x = i; 114 | start_y = j; 115 | } 116 | else if (map_data[i][j] == 1) { 117 | box[box_num + 1][0] = i; 118 | box[box_num + 1][1] = j; 119 | ++box_num; 120 | } 121 | } 122 | } 123 | 124 | bfs(start_x, start_y, 0); 125 | for (int i = 1; i <= box_num; ++i) 126 | bfs(box[i][0], box[i][1], i); 127 | 128 | cout << dfs(0, 0); 129 | 130 | return 0; 131 | } -------------------------------------------------------------------------------- /DataStructure/列表.cpp: -------------------------------------------------------------------------------- 1 | // By ligongzzz 2 | 3 | #include "iostream" 4 | #include "list" 5 | using namespace std; 6 | 7 | template 8 | class mList 9 | { 10 | class node 11 | { 12 | public: 13 | T val; 14 | node* next = nullptr; 15 | node* last = nullptr; 16 | }; 17 | node* head = nullptr; 18 | node* rear = nullptr; 19 | size_t _size = 0; 20 | void clear() 21 | { 22 | for (auto p = head; p;) 23 | { 24 | auto temp = p->next; 25 | delete p; 26 | p = temp; 27 | } 28 | _size = 0; 29 | } 30 | void create_new() 31 | { 32 | head = new node; 33 | rear = new node; 34 | head->next = rear; 35 | rear->last = head; 36 | _size = 0; 37 | } 38 | 39 | public: 40 | mList() 41 | { 42 | create_new(); 43 | } 44 | ~mList() 45 | { 46 | clear(); 47 | } 48 | mList(const mList& other) 49 | { 50 | if (&other == this) 51 | return; 52 | 53 | clear(); 54 | head = new node; 55 | 56 | auto p1 = head; 57 | for (auto p2 = other.head; p2->next; p1 = p1->next, p2 = p2->next) 58 | { 59 | p1->next = new node; 60 | p1->next->val = p2->next->val; 61 | p1->next->last = p1; 62 | } 63 | rear = p1; 64 | } 65 | 66 | void push_back(const T& val) 67 | { 68 | rear->val = val; 69 | rear->next = new node; 70 | rear->next->last = rear; 71 | rear = rear->next; 72 | ++_size; 73 | } 74 | 75 | void pop_back() 76 | { 77 | if (_size <= 0) 78 | return; 79 | rear->last = rear->last->last; 80 | delete rear->last->next; 81 | rear->last->next = rear; 82 | --_size; 83 | } 84 | 85 | void push_front(const T& val) 86 | { 87 | head->val = val; 88 | head->last = new node; 89 | head->last->next = head; 90 | head = head->last; 91 | ++_size; 92 | } 93 | 94 | void pop_front() 95 | { 96 | if (_size <= 0) 97 | return; 98 | head->next = head->next->next; 99 | delete head->next->last; 100 | head->next->last = head; 101 | --_size; 102 | } 103 | 104 | size_t size() 105 | { 106 | return _size; 107 | } 108 | 109 | bool empty() 110 | { 111 | return _size <= 0; 112 | } 113 | 114 | class iterator 115 | { 116 | public: 117 | node* pos = nullptr; 118 | iterator& operator++() 119 | { 120 | if (pos->next) 121 | pos = pos->next; 122 | return *this; 123 | } 124 | iterator operator++(int) 125 | { 126 | auto temp = *this; 127 | if (pos->next) 128 | pos = pos->next; 129 | return temp; 130 | } 131 | iterator& operator--() 132 | { 133 | if (pos->last) 134 | pos = pos->last; 135 | return *this; 136 | } 137 | iterator operator--(int) 138 | { 139 | auto temp = *this; 140 | if (pos->last) 141 | pos = pos->last; 142 | return temp; 143 | } 144 | T& operator*() 145 | { 146 | return pos->val; 147 | } 148 | bool operator==(const iterator& other) 149 | { 150 | return pos == other.pos; 151 | } 152 | bool operator!=(const iterator& other) 153 | { 154 | return pos != other.pos; 155 | } 156 | }; 157 | 158 | iterator begin() 159 | { 160 | iterator result; 161 | result.pos = head->next; 162 | return result; 163 | } 164 | 165 | iterator end() 166 | { 167 | iterator result; 168 | result.pos = rear; 169 | return result; 170 | } 171 | 172 | class reverse_iterator 173 | { 174 | public: 175 | node* pos = nullptr; 176 | 177 | iterator base() 178 | { 179 | iterator result; 180 | result.pos = pos; 181 | return result; 182 | } 183 | reverse_iterator& operator++() 184 | { 185 | if (pos->last) 186 | pos = pos->last; 187 | return *this; 188 | } 189 | reverse_iterator operator++(int) 190 | { 191 | auto temp = *this; 192 | if (pos->last) 193 | pos = pos->last; 194 | return temp; 195 | } 196 | reverse_iterator& operator--() 197 | { 198 | if (pos->next) 199 | pos = pos->next; 200 | return *this; 201 | } 202 | reverse_iterator operator--(int) 203 | { 204 | auto temp = *this; 205 | if (pos->next) 206 | pos = pos->next; 207 | return temp; 208 | } 209 | T& operator*() 210 | { 211 | return pos->val; 212 | } 213 | bool operator==(const reverse_iterator& other) 214 | { 215 | return pos == other.pos; 216 | } 217 | bool operator!=(const reverse_iterator& other) 218 | { 219 | return pos != other.pos; 220 | } 221 | }; 222 | 223 | reverse_iterator rbegin() 224 | { 225 | reverse_iterator result; 226 | result.pos = rear->last; 227 | return result; 228 | } 229 | 230 | reverse_iterator rend() 231 | { 232 | reverse_iterator result; 233 | result.pos = head; 234 | return result; 235 | } 236 | 237 | void insert(const iterator& pos, const T& val) 238 | { 239 | auto temp = new node; 240 | temp->val = val; 241 | temp->next = pos.pos->next; 242 | temp->next->last = temp; 243 | pos.pos->next = temp; 244 | temp->last = pos.pos; 245 | ++_size; 246 | } 247 | 248 | void erase(const iterator& pos) 249 | { 250 | pos.pos->next->last = pos.pos->last; 251 | pos.pos->last->next = pos.pos->next; 252 | delete pos.pos; 253 | --_size; 254 | } 255 | void erase(const iterator& from, const iterator& to) 256 | { 257 | from.pos->last->next = to.pos; 258 | to.pos->last = from.pos; 259 | for (auto p = from.pos; p != to.pos;) 260 | { 261 | auto temp = p->next; 262 | delete p; 263 | p = temp; 264 | } 265 | } 266 | }; 267 | --------------------------------------------------------------------------------