kyopro_codes_cpp_py.json

[
  {
    "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)"
  }
]