File size: 143,147 Bytes
3669989 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 |
[
{
"id": 1,
"name": "answer_A01",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\tint N;\n\tcin >> N; // 入力\n\tcout << N * N << endl; // 出力\n\treturn 0;\n}\n",
"Python": "N = int(input()) # 入力\nprint(N * N) # 出力\n"
},
{
"id": 2,
"name": "answer_A02",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, X, A[109];\nbool Answer = false;\n\nint main() {\n\t// 入力\n\tcin >> N >> X;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 全探索（変数 Answer は「既に x が見つかったかどうか」を表す）\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (A[i] == X) Answer = true;\n\t}\n\n\t// 出力\n\tif (Answer == true) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, X = map(int, input().split())\nA = list(map(int, input().split()))\nAnswer = False\n\n# 全探索（変数 Answer は「既に x が見つかったかどうか」を表す）\nfor i in range(N):\n\tif A[i] == X:\n\t\tAnswer = True\n\n# 出力\nif Answer == True:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
},
{
"id": 3,
"name": "answer_A03",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, K;\nint P[109], Q[109];\nbool Answer = false;\n\nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int i = 1; i <= N; i++) cin >> P[i];\n\tfor (int i = 1; i <= N; i++) cin >> Q[i];\n\n\t// 全探索（Answer は「合計が K になる選び方が見つかったか」を示す）\n\tfor (int x = 1; x <= N; x++) {\n\t\tfor (int y = 1; y <= N; y++) {\n\t\t\tif (P[x] + Q[y] == K) Answer = true;\n\t\t}\n\t}\n\n\t// 出力\n\tif (Answer == true) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, K = map(int, input().split())\nP = list(map(int, input().split()))\nQ = list(map(int, input().split()))\nAnswer = False\n\n# 全探索（Answer は「合計が K になる選び方が見つかったか」を示す）\nfor x in range(N):\n\tfor y in range(N):\n\t\tif P[x] + Q[y] == K:\n\t\t\tAnswer = True\n\n# 出力\nif Answer == True:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
},
{
"id": 4,
"name": "answer_A04",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tint N;\n\tcin >> N;\n\n\t// 上の桁から順番に「2 進法に変換した値」を求める\n\tfor (int x = 9; x >= 0; x--) {\n\t\tint wari = (1 << x); // 2 の x 乗\n\t\tcout << (N / wari) % 2; // 割り算の結果に応じて 0 または 1 を出力\n\t}\n\tcout << endl; // 最後に改行する\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\n\n# 上の桁から順番に「2 進法に変換した値」を求める\nfor x in [9,8,7,6,5,4,3,2,1,0]:\n\twari = (2 ** x)\n\tprint((N // wari) % 2, end='')\n\n# 最後に改行する\nprint(\"\")\n"
},
{
"id": 5,
"name": "answer_A05",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tint N, K, Answer = 0;\n\tcin >> N >> K;\n\n\t// 全探索\n\tfor (int x = 1; x <= N; x++) {\n\t\tfor (int y = 1; y <= N; y++) {\n\t\t\tint z = K - x - y; // 白いカードに書かれるべき整数\n\t\t\tif (z >= 1 && z <= N) Answer += 1;\n\t\t}\n\t}\n\n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, K = map(int, input().split())\nAnswer = 0\n\n# 全探索\nfor x in range(1, N+1):\n\tfor y in range(1, N+1):\n\t\tz = K - x - y\n\t\tif z >= 1 and z <= N:\n\t\t\tAnswer += 1\n\n# 出力\nprint(Answer)\n"
},
{
"id": 6,
"name": "answer_A06",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, A[100009], S[100009];\nint Q, L[100009], R[100009];\n\nint main() {\n\t// 入力\n\tcin >> N >> Q;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tfor (int j = 1; j <= Q; j++) cin >> L[j] >> R[j];\n\n\t// 累積和の計算\n\tS[0] = 0;\n\tfor (int i = 1; i <= N; i++) S[i] = S[i - 1] + A[i];\n\n\t// 質問に答える\n\tfor (int j = 1; j <= Q; j++) {\n\t\tcout << S[R[j]] - S[L[j] - 1] << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "N, Q = map(int, input().split())\nA = list(map(int, input().split()))\nL = [ None ] * Q\nR = [ None ] * Q\nfor j in range(Q):\n\tL[j], R[j] = map(int, input().split())\n \nS = [ None ] * (N + 1)\nS[0] = 0\nfor i in range(N):\n\tS[i + 1] = S[i] + A[i]\n \nfor j in range(Q):\n\tprint(S[R[j]] - S[L[j] - 1])\n"
},
{
"id": 7,
"name": "answer_A07",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, L[100009], R[100009];\nint D, B[100009];\nint Answer[100009];\n\nint main() {\n\t// 入力\n\tcin >> D >> N;\n\tfor (int i = 1; i <= N; i++) cin >> L[i] >> R[i];\n\n\t// 前日比に加算\n\tfor (int i = 1; i <= N; i++) {\n\t\tB[L[i]] += 1;\n\t\tB[R[i] + 1] -= 1;\n\t}\n\n\t// 累積和をとる → 出力\n\tAnswer[0] = 0;\n\tfor (int d = 1; d <= D; d++) Answer[d] = Answer[d - 1] + B[d];\n\tfor (int d = 1; d <= D; d++) cout << Answer[d] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nD = int(input())\nN = int(input())\nL = [ None ] * N\nR = [ None ] * N\nfor i in range(N):\n\tL[i], R[i] = map(int, input().split())\n\n# 前日比に加算\nB = [ 0 ] * (D+2)\nfor i in range(N):\n\tB[L[i]] += 1\n\tB[R[i]+1] -= 1\n\n# 累積和をとる\nAnswer = [ None ] * (D+2)\nAnswer[0] = 0\nfor d in range(1, D+1):\n\tAnswer[d] = Answer[d - 1] + B[d]\n\n# 出力\nfor d in range(1, D+1):\n\tprint(Answer[d])\n"
},
{
"id": 8,
"name": "answer_A08",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint H, W, Q;\nint X[1509][1509], Z[1509][1509];\nint A[100009], B[100009], C[100009], D[100009];\n\nint main() {\n\t// 入力\n\tcin >> H >> W;\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) cin >> X[i][j];\n\t}\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> A[i] >> B[i] >> C[i] >> D[i];\n\n\t// 配列 Z の初期化\n\tfor (int i = 0; i <= H; i++) {\n\t\tfor (int j = 0; j <= W; j++) Z[i][j] = 0;\n\t}\n\n\t// 横方向に累積和をとる\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) Z[i][j] = Z[i][j - 1] + X[i][j];\n\t}\n\n\t// 縦方向に累積和をとる\n\tfor (int j = 1; j <= W; j++) {\n\t\tfor (int i = 1; i <= H; i++) Z[i][j] = Z[i - 1][j] + Z[i][j];\n\t}\n\n\t// 答えを求める\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcout << Z[C[i]][D[i]] + Z[A[i] - 1][B[i] - 1] - Z[A[i] - 1][D[i]] - Z[C[i]][B[i] - 1] << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力（前半）\nH, W = map(int, input().split())\nX = [ None ] * (H)\nZ = [ [ 0 ] * (W + 1) for i in range(H + 1) ]\nfor i in range(H):\n\tX[i] = list(map(int, input().split()))\n\n# 入力（後半）\nQ = int(input())\nA = [ None ] * Q\nB = [ None ] * Q\nC = [ None ] * Q\nD = [ None ] * Q\nfor i in range(Q):\n\tA[i], B[i], C[i], D[i] = map(int, input().split())\n\n# 配列 Z は既に初期化済み\n# 横方向に累積和をとる\n# X[i-1][j-1] などになっているのは、配列が 0 番目から始まるため\nfor i in range(1, H+1):\n\tfor j in range(1, W+1):\n\t\tZ[i][j] = Z[i][j-1] + X[i-1][j-1]\n\n# 縦方向に累積和をとる\nfor j in range(1, W+1):\n\tfor i in range(1, H+1):\n\t\tZ[i][j] = Z[i-1][j] + Z[i][j]\n\n# 答えを求める\nfor i in range(Q):\n\tprint(Z[C[i]][D[i]] + Z[A[i]-1][B[i]-1] - Z[A[i]-1][D[i]] - Z[C[i]][B[i]-1])\n"
},
{
"id": 9,
"name": "answer_A09",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint H, W, N;\nint A[100009], B[100009], C[100009], D[100009];\nint X[1509][1509], Z[1509][1509];\n\nint main() {\n\t// 入力\n\tcin >> H >> W >> N;\n\tfor (int t = 1; t <= N; t++) cin >> A[t] >> B[t] >> C[t] >> D[t];\n\n\t// 各日について加算\n\tfor (int t = 1; t <= N; t++) {\n\t\tX[A[t]][B[t]] += 1;\n\t\tX[A[t]][D[t] + 1] -= 1;\n\t\tX[C[t] + 1][B[t]] -= 1;\n\t\tX[C[t] + 1][D[t] + 1] += 1;\n\t}\n\n\t// 二次元累積和をとる\n\tfor (int i = 0; i <= H; i++) {\n\t\tfor (int j = 0; j <= W; j++) Z[i][j] = 0;\n\t}\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) Z[i][j] = Z[i][j - 1] + X[i][j];\n\t}\n\tfor (int j = 1; j <= W; j++) {\n\t\tfor (int i = 1; i <= H; i++) Z[i][j] = Z[i - 1][j] + Z[i][j];\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) {\n\t\t\tif (j >= 2) cout << \" \";\n\t\t\tcout << Z[i][j];\n\t\t}\n\t\tcout << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nH, W, N = map(int, input().split())\nA = [ None ] * N\nB = [ None ] * N\nC = [ None ] * N\nD = [ None ] * N\nX = [ None ] * (W)\nfor t in range(N):\n\tA[t], B[t], C[t], D[t] = map(int, input().split())\n\n# 各日について加算\nX = [ [ 0 ] * (W + 2) for i in range(H + 2) ]\nZ = [ [ 0 ] * (W + 2) for i in range(H + 2) ]\nfor t in range(N):\n X[A[t]][B[t]] += 1\n X[A[t]][D[t]+1] -= 1\n X[C[t]+1][B[t]] -= 1\n X[C[t]+1][D[t]+1] += 1\n\n# 二次元累積和をとる\nfor i in range(1, H+1):\n\tfor j in range(1, W+1):\n\t\tZ[i][j] = Z[i][j-1] + X[i][j]\nfor j in range(1, W+1):\n\tfor i in range(1, H+1):\n\t\tZ[i][j] = Z[i-1][j] + Z[i][j]\n\n# 出力\nfor i in range(1, H+1):\n\tfor j in range(1, W+1):\n\t\tif j >= 2:\n\t\t\tprint(\" \", end=\"\")\n\t\tprint(Z[i][j], end=\"\")\n\tprint(\"\")\n"
},
{
"id": 10,
"name": "answer_A10",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[100009], P[100009], Q[100009];\nint D, L[100009], R[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tcin >> D;\n\tfor (int d = 1; d <= D; d++) cin >> L[d] >> R[d];\n\n\t// P[i] を求める\n\tP[1] = A[1];\n\tfor (int i = 2; i <= N; i++) P[i] = max(P[i - 1], A[i]);\n\n\t// Q[i] を求める\n\tQ[N] = A[N];\n\tfor (int i = N - 1; i >= 1; i--) Q[i] = max(Q[i + 1], A[i]);\n\n\t// それぞれの日について答えを求める\n\tfor (int d = 1; d <= D; d++) {\n\t\tcout << max(P[L[d] - 1], Q[R[d] + 1]) << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\nD = int(input())\nL = [ None ] * D\nR = [ None ] * D\nfor d in range(D):\n\tL[d], R[d] = map(int, input().split())\n\n# P[i] を求める\n# P[0] などになっているのは、配列が 0 始まりであるため\nP = [ None ] * N\nP[0] = A[0]\nfor i in range(1, N):\n\tP[i] = max(P[i-1], A[i])\n\n# Q[i] を求める\n# Q[N-1] などになっているのは、配列が 0 始まりであるため\nQ = [ None ] * N\nQ[N-1] = A[N-1]\nfor i in reversed(range(0,N-1)):\n\tQ[i] = max(Q[i+1], A[i])\n\n# それぞれの日について答えを求める\n# (L[d]-1)-1 などになっているのは、配列が 0 始まりであるため\nfor d in range(D):\n\tprint(max(P[(L[d]-1)-1], Q[(R[d]+1)-1]))\n"
},
{
"id": 11,
"name": "answer_A11",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, X, A[100009];\n\n// 整数 x が何番目に存在するかを返す\nint search(int x) {\n\tint L = 1, R = N;\n\twhile (L <= R) { // 探索範囲がなくなるまで、比較を続ける\n\t\tint M = (L + R) / 2;\n\t\tif (x < A[M]) R = M - 1;\n\t\tif (x == A[M]) return M;\n\t\tif (x > A[M]) L = M + 1;\n\t}\n\treturn -1; // 整数 x が存在しない（注：この問題の制約で -1 が返されることはない）\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> X;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 二分探索を行う\n\tint Answer = search(X);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 整数 x が何番目に存在するかを返す関数\ndef search(x, A):\n\tL = 0\n\tR = N-1\n\twhile L <= R:\n\t\tM = (L + R) // 2\n\t\tif x < A[M]:\n\t\t\tR = M - 1\n\t\tif x == A[M]:\n\t\t\treturn M\n\t\tif x > A[M]:\n\t\t\tL = M + 1\n\treturn -1 # 整数 x が存在しない（注：この問題の制約で -1 が返されることはない）\n\n\n# 入力（配列 X が 0 番目から始まることに注意）\nN, X = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 二分探索を行う（配列が 0 番目から始まるので、答えに 1 を足している）\nAnswer = search(X, A)\nprint(Answer + 1)\n"
},
{
"id": 12,
"name": "answer_A12",
"Cpp": "#include <iostream>\nusing namespace std;\n\nlong long N, K;\nlong long A[100009];\n\n// 答えが x 以下かを判定し、Yes であれば true、No であれば false を返す\nbool check(long long x) {\n\tlong long sum = 0;\n\tfor (int i = 1; i <= N; i++) sum += x / A[i]; //「x ÷ A[i]」の小数点以下切り捨て\n\tif (sum >= K) return true;\n\treturn false;\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 二分探索\n\t// Left は探索範囲の左端を、Right は探索範囲の右端を表す\n\tlong long Left = 1, Right = 1'000'000'000;\n\twhile (Left < Right) {\n\t\tlong long Mid = (Left + Right) / 2;\n\t\tbool Answer = check(Mid);\n\t\tif (Answer == false) Left = Mid + 1; // 答えが Mid+1 以上であることが分かる\n\t\tif (Answer == true) Right = Mid; // 答えが Mid 以下であることが分かる\n\t}\n\n\t// 出力（このとき Left=Right になっている）\n\tcout << Left << endl;\n\treturn 0;\n}\n",
"Python": "# 答えが x 以下かを判定し、Yes であれば true、No であれば false を返す関数\ndef check(x, N, K, A):\n\tsum = 0\n\tfor i in range(N):\n\t\tsum += x // A[i] # 「x÷A[i]」の小数点以下切り捨て\n\n\tif sum >= K:\n\t\treturn True\n\treturn False\n\n# 入力\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 二分探索\n# Left は探索範囲の左端を、Right は探索範囲の右端を表す\nLeft = 1\nRight = 10 ** 9\nwhile Left < Right:\n\tMid = (Left + Right) // 2\n\tAnswer = check(Mid, N, K, A)\n\n\tif Answer == False:\n\t\tLeft = Mid + 1 # 答えが Mid+1 以上であることが分かる\n\tif Answer == True:\n\t\tRight = Mid # 答えが Mid 以下であることが分かる\n\n# 出力（このとき Left=Right になっている）\nprint(Left)\n"
},
{
"id": 13,
"name": "answer_A13",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, K;\nint A[100009], R[100009];\n\nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// しゃくとり法\n\tfor (int i = 1; i <= N - 1; i++) {\n\t\t// スタート地点を決める\n\t\tif (i == 1) R[i] = 1;\n\t\telse R[i] = R[i - 1];\n\n\t\t// ギリギリまで増やしていく\n\t\twhile (R[i] < N && A[R[i] + 1] - A[i] <= K) {\n\t\t\tR[i] += 1;\n\t\t}\n\t}\n\n\t// 出力（答えは最大 50 億程度になるので long long 型を使う必要があります）\n\tlong long Answer = 0;\n\tfor (int i = 1; i <= N - 1; i++) Answer += (R[i] - i);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（A は 0 番目から始まることに注意）\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 配列の準備（R は 0 番目から始まることに注意）\nR = [ None ] * N\n\n# しゃくとり法\nfor i in range(0, N-1):\n\t# スタート地点を決める\n\tif i == 0:\n\t\tR[i] = 0\n\telse:\n\t\tR[i] = R[i - 1]\n\n\t# ギリギリまで増やしていく\n\twhile R[i] < N-1 and A[R[i]+1]-A[i] <= K:\n\t\tR[i] += 1\n\n# 出力\nAnswer = 0\nfor i in range(0, N-1):\n\tAnswer += (R[i] - i)\nprint(Answer)\n"
},
{
"id": 14,
"name": "answer_A14",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, K, A[1009], B[1009], C[1009], D[1009];\nint P[1000009], Q[1000009];\n\nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int x = 1; x <= N; x++) cin >> A[x];\n\tfor (int y = 1; y <= N; y++) cin >> B[y];\n\tfor (int z = 1; z <= N; z++) cin >> C[z];\n\tfor (int w = 1; w <= N; w++) cin >> D[w];\n\n\t// 配列 P を作成\n\tfor (int x = 1; x <= N; x++) {\n\t\tfor (int y = 1; y <= N; y++) P[(x - 1) * N + y] = A[x] + B[y];\n\t}\n\n\t// 配列 Q を作成\n\tfor (int z = 1; z <= N; z++) {\n\t\tfor (int w = 1; w <= N; w++) Q[(z - 1) * N + w] = C[z] + D[w];\n\t}\n\t// 配列 Q を小さい順にソート\n\tsort(Q + 1, Q + (N * N) + 1);\n\n\t// 二分探索\n\tfor (int i = 1; i <= N * N; i++) {\n\t\tint pos1 = lower_bound(Q + 1, Q + (N * N) + 1, K - P[i]) - Q;\n\t\tif (pos1 <= N * N && Q[pos1] == K - P[i]) {\n\t\t\tcout << \"Yes\" << endl;\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t// 見つからなかった場合\n\tcout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "import bisect\nimport sys\n\n# 入力\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\nC = list(map(int, input().split()))\nD = list(map(int, input().split()))\n\n# 配列 P を作成\nP = []\nfor x in range(N):\n\tfor y in range(N):\n\t\tP.append(A[x] + B[y])\n\n# 配列 Q を作成\nQ = []\nfor z in range(N):\n\tfor w in range(N):\n\t\tQ.append(C[z] + D[w])\n\n# 配列 Q を小さい順にソート\nQ.sort()\n\n# 二分探索\nfor i in range(len(P)):\n\tpos1 = bisect.bisect_left(Q, K-P[i])\n\tif pos1<N*N and Q[pos1]==K-P[i]:\n\t\tprint(\"Yes\")\n\t\tsys.exit(0)\n\n# 見つからなかった場合\nprint(\"No\")\n"
},
{
"id": 15,
"name": "answer_A15",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tint N, A[100009], B[100009];\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 配列 T の作成\n\tvector<int> T;\n\tfor (int i = 1; i <= N; i++) T.push_back(A[i]);\n\tsort(T.begin(), T.end());\n\n\t// 配列 T の重複を消す\n\t// erase 関数・unique 関数は本書の範囲外ですが、ぜひ調べておきましょう\n\tT.erase(unique(T.begin(), T.end()), T.end());\n\n\t// 答えを求める\n\tfor (int i = 1; i <= N; i++) {\n\t\t// vector 型の lower_bound は以下のような形式で書く\n\t\t// vector 型の添字は 0 番目から始まるので、1 を足す必要があることに注意\n\t\tB[i] = lower_bound(T.begin(), T.end(), A[i]) - T.begin();\n\t\tB[i] += 1;\n\t}\n\n\t// 答えを空白区切りで出力\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (i >= 2) cout << \" \";\n\t\tcout << B[i];\n\t}\n\tcout << endl;\n\treturn 0;\n}\n",
"Python": "import bisect\n\n# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# 配列 T の作成（重複も消す）\nT = list(set(A))\nT.sort()\n\n# 答えを求める\nB = [ None ] * N\nfor i in range(N):\n\tB[i] = bisect.bisect_left(T, A[i])\n\tB[i] += 1\n\n# 答えを空白区切りで出力\nAnswer = [str(i) for i in B]\nprint(\" \".join(Answer))\n"
},
{
"id": 16,
"name": "answer_A16",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[100009], B[100009];\nint dp[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 2; i <= N; i++) cin >> A[i];\n\tfor (int i = 3; i <= N; i++) cin >> B[i];\n\n\t// 動的計画法\n\tdp[1] = 0;\n\tdp[2] = A[2];\n\tfor (int i = 3; i <= N; i++) {\n\t\tdp[i] = min(dp[i - 1] + A[i], dp[i - 2] + B[i]);\n\t}\n\n\t// 出力\n\tcout << dp[N] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（A, B が 0 番目から始まっていることに注意）\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n# 動的計画法\ndp = [ None ] * (N+1)\ndp[1] = 0\ndp[2] = A[0]\nfor i in range(3, N+1):\n\tdp[i] = min(dp[i-1]+A[i-2], dp[i-2]+B[i-3])\n\n# 出力\nprint(dp[N])\n"
},
{
"id": 17,
"name": "answer_A17",
"Cpp": "#include <iostream>\n#include <vector> \n#include <algorithm>\nusing namespace std;\n\nint N, A[100009], B[100009], dp[100009];\nvector<int> Answer;\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 2; i <= N; i++) cin >> A[i];\n\tfor (int i = 3; i <= N; i++) cin >> B[i];\n\n\t// 動的計画法\n\tdp[1] = 0;\n\tdp[2] = A[2];\n\tfor (int i = 3; i <= N; i++) dp[i] = min(dp[i - 1] + A[i], dp[i - 2] + B[i]);\n\n\t// 答えの復元\n\t// 変数 Place は現在位置（ゴールから進んでいく）\n\t// たとえば入力例の場合、Place は 5 → 4 → 2 → 1 と変化していく\n\tint Place = N;\n\twhile (true) {\n\t\tAnswer.push_back(Place);\n\t\tif (Place == 1) break;\n\n\t\t// どこから部屋 Place に向かうのが最適かを求める\n\t\tif (dp[Place - 1] + A[Place] == dp[Place]) Place = Place - 1;\n\t\telse Place = Place - 2;\n\t}\n\n\t// 変数 Answer は「ゴールからの経路」になっているので、逆順にする\n\t// たとえば入力例の場合、Answer = {5, 4, 2, 1} を {1, 2, 4, 5} にする\n\treverse(Answer.begin(), Answer.end());\n\n\t// 答えを出力\n\tcout << Answer.size() << endl;\n\tfor (int i = 0; i < Answer.size(); i++) {\n\t\tif (i >= 1) cout << \" \";\n\t\tcout << Answer[i];\n\t}\n\tcout << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（A, B が 0 番目から始まっていることに注意）\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n# 動的計画法\ndp = [ None ] * (N+1)\ndp[1] = 0\ndp[2] = A[0]\nfor i in range(3, N+1):\n\tdp[i] = min(dp[i-1]+A[i-2], dp[i-2]+B[i-3])\n\n# 答えの復元\n# 変数 Place は現在位置（ゴールから進んでいく）\n# たとえば入力例の場合、Place は 5 → 4 → 2 → 1 と変化していく\nAnswer = []\nPlace = N\nwhile True:\n\tAnswer.append(Place)\n\tif Place == 1:\n\t\tbreak\n\n\t# どこから部屋 Place に向かうのが最適かを求める\n\tif dp[Place-1] + A[Place-2] == dp[Place]:\n\t\tPlace = Place - 1\n\telse:\n\t\tPlace = Place - 2\nAnswer.reverse()\n\n# 答えを出力\nAnswer2 = [str(i) for i in Answer]\nprint(len(Answer))\nprint(\" \".join(Answer2))\n"
},
{
"id": 18,
"name": "answer_A18",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, S, A[69];\nbool dp[69][10009];\n\nint main() {\n\t// 入力\n\tcin >> N >> S;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 動的計画法 (i = 0)\n\tdp[0][0] = true;\n\tfor (int i = 1; i <= S; i++) dp[0][i] = false;\n\n\t// 動的計画法 (i >= 1)\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 0; j <= S; j++) {\n\t\t\tif (j < A[i]) {\n\t\t\t\tif (dp[i - 1][j] == true) dp[i][j] = true;\n\t\t\t\telse dp[i][j] = false;\n\t\t\t}\n\t\t\tif (j >= A[i]) {\n\t\t\t\tif (dp[i - 1][j] == true || dp[i - 1][j - A[i]] == true) dp[i][j] = true;\n\t\t\t\telse dp[i][j] = false;\n\t\t\t}\n\t\t}\n\t}\n\n\t// 出力\n\tif (dp[N][S] == true) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, S = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 動的計画法（i=0）\ndp = [ [ None ] * (S + 1) for i in range(N + 1) ]\ndp[0][0] = True\nfor i in range(1, S+1):\n\tdp[0][i] = False\n\n# 動的計画法（i=1）\nfor i in range(1, N+1):\n\tfor j in range(0,S+1):\n\t\tif j < A[i-1]:\n\t\t\tif dp[i-1][j] == True:\n\t\t\t\tdp[i][j] = True\n\t\t\telse:\n\t\t\t\tdp[i][j] = False\n\n\t\tif j >= A[i-1]:\n\t\t\tif dp[i-1][j] == True or dp[i-1][j-A[i-1]] == True:\n\t\t\t\tdp[i][j] = True\n\t\t\telse:\n\t\t\t\tdp[i][j] = False\n\n# 出力\nif dp[N][S] == True:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
},
{
"id": 19,
"name": "answer_A19",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nlong long N, W, w[109], v[109];\nlong long dp[109][100009];\n\nint main() {\n\t// 入力・配列の初期化\n\tcin >> N >> W;\n\tfor (int i = 1; i <= N; i++) cin >> w[i] >> v[i];\n\tfor (int i = 0; i <= N; i++) {\n\t\tfor (int j = 0; j <= W; j++) dp[i][j] = -1'000'000'000'000'000LL;\n\t}\n\n\t// 動的計画法\n\tdp[0][0] = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 0; j <= W; j++) {\n\t\t\tif (j < w[i]) dp[i][j] = dp[i - 1][j];\n\t\t\telse dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);\n\t\t}\n\t}\n\n\t// 答えの出力\n\tlong long Answer = 0;\n\tfor (int i = 0; i <= W; i++) Answer = max(Answer, dp[N][i]);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, W = map(int, input().split())\nw = [ None ] * (N + 1)\nv = [ None ] * (N + 1)\nfor i in range(1, N+1):\n\tw[i], v[i] = map(int, input().split())\n\n# 動的計画法\ndp = [ [ -10 ** 15 ] * (W + 1) for i in range(N + 1) ]\ndp[0][0] = 0\nfor i in range(1, N+1):\n\tfor j in range(0,W+1):\n\t\tif j < w[i]:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\tif j >= w[i]:\n\t\t\tdp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])\n\n# 出力\nprint(max(dp[N]))\n"
},
{
"id": 20,
"name": "answer_A20",
"Cpp": "#include <iostream>\n#include <string>\n#include <algorithm>\nusing namespace std;\n\nint N, M, dp[2009][2009];\nstring S, T;\n\nint main() {\n\t// 入力\n\tcin >> S; N = S.size();\n\tcin >> T; M = T.size();\n\n\t// 動的計画法\n\tdp[0][0] = 0;\n\tfor (int i = 0; i <= N; i++) {\n\t\tfor (int j = 0; j <= M; j++) {\n\t\t\tif (i >= 1 && j >= 1 && S[i - 1] == T[j - 1]) {\n\t\t\t\tdp[i][j] = max({ dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1] + 1 });\n\t\t\t}\n\t\t\telse if (i >= 1 && j >= 1) {\n\t\t\t\tdp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);\n\t\t\t}\n\t\t\telse if (i >= 1) {\n\t\t\t\tdp[i][j] = dp[i - 1][j];\n\t\t\t}\n\t\t\telse if (j >= 1) {\n\t\t\t\tdp[i][j] = dp[i][j - 1];\n\t\t\t}\n\t\t}\n\t}\n\n\t// 出力\n\tcout << dp[N][M] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nS = input()\nT = input()\nN = len(S)\nM = len(T)\n\n# 動的計画法\ndp = [ [ None ] * (M + 1) for i in range(N + 1) ]\ndp[0][0] = 0\nfor i in range(0, N+1):\n\tfor j in range(0,M+1):\n\t\tif i>=1 and j>=1 and S[i-1]==T[j-1]:\n\t\t\tdp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]+1)\n\t\telif i>=1 and j>=1:\n\t\t\tdp[i][j] = max(dp[i-1][j], dp[i][j-1])\n\t\telif i>=1:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\telif j>=1:\n\t\t\tdp[i][j] = dp[i][j-1]\n\n# 出力\nprint(dp[N][M])\n"
},
{
"id": 21,
"name": "answer_A21",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, P[2009], A[2009];\nint dp[2009][2009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> P[i] >> A[i];\n\n\t// 動的計画法（LEN は r-l の値）\n\tdp[1][N] = 0;\n\tfor (int LEN = N - 2; LEN >= 0; LEN--) {\n\t\tfor (int l = 1; l <= N - LEN; l++) {\n\t\t\tint r = l + LEN;\n\n\t\t\t// score1 の値（l-1 番目のブロックを取り除くときの得点）を求める\n\t\t\tint score1 = 0;\n\t\t\tif (l <= P[l - 1] && P[l - 1] <= r) score1 = A[l - 1];\n\n\t\t\t// score2 の値（r+1 番目のブロックを取り除くときの得点）を求める\n\t\t\tint score2 = 0;\n\t\t\tif (l <= P[r + 1] && P[r + 1] <= r) score2 = A[r + 1];\n\n\t\t\t// dp[l][r] を求める\n\t\t\tif (l == 1) {\n\t\t\t\tdp[l][r] = dp[l][r + 1] + score2;\n\t\t\t}\n\t\t\telse if (r == N) {\n\t\t\t\tdp[l][r] = dp[l - 1][r] + score1;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tdp[l][r] = max(dp[l - 1][r] + score1, dp[l][r + 1] + score2);\n\t\t\t}\n\t\t}\n\t}\n\n\t// 出力\n\tint Answer = 0;\n\tfor (int i = 1; i <= N; i++) Answer = max(Answer, dp[i][i]);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nP = [ None ] * (N + 1)\nA = [ None ] * (N + 1)\nfor i in range(1, N+1):\n\tP[i], A[i] = map(int, input().split())\n\n# 動的計画法（LEN は r-l の値)\ndp = [ [ None ] * (N + 1) for i in range(N + 1) ]\ndp[1][N] = 0\nfor LEN in reversed(range(0, N-1)):\n\tfor l in range(1, N-LEN+1):\n\t\tr = l + LEN\n\n\t\t# score1 の値（l-1 番目のブロックを取り除くときの得点）を求める\n\t\tscore1 = 0\n\t\tif l>=2 and l<=P[l-1] and P[l-1]<=r:\n\t\t\tscore1 = A[l-1]\n\n\t\t# score2 の値（r+1 番目のブロックを取り除くときの得点）を求める\n\t\tscore2 = 0\n\t\tif r<=N-1 and l<=P[r+1] and P[r+1]<=r:\n\t\t\tscore2 = A[r+1]\n\n\t\t# dp[l][r] を求める\n\t\tif l==1:\n\t\t\tdp[l][r] = dp[l][r+1] + score2\n\t\telif r==N:\n\t\t\tdp[l][r] = dp[l-1][r] + score1\n\t\telse:\n\t\t\tdp[l][r] = max(dp[l-1][r] + score1, dp[l][r+1] + score2)\n\n# 出力\nAnswer = 0\nfor i in range(1, N+1):\n\tAnswer = max(Answer, dp[i][i])\nprint(Answer)\n"
},
{
"id": 22,
"name": "answer_A22",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[100009], B[100009], dp[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N - 1; i++) cin >> A[i];\n\tfor (int i = 1; i <= N - 1; i++) cin >> B[i];\n\n\t// 配列の初期化\n\tdp[1] = 0;\n\tfor (int i = 2; i <= N; i++) dp[i] = -1000000000;\n\n\t// 動的計画法 → 出力\n\tfor (int i = 1; i <= N - 1; i++) {\n\t\tdp[A[i]] = max(dp[A[i]], dp[i] + 100);\n\t\tdp[B[i]] = max(dp[B[i]], dp[i] + 150);\n\t}\n\tcout << dp[N] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（配列 A, B は 0 番目から始まることに注意！）\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n# 配列の初期化\ndp = [ -(10 ** 9) ] * (N + 1)\ndp[1] = 0\n\n# 動的計画法\nfor i in range(1, N):\n\tdp[A[i-1]] = max(dp[A[i-1]], dp[i] + 100)\n\tdp[B[i-1]] = max(dp[B[i-1]], dp[i] + 150)\n\n# 出力\nprint(dp[N])\n"
},
{
"id": 23,
"name": "answer_A23",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, M, A[109][19];\nint dp[109][1024];\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) {\n\t\tfor (int j = 1; j <= N; j++) cin >> A[i][j];\n\t}\n\n\t// 配列の初期化\n\tfor (int i = 0; i <= M; i++) {\n\t\tfor (int j = 0; j < (1 << N); j++) dp[i][j] = 1'000'000'000;\n\t}\n\n\t// 動的計画法\n\tdp[0][0] = 0;\n\tfor (int i = 1; i <= M; i++) {\n\t\tfor (int j = 0; j < (1 << N); j++) {\n\t\t\t// already[k] = 1 のとき、品物 k は既に無料になっている\n\t\t\tint already[19];\n\t\t\tfor (int k = 1; k <= N; k++) {\n\t\t\t\tif ((j / (1 << (k - 1))) % 2 == 0) already[k] = 0;\n\t\t\t\telse already[k] = 1;\n\t\t\t}\n\n\t\t\t// クーポン券 i を選んだ場合の整数表現 v を計算する\n\t\t\tint v = 0;\n\t\t\tfor (int k = 1; k <= N; k++) {\n\t\t\t\tif (already[k] == 1 || A[i][k] == 1) v += (1 << (k - 1));\n\t\t\t}\n\n\t\t\t// 遷移を行う\n\t\t\tdp[i][j] = min(dp[i][j], dp[i - 1][j]);\n\t\t\tdp[i][v] = min(dp[i][v], dp[i - 1][j] + 1);\n\t\t}\n\t}\n\n\t// 出力（すべて選んだ場合の整数表現は 2^N-1）\n\tif (dp[M][(1 << N) - 1] == 1'000'000'000) cout << \"-1\" << endl;\n\telse cout << dp[M][(1 << N) - 1] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（配列 A は 0 番目から始まることに注意！）\nN, M = map(int, input().split())\nA = [ None ] * M\nfor i in range(0, M):\n\tA[i] = list(map(int, input().split()))\n\n# 配列の初期化\ndp = [ [ 10 ** 9 ] * (2 ** N) for i in range(M + 1) ]\n\n# 動的計画法\ndp[0][0] = 0\nfor i in range(1, M+1):\n\tfor j in range(0, 2 ** N):\n\t\t# already[k] = 1 のとき、品物 k は既に無料になっている\n\t\talready = [ None ] * N\n\t\tfor k in range(0, N):\n\t\t\tif (j // (2 ** k)) % 2 == 0:\n\t\t\t\talready[k] = 0\n\t\t\telse:\n\t\t\t\talready[k] = 1\n\n\t\t# クーポン券 i を選んだ場合の整数表現 v を計算する\n\t\tv = 0\n\t\tfor k in range(0, N):\n\t\t\tif already[k] == 1 or A[i-1][k] == 1:\n\t\t\t\tv += (2 ** k)\n\n\t\t# 遷移を行う\n\t\tdp[i][j] = min(dp[i][j], dp[i-1][j])\n\t\tdp[i][v] = min(dp[i][v], dp[i-1][j] + 1)\n\n# 出力\nif dp[M][2 ** N - 1] == 1000000000:\n\tprint(\"-1\")\nelse:\n\tprint(dp[M][2 ** N - 1])\n"
},
{
"id": 24,
"name": "answer_A24",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[100009], dp[100009];\nint LEN = 0, L[100009]; // LEN は L の長さ（例：L[4] まで書き込まれている場合 LEN=4）\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 動的計画法\n\tfor (int i = 1; i <= N; i++) {\n\t\tint pos = lower_bound(L + 1, L + LEN + 1, A[i]) - L;\n\t\tdp[i] = pos;\n\n\t\t// 配列 L を更新\n\t\tL[dp[i]] = A[i];\n\t\tif (dp[i] > LEN) LEN += 1;\n\t}\n\n\t// 答えを出力\n\tcout << LEN << endl;\n\treturn 0;\n}\n",
"Python": "import bisect\n\n# 入力（A は 0 番目から始まることに注意！）\nN = int(input())\nA = list(map(int, input().split()))\n\n# 動的計画法の準備\nLEN = 0 # LEN は L の長さ（例：L[3] まで書き込まれている場合 LEN=4）\nL = [] # 0 番目から始まることに注意\ndp = [ None ] * N # 0 番目から始まることに注意\n\n# 動的計画法（配列 dp を使った実装）\nfor i in range(N):\n\tpos = bisect.bisect_left(L, A[i])\n\tdp[i] = pos\n\n\t# 配列 L を更新\n\tif dp[i] >= LEN:\n\t\tL.append(A[i])\n\t\tLEN += 1\n\telse:\n\t\tL[dp[i]] = A[i]\n\n# 答えを出力\nprint(LEN)\n"
},
{
"id": 25,
"name": "answer_A24_withoutDP",
"Cpp": "// ###########################\n// # 配列 dp を使わない実装\n// ###########################\n\n#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[100009];\nint LEN = 0, L[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 動的計画法\n\tfor (int i = 1; i <= N; i++) {\n\t\tint pos = lower_bound(L + 1, L + LEN + 1, A[i]) - L;\n\t\tL[pos] = A[i];\n\t\tif (pos > LEN) LEN += 1;\n\t}\n\n\t// 答えを出力\n\tcout << LEN << endl;\n\treturn 0;\n}\n",
"Python": "###########################\n# 配列 dp を使わない実装 \n###########################\n\nimport bisect\n\n# 入力（A は 0 番目から始まることに注意！）\nN = int(input())\nA = list(map(int, input().split()))\n\n# 動的計画法の準備\nLEN = 0\nL = []\n\n# 動的計画法（配列 dp を使った実装）\nfor i in range(N):\n\tpos = bisect.bisect_left(L, A[i])\n\tif pos >= LEN:\n\t\tL.append(A[i])\n\t\tLEN += 1\n\telse:\n\t\tL[pos] = A[i]\n\n# 答えを出力\nprint(LEN)\n"
},
{
"id": 26,
"name": "answer_A25",
"Cpp": "#include <iostream>\nusing namespace std;\n\nlong long H, W;\nchar c[39][39];\nlong long dp[39][39];\n\nint main() {\n\t// 入力\n\tcin >> H >> W;\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) cin >> c[i][j];\n\t}\n\n\t// 動的計画法\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) {\n\t\t\tif (i == 1 && j == 1) {\n\t\t\t\tdp[i][j] = 1;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tdp[i][j] = 0;\n\t\t\t\tif (i >= 2 && c[i - 1][j] == '.') dp[i][j] += dp[i - 1][j];\n\t\t\t\tif (j >= 2 && c[i][j - 1] == '.') dp[i][j] += dp[i][j - 1];\n\t\t\t}\n\t\t}\n\t}\n\n\t// 出力\n\tcout << dp[H][W] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（配列 c が 0 番目から始まることに注意）\nH, W = map(int, input().split())\nc = [ None ] * H\nfor i in range(H):\n\tc[i] = input()\n\n# 動的計画法\ndp = [ [ 0 ] * (W + 1) for i in range(H + 1) ]\nfor i in range(H):\n\tfor j in range(W):\n\t\tif i==0 and j==0:\n\t\t\tdp[i][j] = 1\n\t\telse:\n\t\t\tdp[i][j] = 0\n\t\t\tif i>=1 and c[i-1][j]=='.':\n\t\t\t\tdp[i][j] += dp[i-1][j]\n\t\t\tif j>=1 and c[i][j-1]=='.':\n\t\t\t\tdp[i][j] += dp[i][j-1]\n\n# 出力\nprint(dp[H-1][W-1])\n"
},
{
"id": 27,
"name": "answer_A26",
"Cpp": "#include <iostream>\nusing namespace std;\n\n// x が素数のとき true を、素数ではないとき false を返す\nbool isPrime(int x) {\n\tfor (int i = 2; i * i <= x; i++) {\n\t\tif (x % i == 0) return false;\n\t}\n\treturn true;\n}\n\nint main() {\n\t// 入力\n\tint Q, X[10009];\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> X[i];\n\n\t// 出力\n\tfor (int i = 1; i <= Q; i++) {\n\t\tbool Answer = isPrime(X[i]);\n\t\tif (Answer == true) cout << \"Yes\" << endl;\n\t\tif (Answer == false) cout << \"No\" << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# x が素数のとき true を、素数ではないとき false を返す\ndef isPrime(N):\n\tLIMIT = int(N ** 0.5)\n\tfor i in range(2, LIMIT + 1):\n\t\tif N % i == 0:\n\t\t\treturn False\n\treturn True\n\n# 入力\nQ = int(input())\nX = [ None ] * Q\nfor i in range(Q):\n\tX[i] = int(input())\n\n# 出力\nfor i in range(Q):\n\tAnswer = isPrime(X[i])\n\tif Answer == True:\n\t\tprint(\"Yes\")\n\telse:\n\t\tprint(\"No\")\n"
},
{
"id": 28,
"name": "answer_A27",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint GCD(int A, int B) {\n\twhile (A >= 1 && B >= 1) {\n\t\tif (A >= B) {\n\t\t\tA = (A % B); // A の値を変更する場合\n\t\t}\n\t\telse {\n\t\t\tB = (B % A); // B の値を変更する場合\n\t\t}\n\t}\n\tif (A != 0) return A;\n\treturn B;\n}\n\nint main() {\n\tint A, B;\n\tcin >> A >> B;\n\tcout << GCD(A, B) << endl;\n\treturn 0;\n}\n",
"Python": "def GCD(A, B):\n\twhile A >= 1 and B >= 1:\n\t\tif A >= B:\n\t\t\tA = A % B # A の値を変更する場合\n\t\telse:\n\t\t\tB = B % A # B の値を変更する場合\n\tif A >= 1:\n\t\treturn A\n\treturn B\n\n# 入力\nA, B = map(int, input().split())\nprint(GCD(A, B))\n"
},
{
"id": 29,
"name": "answer_A28",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tlong long N, A[100009]; char T[100009];\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> T[i] >> A[i];\n\n\t// 出力（Answer は現在の黒板の数）\n\tlong long Answer = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (T[i] == '+') Answer += A[i];\n\t\tif (T[i] == '-') Answer -= A[i];\n\t\tif (T[i] == '*') Answer *= A[i];\n\n\t\t// 引き算で答えが 0 未満になった場合\n\t\tif (Answer < 0) Answer += 10000;\n\n\t\t// ここで余りをとっている！\n\t\tAnswer %= 10000;\n\t\tcout << Answer << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nT = [ None ] * N\nA = [ None ] * N\nfor i in range(N):\n\tT[i], A[i] = input().split()\n\tA[i] = int(A[i])\n\n# 出力（Answer は現在の黒板の数）\nAnswer = 0\nfor i in range(N):\n\tif T[i] == '+':\n\t\tAnswer += A[i]\n\tif T[i] == '-':\n\t\tAnswer -= A[i]\n\tif T[i] == '*':\n\t\tAnswer *= A[i]\n\n\t# 引き算で答えが 0 未満になった場合\n\tif Answer < 0:\n\t\tAnswer += 10000\n\n\t# ここで余りをとっている！\n\tAnswer %= 10000\n\tprint(Answer)\n"
},
{
"id": 30,
"name": "answer_A29",
"Cpp": "#include <iostream>\nusing namespace std;\n\n// a の b 乗を m で割った余りを返す関数\n// 変数 a は a^1 → a^2 → a^4 → a^8 → a^16 → ･･･ と変化\nlong long Power(long long a, long long b, long long m) {\n\tlong long p = a, Answer = 1;\n\tfor (int i = 0; i < 30; i++) {\n\t\tint wari = (1 << i);\n\t\tif ((b / wari) % 2 == 1) {\n\t\t\tAnswer = (Answer * p) % m; // 「a の 2^i 乗」が掛けられるとき\n\t\t}\n\t\tp = (p * p) % m;\n\t}\n\treturn Answer;\n}\n\nint main() {\n\tlong long a, b;\n\tcin >> a >> b;\n\tcout << Power(a, b, 1000000007) << endl;\n\treturn 0;\n}\n",
"Python": "# a の b 乗を m で割った余りを返す関数\ndef Power(a, b, m):\n\tp = a\n\tAnswer = 1\n\tfor i in range(30):\n\t\twari = 2 ** i\n\t\tif (b // wari) % 2 == 1:\n\t\t\tAnswer = (Answer * p) % m # a の 2^i 乗が掛けられるとき\n\t\tp = (p * p) % m\n\treturn Answer\n\n# 入力\na, b = map(int, input().split())\n\n# 出力\nprint(Power(a, b, 1000000007))\n"
},
{
"id": 31,
"name": "answer_A30",
"Cpp": "#include <iostream>\nusing namespace std;\n\n// a ÷ b を m で割った余りを返す関数\n// 関数 Power は 5.4 節を参照のこと\nlong long Division(long long a, long long b, long long m) {\n\treturn (a * Power(b, m - 2, m)) % m;\n}\n\nint main() {\n\t// 入力\n\tconst long long M = 1000000007;\n\tlong long n, r;\n\tcin >> n >> r;\n\n\t// 手順 1: 分子 a を求める\n\tlong long a = 1;\n\tfor (int i = 1; i <= n; i++) a = (a * i) % M;\n\n\t// 手順 2: 分母 b を求める\n\tlong long b = 1;\n\tfor (int i = 1; i <= r; i++) b = (b * i) % M;\n\tfor (int i = 1; i <= n - r; i++) b = (b * i) % M;\n\n\t// 手順 3: 答えを求める\n\tcout << Division(a, b, M) << endl;\n\treturn 0;\n}\n",
"Python": "# a の b 乗を m で割った余りを返す関数\ndef Power(a, b, m):\n\tp = a\n\tAnswer = 1\n\tfor i in range(30):\n\t\twari = 2 ** i\n\t\tif (b // wari) % 2 == 1:\n\t\t\tAnswer = (Answer * p) % m # a の 2^i 乗が掛けられるとき\n\t\tp = (p * p) % m\n\treturn Answer\n\n# a÷b を m で割った余りを返す関数\ndef Division(a, b, m):\n\treturn (a * Power(b, m - 2, m)) % m\n\n# 入力など\nn, r = map(int, input().split())\nM = 1000000007\n\n# 手順 1：分子を求める\na = 1\nfor i in range(1, n + 1):\n\ta = (a * i) % M\n\n# 手順 2：分母を求める\nb = 1\nfor i in range(1, r+1):\n\tb = (b * i) % M\nfor i in range(1, n-r+1):\n\tb = (b * i) % M\n\n# 手順 3：答えを求める\nprint(Division(a, b, M))\n"
},
{
"id": 32,
"name": "answer_A31",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\tlong long N;\n\tcin >> N;\n\tlong long A1 = (N / 3); // 3 で割り切れるものの個数\n\tlong long A2 = (N / 5); // 5 で割り切れるものの個数\n\tlong long A3 = (N / 15); // 3, 5 両方で割り切れるもの（= 15 の倍数）の個数\n\tcout << A1 + A2 - A3 << endl;\n\treturn 0;\n}\n",
"Python": "N = int(input())\nA1 = (N // 3) # 3 で割り切れるものの個数\nA2 = (N // 5) # 5 で割り切れるものの個数\nA3 = (N // 15) # 3, 5 両方で割り切れるもの（= 15 の倍数）の個数\nprint(A1 + A2 - A3)\n"
},
{
"id": 33,
"name": "answer_A32",
"Cpp": "#include <iostream>\nusing namespace std;\n\n// 配列 dp について： dp[x]=true のとき勝ちの状態、dp[x]=false のとき負けの状態\nint N, A, B;\nbool dp[100009];\n\nint main() {\n\t// 入力\n\tcin >> N >> A >> B;\n\n\t// 勝者を計算する\n\tfor (int i = 0; i <= N; i++) {\n\t\tif (i >= A && dp[i - A] == false) dp[i] = true; // 勝ちの状態\n\t\telse if (i >= B && dp[i - B] == false) dp[i] = true; // 勝ちの状態\n\t\telse dp[i] = false; // 負けの状態\n\t}\n\n\t// 出力\n\tif (dp[N] == true) cout << \"First\" << endl;\n\telse cout << \"Second\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, A, B = map(int, input().split())\n\n# 配列 dp を定義\n# dp[x]=True のとき勝ちの状態、dp[x]=False のとき負けの状態\ndp = [ None ] * (N+1)\n\n# 勝者を計算する\nfor i in range(N+1):\n\tif i >= A and dp[i-A] == False:\n\t\tdp[i] = True\n\telif i >= B and dp[i-B] == False:\n\t\tdp[i] = True\n\telse:\n\t\tdp[i] = False\n\n# 出力\nif dp[N] == True:\n\tprint(\"First\")\nelse:\n\tprint(\"Second\")\n"
},
{
"id": 34,
"name": "answer_A33",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, A[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 全部 XOR した値（ニム和）を求める\n\tint XOR_Sum = A[1];\n\tfor (int i = 2; i <= N; i++) XOR_Sum = (XOR_Sum ^ A[i]);\n\n\t// 出力\n\tif (XOR_Sum != 0) cout << \"First\" << endl;\n\tif (XOR_Sum == 0) cout << \"Second\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# 全部 XOR した値（ニム和）を求める\nXOR_Sum = A[0]\nfor i in range(1,N):\n\tXOR_Sum = (XOR_Sum ^ A[i])\n\n# 出力\nif XOR_Sum >= 1:\n\tprint(\"First\")\nelse:\n\tprint(\"Second\")\n"
},
{
"id": 35,
"name": "answer_A34",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, X, Y, A[100009];\nint grundy[100009];\n\nint main() {\n\t// [ 入力 ]\n\tcin >> N >> X >> Y;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// [Grundy 数を求める ]\n\t// 変数 grundy[i] : 石が i 個の時の Grundy 数\n\t// 変数 Transit[i]: Grundy 数が i となるような遷移ができるか\n\tfor (int i = 0; i <= 100000; i++) {\n\t\tbool Transit[3] = { false, false, false };\n\t\tif (i >= X) Transit[grundy[i - X]] = true;\n\t\tif (i >= Y) Transit[grundy[i - Y]] = true;\n\t\tif (Transit[0] == false) grundy[i] = 0;\n\t\telse if (Transit[1] == false) grundy[i] = 1;\n\t\telse grundy[i] = 2;\n\t}\n\n\t// [ 出力 ]\n\tint XOR_Sum = 0;\n\tfor (int i = 1; i <= N; i++) XOR_Sum = (XOR_Sum ^ grundy[A[i]]);\n\tif (XOR_Sum != 0) cout << \"First\" << endl;\n\tif (XOR_Sum == 0) cout << \"Second\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, X, Y = map(int, input().split())\nA = list(map(int, input().split()))\n\n# Grundy 数を求める\n# 変数 grundy[i] : 石が i 個の時の Grundy 数\n# 変数 Transit[i]: Grundy 数が i となるような遷移ができるか\ngrundy = [ None ] * 100001\nfor i in range(100001):\n\tTransit = [False, False, False]\n\tif i >= X:\n\t\tTransit[grundy[i-X]] = True\n\tif i >= Y:\n\t\tTransit[grundy[i-Y]] = True\n\n\tif Transit[0] == False:\n\t\tgrundy[i] = 0\n\telif Transit[1] == False:\n\t\tgrundy[i] = 1\n\telse:\n\t\tgrundy[i] = 2\n\n# 出力\nXOR_Sum = 0\nfor i in range(N):\n\tXOR_Sum = (XOR_Sum ^ grundy[A[i]])\nif XOR_Sum >= 1:\n\tprint(\"First\")\nelse:\n\tprint(\"Second\")\n"
},
{
"id": 36,
"name": "answer_A35",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[2009];\nint dp[2009][2009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 動的計画法 [N 段目 ]\n\tfor (int j = 1; j <= N; j++) dp[N][j] = A[j];\n\n\t// 動的計画法 [1 ～ N-1 段目 ]\n\tfor (int i = N - 1; i >= 1; i--) {\n\t\tfor (int j = 1; j <= i; j++) {\n\t\t\tif (i % 2 == 1) dp[i][j] = max(dp[i + 1][j], dp[i + 1][j + 1]);\n\t\t\tif (i % 2 == 0) dp[i][j] = min(dp[i + 1][j], dp[i + 1][j + 1]);\n\t\t}\n\t}\n\n\t// 出力\n\tcout << dp[1][1] << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# 配列 dp を定義\ndp = [ [ None ] * (N+1) for i in range(N+1) ]\n\n# 動的計画法 [N 段目]\nfor j in range(1, N+1):\n\tdp[N][j] = A[j-1]\n\n# 動的計画法 [1 ～ N-1 段目]\nfor i in reversed(range(1, N)):\n\tfor j in range(1, i+1):\n\t\tif i % 2 == 1:\n\t\t\tdp[i][j] = max(dp[i+1][j], dp[i+1][j+1])\n\t\tif i % 2 == 0:\n\t\t\tdp[i][j] = min(dp[i+1][j], dp[i+1][j+1])\n\n# 出力\nprint(dp[1][1])\n"
},
{
"id": 37,
"name": "answer_A36",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\tint N, K;\n\tcin >> N >> K;\n\tif (K >= 2 * N - 2 && K % 2 == 0) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, K = map(int, input().split())\n\n# 出力\nif K >= 2*N-2 and K%2 == 0:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
},
{
"id": 38,
"name": "answer_A37",
"Cpp": "#include <iostream>\nusing namespace std;\n\nlong long N, M, B;\nlong long A[200009], C[200009];\n\nint main() {\n\t// 入力\n\tcin >> N >> M >> B;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tfor (int j = 1; j <= M; j++) cin >> C[j];\n\n\t// 答えの計算\n\tlong long Answer = 0;\n\tfor (int i = 1; i <= N; i++) Answer += A[i] * M;\n\tAnswer += B * N * M;\n\tfor (int j = 1; j <= M; j++) Answer += C[j] * N;\n\n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, M, B = map(int, input().split())\nA = list(map(int, input().split()))\nC = list(map(int, input().split()))\n\n# 答えの計算\nAnswer = 0\nfor i in range(N):\n\tAnswer += A[i] * M\nAnswer += B * N * M\nfor j in range(M):\n\tAnswer += C[j] * N\n\n# 出力\nprint(Answer)\n"
},
{
"id": 39,
"name": "answer_A38",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint D, N;\nint L[10009], R[10009], H[10009], LIM[10009];\n\nint main() {\n\t// 入力\n\tcin >> D >> N;\n\tfor (int i = 1; i <= N; i++) cin >> L[i] >> R[i] >> H[i];\n\n\t// 配列の初期化（1 日は 24 時間）\n\tfor (int i = 1; i <= D; i++) LIM[i] = 24;\n\n\t// 上限値を求める\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = L[i]; j <= R[i]; j++) LIM[j] = min(LIM[j], H[i]);\n\t}\n\n\t// 答えを出力\n\tint Answer = 0;\n\tfor (int i = 1; i <= D; i++) Answer += LIM[i];\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nD, N = map(int, input().split())\nL = [ None ] * N\nR = [ None ] * N\nH = [ None ] * N\nfor i in range(N):\n\tL[i], R[i], H[i] = map(int, input().split())\n\n# 配列の初期化（1 日は 24 時間）\nLIM = [ 24 ] * (D + 1)\n\n# 上限値を求める\nfor i in range(N):\n\tfor j in range(L[i], R[i]+1):\n\t\tLIM[j] = min(LIM[j], H[i])\n\n# 答えを出力\nAnswer = 0\nfor i in range(1, D+1):\n\tAnswer += LIM[i]\nprint(Answer)\n"
},
{
"id": 40,
"name": "answer_A39",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nint N, L[300009], R[300009];\nvector<pair<int, int>> tmp; // 映画をソートするための一時変数\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) {\n\t\tcin >> L[i] >> R[i];\n\t\ttmp.push_back(make_pair(R[i], L[i]));\n\t}\n\n\t// R の小さい順にソート\n\tsort(tmp.begin(), tmp.end());\n\tfor (int i = 1; i <= N; i++) {\n\t\tR[i] = tmp[i - 1].first;\n\t\tL[i] = tmp[i - 1].second;\n\t}\n\n\t// 終了時刻の早いものから貪欲に取っていく（CurrentTime は現在時刻）\n\tint CurrentTime = 0, Answer = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (CurrentTime <= L[i]) {\n\t\t\tCurrentTime = R[i];\n\t\t\tAnswer += 1;\n\t\t}\n\t}\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\n# A は (終了時刻, 開始時刻) になっていることに注意 [終了時刻の昇順にソートするため]\nN = int(input())\nA = []\nfor i in range(N):\n\tl, r = map(int, input().split())\n\tA.append([r, l])\n\n# ソート\nA.sort()\n\n# 終了時刻の早いものから貪欲に取っていく（CurrentTime は現在時刻）\nCurrentTime = 0\nAnswer = 0\nfor i in range(N):\n\tif CurrentTime <= A[i][1]:\n\t\tCurrentTime = A[i][0]\n\t\tAnswer += 1\n\n# 出力\nprint(Answer)\n"
},
{
"id": 41,
"name": "answer_A40",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tint N, A[200009]; long long cnt[109], Answer = 0;\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 個数を数える\n\tfor (int i = 1; i <= 100; i++) cnt[i] = 0;\n\tfor (int i = 1; i <= N; i++) cnt[A[i]] += 1;\n\n\t// 答えを求める\n\t// nC3 = n * (n-1) * (n-2) / 6 を使っている\n\tfor (int i = 1; i <= 100; i++) {\n\t\tAnswer += cnt[i] * (cnt[i] - 1) * (cnt[i] - 2) / 6;\n\t}\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# 個数を数える\ncnt = [ 0 ] * 101\nAnswer = 0\nfor i in range(N):\n\tcnt[A[i]] += 1\n\n# 答えを求める\nfor i in range(1, 101):\n\tAnswer += cnt[i] * (cnt[i]-1) * (cnt[i]-2) // 6;\nprint(Answer)\n"
},
{
"id": 42,
"name": "answer_A41",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tint N; char S[200009];\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> S[i];\n\n\t// 答えを求める\n\tbool Answer = false;\n\tfor (int i = 1; i <= N - 2; i++) {\n\t\tif (S[i] == 'R' && S[i + 1] == 'R' && S[i + 2] == 'R') Answer = true;\n\t\tif (S[i] == 'B' && S[i + 1] == 'B' && S[i + 2] == 'B') Answer = true;\n\t}\n\n\t// 出力\n\tif (Answer == true) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nS = input()\n\n# 答えを求める\nAnswer = False\nfor i in range(0, N-2):\n\tif S[i] == 'R' and S[i+1] == 'R' and S[i+2] == 'R':\n\t\tAnswer = True\n\tif S[i] == 'B' and S[i+1] == 'B' and S[i+2] == 'B':\n\t\tAnswer = True\n\n# 出力\nif Answer == True:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
},
{
"id": 43,
"name": "answer_A42",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, K;\nint A[309], B[309];\n\n// 整数の組 (a, b) が決まったときの、参加可能な生徒数を返す関数\nint GetScore(int a, int b) {\n\tint cnt = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (a <= A[i] && A[i] <= a + K && b <= B[i] && B[i] <= b + K) {\n\t\t\tcnt += 1;\n\t\t}\n\t}\n\treturn cnt;\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int i = 1; i <= N; i++) cin >> A[i] >> B[i];\n\n\t// (a, b) の組を全探索\n\tint Answer = 0;\n\tfor (int a = 1; a <= 100; a++) {\n\t\tfor (int b = 1; b <= 100; b++) {\n\t\t\tint Score = GetScore(a, b);\n\t\t\tAnswer = max(Answer, Score);\n\t\t}\n\t}\n\n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 整数の組 (a, b) が決まったときの、参加可能な生徒数を返す関数\ndef GetScore(a, b, A, B, K):\n\tcnt = 0\n\tfor i in range(N):\n\t\tif a <= A[i] and A[i] <= a + K and b <= B[i] and B[i] <= b+K:\n\t\t\tcnt += 1\n\treturn cnt\n\n# 入力\nN, K = map(int, input().split())\nA = [ None ] * N\nB = [ None ] * N\nfor i in range(N):\n\tA[i], B[i] = map(int, input().split())\n\n# (a, b) の組を全探索\nAnswer = 0\nfor a in range(1, 101):\n\tfor b in range(1, 101):\n\t\tScore = GetScore(a, b, A, B, K)\n\t\tAnswer = max(Answer, Score)\n\n# 出力\nprint(Answer)\n"
},
{
"id": 44,
"name": "answer_A43",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, L;\nint A[200009]; char B[200009];\n\nint main() {\n\t// 入力\n\tcin >> N >> L;\n\tfor (int i = 1; i <= N; i++) cin >> A[i] >> B[i];\n\n\t// 答えを求める\n\tint Answer = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (B[i] == 'E') Answer = max(Answer, L - A[i]);\n\t\tif (B[i] == 'W') Answer = max(Answer, A[i]);\n\t}\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, L = map(int, input().split())\nA = [ None ] * N\nB = [ None ] * N\nfor i in range(N):\n\tA[i], B[i] = input().split()\n\tA[i] = int(A[i])\n\n# 答えを求める\nAnswer = 0\nfor i in range(N):\n\tif B[i] == 'E':\n\t\tAnswer = max(Answer, L - A[i])\n\tif B[i] == 'W':\n\t\tAnswer = max(Answer, A[i])\n\n# 出力\nprint(Answer)\n"
},
{
"id": 45,
"name": "answer_A44",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, Q, State = 1;\nint E[200009];\n\nint main() {\n\t// 入力 → 配列の準備\n\tcin >> N >> Q;\n\tfor (int i = 1; i <= N; i++) E[i] = i;\n\n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tint Type, x, y; cin >> Type;\n\n\t\t// [1] 変更操作\n\t\tif (Type == 1) {\n\t\t\tcin >> x >> y;\n\t\t\tif (State == 1) E[x] = y;\n\t\t\tif (State == 2) E[N + 1 - x] = y;\n\t\t}\n\n\t\t// [2] 反転操作\n\t\tif (Type == 2) {\n\t\t\tif (State == 1) State = 2;\n\t\t\telse State = 1;\n\t\t}\n\n\t\t// [3] 取得操作\n\t\tif (Type == 3) {\n\t\t\tcin >> x;\n\t\t\tif (State == 1) cout << E[x] << endl;\n\t\t\tif (State == 2) cout << E[N + 1 - x] << endl;\n\t\t}\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力・配列の準備\nN, Q = map(int, input().split())\nState = 1\nE = [ None ] * (N+2)\nfor i in range(1, N+1):\n\tE[i] = i\n\n# クエリの処理\nfor i in range(Q):\n\tQuery = input().split()\n\n\t# [1] 変更操作\n\tif int(Query[0]) == 1:\n\t\tx = int(Query[1])\n\t\ty = int(Query[2])\n\t\tif State == 1:\n\t\t\tE[x] = y\n\t\tif State == 2:\n\t\t\tE[N+1-x] = y\n\n\t# [2] 反転操作\n\tif int(Query[0]) == 2:\n\t\tif State == 1:\n\t\t\tState = 2\n\t\telse:\n\t\t\tState = 1\n\n\t# [3] 取得操作\n\tif int(Query[0]) == 3:\n\t\tx = int(Query[1])\n\t\tif State == 1:\n\t\t\tprint(E[x])\n\t\tif State == 2:\n\t\t\tprint(E[N+1-x])\n"
},
{
"id": 46,
"name": "answer_A45",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\t// 入力\n\tint N; char C, A[200009];\n\tcin >> N >> C;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// スコアの計算\n\tint score = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (A[i] == 'W') score += 0;\n\t\tif (A[i] == 'B') score += 1;\n\t\tif (A[i] == 'R') score += 2;\n\t}\n\t// 出力\n\tif (score % 3 == 0 && C == 'W') cout << \"Yes\" << endl;\n\telse if (score % 3 == 1 && C == 'B') cout << \"Yes\" << endl;\n\telse if (score % 3 == 2 && C == 'R') cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, C = input().split()\nA = input()\nN = int(N)\n\n# スコアの計算\nscore = 0\nfor i in range(N):\n\tif A[i] == 'W':\n\t\tscore += 0\n\tif A[i] == 'B':\n\t\tscore += 1\n\tif A[i] == 'R':\n\t\tscore += 2\n\n# 出力\nif score%3 == 0 and C == 'W':\n\tprint(\"Yes\")\nelif score%3 == 1 and C == 'B':\n\tprint(\"Yes\")\nelif score%3 == 2 and C == 'R':\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
},
{
"id": 47,
"name": "answer_A46",
"Cpp": "#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint N, X[159], Y[159];\nint P[159]; // 都市を訪れる順番の情報\nbool visited[159]; // visited[i]=true のとき都市 i を訪問した\n\n// 都市 p と q の間の距離を求める関数\ndouble GetDistance(int p, int q) {\n\treturn sqrt((X[p] - X[q]) * (X[p] - X[q]) + (Y[p] - Y[q]) * (Y[p] - Y[q]));\n}\n\n// 貪欲法によって答えを求める関数\nvoid PlayGreedy() {\n\t// 配列の初期化\n\tint CurrentPlace = 1;\n\tfor (int i = 1; i <= N; i++) visited[i] = false;\n\tP[1] = 1; visited[1] = true;\n\n\t// 貪欲法スタート\n\tfor (int i = 2; i <= N; i++) {\n\t\tdouble MinDist = 10000.0; // 現時点での距離の最小\n\t\tint Min_ID = -1; // 次はどの都市に移動すれば良いか\n\n\t\t// 距離が最小となる都市を探す\n\t\tfor (int j = 1; j <= N; j++) {\n\t\t\tif (visited[j] == true) continue;\n\t\t\tdouble NewDist = GetDistance(CurrentPlace, j);\n\t\t\tif (MinDist > NewDist) {\n\t\t\t\tMinDist = NewDist;\n\t\t\t\tMin_ID = j;\n\t\t\t}\n\t\t}\n\n\t\t// 現在位置の更新\n\t\tvisited[Min_ID] = true;\n\t\tP[i] = Min_ID;\n\t\tCurrentPlace = Min_ID;\n\t}\n\n\t// 最後に訪問する都市\n\tP[N + 1] = 1;\n}\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n\n\t// 貪欲法\n\tPlayGreedy();\n\n\t// 出力\n\tfor (int i = 1; i <= N + 1; i++) cout << P[i] << endl;\n\treturn 0;\n}\n",
"Python": "# 二次元の点を扱うクラス\nclass point2d:\n\tdef __init__(self, x, y):\n\t\tself.x = x\n\t\tself.y = y\n\t# 2 点間の距離を求める関数\n\tdef dist(self, p):\n\t\treturn ((self.x - p.x) ** 2 + (self.y - p.y) ** 2) ** 0.5\n\n# 貪欲法によって答えを求める関数\n# （ここでは都市の番号を 0-indexed で扱っていることに注意）\ndef play_greedy(n, points):\n\t# 配列などの初期化\n\tcurrent_place = 0\n\tvisited = [ False ] * n\n\tvisited[0] = True\n\tP = [ 0 ]\n\t# 貪欲法スタート\n\tfor i in range(1, n):\n\t\tmindist = 10 ** 10 # 現時点での距離の最小\n\t\tmin_id = -1 # 次はどの都市に移動すればよいか\n\t\t# 距離が最小となる都市を探す\n\t\tfor j in range(n):\n\t\t\tif not visited[j] and mindist > points[current_place].dist(points[j]):\n\t\t\t\tmindist = points[current_place].dist(points[j])\n\t\t\t\tmin_id = j\n\t\t# 現在位置の更新\n\t\tvisited[min_id] = True\n\t\tP.append(min_id)\n\t\tcurrent_place = min_id\n\t# 最後に訪問する都市\n\tP.append(0)\n\treturn P\n\n# 入力\nN = int(input())\npoints = [ None ] * N\nfor i in range(N):\n\tx, y = map(int, input().split())\n\tpoints[i] = point2d(x, y)\n\n# 貪欲法\nanswer = play_greedy(N, points)\n\n# 答えを出力（配列 answer の要素は 0-indexed になっていることに注意）\nfor i in answer:\n\tprint(i + 1)"
},
{
"id": 48,
"name": "answer_A47",
"Cpp": "#include <iostream>\n#include <cmath>\n#include <ctime>\n#include <algorithm>\nusing namespace std;\n\nint N, X[159], Y[159];\nint P[159];\n\n// a 以上 b 以下の整数をランダムに返す関数\nint RandInt(int a, int b) {\n\treturn a + rand() % (b - a + 1);\n}\n\n// 都市 p と q の間の距離を求める関数\ndouble GetDistance(int p, int q) {\n\treturn sqrt((X[p] - X[q]) * (X[p] - X[q]) + (Y[p] - Y[q]) * (Y[p] - Y[q]));\n}\n\n// スコアを計算する関数\ndouble GetScore() {\n\tdouble sum = 0;\n\tfor (int i = 1; i <= N; i++) sum += GetDistance(P[i], P[i + 1]);\n\treturn sum;\n}\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n\n\t// 初期解生成\n\tP[1] = 1; P[N + 1] = 1;\n\tfor (int i = 2; i <= N; i++) P[i] = i;\n\n\t// 山登り法\n\tdouble CurrentScore = GetScore();\n\tfor (int t = 1; t <= 200000; t++) {\n\t\t// ランダムに反転させる区間 [L, R] を選ぶ\n\t\tint L = RandInt(2, N);\n\t\tint R = RandInt(2, N);\n\t\tif (L > R) swap(L, R);\n\n\t\t// reverse は配列の L ～ R 番目を反転させる関数\n\t\treverse(P + L, P + R + 1);\n\t\tdouble NewScore = GetScore();\n\n\t\t// 改善すればスコアを更新、悪化すれば元に戻す\n\t\tif (CurrentScore >= NewScore) CurrentScore = NewScore;\n\t\telse reverse(P + L, P + R + 1);\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= N + 1; i++) cout << P[i] << endl;\n\treturn 0;\n}\n",
"Python": "import random\n\n# 二次元の点を扱うクラス\nclass point2d:\n\tdef __init__(self, x, y):\n\t\tself.x = x\n\t\tself.y = y\n\t# 2 点間の距離を求める関数\n\tdef dist(self, p):\n\t\treturn ((self.x - p.x) ** 2 + (self.y - p.y) ** 2) ** 0.5\n\n# 合計距離を計算する関数\ndef get_score(n, points, P):\n\tscore = 0\n\tfor i in range(n):\n\t\tscore += points[P[i]].dist(points[P[i + 1]])\n\treturn score\n\n# 山登り法によって答えを求める関数\n# （ここでは都市の番号を 0-indexed で扱っていることに注意）\ndef hill_climbing(n, points):\n\t# 初期解生成\n\tP = [ i % n for i in range(n + 1) ]\n\tcurrent_score = get_score(n, points, P)\n\t# 山登り法\n\tNUM_LOOPS = 40000\n\tfor t in range(NUM_LOOPS):\n\t\t# 反転させる区間 [L, R] を選ぶ\n\t\tl = random.randint(1, n - 1) # 1 以上 n-1 以下のランダムな整数\n\t\tr = random.randint(1, n - 1) # 1 以上 n-1 以下のランダムな整数\n\t\tif l > r:\n\t\t\tl, r = r, l\n\t\t# P[l], P[l+1], ..., P[r] を逆順にする\n\t\tP[l:r+1] = reversed(P[l:r+1])\n\t\tnew_score = get_score(n, points, P)\n\t\t# 改善すればスコアを更新、悪化すれば元に戻す\n\t\tif current_score >= new_score:\n\t\t\tcurrent_score = new_score\n\t\telse:\n\t\t\tP[l:r+1] = reversed(P[l:r+1])\n\treturn P\n\n# 入力\nN = int(input())\npoints = [ None ] * N\nfor i in range(N):\n\tx, y = map(int, input().split())\n\tpoints[i] = point2d(x, y)\n\n# 山登り法\nanswer = hill_climbing(N, points)\n\n# 答えを出力（配列 answer の要素は 0-indexed になっていることに注意）\nfor i in answer:\n\tprint(i + 1)\n\n# 注意 1：このプログラムを Python で提出すると、山登り法のループを 7,000 回程度しか回せませんが、\n# PyPy3 で提出するとより高速に動作し、山登り法のループを 40,000 回程度回すことができます。"
},
{
"id": 49,
"name": "answer_A48",
"Cpp": "#include <iostream>\n#include <cmath>\n#include <ctime>\n#include <algorithm>\nusing namespace std;\n\nint N, X[159], Y[159];\nint P[159];\n\n// 0 以上 1 以下のランダムな実数を返す関数\ndouble Randouble() {\n\treturn 1.0 * rand() / RAND_MAX;\n}\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n\n\t// 初期解生成\n\tP[1] = 1; P[N + 1] = 1;\n\tfor (int i = 2; i <= N; i++) P[i] = i;\n\n\t// 焼きなまし法（GetScore 関数、RandInt 関数は 7.2 節を参照）\n\tdouble CurrentScore = GetScore();\n\tfor (int t = 1; t <= 200000; t++) {\n\t\tint L = RandInt(2, N);\n\t\tint R = RandInt(2, N);\n\t\tif (L > R) swap(L, R);\n\t\treverse(P + L, P + R + 1);\n\t\tdouble NewScore = GetScore();\n\n\t\t// 7.2 節の解答例から変更した唯一の部分（Probability は採用確率）\n\t\tdouble T = 30.00 - 28.00 * t / 200000.0;\n\t\tdouble Probability = exp(min(0.0, (CurrentScore - NewScore) / T));\n\t\tif (Randouble() < Probability) CurrentScore = NewScore;\n\t\telse reverse(P + L, P + R + 1);\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= N + 1; i++) cout << P[i] << endl;\n\treturn 0;\n}\n",
"Python": "import math\nimport random\n\n# 二次元の点を扱うクラス\nclass point2d:\n\tdef __init__(self, x, y):\n\t\tself.x = x\n\t\tself.y = y\n\t# 2 点間の距離を求める関数\n\tdef dist(self, p):\n\t\treturn ((self.x - p.x) ** 2 + (self.y - p.y) ** 2) ** 0.5\n\n# 合計距離を計算する関数\ndef get_score(n, points, P):\n\tscore = 0\n\tfor i in range(n):\n\t\tscore += points[P[i]].dist(points[P[i + 1]])\n\treturn score\n\n# 焼きなまし法によって答えを求める関数\n# （ここでは都市の番号を 0-indexed で扱っていることに注意）\ndef simulated_annealing(n, points):\n\t# 初期解生成\n\tP = [ i % n for i in range(n + 1) ]\n\tcurrent_score = get_score(n, points, P)\n\t# 焼きなまし法\n\tNUM_LOOPS = 40000\n\tfor t in range(NUM_LOOPS):\n\t\t# 反転させる区間 [L, R] を選ぶ\n\t\tl = random.randint(1, n - 1) # 1 以上 n-1 以下のランダムな整数\n\t\tr = random.randint(1, n - 1) # 1 以上 n-1 以下のランダムな整数\n\t\tif l > r:\n\t\t\tl, r = r, l\n\t\t# P[l], P[l+1], ..., P[r] を逆順にする\n\t\tP[l:r+1] = reversed(P[l:r+1])\n\t\tnew_score = get_score(n, points, P)\n\t\t# 7.2 節の解答例から変更した唯一の部分（probability は採用確率）\n\t\t# （random.random() で 0 以上 1 未満のランダムな実数を生成）\n\t\tT = 30 - 28 * (t / NUM_LOOPS)\n\t\tprobability = math.exp(min((current_score - new_score) / T, 0))\n\t\tif random.random() < probability:\n\t\t\tcurrent_score = new_score\n\t\telse:\n\t\t\tP[l:r+1] = reversed(P[l:r+1])\n\treturn P\n\n# 入力\nN = int(input())\npoints = [ None ] * N\nfor i in range(N):\n\tx, y = map(int, input().split())\n\tpoints[i] = point2d(x, y)\n\n# 焼きなまし法\nanswer = simulated_annealing(N, points)\n\n# 答えを出力（配列 answer の要素は 0-indexed になっていることに注意）\nfor i in answer:\n\tprint(i + 1)\n\n# 注意 1：このプログラムを Python で提出すると、山登り法のループを 7,000 回程度しか回せませんが、\n# PyPy3 で提出するとより高速に動作し、山登り法のループを 40,000 回程度回すことができます。\n# 注意 2：さらにひと工夫すると、PyPy3 でループを 150,000 回程度回せるようになり、スコア 5000 以上も期待できるようになｒみあす。"
},
{
"id": 50,
"name": "answer_A49",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\n#include <functional>\nusing namespace std;\n\n// 盤面の状態を表す構造体\nstruct State {\n\tint score; // 暫定スコア\n\tint X[29]; // 現在の配列 X の値\n\tchar LastMove; // 最後の動き（'A' または 'B'）\n\tint LastPos; // Beam[i-1][ どこ ] から遷移したか\n};\n\n// sort 関数の順序を決める（スコアが大きい方が「大きい」とする）\nbool operator>(const State& a1, const State& a2) {\n\tif (a1.score > a2.score) return true;\n\telse return false;\n}\n\n// 必要な変数・配列（WIDTH はビーム幅、NumState[i] は i 手目時点での状態数）\nconst int WIDTH = 10000;\nconst int N = 20;\nint T, P[109], Q[109], R[109];\nint NumState[109];\nState Beam[109][WIDTH];\nchar Answer[109];\n\n// ビームサーチを行う関数\nvoid BeamSearch() {\n\t// 0 手目の状態を設定\n\tNumState[0] = 1;\n\tBeam[0][0].score = 0;\n\tfor (int i = 1; i <= N; i++) Beam[0][0].X[i] = 0;\n\n\t// ビームサーチ\n\tfor (int i = 1; i <= T; i++) {\n\t\tvector<State> Candidate;\n\t\tfor (int j = 0; j < NumState[i - 1]; j++) {\n\t\t\t// 操作 A の場合\n\t\t\tState SousaA = Beam[i - 1][j];\n\t\t\tSousaA.LastMove = 'A';\n\t\t\tSousaA.LastPos = j;\n\t\t\tSousaA.X[P[i]] += 1;\n\t\t\tSousaA.X[Q[i]] += 1;\n\t\t\tSousaA.X[R[i]] += 1;\n\t\t\tfor (int k = 1; k <= N; k++) {\n\t\t\t\tif (SousaA.X[k] == 0) SousaA.score += 1;\n\t\t\t}\n\n\t\t\t// 操作 B の場合\n\t\t\tState SousaB = Beam[i - 1][j];\n\t\t\tSousaB.LastMove = 'B';\n\t\t\tSousaB.LastPos = j;\n\t\t\tSousaB.X[P[i]] -= 1;\n\t\t\tSousaB.X[Q[i]] -= 1;\n\t\t\tSousaB.X[R[i]] -= 1;\n\t\t\tfor (int k = 1; k <= N; k++) {\n\t\t\t\tif (SousaB.X[k] == 0) SousaB.score += 1;\n\t\t\t}\n\n\t\t\t// 候補に追加\n\t\t\tCandidate.push_back(SousaA);\n\t\t\tCandidate.push_back(SousaB);\n\t\t}\n\n\t\t// ソートして Beam[i] の結果を計算する\n\t\tsort(Candidate.begin(), Candidate.end(), greater<State>());\n\t\tNumState[i] = min(WIDTH, (int)Candidate.size());\n\t\tfor (int j = 0; j < NumState[i]; j++) Beam[i][j] = Candidate[j];\n\t}\n}\n\nint main() {\n\t// 入力\n\tcin >> T;\n\tfor (int i = 1; i <= T; i++) cin >> P[i] >> Q[i] >> R[i];\n\n\t// ビームサーチ\n\tBeamSearch();\n\n\t// ビームサーチの復元（CurrentPlace は配列 Beam のどの位置を見ているかを表す）\n\tint CurrentPlace = 0;\n\tfor (int i = T; i >= 1; i--) {\n\t\tAnswer[i] = Beam[i][CurrentPlace].LastMove;\n\t\tCurrentPlace = Beam[i][CurrentPlace].LastPos;\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= T; i++) cout << Answer[i] << endl;\n\treturn 0;\n}\n",
"Python": "import copy\n\n# 1 回の操作 (P[i], Q[i], R[i]) を表す構造体\nclass round:\n\tdef __init__(self, p, q, r):\n\t\tself.p = p\n\t\tself.q = q\n\t\tself.r = r\n\n# 盤面の状態を表す構造体\nclass state:\n\t# 盤面の状態の初期化\n\tdef __init__(self, n):\n\t\tself.score = 0 # 暫定スコア\n\t\tself.x = [ 0 ] * n # 現在の配列 X の値\n\t\tself.lastmove = '?' # 最後の動き（'A' または 'B'、ただし初期状態では '?' としておく）\n\t\tself.lastpos = -1 # Beam[i-1][どこ] から遷移したか（ただし初期状態では -1 としておく）\n\n# ビームサーチを行う関数\ndef beam_search(N, T, rounds):\n\t# 2 次元配列 beam を用意し、0 手目の状態を設定\n\tWIDTH = 10000\n\tbeam = [ list() for i in range(T + 1) ]\n\tbeam[0].append(state(N))\n\n\t# ビームサーチ\n\tfor i in range(T):\n\t\tcandidate = list()\n\t\tfor j in range(len(beam[i])):\n\t\t\t# 操作 A の場合\n\t\t\tsousa_a = copy.deepcopy(beam[i][j])\n\t\t\tsousa_a.lastmove = 'A'\n\t\t\tsousa_a.lastpos = j\n\t\t\tsousa_a.x[rounds[i].p] += 1\n\t\t\tsousa_a.x[rounds[i].q] += 1\n\t\t\tsousa_a.x[rounds[i].r] += 1\n\t\t\tsousa_a.score += sousa_a.x.count(0) # スコアに「sousa_a.x に含まれる 0 の個数」を加算\n\t\t\t# 操作 B の場合\n\t\t\tsousa_b = copy.deepcopy(beam[i][j])\n\t\t\tsousa_b.lastmove = 'B'\n\t\t\tsousa_b.lastpos = j\n\t\t\tsousa_b.x[rounds[i].p] -= 1\n\t\t\tsousa_b.x[rounds[i].q] -= 1\n\t\t\tsousa_b.x[rounds[i].r] -= 1\n\t\t\tsousa_b.score += sousa_b.x.count(0) # スコアに「sousa_a.x に含まれる 0 の個数」を加算\n\t\t\t# 候補に追加\n\t\t\tcandidate.append(sousa_a)\n\t\t\tcandidate.append(sousa_b)\n\t\t# ソートして beam[i+1] の結果を計算する\n\t\tcandidate.sort(key = lambda s: -s.score)\n\t\tbeam[i + 1] = copy.deepcopy(candidate[:WIDTH]) # 多くとも candidate の上位 WIDTH 件しか記録しない\n\t\n\t# ビームサーチの復元\n\tcurrent_place = 0\n\tanswer = [ None ] * T\n\tfor i in range(T, 0, -1):\n\t\tanswer[i - 1] = beam[i][current_place].lastmove\n\t\tcurrent_place = beam[i][current_place].lastpos\n\treturn answer\n\n\n# 入力\nT = int(input())\nrounds = [ None ] * T\nfor i in range(T):\n\tp, q, r = map(int, input().split())\n\trounds[i] = round(p - 1, q - 1, r - 1) # 書籍とは異なり、ここでは 0-indexed にするために 1 を引いています\n\n# ビームサーチを行って答えを出す（書籍とは異なり、ビームサーチの復元は関数の中で行う）\nanswer = beam_search(20, T, rounds)\n\n# 出力\nfor c in answer:\n\tprint(c)\n\n# 注意 1：このプログラムは、Python で提出するとビーム幅 200 程度、PyPy3 で提出するとビーム幅 350 程度で、実行時間制限の 1 秒ギリギリになります。\n# 注意 2：ここでは deepcopy 関数を使っていますが、これが実行速度を遅くする原因となっています。\n# これを使わずに実装すると、プログラムがより高速になり、ビーム幅をより大きくすることができます。考えてみましょう。"
},
{
"id": 51,
"name": "answer_A49_greedy1_37454pts",
"Cpp": "// ###############################################\n// # 本の 266 ページ前半の貪欲法を用いた実装です\n// ###############################################\n\n#include <iostream>\nusing namespace std;\n\nint T, P[109], Q[109], R[109];\nint A[109];\nint PatA[109], PatB[109];\n\nint main() {\n\t// 入力\n\tcin >> T;\n\tfor (int i = 1; i <= T; i++) cin >> P[i] >> Q[i] >> R[i];\n\n\t// 配列 A の初期化\n\tfor (int i = 1; i <= 20; i++) A[i] = 0;\n\n\t// 貪欲法\n\tint CurrentScore = 0;\n\tfor (int i = 1; i <= T; i++) {\n\t\t// パターン A の場合のスコアを求める\n\t\tint ScoreA = CurrentScore;\n\t\tfor (int j = 1; j <= 20; j++) PatA[j] = A[j];\n\t\tPatA[P[i]] += 1;\n\t\tPatA[Q[i]] += 1;\n\t\tPatA[R[i]] += 1;\n\t\tfor (int j = 1; j <= 20; j++) {\n\t\t\tif (PatA[j] == 0) ScoreA += 1;\n\t\t}\n\n\t\t// パターン B の場合のスコアを求める\n\t\tint ScoreB = CurrentScore;\n\t\tfor (int j = 1; j <= 20; j++) PatB[j] = A[j];\n\t\tPatB[P[i]] -= 1;\n\t\tPatB[Q[i]] -= 1;\n\t\tPatB[R[i]] -= 1;\n\t\tfor (int j = 1; j <= 20; j++) {\n\t\t\tif (PatB[j] == 0) ScoreB += 1;\n\t\t}\n\n\t\t// スコアの大きい方を採用\n\t\tif (ScoreA >= ScoreB) {\n\t\t\tcout << \"A\" << endl;\n\t\t\tCurrentScore = ScoreA;\n\t\t\tfor (int j = 1; j <= 20; j++) A[j] = PatA[j];\n\t\t}\n\t\telse {\n\t\t\tcout << \"B\" << endl;\n\t\t\tCurrentScore = ScoreB;\n\t\t\tfor (int j = 1; j <= 20; j++) A[j] = PatB[j];\n\t\t}\n\t}\n\treturn 0;\n}\n",
"Python": "################################################\n# 本の 266 ページ前半の貪欲法を用いた実装です\n################################################\n\n# 入力\nT = int(input())\nP = [ None ] * T\nQ = [ None ] * T\nR = [ None ] * T\nfor i in range(T):\n\tP[i], Q[i], R[i] = map(int, input().split())\n\tP[i] -= 1 # 0 始まりに直す\n\tQ[i] -= 1\n\tR[i] -= 1\n\n# 配列 A の初期化\nA = [ 0 ] * 20\n\n# 貪欲法\nCurrentScore = 0\nfor i in range(T):\n\t# パターン A の場合のスコアを求める\n\tScoreA = CurrentScore\n\tPatA = [ 0 ] * 20\n\tfor j in range(20):\n\t\tPatA[j] = A[j]\n\tPatA[P[i]] += 1\n\tPatA[Q[i]] += 1\n\tPatA[R[i]] += 1\n\tfor j in range(20):\n\t\tif PatA[j] == 0:\n\t\t\tScoreA += 1\n\n\t# パターン B の場合のスコアを求める\n\tScoreB = CurrentScore\n\tPatB = [ 0 ] * 20\n\tfor j in range(20):\n\t\tPatB[j] = A[j]\n\tPatB[P[i]] -= 1\n\tPatB[Q[i]] -= 1\n\tPatB[R[i]] -= 1\n\tfor j in range(20):\n\t\tif PatB[j] == 0:\n\t\t\tScoreB += 1\n\n\t# スコアの大きい方を採用\n\tif ScoreA >= ScoreB:\n\t\tprint(\"A\")\n\t\tCurrentScore = ScoreA\n\t\tfor j in range(20):\n\t\t\tA[j] = PatA[j]\n\telse:\n\t\tprint(\"B\")\n\t\tCurrentScore = ScoreB\n\t\tfor j in range(20):\n\t\t\tA[j] = PatB[j]\n"
},
{
"id": 52,
"name": "answer_A49_greedy2_40978pts",
"Cpp": "// ###############################################\n// # 本の 272 ページ後半の評価関数を用いた実装です\n// ###############################################\n\n#include <iostream>\n#include <cmath>\nusing namespace std;\n\nint T, P[109], Q[109], R[109];\nint A[109];\nint PatA[109], PatB[109];\n\nint main() {\n\t// 入力\n\tcin >> T;\n\tfor (int i = 1; i <= T; i++) cin >> P[i] >> Q[i] >> R[i];\n\n\t// 配列 A の初期化\n\tfor (int i = 1; i <= 20; i++) A[i] = 0;\n\n\t// 貪欲法\n\tfor (int i = 1; i <= T; i++) {\n\t\t// パターン A の場合のスコアを求める\n\t\tint ScoreA = 0;\n\t\tfor (int j = 1; j <= 20; j++) PatA[j] = A[j];\n\t\tPatA[P[i]] += 1;\n\t\tPatA[Q[i]] += 1;\n\t\tPatA[R[i]] += 1;\n\t\tfor (int j = 1; j <= 20; j++) ScoreA += abs(PatA[j]);\n\n\t\t// パターン B の場合のスコアを求める\n\t\tint ScoreB = 0;\n\t\tfor (int j = 1; j <= 20; j++) PatB[j] = A[j];\n\t\tPatB[P[i]] -= 1;\n\t\tPatB[Q[i]] -= 1;\n\t\tPatB[R[i]] -= 1;\n\t\tfor (int j = 1; j <= 20; j++) ScoreB += abs(PatB[j]);\n\n\t\t// スコアの小さい方を採用\n\t\tif (ScoreA <= ScoreB) {\n\t\t\tcout << \"A\" << endl;\n\t\t\tfor (int j = 1; j <= 20; j++) A[j] = PatA[j];\n\t\t}\n\t\telse {\n\t\t\tcout << \"B\" << endl;\n\t\t\tfor (int j = 1; j <= 20; j++) A[j] = PatB[j];\n\t\t}\n\t}\n\treturn 0;\n}\n",
"Python": "################################################\n# 本の 272 ページ後半の評価関数を用いた実装です\n################################################\n\n# 入力\nT = int(input())\nP = [ None ] * T\nQ = [ None ] * T\nR = [ None ] * T\nfor i in range(T):\n\tP[i], Q[i], R[i] = map(int, input().split())\n\tP[i] -= 1 # 0 始まりに直す\n\tQ[i] -= 1\n\tR[i] -= 1\n\n# 配列 A の初期化\nA = [ 0 ] * 20\n\n# 貪欲法\nfor i in range(T):\n\t# パターン A の場合のスコアを求める\n\tScoreA = 0\n\tPatA = [ 0 ] * 20\n\tfor j in range(20):\n\t\tPatA[j] = A[j]\n\tPatA[P[i]] += 1\n\tPatA[Q[i]] += 1\n\tPatA[R[i]] += 1\n\tfor j in range(20):\n\t\tScoreA += abs(PatA[j])\n\n\t# パターン B の場合のスコアを求める\n\tScoreB = 0\n\tPatB = [ 0 ] * 20\n\tfor j in range(20):\n\t\tPatB[j] = A[j]\n\tPatB[P[i]] -= 1\n\tPatB[Q[i]] -= 1\n\tPatB[R[i]] -= 1\n\tfor j in range(20):\n\t\tScoreB += abs(PatB[j])\n\n\t# スコアの小さい方を採用\n\tif ScoreA <= ScoreB:\n\t\tprint(\"A\")\n\t\tCurrentScore = ScoreA\n\t\tfor j in range(20):\n\t\t\tA[j] = PatA[j]\n\telse:\n\t\tprint(\"B\")\n\t\tCurrentScore = ScoreB\n\t\tfor j in range(20):\n\t\t\tA[j] = PatB[j]\n"
},
{
"id": 53,
"name": "answer_A50",
"Cpp": "#include <iostream>\n#include <cmath>\n#include <ctime>\n#include <algorithm>\nusing namespace std;\n\nint N = 100;\nint Q = 1000;\nint A[109][109], B[109][109];\nint X[1009], Y[1009], H[1009];\n\n// L 以上 R 以下のランダムな整数を返す関数\nint RandInt(int L, int R) {\n\treturn rand() % (R - L + 1) + L;\n}\n\n// 現在のスコアを返す関数\nint GetScore() {\n\tint sum = 0;\n\tfor (int i = 0; i < N; i++) {\n\t\tfor (int j = 0; j < N; j++) sum += abs(A[i][j] - B[i][j]);\n\t}\n\treturn 200000000 - sum;\n}\n\n// X[t]=x, Y[t]=y, H[t]=h に変更する関数\nvoid Change(int t, int x, int y, int h) {\n\tfor (int i = 0; i < N; i++) {\n\t\tfor (int j = 0; j < N; j++) {\n\t\t\tB[j][i] -= max(0, H[t] - abs(X[t] - i) - abs(Y[t] - j));\n\t\t}\n\t}\n\tX[t] = x;\n\tY[t] = y;\n\tH[t] = h;\n\tfor (int i = 0; i < N; i++) {\n\t\tfor (int j = 0; j < N; j++) {\n\t\t\tB[j][i] += max(0, H[t] - abs(X[t] - i) - abs(Y[t] - j));\n\t\t}\n\t}\n}\n\nvoid Yamanobori() {\n\t// 変数の設定（5.95 秒ループを回す）\n\tint TIMELIMIT = 5.95 * CLOCKS_PER_SEC;\n\tint CurrentScore = GetScore();\n\tint ti = clock();\n\n\t// 山登り法スタート\n\twhile (clock() - ti < TIMELIMIT) {\n\t\tint t = RandInt(1, Q);\n\t\tint old_x = X[t], new_x = X[t] + RandInt(-9, 9);\n\t\tint old_y = Y[t], new_y = Y[t] + RandInt(-9, 9);\n\t\tint old_h = H[t], new_h = H[t] + RandInt(-19, 19);\n\t\tif (new_x < 0 || new_x >= N) continue;\n\t\tif (new_y < 0 || new_y >= N) continue;\n\t\tif (new_h <= 0 || new_h > N) continue;\n\n\t\t// とりあえず変更し、スコアを評価する\n\t\tChange(t, new_x, new_y, new_h);\n\t\tint NewScore = GetScore();\n\n\t\t// スコアに応じて採用／不採用を決める\n\t\tif (CurrentScore < NewScore) CurrentScore = NewScore;\n\t\telse Change(t, old_x, old_y, old_h);\n\t}\n}\n\nint main() {\n\t// 入力\n\tfor (int i = 0; i < N; i++) {\n\t\tfor (int j = 0; j < N; j++) cin >> A[i][j];\n\t}\n\n\t// 初期解を生成\n\tfor (int i = 1; i <= 1000; i++) {\n\t\tX[i] = rand() % N; // 0 以上 N-1 以下のランダムな整数\n\t\tY[i] = rand() % N; // 0 以上 N-1 以下のランダムな整数\n\t\tH[i] = 1;\n\t\tB[X[i]][Y[i]] += 1;\n\t}\n\n\t// 山登り法\n\tYamanobori();\n\n\t// 出力\n\tcout << \"1000\" << endl;\n\tfor (int i = 1; i <= 1000; i++) {\n\t\tcout << X[i] << \" \" << Y[i] << \" \" << H[i] << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 本プログラムでは、プログラムの実行速度を上げるため、numpy を使って 2 次元配列を計算しています。\n# numpy で計算しやすくするために、B[i][j] は 100×100 の配列ではなく、左右に広げた 300×300 の配列を使って計算しています。\n# プログラムは https://atcoder.jp/contests/future-contest-2018-qual/submissions/4216898 を参考に、本書籍のコードに基づいて実装しています。\n# ※ 期待されるスコアは、およそ 99.940 億点です。\n# ※ 焼きなまし法の実装は answer_A50_extra.py に載せています。\n\nimport numpy as np\nimport random\nimport time\nimport sys\n\n# 定数の設定・入力\nN = 100\nQ = 1000\nA = np.array([ list(map(int, input().split())) for i in range(N) ])\n\n# 初期解を生成\nX = [ random.randint(0, N - 1) for i in range(Q) ]\nY = [ random.randint(0, N - 1) for i in range(Q) ]\nH = [ 1 ] * Q\nB = np.zeros((3 * N, 3 * N))\nfor i in range(Q):\n\tB[Y[i]][X[i]] += 1\n\n# H = 1, 2, ..., N に設定された場合の「増減分」を持った numpy 配列を作る\ndelta = [ None ] * (N + 1)\nfor i in range(1, N + 1):\n\tdelta[i] = np.array([ [ max(i - abs(y) - abs(x), 0) for x in range(-i + 1, i) ] for y in range(-i + 1, i) ])\n\n# 現在のスコアを取得する関数\ndef get_score():\n\treturn 200000000 - np.absolute(A - B[N:2*N, N:2*N]).sum()\n\n# 山登り法の設定\n# （現在のスコアを np.absolute(A - B[N:2*N, N:2*N]).sum() として、これを最大化するという方法で実装する）\nTIME_LIMIT = 5.4\ncurrent_score = get_score()\nti = time.time()\n\n# 山登り法スタート\nloops = 0\nwhile time.time() - ti < TIME_LIMIT:\n\t# 「小さな変更」をランダムに選ぶ\n\tt = random.randint(0, Q - 1)\n\told_x, new_x = X[t], X[t] + random.randint(-9, +9)\n\told_y, new_y = Y[t], Y[t] + random.randint(-9, +9)\n\told_h, new_h = H[t], H[t] + random.randint(-19, +19)\n\tif new_x < 0 or new_x >= N or new_y < 0 or new_y >= N or new_h <= 0 or new_h > N:\n\t\tcontinue\n\t\n\t# X[t] = new_x, Y[t] = new_y, H[t] = new_h に変更（書籍中の Change(t, new_x, new_y, new_h) の呼び出しに対応）\n\tB[N+Y[t]-H[t]+1:N+Y[t]+H[t], N+X[t]-H[t]+1:N+X[t]+H[t]] -= delta[H[t]]\n\tX[t], Y[t], H[t] = new_x, new_y, new_h\n\tB[N+Y[t]-H[t]+1:N+Y[t]+H[t], N+X[t]-H[t]+1:N+X[t]+H[t]] += delta[H[t]]\n\n\t# スコアを計算\n\tnew_score = get_score()\n\n\t# スコアに応じて採用／不採用を決める\n\tif current_score < new_score:\n\t\t# 採用の場合\n\t\tcurrent_score = new_score\n\telse:\n\t\t# 不採用の場合：X[t] = old_x, Y[t] = old_y, H[t] = old_h に戻す（書籍中の Change(t, old_x, old_y, old_h) の呼び出しに対応）\n\t\tB[N+Y[t]-H[t]+1:N+Y[t]+H[t], N+X[t]-H[t]+1:N+X[t]+H[t]] -= delta[H[t]]\n\t\tX[t], Y[t], H[t] = old_x, old_y, old_h\n\t\tB[N+Y[t]-H[t]+1:N+Y[t]+H[t], N+X[t]-H[t]+1:N+X[t]+H[t]] += delta[H[t]]\n\t\n\tloops += 1\n\n# 出力\nprint(Q)\nfor i in range(Q):\n\tprint(X[i], Y[i], H[i])\nprint(\"score =\", current_score, file = sys.stderr)\nprint(\"loops =\", loops, file = sys.stderr)\n"
},
{
"id": 54,
"name": "answer_A51",
"Cpp": "#include <iostream>\n#include <stack>\n#include <string>\nusing namespace std;\n\nint Q;\nint QueryType[100009]; string x[100009];\nstack<string> S;\n\nint main() {\n\t// 入力\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> QueryType[i];\n\t\tif (QueryType[i] == 1) cin >> x[i];\n\t}\n\n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 1) S.push(x[i]);\n\t\tif (QueryType[i] == 2) cout << S.top() << endl;\n\t\tif (QueryType[i] == 3) S.pop();\n\t}\n\treturn 0;\n}\n",
"Python": "from collections import deque\n\n# 入力\nQ = int(input()) # クエリ数\nqueries = [ input().split() for i in range(Q) ] # クエリの情報（各要素は [\"1\", 題名を表す文字列] or [\"2\"] or [\"3\"]）\n\n# クエリの処理\nS = deque()\nfor q in queries:\n\tif q[0] == \"1\":\n\t\tS.append(q[1])\n\tif q[0] == \"2\":\n\t\tprint(S[-1])\n\tif q[0] == \"3\":\n\t\tS.pop()"
},
{
"id": 55,
"name": "answer_A52",
"Cpp": "#include <iostream>\n#include <queue>\n#include <string>\nusing namespace std;\n\nint Q;\nint QueryType[100009]; string x[100009];\nqueue<string> T;\n\nint main() {\n\t// 入力\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> QueryType[i];\n\t\tif (QueryType[i] == 1) cin >> x[i];\n\t}\n\n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 1) T.push(x[i]);\n\t\tif (QueryType[i] == 2) cout << T.front() << endl;\n\t\tif (QueryType[i] == 3) T.pop();\n\t}\n\treturn 0;\n}\n",
"Python": "from collections import deque\n\n# 入力\nQ = int(input()) # クエリ数\nqueries = [ input().split() for i in range(Q) ] # クエリの情報（各要素は [\"1\", 名前を表す文字列] or [\"2\"] or [\"3\"]）\n\n# クエリの処理\nT = deque()\nfor q in queries:\n\tif q[0] == \"1\":\n\t\tT.append(q[1])\n\tif q[0] == \"2\":\n\t\tprint(T[0])\n\tif q[0] == \"3\":\n\t\tT.popleft()"
},
{
"id": 56,
"name": "answer_A53",
"Cpp": "#include <iostream>\n#include <queue>\n#include <vector>\nusing namespace std;\n\nint Q;\nint QueryType[100009], x[100009];\npriority_queue<int, vector<int>, greater<int>> T;\n\nint main() {\n\t// 入力\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> QueryType[i];\n\t\tif (QueryType[i] == 1) cin >> x[i];\n\t}\n\n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 1) T.push(x[i]);\n\t\tif (QueryType[i] == 2) cout << T.top() << endl;\n\t\tif (QueryType[i] == 3) T.pop();\n\t}\n\treturn 0;\n}\n",
"Python": "import heapq\n\n# 入力\nQ = int(input()) # クエリ数\nqueries = [ input().split() for i in range(Q) ] # クエリの情報（各要素は [\"1\", 値段を表す文字列] or [\"2\"] or [\"3\"]）\n\n# クエリの処理\nT = []\nfor q in queries:\n\tif q[0] == \"1\":\n\t\theapq.heappush(T, int(q[1]))\n\tif q[0] == \"2\":\n\t\tprint(T[0]) # T[0] は「優先度付きキューの中の最小要素」になっている\n\tif q[0] == \"3\":\n\t\theapq.heappop(T)\n\n# 注意 1：Python の heapq モジュールは、deque モジュールとは異なり、関数を使って list を操作するという形式になっています。\n# 注意 2：優先度付きキューの最小要素は T[0] で取り出せますが、例えば小さいほうから 2 番目の要素が T[1] で取り出せるとは限らないことに注意してください。"
},
{
"id": 57,
"name": "answer_A54",
"Cpp": "#include <iostream>\n#include <string>\n#include <map>\nusing namespace std;\n\nint Q;\nint QueryType[100009], y[100009];\nstring x[100009];\nmap<string, int> Map;\n\nint main() {\n\t// 入力\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> QueryType[i];\n\t\tif (QueryType[i] == 1) cin >> x[i] >> y[i];\n\t\tif (QueryType[i] == 2) cin >> x[i];\n\t}\n\n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 1) Map[x[i]] = y[i];\n\t\tif (QueryType[i] == 2) cout << Map[x[i]] << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nQ = int(input()) # クエリ数\nqueries = [ input().split() for i in range(Q) ] # クエリの情報（各要素は [\"1\", 名前を表す文字列, 得点を表す文字列] or [\"2\", 名前を表す文字列]）\n\n# クエリの処理\nMap = {}\nfor q in queries:\n\tif q[0] == \"1\":\n\t\tMap[q[1]] = q[2]\n\tif q[0] == \"2\":\n\t\tprint(Map[q[1]])"
},
{
"id": 58,
"name": "answer_A56",
"Cpp": "#include <iostream>\nusing namespace std;\n\n// 入力で与えられる変数\nlong long N, Q;\nstring S;\nlong long a[200009], b[200009], c[200009], d[200009];\n\n// ハッシュ値を計算するための変数\nlong long mod = 2147483647;\nlong long T[200009], H[200009];\nlong long Power100[200009];\n\n// S[l, r] のハッシュ値を返す関数\n// 余りの計算に注意！（5.3 節）\nlong long Hash_value(int l, int r) {\n\tlong long val = H[r] - (H[l - 1] * Power100[r - l + 1] % mod);\n\tif (val < 0) val += mod;\n\treturn val;\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> Q;\n\tcin >> S;\n\tfor (int i = 1; i <= Q; i++) cin >> a[i] >> b[i] >> c[i] >> d[i];\n\n\t// 文字を数値に変換（C++ の文字列は 0 文字目から始まることに注意！）\n\tfor (int i = 1; i <= N; i++) T[i] = (S[i - 1] - 'a') + 1;\n\n\t// 100 の n 乗（本文中の B^0, B^1, ... に対応）を前計算する\n\tPower100[0] = 1;\n\tfor (int i = 1; i <= N; i++) Power100[i] = 100LL * Power100[i - 1] % mod;\n\n\t// H[1], ..., H[N] を計算する\n\tH[0] = 0;\n\tfor (int i = 1; i <= N; i++) H[i] = (100LL * H[i - 1] + T[i]) % mod;\n\n\t// クエリに答える\n\tfor (int i = 1; i <= Q; i++) {\n\t\tlong long Hash1 = Hash_value(a[i], b[i]);\n\t\tlong long Hash2 = Hash_value(c[i], d[i]);\n\t\tif (Hash1 == Hash2) cout << \"Yes\" << endl;\n\t\telse cout << \"No\" << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nN, Q = map(int, input().split())\nS = input()\nqueries = [ list(map(int, input().split())) for i in range(Q) ]\n\n# 文字を数値に変換（ここでは書籍とは異なり、0-indexed で実装しています）\n# ord(c) で文字 c の文字コード（ASCII コード）を取得\nT = list(map(lambda c: ord(c) - ord('a') + 1, S))\n\n# 100 の n 乗を前計算\nMOD = 2147483647\npower100 = [ None ] * (N + 1)\npower100[0] = 1\nfor i in range(N):\n\tpower100[i + 1] = power100[i] * 100 % MOD\n\n# H[1], H[2], ..., H[N] を計算する\nH = [ None ] * (N + 1)\nH[0] = 0\nfor i in range(N):\n\tH[i + 1] = (H[i] * 100 + T[i]) % MOD\n\n# ハッシュ値を求める関数\n# S[l-1:r] のハッシュ値は (H[r] - H[l - 1] * power100[r - l + 1]) % MOD で計算\n# C++ とは異なり、（負の値）% M (M >= 1) も 0 以上 M-1 以下になることに注意\ndef hash_value(l, r):\n\treturn (H[r] - H[l - 1] * power100[r - l + 1]) % MOD\n\n# クエリに答える\nfor a, b, c, d in queries:\n\thash1 = hash_value(a, b)\n\thash2 = hash_value(c, d)\n\tif hash1 == hash2:\n\t\tprint(\"Yes\")\n\telse:\n\t\tprint(\"No\")\n"
},
{
"id": 59,
"name": "answer_A57",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, Q, A[100009], X[100009], Y[100009];\nint dp[32][100009];\n\nint main() {\n\t// 入力\n\tcin >> N >> Q;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tfor (int j = 1; j <= Q; j++) cin >> X[j] >> Y[j];\n\n\t// 前計算\n\tfor (int i = 1; i <= N; i++) dp[0][i] = A[i];\n\tfor (int d = 1; d <= 29; d++) {\n\t\tfor (int i = 1; i <= N; i++) dp[d][i] = dp[d - 1][dp[d - 1][i]];\n\t}\n\n\t// クエリの処理\n\tfor (int j = 1; j <= Q; j++) {\n\t\tint CurrentPlace = X[j];\n\t\tfor (int d = 29; d >= 0; d--) {\n\t\t\tif ((Y[j] / (1 << d)) % 2 != 0) CurrentPlace = dp[d][CurrentPlace];\n\t\t}\n\t\tcout << CurrentPlace << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nN, Q = map(int, input().split())\nA = list(map(int, input().split()))\nqueries = [ list(map(int, input().split())) for i in range(Q) ]\n\n# 前計算（ここでは書籍とは異なり、0-indexed で実装しています）\nLEVELS = 30\ndp = [ [ None ] * N for i in range(LEVELS) ]\nfor i in range(0, N):\n\tdp[0][i] = A[i] - 1\nfor d in range(1, LEVELS):\n\tfor i in range(0, N):\n\t\tdp[d][i] = dp[d - 1][dp[d - 1][i]]\n\n# クエリの処理（ここでは書籍とは異なり、0-indexed で実装しています）\nfor X, Y in queries:\n\tcurrent_place = X - 1\n\tfor d in range(29, -1, -1):\n\t\tif ((Y >> d) & 1) == 1:\n\t\t\tcurrent_place = dp[d][current_place]\n\tprint(current_place + 1) # current_place は 0-indexed で計算したので、1 を足して出力する\n\n# 注意 1：書籍の C++ プログラムにおいて「Y の 2^d の位を取り出す」は C++ では (Y / (1 << d)) % 2 と実装されていました。\n# Python でも 19 行目は (Y // (2 ** d)) % 2 と実装できますが、((Y >> d) & 1) と計算すると、定数倍の面でより高速です。\n# 注意 2：このプログラムの平均的な実行時間は 2 秒にギリギリ入るくらいであり、提出によっては TLE となる場合があります。\n# 同じプログラムを PyPy3 で提出すると、0.5 秒程度の実行時間で AC することができます。"
},
{
"id": 60,
"name": "answer_A58",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nclass SegmentTree {\npublic:\n\tint dat[300000], siz = 1;\n\n\t// 要素 dat の初期化を行う（最初は全部ゼロ）\n\tvoid init(int N) {\n\t\tsiz = 1;\n\t\twhile (siz < N) siz *= 2;\n\t\tfor (int i = 1; i < siz * 2; i++) dat[i] = 0;\n\t}\n\n\t// クエリ 1 に対する処理\n\tvoid update(int pos, int x) {\n\t\tpos = pos + siz - 1;\n\t\tdat[pos] = x;\n\t\twhile (pos >= 2) {\n\t\t\tpos /= 2;\n\t\t\tdat[pos] = max(dat[pos * 2], dat[pos * 2 + 1]);\n\t\t}\n\t}\n\n\t// クエリ 2 に対する処理\n\t// u は現在のセル番号、[a, b) はセルに対応する半開区間、[l, r) は求めたい半開区間\n\tint query(int l, int r, int a, int b, int u) {\n\t\tif (r <= a || b <= l) return -1000000000; // 一切含まれない場合\n\t\tif (l <= a && b <= r) return dat[u]; // 完全に含まれる場合\n\t\tint m = (a + b) / 2;\n\t\tint AnswerL = query(l, r, a, m, u * 2);\n\t\tint AnswerR = query(l, r, m, b, u * 2 + 1);\n\t\treturn max(AnswerL, AnswerR);\n\t}\n};\n\nint N, Q;\nint Query[100009], pos[100009], x[100009], l[100009], r[100009];\nSegmentTree Z;\n\nint main() {\n\t// 入力\n\tcin >> N >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> Query[i];\n\t\tif (Query[i] == 1) cin >> pos[i] >> x[i];\n\t\tif (Query[i] == 2) cin >> l[i] >> r[i];\n\t}\n\n\t// クエリ処理\n\tZ.init(N);\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (Query[i] == 1) {\n\t\t\tZ.update(pos[i], x[i]);\n\t\t}\n\t\tif (Query[i] == 2) {\n\t\t\t// 最初のセルに対応する半開区間は [1, siz + 1)\n\t\t\tint Answer = Z.query(l[i], r[i], 1, Z.siz + 1, 1);\n\t\t\tcout << Answer << endl;\n\t\t}\n\t}\n\treturn 0;\n}\n",
"Python": "# セグメント木（ここでは書籍とは異なり、pos が 0-indexed になるように実装しています）\nclass segtree:\n\t# 要素 dat の初期化を行う（最初は全部ゼロ）\n\tdef __init__(self, n):\n\t\tself.size = 1\n\t\twhile self.size < n:\n\t\t\tself.size *= 2\n\t\tself.dat = [ 0 ] * (self.size * 2)\n\t\n\t# クエリ 1 に対する処理\n\tdef update(self, pos, x):\n\t\tpos += self.size # pos は 0-indexed なので、A[pos] のみに対応するセルの番号は pos + size\n\t\tself.dat[pos] = x\n\t\twhile pos >= 2:\n\t\t\tpos //= 2\n\t\t\tself.dat[pos] = max(self.dat[pos * 2], self.dat[pos * 2 + 1])\n\t\n\t# クエリ 2 に対する処理\n\t# u は現在のセル番号、[a, b) はセルに対応する半開区間、[l, r) は求めたい半開区間\n\tdef query(self, l, r, a, b, u):\n\t\tif r <= a or b <= l:\n\t\t\treturn -1000000000 # 一切含まれない場合\n\t\tif l <= a and b <= r:\n\t\t\treturn self.dat[u] # 完全に含まれる場合\n\t\tm = (a + b) // 2\n\t\tanswerl = self.query(l, r, a, m, u * 2)\n\t\tanswerr = self.query(l, r, m, b, u * 2 + 1)\n\t\treturn max(answerl, answerr)\n\n# 入力\nN, Q = map(int, input().split())\nqueries = [ list(map(int, input().split())) for i in range(Q) ]\n\n# クエリの処理\nZ = segtree(N)\nfor q in queries:\n\ttp, *cont = q\n\tif tp == 1:\n\t\tpos, x = cont\n\t\tZ.update(pos - 1, x) # pos は 1-indexed で入力されるので、update 関数の引数は pos - 1 にします\n\tif tp == 2:\n\t\tl, r = cont\n\t\tanswer = Z.query(l - 1, r - 1, 0, Z.size, 1) # 0-indexed の実装では、最初のセルに対応する半開区間は [0, size) です\n\t\tprint(answer)"
},
{
"id": 61,
"name": "answer_A59",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nclass SegmentTree {\npublic:\n\tint dat[300000], siz = 1;\n\n\t// 要素 dat の初期化を行う（最初は全部ゼロ）\n\tvoid init(int N) {\n\t\tsiz = 1;\n\t\twhile (siz < N) siz *= 2;\n\t\tfor (int i = 1; i < siz * 2; i++) dat[i] = 0;\n\t}\n\n\t// クエリ 1 に対する処理\n\tvoid update(int pos, int x) {\n\t\tpos = pos + siz - 1;\n\t\tdat[pos] = x;\n\t\twhile (pos >= 2) {\n\t\t\tpos /= 2;\n\t\t\tdat[pos] = dat[pos * 2] + dat[pos * 2 + 1]; // 8.8 節から変更した部分\n\t\t}\n\t}\n\n\t// クエリ 2 に対する処理\n\tint query(int l, int r, int a, int b, int u) {\n\t\tif (r <= a || b <= l) return 0; // 8.8 節から変更した部分\n\t\tif (l <= a && b <= r) return dat[u];\n\t\tint m = (a + b) / 2;\n\t\tint AnswerL = query(l, r, a, m, u * 2);\n\t\tint AnswerR = query(l, r, m, b, u * 2 + 1);\n\t\treturn AnswerL + AnswerR; // 8.8 節から変更した部分\n\t}\n};\n\nint N, Q;\nint Query[100009], pos[100009], x[100009], l[100009], r[100009];\nSegmentTree Z;\n\nint main() {\n\t// 入力\n\tcin >> N >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> Query[i];\n\t\tif (Query[i] == 1) cin >> pos[i] >> x[i];\n\t\tif (Query[i] == 2) cin >> l[i] >> r[i];\n\t}\n\n\t// クエリ処理\n\tZ.init(N);\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (Query[i] == 1) {\n\t\t\tZ.update(pos[i], x[i]);\n\t\t}\n\t\tif (Query[i] == 2) {\n\t\t\t// 最初のセルに対応する半開区間は [1, siz + 1)\n\t\t\tint Answer = Z.query(l[i], r[i], 1, Z.siz + 1, 1);\n\t\t\tcout << Answer << endl;\n\t\t}\n\t}\n\treturn 0;\n}\n",
"Python": "# セグメント木（ここでは書籍とは異なり、pos が 0-indexed になるように実装しています）\nclass segtree:\n\t# 要素 dat の初期化を行う（最初は全部ゼロ）\n\tdef __init__(self, n):\n\t\tself.size = 1\n\t\twhile self.size < n:\n\t\t\tself.size *= 2\n\t\tself.dat = [ 0 ] * (self.size * 2)\n\t\n\t# クエリ 1 に対する処理\n\tdef update(self, pos, x):\n\t\tpos += self.size # pos は 0-indexed なので、A[pos] のみに対応するセルの番号は pos + size\n\t\tself.dat[pos] = x\n\t\twhile pos >= 2:\n\t\t\tpos //= 2\n\t\t\tself.dat[pos] = self.dat[pos * 2] + self.dat[pos * 2 + 1] # 8.8 節から変更した部分\n\t\n\t# クエリ 2 に対する処理\n\t# u は現在のセル番号、[a, b) はセルに対応する半開区間、[l, r) は求めたい半開区間\n\tdef query(self, l, r, a, b, u):\n\t\tif r <= a or b <= l:\n\t\t\treturn 0 # 8.8 節から変更した部分\n\t\tif l <= a and b <= r:\n\t\t\treturn self.dat[u]\n\t\tm = (a + b) // 2\n\t\tanswerl = self.query(l, r, a, m, u * 2)\n\t\tanswerr = self.query(l, r, m, b, u * 2 + 1)\n\t\treturn answerl + answerr # 8.8 節から変更した部分\n\n# 入力\nN, Q = map(int, input().split())\nqueries = [ list(map(int, input().split())) for i in range(Q) ]\n\n# クエリの処理\nZ = segtree(N)\nfor q in queries:\n\ttp, *cont = q\n\tif tp == 1:\n\t\tpos, x = cont\n\t\tZ.update(pos - 1, x) # pos は 1-indexed で入力されるので、update 関数の引数は pos - 1 にします\n\tif tp == 2:\n\t\tl, r = cont\n\t\tanswer = Z.query(l - 1, r - 1, 0, Z.size, 1) # 0-indexed の実装では、最初のセルに対応する半開区間は [0, size) です\n\t\tprint(answer)"
},
{
"id": 62,
"name": "answer_A60",
"Cpp": "#include <iostream>\n#include <stack>\nusing namespace std;\n\nint N, A[200009];\nint Answer[200009];\nstack<pair<int, int>> Level2;\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// スタックの変化の再現\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (i >= 2) {\n\t\t\tLevel2.push(make_pair(i - 1, A[i - 1]));\n\t\t\twhile (!Level2.empty()) {\n\t\t\t\tint kabuka = Level2.top().second;\n\t\t\t\tif (kabuka <= A[i]) Level2.pop();\n\t\t\t\telse break;\n\t\t\t}\n\t\t}\n\n\t\t// 起算日の特定\n\t\tif (!Level2.empty()) Answer[i] = Level2.top().first;\n\t\telse Answer[i] = -1;\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (i >= 2) cout << \" \";\n\t\tcout << Answer[i];\n\t}\n\tcout << endl;\n\treturn 0;\n}\n",
"Python": "from collections import deque\n\n# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# スタックの変化の再現\n# （スタックには (日付, 株価) のタプルを記録する）\nanswer = [ None ] * N\nlevel2 = deque()\nfor i in range(N):\n\tif i >= 1:\n\t\tlevel2.append((i, A[i - 1]))\n\t\twhile len(level2) >= 1:\n\t\t\tkabuka = level2[-1][1] # 株価はタプルの 2 番目の要素\n\t\t\tif kabuka <= A[i]:\n\t\t\t\tlevel2.pop()\n\t\t\telse:\n\t\t\t\tbreak\n\tif len(level2) >= 1:\n\t\tanswer[i] = level2[-1][0] # 日付はタプルの 1 番目の要素\n\telse:\n\t\tanswer[i] = -1\n\n# answer を空白区切りで出力\nprint(*answer)"
},
{
"id": 63,
"name": "answer_A61",
"Cpp": "#include <iostream>\n#include <vector>\nusing namespace std;\n\nint N, M;\nint A[100009], B[100009];\nvector<int> G[100009]; // 隣接リスト\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) {\n\t\tcin >> A[i] >> B[i];\n\t\tG[A[i]].push_back(B[i]); // 「頂点 A[i] に隣接する頂点」として B[i] を追加\n\t\tG[B[i]].push_back(A[i]); // 「頂点 B[i] に隣接する頂点」として A[i] を追加\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= N; i++) {\n\t\tcout << i << \": {\";\n\t\tfor (int j = 0; j < G[i].size(); j++) {\n\t\t\tif (j >= 1) cout << \", \";\n\t\t\tcout << G[i][j];\n\t\t}\n\t\tcout << \"}\" << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "# 入力\nN, M = map(int, input().split())\nedges = [ list(map(int, input().split())) for i in range(M) ]\n\n# 隣接リストの作成\nG = [ list() for i in range(N + 1) ] # G[i] は頂点 i に隣接する頂点のリスト\nfor a, b in edges:\n\tG[a].append(b) # 頂点 a に隣接する頂点として b を追加\n\tG[b].append(a) # 頂点 b に隣接する頂点として a を追加\n\n# 出力\nfor i in range(1, N + 1):\n\toutput = ''\n\toutput += str(i)\n\toutput += ': {'\n\toutput += ', '.join(map(str, G[i])) # 例えば G[i] = { 2, 7, 5 } のとき、ここで \"2, 7, 5\" という文字列が output の後ろに連結される\n\toutput += '}'\n\tprint(output)"
},
{
"id": 64,
"name": "answer_A62",
"Cpp": "#include <iostream>\n#include <vector>\n#include <string>\nusing namespace std;\n\nint N, M, A[100009], B[100009];\nvector<int> G[100009];\nbool visited[100009]; // 頂点 x が青色の場合、visited[x] = true\n\nvoid dfs(int pos) { // pos は現在位置\n\tvisited[pos] = true;\n\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\tint nex = G[pos][i];\n\t\tif (visited[nex] == false) dfs(nex);\n\t}\n\treturn;\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) {\n\t\tcin >> A[i] >> B[i];\n\t\tG[A[i]].push_back(B[i]);\n\t\tG[B[i]].push_back(A[i]);\n\t}\n\n\t// 深さ優先探索\n\tfor (int i = 1; i <= N; i++) visited[i] = false;\n\tdfs(1);\n\n\t// 答えの出力\n\tstring Answer = \"The graph is connected.\";\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (visited[i] == false) Answer = \"The graph is not connected.\";\n\t}\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "import sys\n\n# 再帰呼び出しの深さの上限を 120000 に設定\nsys.setrecursionlimit(120000)\n\n# 深さ優先探索を行う関数（pos は現在位置、visited[x] は頂点 x が青色かどうかを表す真偽値）\ndef dfs(pos, G, visited):\n\tvisited[pos] = True\n\tfor i in G[pos]:\n\t\tif visited[i] == False:\n\t\t\tdfs(i, G, visited)\n\n# 入力\nN, M = map(int, input().split())\nedges = [ list(map(int, input().split())) for i in range(M) ]\n\n# 隣接リストの作成\nG = [ list() for i in range(N + 1) ] # G[i] は頂点 i に隣接する頂点のリスト\nfor a, b in edges:\n\tG[a].append(b) # 頂点 a に隣接する頂点として b を追加\n\tG[b].append(a) # 頂点 b に隣接する頂点として a を追加\n\n# 深さ優先探索\nvisited = [ False ] * (N + 1)\ndfs(1, G, visited)\n\n# 連結かどうかの判定（answer = True のとき連結）\nanswer = True\nfor i in range(1, N + 1):\n\tif visited[i] == False:\n\t\tanswer = False\n\n# 答えの出力\nif answer == True:\n\tprint(\"The graph is connected.\")\nelse:\n\tprint(\"The graph is not connected.\")"
},
{
"id": 65,
"name": "answer_A63",
"Cpp": "#include <iostream>\n#include <queue>\n#include <vector>\nusing namespace std;\n\nint N, M, A[100009], B[100009];\nint dist[100009];\nvector<int> G[100009];\nqueue<int> Q;\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) {\n\t\tcin >> A[i] >> B[i];\n\t\tG[A[i]].push_back(B[i]);\n\t\tG[B[i]].push_back(A[i]);\n\t}\n\n\t// 幅優先探索（dist[i]=? ではなく dist[i]=-1 で初期化していることに注意）\n\tfor (int i = 1; i <= N; i++) dist[i] = -1;\n\tQ.push(1);\n\tdist[1] = 0;\n\twhile (!Q.empty()) {\n\t\tint pos = Q.front(); Q.pop();\n\t\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\t\tint to = G[pos][i];\n\t\t\tif (dist[to] == -1) {\n\t\t\t\tdist[to] = dist[pos] + 1;\n\t\t\t\tQ.push(to);\n\t\t\t}\n\t\t}\n\t}\n\n\t// 出力\n\tfor (int i = 1; i <= N; i++) cout << dist[i] << endl;\n\treturn 0;\n}\n",
"Python": "from collections import deque\n\n# 入力\nN, M = map(int, input().split())\nedges = [ list(map(int, input().split())) for i in range(M) ]\n\n# 隣接リストの作成\nG = [ list() for i in range(N + 1) ]\nfor a, b in edges:\n\tG[a].append(b)\n\tG[b].append(a)\n\n# 幅優先探索の初期化（dist[i] = ? ではなく dist[i] = -1 で初期化していることに注意）\ndist = [ -1 ] * (N + 1)\ndist[1] = 0\nQ = deque()\nQ.append(1)\n\n# 幅優先探索\nwhile len(Q) >= 1:\n\tpos = Q.popleft() # キュー Q の先頭要素を取り除き、その値を pos に代入する\n\tfor nex in G[pos]:\n\t\tif dist[nex] == -1:\n\t\t\tdist[nex] = dist[pos] + 1\n\t\t\tQ.append(nex)\n\n# 頂点 1 から各頂点までの最短距離を出力\nfor i in range(1, N + 1):\n\tprint(dist[i])"
},
{
"id": 66,
"name": "answer_A64",
"Cpp": "#include <iostream>\n#include <queue>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\n// 入力・グラフ\nint N, M, A[100009], B[100009], C[100009];\nvector<pair<int, int>> G[100009];\n\n// ダイクストラ法\nint cur[100009]; bool kakutei[100009];\npriority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Q;\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) {\n\t\tcin >> A[i] >> B[i] >> C[i];\n\t\tG[A[i]].push_back(make_pair(B[i], C[i]));\n\t\tG[B[i]].push_back(make_pair(A[i], C[i]));\n\t}\n\n\t// 配列の初期化\n\tfor (int i = 1; i <= N; i++) kakutei[i] = false;\n\tfor (int i = 1; i <= N; i++) cur[i] = 2000000000;\n\n\t// スタート地点をキューに追加\n\tcur[1] = 0;\n\tQ.push(make_pair(cur[1], 1));\n\n\t// ダイクストラ法\n\twhile (!Q.empty()) {\n\t\t// 次に確定させるべき頂点を求める\n\t\tint pos = Q.top().second; Q.pop();\n\n\t\t// Q の最小要素が「既に確定した頂点」の場合\n\t\tif (kakutei[pos] == true) continue;\n\n\t\t// cur[x] の値を更新する\n\t\tkakutei[pos] = true;\n\t\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\t\tint nex = G[pos][i].first;\n\t\t\tint cost = G[pos][i].second;\n\t\t\tif (cur[nex] > cur[pos] + cost) {\n\t\t\t\tcur[nex] = cur[pos] + cost;\n\t\t\t\tQ.push(make_pair(cur[nex], nex));\n\t\t\t}\n\t\t}\n\t}\n\n\t// 答えを出力\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (cur[i] == 2000000000) cout << \"-1\" << endl;\n\t\telse cout << cur[i] << endl;\n\t}\n\treturn 0;\n}\n",
"Python": "import heapq\n\n# 入力\nN, M = map(int, input().split())\nedges = [ list(map(int, input().split())) for i in range(M) ]\n\n# 隣接リストの作成（重み付きグラフなので、各辺について (隣接頂点, 重み) のタプルを記録する）\nG = [ list() for i in range(N + 1) ]\nfor a, b, c in edges:\n\tG[a].append((b, c))\n\tG[b].append((a, c))\n\n# 配列・キューの初期化（キューには (距離, 頂点番号) のタプルを記録する）\nINF = 10 ** 10\nkakutei = [ False ] * (N + 1)\ncur = [ INF ] * (N + 1)\ncur[1] = 0\nQ = []\nheapq.heappush(Q, (cur[1], 1))\n\n# ダイクストラ法\nwhile len(Q) >= 1:\n\t# 次に確定させるべき頂点を求める\n\t# （ここでは、優先度付きキュー Q の最小要素を取り除き、その要素の 2 番目の値（頂点番号）を pos に代入する）\n\tpos = heapq.heappop(Q)[1]\n\n\t# Q の最小要素が「既に確定した頂点」の場合\n\tif kakutei[pos] == True:\n\t\tcontinue\n\t\n\t# cur[x] の値を更新する\n\tkakutei[pos] = True\n\tfor e in G[pos]:\n\t\t# 書籍内のコードとは pos = e[0], cost = e[1] で対応している\n\t\tif cur[e[0]] > cur[pos] + e[1]:\n\t\t\tcur[e[0]] = cur[pos] + e[1]\n\t\t\theapq.heappush(Q, (cur[e[0]], e[0]))\n\n# 答えを出力\nfor i in range(1, N + 1):\n\tif cur[i] != INF:\n\t\tprint(cur[i])\n\telse:\n\t\tprint(\"-1\")"
},
{
"id": 67,
"name": "answer_A65",
"Cpp": "#include <iostream>\n#include <vector>\nusing namespace std;\n\nint N, A[100009], dp[100009];\nvector<int> G[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 2; i <= N; i++) {\n\t\tcin >> A[i];\n\t\tG[A[i]].push_back(i); // 「上司→部下」の方向に辺を追加\n\t}\n\t// 動的計画法（dp[x] は社員 x の部下の数）\n\tfor (int i = N; i >= 1; i--) {\n\t\tdp[i] = 0;\n\t\tfor (int j = 0; j < G[i].size(); j++) dp[i] += (dp[G[i][j]] + 1);\n\t}\n\t// 空白区切りで出力\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (i >= 2) cout << \" \";\n\t\tcout << dp[i];\n\t}\n\tcout << endl;\n\treturn 0;\n}\n",
"Python": "# 入力（A[2], ..., A[N] が入力される値になるようにする）\nN = int(input())\nA = [ 0 ] * 2 + list(map(int, input().split()))\n\n# 隣接リストの作成\nG = [ list() for i in range(N + 1) ]\nfor i in range(2, N + 1):\n\tG[A[i]].append(i) # 上司 → 部下の方向に方向に辺を追加\n\n# 動的計画法（dp[x] は社員 x の部下の数）\ndp = [ 0 ] * (N + 1)\nfor i in range(N, 0, -1):\n\tfor j in G[i]:\n\t\tdp[i] += (dp[j] + 1)\n\n# 答え (dp[1], dp[2], ..., dp[N]) を空白区切りで出力\nprint(*dp[1:])"
},
{
"id": 68,
"name": "answer_A66",
"Cpp": "#include <iostream>\n#include <vector>\nusing namespace std;\n\nclass UnionFind {\npublic:\n\tint par[100009];\n\tint siz[100009];\n\n\t// N 頂点の Union-Find を作成\n\tvoid init(int N) {\n\t\tfor (int i = 1; i <= N; i++) par[i] = -1; // 最初は親が無い\n\t\tfor (int i = 1; i <= N; i++) siz[i] = 1; // 最初はグループの頂点数が 1\n\t}\n\n\t// 頂点 x の根を返す関数\n\tint root(int x) {\n\t\twhile (true) {\n\t\t\tif (par[x] == -1) break; // 1 個先（親）がなければ、ここが根\n\t\t\tx = par[x]; // 1 個先（親）に進む\n\t\t}\n\t\treturn x;\n\t}\n\n\t// 要素 u と v を統合する関数\n\tvoid unite(int u, int v) {\n\t\tint RootU = root(u);\n\t\tint RootV = root(v);\n\t\tif (RootU == RootV) return; // u と v が同グループのときは処理を行わない\n\t\tif (siz[RootU] < siz[RootV]) {\n\t\t\tpar[RootU] = RootV;\n\t\t\tsiz[RootV] = siz[RootU] + siz[RootV];\n\t\t}\n\t\telse {\n\t\t\tpar[RootV] = RootU;\n\t\t\tsiz[RootU] = siz[RootU] + siz[RootV];\n\t\t}\n\t}\n\n\t// 要素 u と v が同一のグループかどうかを返す関数\n\tbool same(int u, int v) {\n\t\tif (root(u) == root(v)) return true;\n\t\treturn false;\n\t}\n};\n\nint N, Q;\nint Query[100009], u[100009], v[100009];\n\nint main() {\n\t// 入力\n\tcin >> N >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> Query[i] >> u[i] >> v[i];\n\n\t// クエリの処理\n\tUnionFind UF;\n\tUF.init(N);\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (Query[i] == 1) {\n\t\t\tUF.unite(u[i], v[i]);\n\t\t}\n\t\tif (Query[i] == 2) {\n\t\t\tif (UF.same(u[i], v[i]) == true) cout << \"Yes\" << endl;\n\t\t\telse cout << \"No\" << endl;\n\t\t}\n\t}\n\treturn 0;\n}\n",
"Python": "# Union-Find 木\nclass unionfind:\n\t# n 頂点の Union-Find 木を作成\n\t# （ここでは頂点番号が 1-indexed になるように実装しているが、0-indexed の場合は par, size のサイズは n でよい）\n\tdef __init__(self, n):\n\t\tself.n = n\n\t\tself.par = [ -1 ] * (n + 1) # 最初は親が無い\n\t\tself.size = [ 1 ] * (n + 1) # 最初はグループの頂点数が 1\n\t\n\t# 頂点 x の根を返す関数\n\tdef root(self, x):\n\t\t# 1 個先（親）がなくなる（つまり根に到達する）まで、1 個先（親）に進み続ける\n\t\twhile self.par[x] != -1:\n\t\t\tx = self.par[x]\n\t\treturn x\n\t\n\t# 要素 u, v を統合する関数\n\tdef unite(self, u, v):\n\t\trootu = self.root(u)\n\t\trootv = self.root(v)\n\t\tif rootu != rootv:\n\t\t\t# u と v が異なるグループのときのみ処理を行う\n\t\t\tif self.size[rootu] < self.size[rootv]:\n\t\t\t\tself.par[rootu] = rootv\n\t\t\t\tself.size[rootv] += self.size[rootu]\n\t\t\telse:\n\t\t\t\tself.par[rootv] = rootu\n\t\t\t\tself.size[rootu] += self.size[rootv]\n\t\n\t# 要素 u と v が同一のグループかどうかを返す関数\n\tdef same(self, u, v):\n\t\treturn self.root(u) == self.root(v)\n\n# 入力\nN, Q = map(int, input().split())\nqueries = [ list(map(int, input().split())) for i in range(Q) ]\n\n# クエリの処理\nuf = unionfind(N)\nfor tp, u, v in queries:\n\tif tp == 1:\n\t\tuf.unite(u, v)\n\tif tp == 2:\n\t\tif uf.same(u, v):\n\t\t\tprint(\"Yes\")\n\t\telse:\n\t\t\tprint(\"No\")"
},
{
"id": 69,
"name": "answer_A67",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\n// Union-Find クラスの実装は 9.6 節参照\nint N, M;\nint A[100009], B[100009], C[100009];\nUnionFind UF;\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) cin >> A[i] >> B[i] >> C[i];\n\n\t// 辺を長さの小さい順にソートする\n\tvector<pair<int, int>> EdgeList;\n\tfor (int i = 1; i <= M; i++) EdgeList.push_back(make_pair(C[i], i));\n\tsort(EdgeList.begin(), EdgeList.end());\n\n\t// 最小全域木を求める\n\tint Answer = 0; UF.init(N);\n\tfor (int i = 0; i < EdgeList.size(); i++) {\n\t\tint idx = EdgeList[i].second;\n\t\tif (UF.same(A[idx], B[idx]) == false) {\n\t\t\tUF.unite(A[idx], B[idx]);\n\t\t\tAnswer += C[idx];\n\t\t}\n\t}\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# Union-Find 木\nclass unionfind:\n\t# n 頂点の Union-Find 木を作成\n\t# （ここでは頂点番号が 1-indexed になるように実装しているが、0-indexed の場合は par, size のサイズは n でよい）\n\tdef __init__(self, n):\n\t\tself.n = n\n\t\tself.par = [ -1 ] * (n + 1) # 最初は親が無い\n\t\tself.size = [ 1 ] * (n + 1) # 最初はグループの頂点数が 1\n\t\n\t# 頂点 x の根を返す関数\n\tdef root(self, x):\n\t\t# 1 個先（親）がなくなる（つまり根に到達する）まで、1 個先（親）に進み続ける\n\t\twhile self.par[x] != -1:\n\t\t\tx = self.par[x]\n\t\treturn x\n\t\n\t# 要素 u, v を統合する関数\n\tdef unite(self, u, v):\n\t\trootu = self.root(u)\n\t\trootv = self.root(v)\n\t\tif rootu != rootv:\n\t\t\t# u と v が異なるグループのときのみ処理を行う\n\t\t\tif self.size[rootu] < self.size[rootv]:\n\t\t\t\tself.par[rootu] = rootv\n\t\t\t\tself.size[rootv] += self.size[rootu]\n\t\t\telse:\n\t\t\t\tself.par[rootv] = rootu\n\t\t\t\tself.size[rootu] += self.size[rootv]\n\t\n\t# 要素 u と v が同一のグループかどうかを返す関数\n\tdef same(self, u, v):\n\t\treturn self.root(u) == self.root(v)\n\n# 入力\nN, M = map(int, input().split())\nedges = [ list(map(int, input().split())) for i in range(M) ]\n\n# 辺を長さの小さい順にソートする\nedges.sort(key = lambda x: x[2])\n\n# 最小全域木を求める\nuf = unionfind(N)\nanswer = 0\nfor a, b, c in edges:\n\tif not uf.same(a, b):\n\t\tuf.unite(a, b)\n\t\tanswer += c\n\n# 答えの出力\nprint(answer)"
},
{
"id": 70,
"name": "answer_A68",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nstruct Edge {\n\tint to, cap, rev;\n};\n\nclass MaximumFlow {\npublic:\n\tint size_ = 0;\n\tbool used[409];\n\tvector<Edge> G[409];\n\n\t// 頂点数 N の残余グラフを準備\n\tvoid init(int N) {\n\t\tsize_ = N;\n\t\tfor (int i = 0; i <= size_; i++) G[i].clear();\n\t}\n\n\t// 頂点 a から b に向かう、上限 c リットル／秒の辺を追加\n\tvoid add_edge(int a, int b, int c) {\n\t\tint Current_Ga = G[a].size(); // 現時点での G[a] の要素数\n\t\tint Current_Gb = G[b].size(); // 現時点での G[b] の要素数\n\t\tG[a].push_back(Edge{ b, c, Current_Gb });\n\t\tG[b].push_back(Edge{ a, 0, Current_Ga });\n\t}\n\n\t// 深さ優先探索（F はスタートから pos に到達する過程での \" 残余グラフの辺の容量 \" の最小値）\n\t// 返り値は流したフローの量（流せない場合は 0 を返す）\n\tint dfs(int pos, int goal, int F) {\n\t\t// ゴールに到着：フローを流せる！\n\t\tif (pos == goal) return F;\n\t\tused[pos] = true;\n\n\t\t// 探索する\n\t\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\t\t// 容量 0 の辺は使えない\n\t\t\tif (G[pos][i].cap == 0) continue;\n\n\t\t\t// 既に訪問した頂点に行っても意味がない\n\t\t\tif (used[G[pos][i].to] == true) continue;\n\n\t\t\t// 目的地までのパスを探す\n\t\t\tint flow = dfs(G[pos][i].to, goal, min(F, G[pos][i].cap));\n\n\t\t\t// フローを流せる場合、残余グラフの容量を flow だけ増減させる\n\t\t\tif (flow >= 1) {\n\t\t\t\tG[pos][i].cap -= flow;\n\t\t\t\tG[G[pos][i].to][G[pos][i].rev].cap += flow;\n\t\t\t\treturn flow;\n\t\t\t}\n\t\t}\n\n\t\t// すべての辺を探索しても見つからなかった ･･･\n\t\treturn 0;\n\t}\n\n\t// 頂点 s から頂点 t までの最大フローの総流量を返す\n\tint max_flow(int s, int t) {\n\t\tint Total_Flow = 0;\n\t\twhile (true) {\n\t\t\tfor (int i = 0; i <= size_; i++) used[i] = false;\n\t\t\tint F = dfs(s, t, 1000000000);\n\n\t\t\t// フローを流せなくなったら操作終了\n\t\t\tif (F == 0) break;\n\t\t\tTotal_Flow += F;\n\t\t}\n\t\treturn Total_Flow;\n\t}\n};\n\nint N, M;\nint A[409], B[409], C[409];\nMaximumFlow Z;\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) cin >> A[i] >> B[i] >> C[i];\n\n\t// 辺を追加\n\tZ.init(N);\n\tfor (int i = 1; i <= M; i++) {\n\t\tZ.add_edge(A[i], B[i], C[i]);\n\t}\n\n\t// 答えを出力\n\tcout << Z.max_flow(1, N) << endl;\n\treturn 0;\n}\n",
"Python": "# 最大フロー用の辺の構造体\nclass maxflow_edge:\n\tdef __init__(self, to, cap, rev):\n\t\tself.to = to\n\t\tself.cap = cap\n\t\tself.rev = rev\n\n# 深さ優先探索\ndef dfs(pos, goal, F, G, used):\n\tif pos == goal:\n\t\treturn F # ゴールに到着：フローを流せる！\n\t# 探索する\n\tused[pos] = True\n\tfor e in G[pos]:\n\t\t# 容量が 1 以上でかつ、まだ訪問していない頂点にのみ行く\n\t\tif e.cap > 0 and not used[e.to]:\n\t\t\tflow = dfs(e.to, goal, min(F, e.cap), G, used)\n\t\t\t# フローを流せる場合、残余グラフの容量を flow だけ増減させる\n\t\t\tif flow >= 1:\n\t\t\t\te.cap -= flow\n\t\t\t\tG[e.to][e.rev].cap += flow\n\t\t\t\treturn flow\n\t# すべての辺を探索しても見つからなかった…\n\treturn 0\n\n# 頂点 s から頂点 t までの最大フローの総流量を返す（頂点数 N、辺のリスト edges）\ndef maxflow(N, s, t, edges):\n\t# 初期状態の残余グラフを構築\n\t# （ここは書籍とは少し異なる実装をしているため、8 行目は G[a] に追加された後なので len(G[a]) - 1 となっていることに注意）\n\tG = [ list() for i in range(N + 1) ]\n\tfor a, b, c in edges:\n\t\tG[a].append(maxflow_edge(b, c, len(G[b])))\n\t\tG[b].append(maxflow_edge(a, 0, len(G[a]) - 1))\n\tINF = 10 ** 10\n\ttotal_flow = 0\n\twhile True:\n\t\tused = [ False ] * (N + 1)\n\t\tF = dfs(s, t, INF, G, used)\n\t\tif F > 0:\n\t\t\ttotal_flow += F\n\t\telse:\n\t\t\tbreak # フローを流せなくなったら、操作終了\n\treturn total_flow\n\n# 入力\nN, M = map(int, input().split())\nedges = [ list(map(int, input().split())) for i in range(M) ]\n\n# 答えを求めて出力\nanswer = maxflow(N, 1, N, edges)\nprint(answer)"
},
{
"id": 71,
"name": "answer_A69",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nint N; char c[159][159];\nMaximumFlow Z; // MaximumFlow クラスは 9.8 節参照\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 1; j <= N; j++) cin >> c[i][j];\n\t}\n\n\t// グラフを構成する\n\tZ.init(2 * N + 2);\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 1; j <= N; j++) {\n\t\t\tif (c[i][j] == '#') Z.add_edge(i, N + j, 1);\n\t\t}\n\t}\n\tfor (int i = 1; i <= N; i++) {\n\t\tZ.add_edge(2 * N + 1, i, 1); // 「s → 青色」の辺\n\t\tZ.add_edge(N + i, 2 * N + 2, 1); // 「赤色 → t」の辺\n\t}\n\t// 答えの出力\n\tcout << Z.max_flow(2 * N + 1, 2 * N + 2) << endl;\n\treturn 0;\n}\n",
"Python": "# 最大フロー用の辺の構造体\nclass maxflow_edge:\n\tdef __init__(self, to, cap, rev):\n\t\tself.to = to\n\t\tself.cap = cap\n\t\tself.rev = rev\n\n# 深さ優先探索\ndef dfs(pos, goal, F, G, used):\n\tif pos == goal:\n\t\treturn F # ゴールに到着：フローを流せる！\n\t# 探索する\n\tused[pos] = True\n\tfor e in G[pos]:\n\t\t# 容量が 1 以上でかつ、まだ訪問していない頂点にのみ行く\n\t\tif e.cap > 0 and not used[e.to]:\n\t\t\tflow = dfs(e.to, goal, min(F, e.cap), G, used)\n\t\t\t# フローを流せる場合、残余グラフの容量を flow だけ増減させる\n\t\t\tif flow >= 1:\n\t\t\t\te.cap -= flow\n\t\t\t\tG[e.to][e.rev].cap += flow\n\t\t\t\treturn flow\n\t# すべての辺を探索しても見つからなかった…\n\treturn 0\n\n# 頂点 s から頂点 t までの最大フローの総流量を返す（頂点数 N、辺のリスト edges）\ndef maxflow(N, s, t, edges):\n\t# 初期状態の残余グラフを構築\n\t# （ここは書籍とは少し異なる実装をしているため、8 行目は G[a] に追加された後なので len(G[a]) - 1 となっていることに注意）\n\tG = [ list() for i in range(N + 1) ]\n\tfor a, b, c in edges:\n\t\tG[a].append(maxflow_edge(b, c, len(G[b])))\n\t\tG[b].append(maxflow_edge(a, 0, len(G[a]) - 1))\n\tINF = 10 ** 10\n\ttotal_flow = 0\n\twhile True:\n\t\tused = [ False ] * (N + 1)\n\t\tF = dfs(s, t, INF, G, used)\n\t\tif F > 0:\n\t\t\ttotal_flow += F\n\t\telse:\n\t\t\tbreak # フローを流せなくなったら、操作終了\n\treturn total_flow\n\n# 入力\nN = int(input())\nC = [ input() for i in range(N) ]\n\n# 最大フローを求めたいグラフを構築する（辺の要素は (辺の始点の番号, 辺の終点の番号, 辺の容量) のタプル）\nedges = []\nfor i in range(N):\n\tfor j in range(N):\n\t\tif C[i][j] == '#':\n\t\t\tedges.append((i + 1, N + j + 1, 1))\nfor i in range(N):\n\tedges.append((2 * N + 1, i + 1, 1)) # 「s → 青色」の辺\n\tedges.append((N + i + 1, 2 * N + 2, 1)) # 「赤色 → t」の辺\n\n# 答えを求めて出力\nanswer = maxflow(2 * N + 2, 2 * N + 1, 2 * N + 2, edges)\nprint(answer)"
},
{
"id": 72,
"name": "answer_A70",
"Cpp": "#include <iostream>\n#include <vector>\n#include <queue>\nusing namespace std;\n\nint N, A[19];\nint M, X[109], Y[109], Z[109];\nint dist[1033];\nvector<int> G[1033];\n\n// 頂点 pos の状態から「idx 種類目の操作」を行ったときの頂点番号を返す\nint GetNext(int pos, int idx) {\n\tint State[19]; // State[i] はランプ i の状態\n\n\t// 2 進法に直す方法は 1.4 節を参照\n\tfor (int i = 1; i <= N; i++) {\n\t\tint wari = (1 << (i - 1));\n\t\tState[i] = (pos / wari) % 2;\n\t}\n\tState[X[idx]] = 1 - State[X[idx]]; // ランプ X[idx] を反転\n\tState[Y[idx]] = 1 - State[Y[idx]]; // ランプ Y[idx] を反転\n\tState[Z[idx]] = 1 - State[Z[idx]]; // ランプ Z[idx] を反転\n\n\t// 10 進法に変換する方法も 1.4 節を参照\n\tint ret = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (State[i] == 1) ret += (1 << (i - 1));\n\t}\n\treturn ret;\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tfor (int j = 1; j <= M; j++) cin >> X[j] >> Y[j] >> Z[j];\n\n\t// グラフに辺を追加\n\tfor (int i = 0; i < (1 << N); i++) {\n\t\tfor (int j = 1; j <= M; j++) {\n\t\t\tint NextState = GetNext(i, j);\n\t\t\tG[i].push_back(NextState);\n\t\t}\n\t}\n\n\t// スタート地点・ゴール地点の頂点番号を求める\n\tint Goal = (1 << N) - 1; // (1<<N) は「2 の N 乗」\n\tint Start = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (A[i] == 1) Start += (1 << (i - 1));\n\t}\n\n\t// 配列の初期化／スタート地点をキューに入れる\n\tqueue<int> Q;\n\tfor (int i = 0; i < (1 << N); i++) dist[i] = -1;\n\tdist[Start] = 0;\n\tQ.push(Start);\n\n\t// 幅優先探索\n\twhile (!Q.empty()) {\n\t\tint pos = Q.front(); Q.pop();\n\t\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\t\tint nex = G[pos][i];\n\t\t\tif (dist[nex] == -1) {\n\t\t\t\tdist[nex] = dist[pos] + 1;\n\t\t\t\tQ.push(nex);\n\t\t\t}\n\t\t}\n\t}\n\n\t// 答えを出力\n\tcout << dist[Goal] << endl;\n\treturn 0;\n}\n",
"Python": "from collections import deque\n\n# 入力（ここでは書籍とは異なり、ランプの番号が 0-indexed になるように実装しています）\nN, M = map(int, input().split())\nA = list(map(int, input().split()))\nactions = [ list(map(lambda x: int(x) - 1, input().split())) for i in range(M) ] # ここでは X[i], Y[i], Z[i] を 0-indexed に変換して受け取る\n\n# 頂点 pos の状態から「ランプ x, y, z の状態」を反転させたときの頂点番号を返す関数\ndef get_next(pos, x, y, z):\n\t# pos の 2 進法表記を使って、頂点 pos が表すランプの状態 state を計算\n\t# （pos の 2^i の位は (pos // (2 ** i)) % 2 で計算できる → 1.4 節を参照）\n\tstate = [ (pos // (2 ** i)) % 2 for i in range(N) ]\n\t# ランプ x, y, z を反転\n\tstate[x] = 1 - state[x]\n\tstate[y] = 1 - state[y]\n\tstate[z] = 1 - state[z]\n\t# ランプの状態 state を指す頂点の番号を計算\n\t# （2 進法を 10 進法に変換する方法は 1.4 節を参照）\n\tret = 0\n\tfor i in range(N):\n\t\tif state[i] == 1:\n\t\t\tret += 2 ** i\n\treturn ret\n\n# グラフに辺を追加\nG = [ list() for i in range(2 ** N) ]\nfor i in range(2 ** N):\n\tfor x, y, z in actions:\n\t\tnextstate = get_next(i, x, y, z)\n\t\tG[i].append(nextstate)\n\n# スタート地点・ゴール地点の頂点番号を決める\nstart = 0\nfor i in range(N):\n\tif A[i] == 1:\n\t\tstart += 2 ** i\ngoal = 2 ** N - 1\n\n# 幅優先探索の初期化\ndist = [ -1 ] * (2 ** N)\ndist[start] = 0\nQ = deque()\nQ.append(start)\n\n# 幅優先探索\nwhile len(Q) >= 1:\n\tpos = Q.popleft() # キュー Q の先頭要素を取り除き、その値を pos に代入する\n\tfor nex in G[pos]:\n\t\tif dist[nex] == -1:\n\t\t\tdist[nex] = dist[pos] + 1\n\t\t\tQ.append(nex)\n\n# 答えを出力\nprint(dist[goal])\n\n# 注意 1：この問題に対してはより簡潔な実装もありますので、\n# もしよければ answer_A70_extra.py もご覧ください。"
},
{
"id": 73,
"name": "answer_A71",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nint N, A[69], B[69];\nint Answer = 0;\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tfor (int i = 1; i <= N; i++) cin >> B[i];\n\n\t// 配列のソート（reverse 関数は配列を逆順にする関数）\n\tsort(A + 1, A + N + 1);\n\tsort(B + 1, B + N + 1); reverse(B + 1, B + N + 1);\n\n\t// 答えを求める\n\tfor (int i = 1; i <= N; i++) Answer += A[i] * B[i];\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n# 配列のソート（A は昇順に、B は降順にソート）\nA.sort()\nB.sort(reverse = True)\n\n# 答えは A[i] * B[i] の総和\nprint(sum([ A[i] * B[i] for i in range(N) ]))"
},
{
"id": 74,
"name": "answer_A72",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nint H, W, K;\nint Answer = 0;\nchar c[19][109], d[19][109]; // 配列 d はマス目 D に対応\n\n// 残り remaining_steps 回の「列に対する操作」で、最大何個のマスを黒くできるかを返す関数\nint paintRow(int remaining_steps) {\n\t// 各列に対する「白マスの個数」を計算し、大きい順にソートする\n\tvector<pair<int, int>> Column;\n\tfor (int j = 1; j <= W; j++) {\n\t\tint cnt = 0;\n\t\tfor (int i = 1; i <= H; i++) {\n\t\t\tif (d[i][j] == '.') cnt += 1;\n\t\t}\n\t\tColumn.push_back(make_pair(cnt, j));\n\t}\n\tsort(Column.begin(), Column.end());\n\treverse(Column.begin(), Column.end());\n\n\t// 列に対して操作を行う\n\tfor (int j = 0; j < remaining_steps; j++) {\n\t\tint idx = Column[j].second;\n\t\tfor (int i = 1; i <= H; i++) d[i][idx] = '#';\n\t}\n\n\t// 黒マスの個数を数える\n\tint ret = 0;\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) {\n\t\t\tif (d[i][j] == '#') ret += 1;\n\t\t}\n\t}\n\treturn ret;\n}\n\nint main() {\n\t// 入力\n\tcin >> H >> W >> K;\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W; j++) cin >> c[i][j];\n\t}\n\n\t// ビット全探索\n\tfor (int t = 0; t < (1 << H); t++) {\n\t\t// まずはマス目を初期盤面に設定\n\t\tfor (int i = 1; i <= H; i++) {\n\t\t\tfor (int j = 1; j <= W; j++) d[i][j] = c[i][j];\n\t\t}\n\n\t\t// 行に対して操作を行う\n\t\t// 変数 remaining_steps は残り操作回数\n\t\tint remaining_steps = K;\n\t\tfor (int i = 1; i <= H; i++) {\n\t\t\tint wari = (1 << (i - 1));\n\t\t\tif ((t / wari) % 2 == 0) continue;\n\t\t\tremaining_steps -= 1;\n\t\t\tfor (int j = 1; j <= W; j++) d[i][j] = '#'; // i 行目を黒く塗る\n\t\t}\n\n\t\t// 列に対して操作を行う\n\t\tif (remaining_steps >= 0) {\n\t\t\tint SubAnswer = paintRow(remaining_steps);\n\t\t\tAnswer = max(Answer, SubAnswer);\n\t\t}\n\t}\n\n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "import itertools\n\n# 入力\nH, W, K = map(int, input().split())\nc = [ input() for i in range(H) ]\n\n# 残り remaining_steps 回の「列に対する操作」で、最大何個のマスを黒くできるかを返す関数\ndef paint_row(H, W, d, remaining_steps):\n\t# 各列に対して (白マスの個数, 列の番号) のタプルを記録し、大きい順にソートする\n\tcolumn = [ ([ d[i][j] for i in range(H) ].count('.'), j) for j in range(W) ]\n\tcolumn.sort(reverse = True)\n\n\t# 列に対して操作を行う\n\tfor j in range(remaining_steps):\n\t\tidx = column[j][1]\n\t\tfor i in range(H):\n\t\t\td[i][idx] = '#'\n\t\n\t# 黒マスの個数を数えて、これを返す\n\treturn sum(map(lambda l: l.count('#'), d))\n\n# 行の塗り方を全探索\n# （ここでは「ビット全探索」ではなく itertools.product を使って 2^H 通りの塗り方を全列挙しています）\nanswer = 0\nfor v in itertools.product([ 0, 1 ], repeat = H):\n\t# 行に対して操作を行う（paint_row 関数でいくつかの d[i][j] を書き換えるため、d は string の配列ではなく 2 次元リストにしています）\n\td = [ list(c[i]) for i in range(H) ]\n\tremaining_steps = K\n\tfor i in range(H):\n\t\tif v[i] == 1:\n\t\t\td[i] = [ '#' ] * W\n\t\t\tremaining_steps -= 1\n\tif remaining_steps >= 0:\n\t\tsubanswer = paint_row(H, W, d, remaining_steps)\n\t\tanswer = max(answer, subanswer)\n\n# 出力\nprint(answer)"
},
{
"id": 75,
"name": "answer_A73",
"Cpp": "#include <iostream>\n#include <queue>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\n// 入力・グラフを表す変数\nint N, M, A[100009], B[100009], C[100009], D[100009];\nvector<pair<int, int>> G[8009];\n\n// ダイクストラ法で使う変数\nlong long cur[8009]; bool kakutei[8009];\npriority_queue<pair<long long, int>, vector<pair<long long, int>>, greater<pair<long long, int>>> Q;\n\nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) {\n\t\tcin >> A[i] >> B[i] >> C[i] >> D[i];\n\t\tif (D[i] == 1) {\n\t\t\tG[A[i]].push_back(make_pair(B[i], 10000 * C[i] - 1));\n\t\t\tG[B[i]].push_back(make_pair(A[i], 10000 * C[i] - 1));\n\t\t}\n\t\telse {\n\t\t\tG[A[i]].push_back(make_pair(B[i], 10000 * C[i]));\n\t\t\tG[B[i]].push_back(make_pair(A[i], 10000 * C[i]));\n\t\t}\n\t}\n\n\t// 配列の初期化\n\tfor (int i = 1; i <= N; i++) kakutei[i] = false;\n\tfor (int i = 1; i <= N; i++) cur[i] = (1LL << 60);\n\n\t// スタート地点をキューに追加\n\tcur[1] = 0;\n\tQ.push(make_pair(cur[1], 1));\n\n\t// ダイクストラ法\n\twhile (!Q.empty()) {\n\t\t// 次に確定させるべき頂点を求める\n\t\tint pos = Q.top().second; Q.pop();\n\t\tif (kakutei[pos] == true) continue;\n\n\t\t// cur[nex] の値を更新する\n\t\tkakutei[pos] = true;\n\t\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\t\tint nex = G[pos][i].first;\n\t\t\tint cost = G[pos][i].second;\n\t\t\tif (cur[nex] > cur[pos] + cost) {\n\t\t\t\tcur[nex] = cur[pos] + cost;\n\t\t\t\tQ.push(make_pair(cur[nex], nex));\n\t\t\t}\n\t\t}\n\t}\n\n\t// 答えを出力\n\t// マラソンコースの距離：cur[N]/10000 を小数点以下切り上げた値\n\t// コース上の木の数：cur[N] と Distance*10000 の差分\n\tlong long Distance = (cur[N] + 9999) / 10000;\n\tlong long NumTrees = Distance * 10000 - cur[N];\n\tcout << Distance << \" \" << NumTrees << endl;\n\treturn 0;\n}\n",
"Python": "import heapq\n\n# 入力\nN, M = map(int, input().split())\nroads = [ list(map(int, input().split())) for i in range(M) ]\n\n# グラフの作成\nG = [ list() for i in range(N + 1) ]\nfor a, b, c, d in roads:\n\tif d == 1:\n\t\tG[a].append((b, 10000 * c - 1))\n\t\tG[b].append((a, 10000 * c - 1))\n\telse:\n\t\tG[a].append((b, 10000 * c))\n\t\tG[b].append((a, 10000 * c))\n\n# ダイクストラ法（ダイクストラ法の詳しい説明については本書籍の 9.4 節、および ../chap09/answer_A64.py を参照）\nINF = 10 ** 10\nkakutei = [ False ] * (N + 1)\ncur = [ INF ] * (N + 1)\ncur[1] = 0\nQ = []\nheapq.heappush(Q, (cur[1], 1))\nwhile len(Q) >= 1:\n\tpos = heapq.heappop(Q)[1]\n\tif kakutei[pos] == True:\n\t\tcontinue\n\tkakutei[pos] = True\n\tfor e in G[pos]:\n\t\tif cur[e[0]] > cur[pos] + e[1]:\n\t\t\tcur[e[0]] = cur[pos] + e[1]\n\t\t\theapq.heappush(Q, (cur[e[0]], e[0]))\n\n# 答えを求めて出力\n# マラソンコースの距離：cur[N] / 10000 を小数点以下切り上げた値\n# コース上の木の数：cur[N] と distance * 10000 の差分\ndistance = (cur[N] + 9999) // 10000\nnum_trees = distance * 10000 - cur[N]\nprint(distance, num_trees)"
},
{
"id": 76,
"name": "answer_A74",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, P[109][109];\nint X[109], InversionX = 0;\nint Y[109], InversionY = 0;\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 1; j <= N; j++) {\n\t\t\tcin >> P[i][j];\n\t\t\tif (P[i][j] != 0) { X[i] = P[i][j]; Y[j] = P[i][j]; }\n\t\t}\n\t}\n\n\t// X の転倒数・Y の転倒数を求める\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = i + 1; j <= N; j++) {\n\t\t\tif (X[i] > X[j]) InversionX += 1;\n\t\t\tif (Y[i] > Y[j]) InversionY += 1;\n\t\t}\n\t}\n\n\t// 出力\n\tcout << InversionX + InversionY << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nP = [ list(map(int, input().split())) for i in range(N) ]\n\n# 「転倒数を求める問題」2 つに分解する\nX = [ None ] * N\nY = [ None ] * N\nfor i in range(N):\n\tfor j in range(N):\n\t\tif P[i][j] != 0:\n\t\t\tX[i] = P[i][j]\n\t\t\tY[j] = P[i][j]\n\n# 転倒数を求める関数\ndef inversion(A):\n\tanswer = 0\n\tfor i in range(len(A)):\n\t\tfor j in range(i + 1, len(A)):\n\t\t\tif A[i] > A[j]:\n\t\t\t\tanswer += 1\n\treturn answer\n\n# 答えを出力\nprint(inversion(X) + inversion(Y))"
},
{
"id": 77,
"name": "answer_A75",
"Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n\nint N, T[109], D[109];\nint dp[109][1449], Answer = 0;\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> T[i] >> D[i];\n\n\t// D[i] の小さい順に並べ替える\n\tvector<pair<int, int>> Problems;\n\tfor (int i = 1; i <= N; i++) Problems.push_back(make_pair(D[i], T[i]));\n\tsort(Problems.begin(), Problems.end());\n\tfor (int i = 1; i <= N; i++) {\n\t\tD[i] = Problems[i - 1].first;\n\t\tT[i] = Problems[i - 1].second;\n\t}\n\n\t// 配列の初期化\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 0; j <= 1440; j++) dp[i][j] = -1;\n\t}\n\n\t// 動的計画法\n\tdp[0][0] = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 0; j <= 1440; j++) {\n\t\t\tif (j > D[i] || j < T[i]) dp[i][j] = dp[i - 1][j];\n\t\t\telse dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - T[i]] + 1);\n\t\t}\n\t}\n\n\t// 答えを出力\n\tfor (int i = 0; i <= 1440; i++) Answer = max(Answer, dp[N][i]);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN = int(input())\nproblems = [ list(map(int, input().split())) for i in range(N) ] # タプル (T[i], D[i]) が N 個並んだ配列になる\n\n# D[i] の小さい順に並べ替える\nproblems.sort(key = lambda p: p[1])\n\n# 動的計画法：前準備\nMAX_D = max(map(lambda p: p[1], problems)) # D[i] の最大値（書籍内のコードでは「1440」という定数を使っているが、ここでは代わりに MAX_D を使うことにする）\ndp = [ [ -(10 ** 10) ] * (MAX_D + 1) for i in range(N + 1) ]\n\n# 動的計画法\ndp[0][0] = 0\nfor i in range(N):\n\tt, d = problems[i] # 書籍中の T[i], D[i] に対応\n\tfor j in range(MAX_D + 1):\n\t\tif j > d or j < t:\n\t\t\tdp[i + 1][j] = dp[i][j]\n\t\telse:\n\t\t\tdp[i + 1][j] = max(dp[i][j], dp[i][j - t] + 1)\n\n# 答えを出力\nanswer = max(dp[N])\nprint(answer)"
},
{
"id": 78,
"name": "answer_A76",
"Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n\nconst long long mod = 1000000007;\nlong long N, W, L, R, X[150009];\nint dp[150009], sum[150009];\n\nint main() {\n\t// 入力\n\tcin >> N >> W >> L >> R;\n\tfor (int i = 1; i <= N; i++) cin >> X[i];\n\n\t// 西岸を足場 0、東岸を足場 N+1 とみなす\n\tX[0] = 0; X[N + 1] = W;\n\n\t// 動的計画法・出力\n\tdp[0] = 1; sum[0] = 1;\n\tfor (int i = 1; i <= N + 1; i++) {\n\t\tint posL = lower_bound(X, X + N + 2, X[i] - R) - X;\n\t\tint posR = lower_bound(X, X + N + 2, X[i] - L + 1) - X; posR--;\n\n\t\t// dp[i] の値を累積和で計算（引き算の余りに注意！）\n\t\tif (posR == -1) dp[i] = 0;\n\t\telse dp[i] = sum[posR];\n\t\tif (posL >= 1) dp[i] -= sum[posL - 1];\n\t\tdp[i] = (dp[i] + mod) % mod;\n\n\t\t// 累積和 sum[i] を更新\n\t\tsum[i] = sum[i - 1] + dp[i];\n\t\tsum[i] %= mod;\n\t}\n\tcout << dp[N + 1] << endl;\n\treturn 0;\n}\n",
"Python": "import bisect\n\n# 入力\nN, W, L, R = map(int, input().split())\nX = list(map(int, input().split()))\n\n# 西岸を足場 0、東岸を足場 N+1 とみなす\nX = [ 0 ] + X + [ W ]\n\n# 動的計画法（書籍内の sum[i] は本コードの dpsum[i] に対応）\nMOD = 10 ** 9 + 7 # = 1000000007\ndp = [ 0 ] * (N + 2)\ndpsum = [ 0 ] * (N + 2)\ndp[0] = 1\ndpsum[0] = 1\nfor i in range(1, N + 2):\n\tposl = bisect.bisect_left(X, X[i] - R)\n\tposr = bisect.bisect_left(X, X[i] - L + 1) - 1\n\t# dp[i] の値を累積和で計算（C++ とは異なり、（負の値）% MOD も 0 以上 MOD-1 以下になることに注意）\n\tdp[i] = (dpsum[posr] if posr >= 0 else 0) - (dpsum[posl - 1] if posl >= 1 else 0)\n\tdp[i] %= MOD\n\t# 累積和 dpsum[i] の値を更新\n\tdpsum[i] = dpsum[i - 1] + dp[i]\n\tdpsum[i] %= MOD\n\n# 出力\nprint(dp[N + 1])"
},
{
"id": 79,
"name": "answer_A77",
"Cpp": "#include <iostream>\nusing namespace std;\n\nint N, L, K, A[100009];\n\nbool check(int x) {\n\tint Count = 0, Last_Kireme = 0;// Count は現時点で何回切ったかを表す\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (A[i] - Last_Kireme >= x && L - A[i] >= x) {\n\t\t\tCount += 1;\n\t\t\tLast_Kireme = A[i];\n\t\t}\n\t}\n\tif (Count >= K) return true;\n\treturn false;\n}\n\nint main() {\n\t// 入力\n\tcin >> N >> L >> K;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\n\t// 二分探索（left: 現在の下限／ right: 現在の上限）\n\tlong long left = 1, right = 1'000'000'000;\n\twhile (left < right) {\n\t\tlong long mid = (left + right + 1) / 2;\n\t\tbool Answer = check(mid);\n\t\tif (Answer == false) right = mid - 1; // 答えが前半部分に絞られる\n\t\tif (Answer == true) left = mid; // 答えが後半部分に絞られる\n\t}\n\n\t// 出力\n\tcout << left << endl;\n\treturn 0;\n}\n",
"Python": "# 入力\nN, L = map(int, input().split())\nK = int(input())\nA = list(map(int, input().split()))\n\n# スコアの最大値が x 以上かを判定する関数\ndef check(x):\n\tcnt = 0 # 現時点で何回切ったかを表す\n\tlast_kireme = 0 # 最後どこで切ったかを表す\n\tfor i in range(N):\n\t\tif A[i] - last_kireme >= x and L - A[i] >= x:\n\t\t\tcnt += 1\n\t\t\tlast_kireme = A[i]\n\treturn cnt >= K\n\n# 二分探索（left: 現在の上限 ／ right: 現在の下限）\nleft, right = 1, 10 ** 9\nwhile left < right:\n\tmid = (left + right + 1) // 2\n\tanswer = check(mid)\n\tif answer == False:\n\t\tright = mid - 1 # 答えが前半部分に絞られる\n\telse:\n\t\tleft = mid # 答えが後半部分に絞られる\n\n# 出力\nprint(left)"
}
] |