kyopro_editorial_cpp_py.json

[
  {
    "id": 1,
    "name": "B001",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint main() {\n\t// 入力\n\tint A, B;\n\tcin >> A >> B;\n\t\n\t// 出力\n\tcout << A + B << endl;\n\treturn 0;\n}\n",
    "Python": "A, B = map(int, input().split()) # 入力\nprint(A + B) # 出力\n"
  },
  {
    "id": 2,
    "name": "B002",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint main() {\n\t// 入力\n\tint A, B;\n\tcin >> A >> B;\n\t\n\t// 答えを求める\n\tbool Answer = false;\n\tfor (int i = A; i <= B; i++) {\n\t\tif (100 % i == 0) Answer = true;\n\t}\n\t\n\t// 出力\n\tif (Answer == true) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nA, B = map(int, input().split())\n\n# 答えを求める\nAnswer = False\nfor i in range(A, B + 1):\n\tif 100 % i == 0:\n\t\tAnswer = True\n\n# 出力\nif Answer == True:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
  },
  {
    "id": 3,
    "name": "B003",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint main() {\n\t// 入力\n\tint N, A[109];\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\t\n\t// 答えを求める\n\tbool Answer = false;\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = i + 1; j <= N; j++) {\n\t\t\tfor (int k = j + 1; k <= N; k++) {\n\t\t\t\tif (A[i] + A[j] + A[k] == 1000) Answer = true;\n\t\t\t}\n\t\t}\n\t}\n\t\n\t// 出力\n\tif (Answer == true) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# 答えを求める\nAnswer = False\nfor i in range(N):\n\tfor j in range(i+1, N):\n\t\tfor k in range(j+1, N):\n\t\t\tif A[i] + A[j] + A[k] == 1000:\n\t\t\t\tAnswer = True\n\n# 出力\nif Answer == True:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
  },
  {
    "id": 4,
    "name": "B004",
    "Cpp": "#include <iostream>\n#include <string>\nusing namespace std;\n \nint main() {\n\t// 入力\n\tstring N;\n\tcin >> N;\n\t\n\t// 答えを求める\n\tint Answer = 0;\n\tfor (int i = 0; i < N.size(); i++) {\n\t\tint keta;\n\t\tint kurai = (1 << (N.size() - 1 - i));\n\t\tif (N[i] == '0') keta = 0;\n\t\tif (N[i] == '1') keta = 1;\n\t\tAnswer += keta * kurai;\n\t}\n\t\n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = input()\n\n# 答えを求める\nAnswer = 0\nfor i in range(len(N)):\n\tketa = 0\n\tkurai = (2 ** (len(N) - 1 - i))\n\tif N[i] == '1':\n\t\tketa = 1\n\tAnswer += keta * kurai\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 5,
    "name": "B006",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint N, A[100009];\nint Q, L[100009], R[100009];\nint Atari[100009], Hazre[100009];\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> L[i] >> R[i];\n \n\t// アタリの個数・ハズレの個数の累積和を求める\n\tAtari[0] = 0;\n\tHazre[0] = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tAtari[i] = Atari[i - 1]; if (A[i] == 1) Atari[i] += 1;\n\t\tHazre[i] = Hazre[i - 1]; if (A[i] == 0) Hazre[i] += 1;\n\t}\n \n\t// 質問に答える\n\tfor (int i = 1; i <= Q; i++) {\n\t\tint NumAtari = Atari[R[i]] - Atari[L[i] - 1];\n\t\tint NumHazre = Hazre[R[i]] - Hazre[L[i] - 1];\n\t\tif (NumAtari > NumHazre) cout << \"win\" << endl;\n\t\telse if (NumAtari == NumHazre) cout << \"draw\" << endl;\n\t\telse cout << \"lose\" << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nA = list(map(int, input().split()))\nQ = int(input())\nL = [ None ] * Q\nR = [ None ] * Q\nfor i in range(Q):\n\tL[i], R[i] = map(int, input().split())\n\n# アタリの個数・ハズレの個数の累積和を求める\n# 配列 A が 0 番目から始まっていることに注意！\nAtari = [ 0 ] * (N + 1)\nHazre = [ 0 ] * (N + 1)\nfor i in range(1, N+1):\n\t# アタリについて計算\n\tAtari[i] = Atari[i - 1]\n\tif A[i - 1] == 1:\n\t\tAtari[i] += 1\n\t# ハズレについて計算\n\tHazre[i] = Hazre[i - 1]\n\tif A[i - 1] == 0:\n\t\tHazre[i] += 1\n\n# 質問に答える\nfor i in range(Q):\n\tNumAtari = Atari[R[i]] - Atari[L[i] - 1]\n\tNumHazre = Hazre[R[i]] - Hazre[L[i] - 1]\n\tif NumAtari > NumHazre:\n\t\tprint(\"win\")\n\telif NumAtari == NumHazre:\n\t\tprint(\"draw\")\n\telse:\n\t\tprint(\"lose\")\n"
  },
  {
    "id": 6,
    "name": "B007",
    "Cpp": "#include <iostream>\nusing namespace std;\n\nint N, T;\nint L[500009], R[500009];\nint Answer[500009], B[500009];\n\nint main() {\n\t// 入力\n\tcin >> T >> N;\n\tfor (int i = 1; i <= N; i++) cin >> L[i] >> R[i];\n\n\t// 前日比に加算\n\tfor (int i = 0; i <= T; i++) B[i] = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tB[L[i]] += 1;\n\t\tB[R[i]] -= 1;\n\t}\n\n\t// 累積和をとる\n\tAnswer[0] = B[0];\n\tfor (int d = 1; d <= T; d++) Answer[d] = Answer[d - 1] + B[d];\n\n\t// 出力\n\tfor (int d = 0; d < T; d++) cout << Answer[d] << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nT = 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 ] * (T + 1)\nfor i in range(N):\n\tB[L[i]] += 1\n\tB[R[i]] -= 1\n\n# 累積和をとる\nAnswer = [ None ] * (T + 1)\nAnswer[0] = B[0]\nfor d in range(1, T+1):\n\tAnswer[d] = Answer[d-1] + B[d]\n\n# 出力\nfor d in range(T):\n\tprint(Answer[d])\n"
  },
  {
    "id": 7,
    "name": "B008",
    "Cpp": "#include <iostream>\nusing namespace std;\n \n// 入力で与えられる変数\nint N, X[100009], Y[100009];\nint Q, A[100009], B[100009], C[100009], D[100009];\n \n// 各座標にある点の数 S[i][j]、二次元累積和 T[i][j]\nint S[1509][1509];\nint T[1509][1509];\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> A[i] >> B[i] >> C[i] >> D[i];\n \n\t// 各座標にある点の数を数える\n\tfor (int i = 1; i <= N; i++) S[X[i]][Y[i]] += 1;\n \n\t// 累積和をとる\n\tfor (int i = 0; i <= 1500; i++) {\n\t\tfor (int j = 0; j <= 1500; j++) T[i][j] = 0;\n\t}\n\tfor (int i = 1; i <= 1500; i++) {\n\t\tfor (int j = 1; j <= 1500; j++) T[i][j] = T[i][j - 1] + S[i][j];\n\t}\n\tfor (int i = 1; i <= 1500; i++) {\n\t\tfor (int j = 1; j <= 1500; j++) T[i][j] = T[i - 1][j] + T[i][j];\n\t}\n \n\t// 答えを求める\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcout << T[C[i]][D[i]] + T[A[i] - 1][B[i] - 1] - T[A[i] - 1][D[i]] - T[C[i]][B[i] - 1] << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "# 入力（前半）\nN = int(input())\nX = [ None ] * N\nY = [ None ] * N\nfor i in range(N):\n\tX[i], Y[i] = 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# 各座標にある点の数を数える\nS = [ [ 0 ] * 1501 for i in range(1501) ]\nfor i in range(N):\n\tS[X[i]][Y[i]] += 1\n\n# 累積和をとる\nT = [ [ 0 ] * 1501 for i in range(1501) ]\nfor i in range(1, 1501):\n\tfor j in range(1, 1501):\n\t\tT[i][j] = T[i][j-1] + S[i][j]\nfor j in range(1, 1501):\n\tfor i in range(1, 1501):\n\t\tT[i][j] = T[i-1][j] + T[i][j]\n\n# 答えを求める\nfor i in range(Q):\n\tprint(T[C[i]][D[i]] + T[A[i] - 1][B[i] - 1] - T[A[i] - 1][D[i]] - T[C[i]][B[i] - 1])\n"
  },
  {
    "id": 8,
    "name": "B009",
    "Cpp": "#include <iostream>\nusing namespace std;\n \n// 入力で与えられる変数\nint N;\nint A[100009], B[100009], C[100009], D[100009];\n \n// 座標 (i+0.5, j+0.5) に置かれている紙の数 T[i][j]\nint T[1509][1509];\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i] >> B[i] >> C[i] >> D[i];\n \n\t// 各紙について +1/-1 を加算\n\tfor (int i = 0; i <= 1500; i++) {\n\t\tfor (int j = 0; j <= 1500; j++) T[i][j] = 0;\n\t}\n\tfor (int i = 1; i <= N; i++) {\n\t\tT[A[i]][B[i]] += 1;\n\t\tT[A[i]][D[i]] -= 1;\n\t\tT[C[i]][B[i]] -= 1;\n\t\tT[C[i]][D[i]] += 1;\n\t}\n \n\t// 二次元累積和をとる\n\tfor (int i = 0; i <= 1500; i++) {\n\t\tfor (int j = 1; j <= 1500; j++) T[i][j] = T[i][j - 1] + T[i][j];\n\t}\n\tfor (int i = 1; i <= 1500; i++) {\n\t\tfor (int j = 0; j <= 1500; j++) T[i][j] = T[i - 1][j] + T[i][j];\n\t}\n \n\t// 面積を数える\n\tint Answer = 0;\n\tfor (int i = 0; i <= 1500; i++) {\n\t\tfor (int j = 0; j <= 1500; j++) {\n\t\t\tif (T[i][j] >= 1) Answer += 1;\n\t\t}\n\t}\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nA = [ None ] * N\nB = [ None ] * N\nC = [ None ] * N\nD = [ None ] * N\nfor i in range(N):\n\tA[i], B[i], C[i], D[i] = map(int, input().split())\n\n# 各紙について +1/-1 を加算\nT = [ [ 0 ] * 1501 for i in range(1501) ]\nfor i in range(N):\n\tT[A[i]][B[i]] += 1\n\tT[A[i]][D[i]] -= 1\n\tT[C[i]][B[i]] -= 1\n\tT[C[i]][D[i]] += 1\n\n# 累積和をとる\nfor i in range(0, 1501):\n\tfor j in range(1, 1501):\n\t\tT[i][j] = T[i][j-1] + T[i][j]\nfor i in range(1, 1501):\n\tfor j in range(0, 1501):\n\t\tT[i][j] = T[i-1][j] + T[i][j]\n\n# 面積を数える\nAnswer = 0\nfor i in range(1501):\n\tfor j in range(1501):\n\t\tif T[i][j] >= 1:\n\t\t\tAnswer += 1\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 9,
    "name": "B011",
    "Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n \nint N, A[100009];\nint Q, X[100009];\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> X[i];\n \n\t// 配列 X をソート\n\tsort(A + 1, A + N + 1);\n \n\t// 質問に答える\n\tfor (int i = 1; i <= Q; i++) {\n\t\tint pos1 = lower_bound(A + 1, A + N + 1, X[i]) - A;\n\t\tcout << pos1 - 1 << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "import bisect\n\n# 入力\nN = int(input())\nA = list(map(int, input().split()))\nQ = int(input())\nX = [ None ] * Q\nfor i in range(Q):\n\tX[i] = int(input())\n\n# 配列 X をソート\nA.sort()\n\n# 質問に答える（配列 A は 0 番目から始まっていることに注意！）\nfor i in range(Q):\n\tpos1 = bisect.bisect_left(A, X[i])\n\tprint(pos1)\n"
  },
  {
    "id": 10,
    "name": "B012",
    "Cpp": "#include <iostream>\nusing namespace std;\n \n// 関数 f\ndouble f(double x) {\n\treturn x * x * x + x;\n}\n \nint main() {\n\t// 入力\n\tint N;\n\tcin >> N;\n \n\t// 二分探索\n\tdouble Left = 0, Right = 100, Mid;\n\tfor (int i = 0; i < 20; i++) {\n\t\tMid = (Left + Right) / 2.0;\n\t\tdouble val = f(Mid);\n \n\t\t// 探索範囲を絞る\n\t\tif (val > 1.0 * N) Right = Mid; // 左半分に絞られる\n\t\telse Left = Mid; // 右半分に絞られる\n\t}\n \n\t// 出力\n\tprintf(\"%.12lf\\n\", Mid);\n\treturn 0;\n}\n",
    "Python": "def f(x):\n\treturn x*x*x + x\n\nN = int(input())\n\n# 二分探索\nLeft = 0.0\nRight = 100.0\nfor i in range(20):\n\tMid = (Left + Right) / 2\n\tval = f(Mid)\n\n\t# 探索範囲を絞る\n\tif val > N:\n\t\tRight = Mid # 左半分に絞られる\n\telse:\n\t\tLeft = Mid # 右半分に絞られる\n\n# 出力\nprint(Mid)\n"
  },
  {
    "id": 11,
    "name": "B013",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nlong long N, K;\nlong long A[100009];\nlong long S[100009]; // 累積和\nlong long R[100009]; // 左端が決まったとき、右端はどこまで行けるか\n \n// A[l] から A[r] までの合計値\nlong long sum(int l, int r) {\n\treturn S[r] - S[l - 1];\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\tS[0] = 0;\n\tfor (int i = 1; i <= N; i++) S[i] = S[i - 1] + A[i];\n \n\t// しゃくとり法\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (i == 1) R[i] = 0;\n\t\telse R[i] = R[i - 1];\n\t\twhile (R[i] < N && sum(i, R[i] + 1) <= K) {\n\t\t\tR[i] += 1;\n\t\t}\n\t}\n\t\n\t// 答えを求める\n\tlong long Answer = 0;\n\tfor (int i = 1; i <= N; i++) Answer += (R[i] - i + 1);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "# A[l] から A[r] までの合計値\ndef sum(l, r, S):\n\treturn S[r+1] - S[l]\n\n# 入力\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 累積和をとる\nS = [ 0 ] * (N + 1)\nfor i in range(1, N+1):\n\tS[i] = S[i-1] + A[i-1]\n\n# 配列の準備（R は 0 番目から始まることに注意）\nR = [ None ] * N\n\n# しゃくとり法\nfor i in range(N):\n\tif i == 0:\n\t\tR[i] = -1\n\telse:\n\t\tR[i] = R[i - 1]\n\twhile R[i] < N-1 and sum(i,R[i]+1,S) <= K:\n\t\tR[i] += 1\n\n# 答えを求める\nAnswer = 0\nfor i in range(N):\n\tAnswer += (R[i] - i + 1)\nprint(Answer)\n"
  },
  {
    "id": 12,
    "name": "B014",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n \n// 「配列 A にあるカードからいくつか選んだときの合計」として考えられるものを列挙\n// ビット全探索を使う\nvector<long long> Enumerate(vector<long long> A) {\n\tvector<long long> SumList;\n\tfor (int i = 0; i < (1 << A.size()); i++) {\n\t\tlong long sum = 0; // 現在の合計値\n\t\tfor (int j = 0; j < A.size(); j++) {\n\t\t\tint wari = (1 << j);\n\t\t\tif ((i / wari) % 2 == 1) sum += A[j];\n\t\t}\n\t\tSumList.push_back(sum);\n\t}\n\treturn SumList;\n}\n \nlong long N, K;\nlong long A[39];\n \nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n \n\t// カードを半分ずつに分ける\n\tvector<long long> L1, L2;\n\tfor (int i = 1; i <= N / 2; i++) L1.push_back(A[i]);\n\tfor (int i = N / 2 + 1; i <= N; i++) L2.push_back(A[i]);\n \n\t// それぞれについて、「あり得るカードの合計」を全列挙\n\tvector<long long> Sum1 = Enumerate(L1);\n\tvector<long long> Sum2 = Enumerate(L2);\n\tsort(Sum1.begin(), Sum1.end());\n\tsort(Sum2.begin(), Sum2.end());\n \n\t// 二分探索で Sum1[i] + Sum2[j] = K となるものが存在するかを見つける\n\tfor (int i = 0; i < Sum1.size(); i++) {\n\t\tint pos = lower_bound(Sum2.begin(), Sum2.end(), K - Sum1[i]) - Sum2.begin();\n\t\tif (pos < Sum2.size() && Sum2[pos] == K - Sum1[i]) {\n\t\t\tcout << \"Yes\" << endl;\n\t\t\treturn 0;\n\t\t}\n\t}\n\tcout << \"No\" << endl;\n\treturn 0;\n}\n",
    "Python": "import bisect\nimport sys\n\n# 「配列 A にあるカードからいくつか選んだときの合計」として考えられるものを列挙\n# ビット全探索を使う\ndef Enumerate(A):\n\tSumList = []\n\tfor i in range(2 ** len(A)):\n\t\tsum = 0 # 現在の合計値\n\t\tfor j in range(len(A)):\n\t\t\twari = (2 ** j)\n\t\t\tif (i // wari) % 2 == 1:\n\t\t\t\tsum += A[j]\n\t\tSumList.append(sum)\n\treturn SumList\n\n# 入力\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\n\n# カードを半分ずつに分ける\nL1 = A[0:(N//2)]\nL2 = A[(N//2):N]\n\n# それぞれについて、「あり得るカードの合計」を全列挙\nSum1 = Enumerate(L1)\nSum2 = Enumerate(L2)\nSum1.sort()\nSum2.sort()\n\n# 二分探索で Sum1[i] + Sum2[j] = K となるものが存在するかを見つける\nfor i in range(len(Sum1)):\n\tpos = bisect.bisect_left(Sum2, K-Sum1[i])\n\tif pos<len(Sum2) and Sum2[pos]==K-Sum1[i]:\n\t\tprint(\"Yes\")\n\t\tsys.exit(0)\n\n# 見つからなかった場合\nprint(\"No\")\n"
  },
  {
    "id": 13,
    "name": "B016",
    "Cpp": "#include <iostream>\n#include <cmath>\n#include <algorithm>\nusing namespace std;\n\nint N, H[100009];\nint dp[100009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> H[i];\n\n\t// 動的計画法\n\tdp[1] = 0;\n\tdp[2] = abs(H[1] - H[2]);\n\tfor (int i = 3; i <= N; i++) {\n\t\tdp[i] = min(dp[i - 1] + abs(H[i - 1] - H[i]), dp[i - 2] + abs(H[i - 2] - H[i]));\n\t}\n\n\t// 出力\n\tcout << dp[N] << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nH = list(map(int, input().split()))\n\n# 配列の準備\ndp = [ None ] * N\n\n# 動的計画法\ndp[0] = 0\ndp[1] = abs(H[0] - H[1])\nfor i in range(2, N):\n\tdp[i] = min(dp[i-1] + abs(H[i-1]-H[i]), dp[i-2] + abs(H[i-2]-H[i]))\n\n# 出力\nprint(dp[N-1])\n"
  },
  {
    "id": 14,
    "name": "B017",
    "Cpp": "#include <iostream>\n#include <cmath>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n \nint N, H[100009];\nint dp[100009];\nvector<int> Answer;\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> H[i];\n \n\t// 動的計画法\n\tdp[1] = 0;\n\tdp[2] = abs(H[1] - H[2]);\n\tfor (int i = 3; i <= N; i++) {\n\t\tdp[i] = min(dp[i - 1] + abs(H[i - 1] - H[i]), dp[i - 2] + abs(H[i - 2] - H[i]));\n\t}\n \n\t// 動的計画法の復元\n\tint Place = N;\n\twhile (true) {\n\t\tAnswer.push_back(Place);\n\t\tif (Place == 1) break;\n \n\t\t// どちらに移動するかを求める\n\t\tif (dp[Place - 1] + abs(H[Place - 1] - H[Place]) == dp[Place]) Place = Place - 1;\n\t\telse Place = Place - 2;\n\t}\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) cout << \" \";\n\t\tcout << Answer[i];\n\t}\n\tcout << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nH = list(map(int, input().split()))\n\n# 配列の準備\ndp = [ None ] * N\n\n# 動的計画法\ndp[0] = 0\ndp[1] = abs(H[0] - H[1])\nfor i in range(2, N):\n\tdp[i] = min(dp[i-1] + abs(H[i-1]-H[i]), dp[i-2] + abs(H[i-2]-H[i]))\n\n# 答えの復元\n# 変数 Place は現在位置（ゴールから進んでいく）\nAnswer = []\nPlace = N-1\nwhile True:\n\tAnswer.append(Place + 1)\n\tif Place == 0:\n\t\tbreak\n\n\t# どこから部屋 Place に向かうのが最適かを求める\n\tif dp[Place-1] + abs(H[Place-1]-H[Place]) == 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": 15,
    "name": "B018",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n \nint N, S, A[69];\nbool dp[69][10009];\nvector<int> Answer;\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] == false) {\n\t\tcout << \"-1\" << endl;\n\t\treturn 0;\n\t}\n \n\t// 答えの復元（Place は \"現在の総和\"）\n\tint Place = S;\n\tfor (int i = N; i >= 1; i--) {\n\t\tif (dp[i - 1][Place] == true) {\n\t\t\tPlace = Place - 0; // カード i を選ばない\n\t\t}\n\t\telse {\n\t\t\tPlace = Place - A[i]; // カード i を選ぶ\n\t\t\tAnswer.push_back(i);\n\t\t}\n\t}\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": "import sys\n\n# 入力\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] == False:\n\tprint(\"-1\")\n\tsys.exit(0)\n\n# 答えの復元\nAnswer = []\nPlace = S\nfor i in reversed(range(1,N+1)):\n\tif dp[i-1][Place] == True:\n\t\tPlace = Place - 0 # カード i を選ばない\n\telse:\n\t\tPlace = Place - A[i-1] # カード i を選ぶ\n\t\tAnswer.append(i)\nAnswer.reverse()\n\n# 答えを出力\nAnswer2 = [str(i) for i in Answer]\nprint(len(Answer))\nprint(\" \".join(Answer2))\n"
  },
  {
    "id": 16,
    "name": "B019",
    "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 <= 100000; 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 <= 100000; j++) {\n\t\t\tif (j < v[i]) dp[i][j] = dp[i - 1][j];\n\t\t\telse dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);\n\t\t}\n\t}\n\n\t// 答えの出力\n\tlong long Answer = 0;\n\tfor (int i = 0; i <= 100000; i++) {\n\t\tif (dp[N][i] <= W) Answer = i;\n\t}\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 ] * 100001 for i in range(N + 1) ]\ndp[0][0] = 0\nfor i in range(1, N+1):\n\tfor j in range(100001):\n\t\tif j < v[i]:\n\t\t\tdp[i][j] = dp[i-1][j]\n\t\tif j >= v[i]:\n\t\t\tdp[i][j] = min(dp[i-1][j], dp[i-1][j-v[i]]+w[i])\n\n# 出力\nAnswer = 0\nfor i in range(100001):\n\tif dp[N][i] <= W:\n\t\tAnswer = i\nprint(Answer)\n"
  },
  {
    "id": 17,
    "name": "B020",
    "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] = min({ dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] });\n\t\t\t}\n\t\t\telse if (i >= 1 && j >= 1) {\n\t\t\t\tdp[i][j] = min({ dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1 });\n\t\t\t}\n\t\t\telse if (i >= 1) {\n\t\t\t\tdp[i][j] = dp[i - 1][j] + 1;\n\t\t\t}\n\t\t\telse if (j >= 1) {\n\t\t\t\tdp[i][j] = dp[i][j - 1] + 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()\n\n# 配列の準備\ndp = [ [ None ] * (len(T) + 1) for i in range(len(S) + 1) ]\n\n# 動的計画法\ndp[0][0] = 0\nfor i in range(len(S)+1):\n\tfor j in range(len(T)+1):\n\t\tif i>=1 and j>=1 and S[i-1]==T[j-1]:\n\t\t\tdp[i][j] = min(dp[i-1][j]+1, dp[i][j-1]+1, dp[i-1][j-1])\n\t\telif i>=1 and j>=1:\n\t\t\tdp[i][j] = min(dp[i-1][j]+1, dp[i][j-1]+1, dp[i-1][j-1]+1)\n\t\telif i>=1:\n\t\t\tdp[i][j] = dp[i-1][j]+1\n\t\telif j>=1:\n\t\t\tdp[i][j] = dp[i][j-1]+1\n\n# 出力\nprint(dp[len(S)][len(T)])\n"
  },
  {
    "id": 18,
    "name": "B021",
    "Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n \nint N;\nint dp[1009][1009];\nstring S;\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tcin >> S;\n \n\t// 動的計画法（初期状態）\n\tfor (int i = 0; i < N; i++) dp[i][i] = 1;\n\tfor (int i = 0; i < N - 1; i++) {\n\t\tif (S[i] == S[i + 1]) dp[i][i + 1] = 2;\n\t\telse dp[i][i + 1] = 1;\n\t}\n \n\t// 動的計画法（状態遷移）\n\tfor (int LEN = 2; LEN <= N - 1; LEN++) {\n\t\tfor (int l = 0; l < N - LEN; l++) {\n\t\t\tint r = l + LEN;\n \n\t\t\tif (S[l] == S[r]) {\n\t\t\t\tdp[l][r] = max({ dp[l][r - 1], dp[l + 1][r], dp[l + 1][r - 1] + 2 });\n\t\t\t}\n\t\t\telse {\n\t\t\t\tdp[l][r] = max({ dp[l][r - 1], dp[l + 1][r] });\n\t\t\t}\n\t\t}\n\t}\n \n\t// 答えを求める\n\tcout << dp[0][N - 1] << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nS = input()\n\n# 動的計画法（初期状態）\ndp = [ [ None ] * N for i in range(N) ]\nfor i in range(N):\n\tdp[i][i] = 1\nfor i in range(N-1):\n\tif S[i] == S[i+1]:\n\t\tdp[i][i+1] = 2\n\telse:\n\t\tdp[i][i+1] = 1\n\n# 動的計画法（状態遷移）\nfor LEN in range(2,N):\n\tfor l in range(N-LEN):\n\t\tr = l + LEN\n\t\tif S[l] == S[r]:\n\t\t\tdp[l][r] = max(dp[l][r-1], dp[l+1][r], dp[l+1][r-1]+2)\n\t\telse:\n\t\t\tdp[l][r] = max(dp[l][r-1], dp[l+1][r])\n\n# 出力\nprint(dp[0][N-1])\n"
  },
  {
    "id": 19,
    "name": "B022",
    "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// 配列 dp の初期化\n\tdp[1] = 0;\n\tfor (int i = 2; i <= N; i++) dp[i] = 2000000000;\n\n\t// 動的計画法\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (i <= N - 1) dp[i + 1] = min(dp[i + 1], dp[i] + A[i + 1]); // 部屋 i+1 に行く場合\n\t\tif (i <= N - 2) dp[i + 2] = min(dp[i + 2], dp[i] + B[i + 2]); // 部屋 i+2 に行く場合\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# 配列 dp の初期化\ndp = [ 2000000000 ] * N\ndp[0] = 0\n\n# 動的計画法\nfor i in range(N):\n\tif i <= N-2:\n\t\tdp[i+1] = min(dp[i+1], dp[i] + A[i])\n\tif i <= N-3:\n\t\tdp[i+2] = min(dp[i+2], dp[i] + B[i])\n\n# 出力\nprint(dp[N-1])\n"
  },
  {
    "id": 20,
    "name": "B023",
    "Cpp": "#include <iostream>\n#include <cmath>\n#include <algorithm>\nusing namespace std;\n \nint N, X[19], Y[19];\ndouble dp[1 << 16][19];\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 0; i < N; i++) cin >> X[i] >> Y[i];\n \n\t// 配列 dp の初期化\n\tfor (int i = 0; i < (1 << N); i++) {\n\t\tfor (int j = 0; j < N; j++) dp[i][j] = 1e9;\n\t}\n \n\t// 動的計画法（dp[通った都市][今いる都市] となっている）\n\tdp[0][0] = 0;\n\tfor (int i = 0; i < (1 << N); i++) {\n\t\tfor (int j = 0; j < N; j++) {\n\t\t\tif (dp[i][j] >= 1e9) continue;\n \n\t\t\t// 都市 j から都市 k に移動したい！\n\t\t\tfor (int k = 0; k < N; k++) {\n\t\t\t\t// 既に都市 k を通っていた場合\n\t\t\t\tif ((i / (1 << k)) % 2 == 1) continue;\n \n\t\t\t\t// 状態遷移\n\t\t\t\tdouble DIST = sqrt(1.0 * (X[j] - X[k]) * (X[j] - X[k]) + 1.0 * (Y[j] - Y[k]) * (Y[j] - Y[k]));\n\t\t\t\tdp[i + (1 << k)][k] = min(dp[i + (1 << k)][k], dp[i][j] + DIST);\n\t\t\t}\n\t\t}\n\t}\n \n\t// 答えを出力\n\tprintf(\"%.12lf\\n\", dp[(1 << N) - 1][0]);\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nX = [ None ] * N\nY = [ None ] * N\nfor i in range(N):\n\tX[i], Y[i] = map(int, input().split())\n\n# 配列 dp の初期化\ndp = [ [ 1000000000.0 ] * N for i in range(2 ** N) ]\n\n# 動的計画法（dp[通った都市][今いる都市] となっている）\ndp[0][0] = 0\nfor i in range(2 ** N):\n\tfor j in range(N):\n\t\tif dp[i][j] < 1000000000.0:\n\n\t\t\t# 都市 j から k に移動したい！\n\t\t\tfor k in range(N):\n\t\t\t\tif (i // (2 ** k)) % 2 == 0:\n\t\t\t\t\tDIST = ((1.0*(X[j]-X[k])* (X[j]-X[k]) + 1.0*(Y[j]-Y[k])*(Y[j]-Y[k])) ** 0.5)\n\t\t\t\t\tdp[i + (2 ** k)][k] = min(dp[i + (2 ** k)][k], dp[i][j] + DIST)\n\n# 出力\nprint(dp[(2 ** N) - 1][0])\n"
  },
  {
    "id": 21,
    "name": "B024",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n \nint N, X[100009], Y[100009];\nint LEN, L[100009];\n \n// 配列 A の最長増加部分列（LIS）の長さを計算する\n// 配列 dp を使わない実装方法を利用している\nint Get_LISvalue(vector<int> A) {\n\tLEN = 0;\n\tfor (int i = 1; i <= A.size(); i++) L[i] = 0;\n \n\t// 動的計画法\n\tfor (int i = 0; i < A.size(); 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\treturn LEN;\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\tvector<pair<int, int>> tmp;\n\tfor (int i = 1; i <= N; i++) tmp.push_back(make_pair(X[i], -Y[i]));\n\tsort(tmp.begin(), tmp.end());\n\t\n\t// LIS を求めるべき配列は？\n\tvector<int> A;\n\tfor (int i = 0; i < tmp.size(); i++) {\n\t\tA.push_back(-tmp[i].second);\n\t}\n \n\t// 出力\n\tcout << Get_LISvalue(A) << endl;\n\treturn 0;\n}\n",
    "Python": "import bisect\n\n# 配列 A の最長増加部分列（LIS）の長さを計算する\n# 配列 dp を使わない実装方法を利用している\ndef Get_LISvalue(A):\n\tLEN = 0\n\tL = []\n\tfor i in range(N):\n\t\tpos = bisect.bisect_left(L, A[i])\n\t\tif pos == LEN:\n\t\t\tL.append(A[i])\n\t\t\tLEN += 1\n\t\telse:\n\t\t\tL[pos] = A[i]\n\treturn LEN\n\n# 入力\nN = int(input())\nX = [ None ] * N\nY = [ None ] * N\nfor i in range(N):\n\tX[i], Y[i] = map(int, input().split())\n\n# ソート\ntmp = []\nfor i in range(N):\n\ttmp.append([X[i], -Y[i]])\ntmp.sort()\n\n# LIS を求めるべき配列は？\nA = []\nfor i in range(N):\n\tA.append(-tmp[i][1])\n\n# 出力\nprint(Get_LISvalue(A))\n"
  },
  {
    "id": 22,
    "name": "B026",
    "Cpp": "#include <iostream>\nusing namespace std;\n\nint N;\nbool Deleted[1000009]; // 整数 x が消されている場合に限り Deleted[x]=true\n\nint main() {\n\t// 入力\n\tcin >> N;\n\n\t// エラトステネスのふるい（i は √N 以下の最大の整数までループする）\n\tfor (int i = 2; i <= N; i++) Deleted[i] = false;\n\tfor (int i = 2; i * i <= N; i++) {\n\t\tif (Deleted[i] == true) continue;\n\t\tfor (int j = i * 2; j <= N; j += i) Deleted[j] = true;\n\t}\n\n\t// 答えを出力\n\tfor (int i = 2; i <= N; i++) {\n\t\tif (Deleted[i] == false) cout << i << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\n\n# エラトステネスのふるい\n# 整数 x が消されている場合に限り Deleted[x]=true\nDeleted = [ False ] * 1000009\nLIMIT = int(N ** 0.5)\nfor i in range(2, LIMIT+1):\n\tif Deleted[i] == False:\n\t\tfor j in range(i*2, N+1, i):\n\t\t\tDeleted[j] = True\n\n# 答えを出力\nfor i in range(2, N+1):\n\tif Deleted[i] == False:\n\t\tprint(i)\n"
  },
  {
    "id": 23,
    "name": "B027",
    "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\tlong long A, B;\n\tcin >> A >> B;\n\tcout << A * B / 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(A * B // GCD(A, B))\n"
  },
  {
    "id": 24,
    "name": "B028",
    "Cpp": "#include <iostream>\nusing namespace std;\n\nconst int mod = 1000000007;\nint N, a[10000009];\n\nint main() {\n\t// 入力\n\tcin >> N;\n\n\t// フィボナッチ数列の計算\n\ta[1] = 1;\n\ta[2] = 1;\n\tfor (int i = 3; i <= N; i++) {\n\t\ta[i] = (a[i - 1] + a[i - 2]) % mod;\n\t}\n\n\t// 出力\n\tcout << a[N] << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\n\n# フィボナッチ数の計算\na = [ None ] * (N + 1)\na[1] = 1\na[2] = 1\nfor i in range(3, N+1):\n\ta[i] = (a[i-1] + a[i-2]) % 1000000007\n\n# 出力\nprint(a[N])\n"
  },
  {
    "id": 25,
    "name": "B029",
    "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 < 60; i++) {\n\t\tlong long wari = (1LL << 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(60):\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": 26,
    "name": "B030",
    "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\n// a ÷ b を m で割った余りを返す関数\nlong long Division(long long a, long long b, long long m) {\n\treturn (a * Power(b, m - 2, m)) % m;\n}\n\n// nCr mod 1000000007 を返す関数\nlong long ncr(int n, int r) {\n\tconst long long M = 1000000007;\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\treturn Division(a, b, M);\n}\n\nint main() {\n\t// 入力\n\tlong long H, W;\n\tcin >> H >> W;\n\n\t// 出力\n\tcout << ncr(H + W - 2, W - 1) << 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# nCr mod 1000000007 を返す関数\ndef ncr(n, r):\n\tM = 1000000007;\n\n\t# 手順 1: 分子 a を求める\n\ta = 1;\n\tfor i in range(1, n+1):\n\t\ta = (a*i) % M\n\n\t# 手順 2: 分母 b を求める\n\tb = 1;\n\tfor i in range(1, r+1):\n\t\tb = (b * i) % M\n\tfor i in range(1, n-r+1):\n\t\tb = (b * i) % M\n\n\t# 手順 3: 答えを求める\n\treturn Division(a, b, M);\n\n# 入力\nH, W = map(int, input().split())\n\n# 出力\nprint(ncr(H + W - 2, W - 1))\n"
  },
  {
    "id": 27,
    "name": "B031",
    "Cpp": "#include <iostream>\nusing namespace std;\n\nint main() {\n\tlong long N;\n\tcin >> N;\n\n\tlong long A1 = (N /   3); // 3 で割り切れるものの個数\n\tlong long A2 = (N /   5); // 5 で割り切れるものの個数\n\tlong long A3 = (N /   7); // 5 で割り切れるものの個数\n\tlong long A4 = (N /  15); // 3, 5 で割り切れるもの（= 15 の倍数）の個数\n\tlong long A5 = (N /  21); // 3, 7 で割り切れるもの（= 21 の倍数）の個数\n\tlong long A6 = (N /  35); // 5, 7 で割り切れるもの（= 35 の倍数）の個数\n\tlong long A7 = (N / 105); // 3, 5, 7 で割り切れるもの（= 105 の倍数）の個数\n\tcout << A1 + A2 + A3 - A4 - A5 - A6 + A7 << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\n\n# 計算\nA1 = (N //   3); # 3 で割り切れるものの個数\nA2 = (N //   5); # 5 で割り切れるものの個数\nA3 = (N //   7); # 5 で割り切れるものの個数\nA4 = (N //  15); # 3, 5 で割り切れるもの（= 15 の倍数）の個数\nA5 = (N //  21); # 3, 7 で割り切れるもの（= 21 の倍数）の個数\nA6 = (N //  35); # 5, 7 で割り切れるもの（= 35 の倍数）の個数\nA7 = (N // 105); # 3, 5, 7 で割り切れるもの（= 105 の倍数）の個数\n\n# 出力\nprint(A1 + A2 + A3 - A4 - A5 - A6 + A7)\n"
  },
  {
    "id": 28,
    "name": "B032",
    "Cpp": "#include <iostream>\nusing namespace std;\n\n// 配列 dp について： dp[x]=true のとき勝ちの状態、dp[x]=false のとき負けの状態\nint N, K, A[109];\nbool dp[100009];\n\nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tfor (int i = 1; i <= K; i++) cin >> A[i];\n\n\t// 勝者を計算する\n\tfor (int i = 0; i <= N; i++) {\n\t\tdp[i] = false;\n\t\tfor (int j = 1; j <= K; j++) {\n\t\t\tif (i >= A[j] && dp[i - A[j]] == false) {\n\t\t\t\tdp[i] = true; // 負けの状態に遷移できれば、勝ちの状態\n\t\t\t}\n\t\t}\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, K = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 勝者を計算する\n# 配列 dp について： dp[x]=true のとき勝ちの状態、dp[x]=false のとき負けの状態\ndp = [ None ] * (N + 1)\nfor i in range(N+1):\n\tdp[i] = False\n\tfor j in range(K):\n\t\tif i>=A[j] and dp[i-A[j]]==False:\n\t\t\tdp[i] = True # 負けの状態に遷移できれば、勝ちの状態\n\n# 出力\nif dp[N] == True:\n\tprint(\"First\")\nelse:\n\tprint(\"Second\")\n"
  },
  {
    "id": 29,
    "name": "B033",
    "Cpp": "#include <iostream>\nusing namespace std;\n\nint H, W;\nint N, A[200009], B[200009];\n\nint main() {\n\t// 入力\n\tcin >> N >> H >> W;\n\tfor (int i = 1; i <= N; i++) cin >> A[i] >> B[i];\n\n\t// 全部 XOR した値（ニム和）を求める\n\tint XOR_Sum = 0;\n\tfor (int i = 1; i <= N; i++) XOR_Sum = (XOR_Sum ^ (A[i] - 1));\n\tfor (int i = 1; i <= N; i++) XOR_Sum = (XOR_Sum ^ (B[i] - 1));\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, H, W = 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# 全部 XOR した値（ニム和）を求める\nXOR_Sum = 0\nfor i in range(N):\n\tXOR_Sum = (XOR_Sum ^ (A[i]-1))\n\tXOR_Sum = (XOR_Sum ^ (B[i]-1))\n\n# 出力\nif XOR_Sum != 0:\n\tprint(\"First\")\nelse:\n\tprint(\"Second\")\n"
  },
  {
    "id": 30,
    "name": "B034",
    "Cpp": "#include <iostream>\nusing namespace std;\n\nlong long N, X, Y, A[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\tint XOR_Sum = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (A[i] % 5 == 0 || A[i] % 5 == 1) XOR_Sum ^= 0;\n\t\tif (A[i] % 5 == 2 || A[i] % 5 == 3) XOR_Sum ^= 1;\n\t\tif (A[i] % 5 == 4) XOR_Sum ^= 2;\n\t}\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, X, Y = map(int, input().split())\nA = list(map(int, input().split()))\n\n# Grundy 数を計算\nXOR_Sum = 0\nfor i in range(N):\n\tGrundy = [0, 0, 1, 1, 2] # 5 で割った余りに対応する Grundy 数\n\tXOR_Sum ^= Grundy[A[i] % 5]\n\n# 出力\nif XOR_Sum != 0:\n\tprint(\"First\")\nelse:\n\tprint(\"Second\")\n"
  },
  {
    "id": 31,
    "name": "B036",
    "Cpp": "#include <iostream>\n#include <string>\nusing namespace std;\n \nint N, K;\nstring S;\n \nint main() {\n\t// 入力\n\tcin >> N >> K;\n\tcin >> S;\n \n\t// ON となっているものの個数を数える\n\tint numON = 0;\n\tfor (int i = 0; i < N; i++) {\n\t\tif (S[i] == '1') numON += 1;\n\t}\n \n\t// 答えを出力\n\tif (numON % 2 == K % 2) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN, K = map(int, input().split())\nS = input()\n\n# ON となっているものの個数を数える\nnumON = 0\nfor i in range(N):\n\tif S[i] == '1':\n\t\tnumON += 1\n\n# 答えを出力\nif numON%2 == K%2:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
  },
  {
    "id": 32,
    "name": "B037",
    "Cpp": "#include <iostream>\n#include <string>\nusing namespace std;\n \nlong long N;\nlong long R[18][10]; // R[i][j] は「下から i 桁目が j となるような N 以下の整数の個数」\nlong long Power10[18];\n \nint main() {\n\t// 入力\n\tcin >> N;\n \n\t// 10 の N 乗を求める\n\tPower10[0] = 1;\n\tfor (int i = 1; i <= 16; i++) Power10[i] = 10LL * Power10[i - 1];\n \n\t// R[i][j] の値を計算\n\tfor (int i = 0; i <= 15; i++) {\n\t\t// 下から i 桁目の数字を求める\n\t\tlong long Digit = (N / Power10[i]) % 10LL;\n \n\t\t// R[i][j] の値を求める\n\t\tfor (int j = 0; j < 10; j++) {\n\t\t\tif (j < Digit) {\n\t\t\t\tR[i][j] = (N / Power10[i + 1] + 1LL) * Power10[i];\n\t\t\t}\n\t\t\tif (j == Digit) {\n\t\t\t\tR[i][j] = (N / Power10[i + 1]) * Power10[i] + (N % Power10[i]) + 1LL;\n\t\t\t}\n\t\t\tif (j > Digit) {\n\t\t\t\tR[i][j] = (N / Power10[i + 1]) * Power10[i];\n\t\t\t}\n\t\t}\n\t}\n \n\t// 答えを求める\n\tlong long Answer = 0;\n\tfor (int i = 0; i <= 15; i++) {\n\t\tfor (int j = 0; j < 10; j++) Answer += 1LL * j * R[i][j];\n\t}\n \n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\n\n# 10 の N 乗を求める\nPower10 = [ None ] * 17\nfor i in range(17):\n\tPower10[i] = 10 ** i\n\n# R[i][j] の値を計算\nR = [ [ None ] * 10 for i in range(17) ]\nfor i in range(16):\n\t# 下から i 桁目の数字を求める\n\tDigit = (N // Power10[i]) % 10;\n\n\t# R[i][j] の値を求める\n\tfor j in range(10):\n\t\tif j < Digit:\n\t\t\tR[i][j] = (N // Power10[i + 1] + 1) * Power10[i]\n\t\tif j == Digit:\n\t\t\tR[i][j] = (N // Power10[i + 1]) * Power10[i] + (N % Power10[i]) + 1\n\t\tif j > Digit:\n\t\t\tR[i][j] = (N // Power10[i + 1]) * Power10[i]\n\n# 答えを求める\nAnswer = 0\nfor i in range(16):\n\tfor j in range(10):\n\t\tAnswer += j * R[i][j]\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 33,
    "name": "B038",
    "Cpp": "#include <iostream>\n#include <string>\n#include <algorithm>\nusing namespace std;\n \nint N, ret1[1 << 18], ret2[1 << 18];\nstring S;\n \nint main() {\n\t// 入力\n\tcin >> N >> S;\n \n\t// 答えを求める\n\tint streak1 = 1; ret1[0] = 1; // streak1 は「何個 A が連続したか」+ 1\n\tfor (int i = 0; i < N - 1; i++) {\n\t\tif (S[i] == 'A') streak1 += 1;\n\t\tif (S[i] == 'B') streak1 = 1;\n\t\tret1[i + 1] = streak1;\n\t}\n\tint streak2 = 1; ret2[N - 1] = 1; // streak2 は「何個 B が連続したか」+ 1\n\tfor (int i = N - 2; i >= 0; i--) {\n\t\tif (S[i] == 'B') streak2 += 1;\n\t\tif (S[i] == 'A') streak2 = 1;\n\t\tret2[i] = streak2;\n\t}\n \n\t// 出力\n\tlong long Answer = 0;\n\tfor (int i = 0; i < N; i++) Answer += max(ret1[i], ret2[i]);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nS = input()\n\n# 配列の準備\nret1 = [ None ] * N\nret2 = [ None ] * N\n\n# 答えを求める（前半）\nstreak1 = 1 # streak1 は「何個 A が連続したか」+ 1\nret1[0] = 1\nfor i in range(N-1):\n\tif S[i] == 'A':\n\t\tstreak1 += 1\n\tif S[i] == 'B':\n\t\tstreak1 = 1\n\tret1[i+1] = streak1\n\n# 答えを求める（後半）\nstreak2 = 1\nret2[N-1] = 1\nfor i in reversed(range(N-1)):\n\tif S[i] == 'A':\n\t\tstreak2 = 1\n\tif S[i] == 'B':\n\t\tstreak2 += 1\n\tret2[i] = streak2\n\n# 出力\nAnswer = 0\nfor i in range(N):\n\tAnswer += max(ret1[i], ret2[i])\nprint(Answer)\n"
  },
  {
    "id": 34,
    "name": "B039",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint N, D;\nint X[2009], Y[2009];\nbool used[2009]; // used[i] は仕事 i を選んだかどうか\nint Answer = 0;\n \nint main() {\n\t// 入力\n\tcin >> N >> D;\n\tfor (int i = 1; i <= N; i++) cin >> X[i] >> Y[i];\n \n\t// 答えを求める\n\tfor (int i = 1; i <= D; i++) {\n\t\tint maxValue = 0; // 給料の最大値\n\t\tint maxID = -1;   // 給料が最大となる仕事の番号\n\t\tfor (int j = 1; j <= N; j++) {\n\t\t\tif (used[j] == true) continue;\n\t\t\tif (maxValue < Y[j] && X[j] <= i) {\n\t\t\t\tmaxValue = Y[j];\n\t\t\t\tmaxID = j;\n\t\t\t}\n\t\t}\n \n\t\t// 選べる仕事がある場合\n\t\tif (maxID != -1) {\n\t\t\tAnswer += maxValue;\n\t\t\tused[maxID] = true;\n\t\t}\n\t}\n \n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN, D = map(int, input().split())\nX = [ None ] * N\nY = [ None ] * N\nfor i in range(N):\n\tX[i], Y[i] = map(int, input().split())\n\n# 配列の準備\n# used[i] は仕事 i を選んだかどうか\nused = [ False ] * N\n\n# 答えを求める\nAnswer = 0\nfor i in range(1, D+1):\n\tmaxValue = 0 # 給料の最大値\n\tmaxID = -1   # 給料が最大となる仕事の番号\n\tfor j in range(N):\n\t\tif used[j] == False and maxValue < Y[j] and X[j] <= i:\n\t\t\tmaxValue = Y[j]\n\t\t\tmaxID = j\n\n\t# 選べる仕事がある場合\n\tif maxID != -1:\n\t\tAnswer += maxValue\n\t\tused[maxID] = True\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 35,
    "name": "B040",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nlong long N, A[200009];\nlong long cnt[109];\nlong long Answer = 0;\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 = 0; i < 100; i++) cnt[i] = 0;\n\tfor (int i = 1; i <= N; i++) cnt[A[i] % 100] += 1;\n \n\t// 答えを求める\n\tfor (int i = 1; i < 50; i++) Answer += cnt[i] * cnt[100 - i];\n\tAnswer += cnt[0] * (cnt[0] - 1LL) / 2LL;\n\tAnswer += cnt[50] * (cnt[50] - 1LL) / 2LL;\n \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 ] * 100\nfor i in range(N):\n\tcnt[A[i] % 100] += 1\n \n# 答えを求める\nAnswer = 0\nfor i in range(1, 50):\n\tAnswer += cnt[i] * cnt[100-i]\nAnswer += cnt[0] * (cnt[0] - 1) // 2\nAnswer += cnt[50] * (cnt[50] - 1) // 2\n \n# 出力\nprint(Answer)\n"
  },
  {
    "id": 36,
    "name": "B041",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n \nint X, Y;\n \nint main() {\n\t// 入力\n\tcin >> X >> Y;\n \n\t// 逆から考えていく\n\tvector<pair<int, int>> Answer;\n\twhile (X >= 2 || Y >= 2) {\n\t\tAnswer.push_back(make_pair(X, Y));\n\t\tif (X > Y) X -= Y;\n\t\telse Y -= X;\n\t}\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\tcout << Answer[i].first << \" \" << Answer[i].second << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "# 入力\nX, Y = map(int, input().split())\n\n# 逆から考えていく\nAnswer = []\nwhile X>=2 or Y>=2:\n\tAnswer.append([X, Y])\n\tif X > Y:\n\t\tX -= Y\n\telse:\n\t\tY -= X\nAnswer.reverse()\n\n# 出力\nprint(len(Answer))\nfor i in range(len(Answer)):\n\tprint(str(Answer[i][0]) + ' ' + str(Answer[i][1]))\n"
  },
  {
    "id": 37,
    "name": "B042",
    "Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n \nlong long N;\nlong long A[100009], B[100009];\n \n// omote=1 のとき表の総和が正、ura=1 のとき裏の総和が正\n// omote=2 のとき表の総和が負、ura=2 のとき裏の総和が負\nlong long solve(int omote, int ura) {\n\tlong long sum = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tlong long card1 = A[i]; if (omote == 2) card1 = -A[i];\n\t\tlong long card2 = B[i]; if (ura == 2) card2 = -B[i];\n\t\t// カード i は選ぶべきか？\n\t\tif (card1 + card2 >= 0) {\n\t\t\tsum += (card1 + card2);\n\t\t}\n\t}\n\treturn sum;\n}\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i] >> B[i];\n \n\t// 表の総和の正負と、裏の総和の正負を全探索\n\tlong long Answer1 = solve(1, 1);\n\tlong long Answer2 = solve(1, 2);\n\tlong long Answer3 = solve(2, 1);\n\tlong long Answer4 = solve(2, 2);\n \n\t// 答えを出力\n\tcout << max({ Answer1,Answer2,Answer3,Answer4 }) << endl;\n\treturn 0;\n}\n",
    "Python": "# omote=1 のとき表の総和が正、ura=1 のとき裏の総和が正\n# omote=2 のとき表の総和が負、ura=2 のとき裏の総和が負\ndef solve(omote, ura, A, B):\n\tsum = 0\n\tfor i in range(N):\n\t\tcard1 = A[i]\n\t\tif omote == 2:\n\t\t\tcard1 = -A[i]\n\t\tcard2 = B[i]\n\t\tif ura == 2:\n\t\t\tcard2 = -B[i]\n\t\t# カード i は選ぶべきか？\n\t\tif card1 + card2 >= 0:\n\t\t\tsum += (card1 + card2)\n\treturn sum\n\n# 入力\nN = int(input())\nA = [ None ] * N\nB = [ None ] * N\nfor i in range(N):\n\tA[i], B[i] = map(int, input().split())\n\n# 表の総和の正負と、裏の総和の正負を全探索\nAnswer1 = solve(1, 1, A, B);\nAnswer2 = solve(1, 2, A, B);\nAnswer3 = solve(2, 1, A, B);\nAnswer4 = solve(2, 2, A, B);\n\n# 出力\nprint(max(Answer1, Answer2, Answer3, Answer4))\n"
  },
  {
    "id": 38,
    "name": "B043",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint N, M;\nint A[200009];\nint Incorrect[200009];\n \nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) cin >> A[i];\n \n\t// 不正解数を求める\n\tfor (int i = 1; i <= N; i++) Incorrect[i] = 0;\n\tfor (int i = 1; i <= M; i++) Incorrect[A[i]] += 1;\n \n\t// 答えを出力\n\tfor (int i = 1; i <= N; i++) cout << M - Incorrect[i] << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN, M = map(int, input().split())\nA = list(map(int, input().split()))\n\n# 配列の準備\nIncorrect = [ 0 ] * (N + 1)\n\n# 不正解数を求める\nfor i in range(M):\n\tIncorrect[A[i]] += 1\n\n# 答えを出力\nfor i in range(1, N+1):\n\tprint(M - Incorrect[i])\n"
  },
  {
    "id": 39,
    "name": "B044",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nint N, A[509][509];\nint Q, QueryType[200009], x[200009], y[200009];\nint T[509];\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 >> A[i][j];\n\t}\n \n\t// 配列 T を初期化\n\tfor (int i = 1; i <= N; i++) T[i] = i;\n \n\t// クエリの処理\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tcin >> QueryType[i] >> x[i] >> y[i];\n\t\tif (QueryType[i] == 1) {\n\t\t\tswap(T[x[i]], T[y[i]]);\n\t\t}\n\t\tif (QueryType[i] == 2) {\n\t\t\tcout << A[T[x[i]]][y[i]] << endl;\n\t\t}\n\t}\n\treturn 0;\n}\n",
    "Python": "# 入力\nN = int(input())\nA = [ None ] * N\nfor i in range(N):\n\tA[i] = list(map(int, input().split()))\n\n# 配列 T を初期化\n# 配列 A が 0 始まりなので、配列 T も 0 始まり\nT = [ None ] * N\nfor i in range(N):\n\tT[i] = i\n\n# クエリの処理\nQ = int(input())\nfor i in range(Q):\n\tQuery = list(map(int, input().split()))\n\tif Query[0] == 1:\n\t\tT[Query[1]-1],T[Query[2]-1] = T[Query[2]-1],T[Query[1]-1]\n\tif Query[0] == 2:\n\t\tprint(A[T[Query[1]-1]][Query[2]-1])\n"
  },
  {
    "id": 40,
    "name": "B045",
    "Cpp": "#include <iostream>\nusing namespace std;\n \nlong long a, b, c;\n \nint main() {\n\t// 入力\n\tcin >> a >> b >> c;\n \n\t// 出力\n\tif (a + b + c == 0) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\na, b, c = map(int, input().split())\n\n# 出力\nif a + b + c == 0:\n\tprint(\"Yes\")\nelse:\n\tprint(\"No\")\n"
  },
  {
    "id": 41,
    "name": "B051",
    "Cpp": "#include <iostream>\n#include <stack>\nusing namespace std;\n \nint main() {\n\t// 入力\n\tstring S;\n\tcin >> S;\n \n\t// 左から順番に見ていく\n\t// 文字列は 0 文字目から始まることに注意\n\tstack<int> Stack;\n\tfor (int i = 0; i < S.size(); i++) {\n\t\tif (S[i] == '(') {\n\t\t\tStack.push(i + 1);\n\t\t}\n\t\tif (S[i] == ')') {\n\t\t\tcout << Stack.top() << \" \" << i + 1 << endl;\n\t\t\tStack.pop();\n\t\t}\n\t}\n\treturn 0;\n}\n",
    "Python": "# 入力\nS = input()\n\n# 左から順番に見ていく\n# 文字列は 0 文字目から始まることに注意\nStack = []\nfor i in range(len(S)):\n\tif S[i] == '(':\n\t\tStack.append(i + 1)\n\tif S[i] == ')':\n\t\tprint(Stack.pop(), i + 1)\n"
  },
  {
    "id": 42,
    "name": "B052",
    "Cpp": "#include <iostream>\n#include <queue>\nusing namespace std;\n \nint N, X;\nchar A[100009];\nqueue<int> Q;\n \nint main() {\n\t// 入力\n\tcin >> N >> X;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n \n\t// シミュレーション\n\tQ.push(X); A[X] = '@';\n\twhile (!Q.empty()) {\n\t\tint pos = Q.front(); Q.pop();\n\t\tif (pos - 1 >= 1 && A[pos - 1] == '.') {\n\t\t\tA[pos - 1] = '@';\n\t\t\tQ.push(pos - 1);\n\t\t}\n\t\tif (pos + 1 <= N && A[pos + 1] == '.') {\n\t\t\tA[pos + 1] = '@';\n\t\t\tQ.push(pos + 1);\n\t\t}\n\t}\n \n\t// 出力\n\tfor (int i = 1; i <= N; i++) cout << A[i];\n\tcout << endl;\n\treturn 0;\n}\n",
    "Python": "from collections import deque\n\n\n# 入力\nN, X = map(int, input().split())\nX -= 1\nA = list(input())\n\n# シミュレーション\nQ = deque([X])\nQ.append(X)\nA[X] = '@'\nwhile Q:\n\tpos = Q.popleft()\n\tif pos - 1 >= 0 and A[pos - 1] == '.':\n\t\tA[pos - 1] = '@'\n\t\tQ.append(pos - 1)\n\tif pos + 1 < N and A[pos + 1] == '.':\n\t\tA[pos + 1] = '@'\n\t\tQ.append(pos + 1)\n\n# 出力\nprint(\"\".join(A))\n"
  },
  {
    "id": 43,
    "name": "B053",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <queue>\nusing namespace std;\n\nlong long N, D;\nlong long X[200009], Y[200009];\nvector<long long> G[375]; // G[i] は i 日目から始まる仕事の給料のリスト\nlong long Answer = 0;\n\nint main() {\n\t// 入力\n\tcin >> N >> D;\n\tfor (int i = 1; i <= N; i++) {\n\t\tcin >> X[i] >> Y[i];\n\t\tG[X[i]].push_back(Y[i]);\n\t}\n\n\t// 答えを求める\n\tpriority_queue<long long> Q;\n\tfor (int i = 1; i <= D; i++) {\n\t\t// i 日目から始まる仕事をキューに追加\n\t\tfor (int j : G[i]) Q.push(j);\n\n\t\t// やる仕事を選択し、その仕事をキューから削除する\n\t\tif (!Q.empty()) {\n\t\t\tAnswer += Q.top();\n\t\t\tQ.pop();\n\t\t}\n\t}\n\n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "import heapq\n\n\nG = [list() for _ in range(2005)] # G[i] は i 日目から始まる仕事の給料のリスト\n\n# 入力\nN, D = map(int, input().split())\nfor _ in range(N):\n\tX, Y = map(int, input().split())\n\tG[X].append(Y)\n\n# 答えを求める\nQ = []\nAnswer = 0\nfor i in range(1, D + 1):\n\t# i 日目から始まる仕事をキューに追加\n\t# heap は最小値を取り出すので -1 倍する\n\tfor y in G[i]: heapq.heappush(Q, -y)\n\n\t# やる仕事を選択し、その仕事をキューから削除する\n\tif Q:\n\t\tAnswer -= heapq.heappop(Q)\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 44,
    "name": "B054",
    "Cpp": "#include <iostream>\n#include <map>\nusing namespace std;\n \nint N, A[100009];\nmap<int, int> Map;\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n \n\t// 答えを求める\n\tlong long Answer = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tAnswer += Map[A[i]];\n\t\tMap[A[i]] += 1;\n\t}\n \n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "Map = {}\n \n# 入力\nN = int(input())\nA = [int(input()) for _ in range(N)]\n\n# 答えを求める\nAnswer = 0\nfor a in A:\n\t# dict.get にはキーが存在しなかった場合のデフォルト値を設定できる\n\tAnswer += Map.get(a, 0)\n\tMap[a] = Map.get(a, 0) + 1\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 45,
    "name": "B055",
    "Cpp": "#include <iostream>\n#include <set>\n#include <algorithm>\nusing namespace std;\n \nlong long Q, QueryType[100009], x[100009];\nset<long long> Set1, Set2;\n \n// r 以下の最大値を返す\nlong long GetDown(long long r) {\n\tauto itr = Set2.lower_bound(-r);\n \n\t// r 以下のものが存在しない場合、非常に小さい値を返す\n\tif (itr == Set2.end()) return -100000000000000LL;\n \n\t// 存在する場合\n\treturn -(*itr);\n}\n \n// r 以上の最小値を返す\nlong long GetUp(long long r) {\n\tauto itr = Set1.lower_bound(r);\n \n\t// r 以上のものが存在しない場合、非常に大きい値を返す\n\tif (itr == Set1.end()) return 100000000000000LL;\n \n\t// 存在する場合\n\treturn (*itr);\n}\n \nint main() {\n\t// 入力\n\tcin >> Q;\n\tfor (int i = 1; i <= Q; i++) cin >> QueryType[i] >> x[i];\n \n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 1) {\n\t\t\tSet1.insert(x[i]);\n\t\t\tSet2.insert(-x[i]);\n\t\t}\n\t\tif (QueryType[i] == 2) {\n\t\t\tlong long v1 = GetDown(x[i]);\n\t\t\tlong long v2 = GetUp(x[i]);\n\t\t\tlong long Answer = min(x[i] - v1, v2 - x[i]);\n\t\t\tif (Answer == 100000000000000LL) cout << \"-1\" << endl;\n\t\t\telse cout << Answer << endl;\n\t\t}\n\t}\n\treturn 0;\n}\n",
    "Python": "# Python には C++ の std::set に相当する標準ライブラリが存在しません。\n# std::set に相当する外部のライブラリを使用するのが良いでしょう。\n\n# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py\nimport math\nfrom bisect import bisect_left, bisect_right\nfrom typing import Generic, Iterable, Iterator, TypeVar, Union, List\nT = TypeVar('T')\n\nclass SortedSet(Generic[T]):\n    BUCKET_RATIO = 50\n    REBUILD_RATIO = 170\n\n    def _build(self, a=None) -> None:\n        \"Evenly divide `a` into buckets.\"\n        if a is None: a = list(self)\n        size = self.size = len(a)\n        bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))\n        self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]\n    \n    def __init__(self, a: Iterable[T] = []) -> None:\n        \"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)\"\n        a = list(a)\n        if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):\n            a = sorted(set(a))\n        self._build(a)\n\n    def __iter__(self) -> Iterator[T]:\n        for i in self.a:\n            for j in i: yield j\n\n    def __reversed__(self) -> Iterator[T]:\n        for i in reversed(self.a):\n            for j in reversed(i): yield j\n    \n    def __len__(self) -> int:\n        return self.size\n    \n    def __repr__(self) -> str:\n        return \"SortedSet\" + str(self.a)\n    \n    def __str__(self) -> str:\n        s = str(list(self))\n        return \"{\" + s[1 : len(s) - 1] + \"}\"\n\n    def _find_bucket(self, x: T) -> List[T]:\n        \"Find the bucket which should contain x. self must not be empty.\"\n        for a in self.a:\n            if x <= a[-1]: return a\n        return a\n\n    def __contains__(self, x: T) -> bool:\n        if self.size == 0: return False\n        a = self._find_bucket(x)\n        i = bisect_left(a, x)\n        return i != len(a) and a[i] == x\n\n    def add(self, x: T) -> bool:\n        \"Add an element and return True if added. / O(√N)\"\n        if self.size == 0:\n            self.a = [[x]]\n            self.size = 1\n            return True\n        a = self._find_bucket(x)\n        i = bisect_left(a, x)\n        if i != len(a) and a[i] == x: return False\n        a.insert(i, x)\n        self.size += 1\n        if len(a) > len(self.a) * self.REBUILD_RATIO:\n            self._build()\n        return True\n\n    def discard(self, x: T) -> bool:\n        \"Remove an element and return True if removed. / O(√N)\"\n        if self.size == 0: return False\n        a = self._find_bucket(x)\n        i = bisect_left(a, x)\n        if i == len(a) or a[i] != x: return False\n        a.pop(i)\n        self.size -= 1\n        if len(a) == 0: self._build()\n        return True\n    \n    def lt(self, x: T) -> Union[T, None]:\n        \"Find the largest element < x, or None if it doesn't exist.\"\n        for a in reversed(self.a):\n            if a[0] < x:\n                return a[bisect_left(a, x) - 1]\n\n    def le(self, x: T) -> Union[T, None]:\n        \"Find the largest element <= x, or None if it doesn't exist.\"\n        for a in reversed(self.a):\n            if a[0] <= x:\n                return a[bisect_right(a, x) - 1]\n\n    def gt(self, x: T) -> Union[T, None]:\n        \"Find the smallest element > x, or None if it doesn't exist.\"\n        for a in self.a:\n            if a[-1] > x:\n                return a[bisect_right(a, x)]\n\n    def ge(self, x: T) -> Union[T, None]:\n        \"Find the smallest element >= x, or None if it doesn't exist.\"\n        for a in self.a:\n            if a[-1] >= x:\n                return a[bisect_left(a, x)]\n    \n    def __getitem__(self, x: int) -> T:\n        \"Return the x-th element, or IndexError if it doesn't exist.\"\n        if x < 0: x += self.size\n        if x < 0: raise IndexError\n        for a in self.a:\n            if x < len(a): return a[x]\n            x -= len(a)\n        raise IndexError\n    \n    def index(self, x: T) -> int:\n        \"Count the number of elements < x.\"\n        ans = 0\n        for a in self.a:\n            if a[-1] >= x:\n                return ans + bisect_left(a, x)\n            ans += len(a)\n        return ans\n\n    def index_right(self, x: T) -> int:\n        \"Count the number of elements <= x.\"\n        ans = 0\n        for a in self.a:\n            if a[-1] > x:\n                return ans + bisect_right(a, x)\n            ans += len(a)\n        return ans\n\n# SortedSet ここまで\n \n# 入力\nQ = int(input())\nQuery = [tuple(map(int, input().split())) for _ in range(Q)]\n\n# クエリの処理\nINF = 1 << 61\nSet = SortedSet([-INF, INF]) # x より小さい / 大きい数が存在しなかったときのための番兵\n\nfor type, x in Query:\n\tif type == 1:\n\t\tSet.add(x)\n\tif type == 2:\n\t\tif len(Set) == 2:\n\t\t\tprint(-1)\n\t\t\tcontinue\n\t\tv1 = Set.le(x)\n\t\tv2 = Set.ge(x)\n\t\tAnswer = min(x - v1, v2 - x)\n\t\tprint(Answer)\n"
  },
  {
    "id": 46,
    "name": "B056",
    "Cpp": "#include <iostream>\n#include <string>\n#include <algorithm>\nusing namespace std;\n\n// 入力で与えられる変数など\nint N, Q, L[100009], R[100009];\nstring S;\nstring SRev; // S の逆順\n\n// 文字列を数値に変換した値（それぞれ S, SRev に対応）\nint T[100009];\nint TRev[100009];\n\n// ハッシュ値など\nlong long mod = 2147483647;\nlong long Power100[100009];\nlong long H[100009];    // S のハッシュ\nlong long HRev[100009]; // SRev のハッシュ\n\n// 文字列の l～r 番目を前から読んだ時のハッシュ値を返す関数\nlong long GetHashLeft(int l, int r) {\n\tlong long val = H[r] - (Power100[r - l + 1] * H[l - 1] % mod);\n\tif (val < 0) val += mod;\n\treturn val;\n}\n\n// 文字列の l～r 番目を後ろから読んだ時のハッシュ値を返す関数\nlong long GetHashRight(int l, int r) {\n\tint true_l = N + 1 - r;\n\tint true_r = N + 1 - l;\n\tlong long val = HRev[true_r] - (Power100[true_r - true_l + 1] * HRev[true_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 >> L[i] >> R[i];\n\tSRev = S;\n\treverse(SRev.begin(), SRev.end());\n\n\t// S, SRev の文字を数値に変換\n\tfor (int i = 1; i <= N; i++) T[i] = (int)(S[i - 1] - 'a') + 1;\n\tfor (int i = 1; i <= N; i++) TRev[i] = (int)(SRev[i - 1] - 'a') + 1;\n\n\t// 100 の n 乗を前計算\n\tPower100[0] = 1;\n\tfor (int i = 1; i <= N; i++) Power100[i] = (100LL * Power100[i - 1]) % mod;\n\n\t// S のハッシュ値を前計算\n\tH[0] = 1;\n\tfor (int i = 1; i <= N; i++) H[i] = (100LL * H[i - 1] + T[i]) % mod;\n\n\t// SRev のハッシュ値を前計算\n\tHRev[0] = 1;\n\tfor (int i = 1; i <= N; i++) HRev[i] = (100LL * HRev[i - 1] + TRev[i]) % mod;\n\n\t// クエリの処理\n\tfor (int i = 1; i <= Q; i++) {\n\t\tlong long v1 = GetHashLeft(L[i], R[i]);\n\t\tlong long v2 = GetHashRight(L[i], R[i]);\n\t\t// 左から読んだ時・右から読んだ時のハッシュ値が一致していれば回文\n\t\tif (v1 == v2) cout << \"Yes\" << endl;\n\t\telse cout << \"No\" << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "mod = 2147483647\n\n# 文字列の l～r 番目を前から読んだ時のハッシュ値を返す関数\ndef GetHashLeft(l: int, r: int) -> int:\n\tval = H[r] - Power100[r - l + 1] * H[l - 1]\n\treturn val % mod\n\n# 文字列の l～r 番目を後ろから読んだ時のハッシュ値を返す関数\ndef GetHashRight(l: int, r: int) -> int:\n\tl, r = N + 1 - r, N + 1 - l\n\tval = HRev[r] - Power100[r - l + 1] * HRev[l - 1]\n\treturn val % mod\n\n# 入力\nN, Q = map(int, input().split())\nS = input()\nQuery = [tuple(map(int, input().split())) for _ in range(Q)]\n\n# S の各文字を数値に変換\nS = list(S)\nfor i in range(N):\n\tS[i] = ord(S[i]) - ord('a') + 1\nSRev = S[::-1]\n\n# 100 の n 乗を前計算\nPower100 = [1] * (N + 1)\nfor i in range(N):\n\tPower100[i + 1] = Power100[i] * 100 % mod\n\n# S のハッシュ値を前計算\nH = [1] * (N + 1)\nfor i in range(N):\n\tH[i + 1] = (H[i] * 100 + S[i]) % mod\n\n# SRev のハッシュ値を前計算\nHRev = [1] * (N + 1)\nfor i in range(N):\n\tHRev[i + 1] = (HRev[i] * 100 + SRev[i]) % mod\n\n# クエリの処理\nfor L, R in Query:\n\tv1 = GetHashLeft(L, R)\n\tv2 = GetHashRight(L, R)\n\t# 左から読んだ時・右から読んだ時のハッシュ値が一致していれば回文\n\tif v1 == v2:\n\t\tprint(\"Yes\")\n\telse:\n\t\tprint(\"No\")\n"
  },
  {
    "id": 47,
    "name": "B057",
    "Cpp": "#include <iostream>\n#include <string>\nusing namespace std;\n \nint N, K;\nint dp[32][300009];\n \nint main() {\n\t// 入力\n\tcin >> N >> K;\n \n\t// 1 回操作した後の値を求める\n\tfor (int i = 1; i <= N; i++) {\n\t\tstring str = to_string(i);\n\t\tdp[0][i] = i;\n\t\tfor (int j = 0; j < str.size(); j++) {\n\t\t\tdp[0][i] -= (int)(str[j] - '0');\n\t\t}\n\t}\n \n\t// 前計算\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 i = 1; i <= N; i++) {\n\t\tint CurrentNum = i; // 現在の整数\n\t\tfor (int d = 29; d >= 0; d--) {\n\t\t\tif ((K / (1 << d)) % 2 != 0) CurrentNum = dp[d][CurrentNum];\n\t\t}\n\t\tcout << CurrentNum << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "dp = [[0] * 300009 for _ in range(30)]\n \n# 入力\nN, K = map(int, input().split())\n\n# 1 回操作した後の値を求める\nfor i in range(N + 1):\n\tdp[0][i] = i - sum(map(int, str(i)))\n\n# 前計算\nfor d in range(29):\n\tfor i in range(N + 1):\n\t\tdp[d + 1][i] = dp[d][dp[d][i]]\n\n# 答えを求める\nfor num in range(1, N + 1):\n\tfor d in range(30):\n\t\tif K & (1 << d):\n\t\t\tnum = dp[d][num]\n\tprint(num)\n"
  },
  {
    "id": 48,
    "name": "B058",
    "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] = min(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 min(AnswerL, AnswerR);\n\t}\n};\n \nint N, L, R, X[100009];\nint dp[100009];\nSegmentTree Z;\n \nint main() {\n\t// 入力\n\tcin >> N >> L >> R;\n\tfor (int i = 1; i <= N; i++) cin >> X[i];\n \n\t// セグメント木の準備\n\tZ.init(N);\n\tdp[1] = 0;\n\tZ.update(1, 0);\n \n\t// 動的計画法\n\tfor (int i = 2; i <= N; i++) {\n\t\tint posL = lower_bound(X + 1, X + N + 1, X[i] - R) - X;\n\t\tint posR = lower_bound(X + 1, X + N + 1, X[i] - L + 1) - X - 1;\n\t\tdp[i] = Z.query(posL, posR + 1, 1, Z.siz + 1, 1) + 1;\n\t\tZ.update(i, dp[i]);\n\t}\n \n\t// 答えを出力\n\tcout << dp[N] << endl;\n\treturn 0;\n}\n",
    "Python": "import bisect\n\n\nINF = 1 << 61\nsiz = 1 << 17\ndat = [INF] * (siz * 2)\n\n# 代入 seg[i] = v\ndef update(i: int, v: int) -> None:\n\ti += siz\n\tdat[i] = v\n\twhile i > 1:\n\t\ti >>= 1\n\t\tdat[i] = min(dat[i * 2], dat[i * 2 + 1])\n\n# min(seg[l], seg[l + 1], ..., seg[r - 1]) を求める\ndef query(l: int, r: int) -> int:\n\tl += siz\n\tr += siz\n\tanswer = INF\n\twhile l < r:\n\t\tif l & 1:\n\t\t\tif answer > dat[l]:\n\t\t\t\tanswer = dat[l]\n\t\t\tl += 1\n\t\tif r & 1:\n\t\t\tr -= 1\n\t\t\tif answer > dat[r]:\n\t\t\t\tanswer = dat[r]\n\t\tl >>= 1\n\t\tr >>= 1\n\treturn answer\n\n# 入力\nN, L, R = map(int, input().split())\nX = list(map(int, input().split()))\ndp = [0] * N\n\n# 動的計画法\nupdate(0, 0)\nfor i in range(1, N):\n\tx = X[i]\n\tposL = bisect.bisect_left(X, x - R)\n\tposR = bisect.bisect_right(X, x - L)\n\tdp[i] = query(posL, posR) + 1\n\tupdate(i, dp[i])\n\nprint(dp[-1])\n"
  },
  {
    "id": 49,
    "name": "B059",
    "Cpp": "#include <iostream>\n#include <algorithm>\nusing namespace std;\n \nclass SegmentTree {\npublic:\n\tint dat[600000], 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, A[150009];\nSegmentTree Z;\n \nint main() {\n\t// 入力\n\tcin >> N;\n\tfor (int i = 1; i <= N; i++) cin >> A[i];\n \n\t// セグメント木の準備\n\tZ.init(N);\n \n\t// 答えを求める\n\tlong long Answer = 0;\n\tfor (int i = 1; i <= N; i++) {\n\t\tAnswer += Z.query(A[i] + 1, N + 1, 1, Z.siz + 1, 1);\n\t\tZ.update(A[i], 1);\n\t}\n \n\t// 出力\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "siz = 1 << 18\ndat = [0] * (siz * 2)\n\n# 代入 seg[i] = v\ndef update(i: int, v: int) -> None:\n\ti += siz\n\tdat[i] = v\n\twhile i > 1:\n\t\ti >>= 1\n\t\tdat[i] = dat[i * 2] + dat[i * 2 + 1]\n\n# sum(seg[l], seg[l + 1], ..., seg[r - 1]) を求める\ndef query(l: int, r: int) -> int:\n\tl += siz\n\tr += siz\n\tanswer = 0\n\twhile l < r:\n\t\tif l & 1:\n\t\t\tanswer += dat[l]\n\t\t\tl += 1\n\t\tif r & 1:\n\t\t\tr -= 1\n\t\t\tanswer += dat[r]\n\t\tl >>= 1\n\t\tr >>= 1\n\treturn answer\n\n# 入力\nN = int(input())\nA = list(map(int, input().split()))\n\n# 答えを求める\nAnswer = 0\nfor a in A:\n\tAnswer += query(a + 1, siz)\n\tupdate(a, 1)\n\n# 出力\nprint(Answer)\n"
  },
  {
    "id": 50,
    "name": "B061",
    "Cpp": "#include <iostream>\n#include <vector>\nusing namespace std;\n \nint N, M, 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\tint MaxFriends = 0; // 友達の数の最大値\n\tint MaxID = 0;      // 番号\n\tfor (int i = 1; i <= N; i++) {\n\t\tif (MaxFriends < (int)G[i].size()) {\n\t\t\tMaxFriends = (int)G[i].size();\n\t\t\tMaxID = i;\n\t\t}\n\t}\n \n\t// 出力\n\tcout << MaxID << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nN, M = map(int, input().split())\n\n# 友達の数を数える\nfriend = [0] * N\nfor _ in range(M):\n    A, B = map(int, input().split())\n    A -= 1\n    B -= 1\n    friend[A] += 1\n    friend[B] += 1\n\nmx = max(friend)\nans = friend.index(mx)\nprint(ans + 1)\n"
  },
  {
    "id": 51,
    "name": "B062",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <string>\nusing namespace std;\n \n// 入力\nint N, M, A[100009], B[100009];\n \n// 深さ優先探索\nvector<int> G[100009];\nbool visited[100009];\n \n// 深さ優先探索の跡\nvector<int> Path, Answer;\n \nvoid dfs(int pos) {\n\t// ゴール地点にたどり着いた！\n\tif (pos == N) {\n\t\tAnswer = Path;\n\t\treturn;\n\t}\n \n\t// その他の場合\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) {\n\t\t\tPath.push_back(nex); // 頂点 nex を経路に追加\n\t\t\tdfs(nex);\n\t\t\tPath.pop_back(); // 頂点 nex を経路から削除\n\t\t}\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\tPath.push_back(1); // 頂点 1（スタート地点）を経路に追加\n\tdfs(1);\n \n\t// 答えの出力\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": "import sys\nsys.setrecursionlimit(1 << 20)  # 再帰上限がデフォルトで 1000 なので変更する\n\n# 入力\nN, M = map(int, input().split())\ng = [[] for _ in range(N)]\nfor i in range(M):\n    A, B = map(int, input().split())\n    A -= 1\n    B -= 1\n    g[A].append(B)\n    g[B].append(A)\n\n# 深さ優先探索\nvisited = [False] * (N + 1)\npath = []\n\ndef dfs(i: int):\n    path.append(i)\n    # ゴール地点にたどり着いた！\n    if i == N - 1:\n        # 答えを出力して終了\n        for x in path:\n            print(x + 1) # 1-indexed に変更\n        exit(0)\n\n    # その他の場合\n    visited[i] = True\n    for j in g[i]:\n        if not visited[j]:\n            dfs(j)\n    path.pop()\n\ndfs(0)\n"
  },
  {
    "id": 52,
    "name": "B063",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <queue>\nusing namespace std;\n\n// 入力\nint H, W;\nint sx, sy, start; // スタートの座標 (sx, sy) と頂点番号 sx*H+sy\nint gx, gy, goal;  // ゴールの座標 (gx, gy) と頂点番号 gx*W+gy\nchar c[59][59];\n\n// グラフ・最短経路\nint dist[2509];\nvector<int> G[2509];\n\nint main() {\n\t// 入力\n\tcin >> H >> W;\n\tcin >> sx >> sy; start = sx * W + sy;\n\tcin >> gx >> gy; goal = gx * W + gy;\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// 横方向の辺 [(i, j) - (i, j+1)] をグラフに追加\n\tfor (int i = 1; i <= H; i++) {\n\t\tfor (int j = 1; j <= W - 1; j++) {\n\t\t\tint idx1 = i * W + j; // 頂点 (i, j) の頂点番号\n\t\t\tint idx2 = i * W + (j + 1); // 頂点 (i, j+1) の頂点番号\n\t\t\tif (c[i][j] == '.' && c[i][j + 1] == '.') {\n\t\t\t\tG[idx1].push_back(idx2);\n\t\t\t\tG[idx2].push_back(idx1);\n\t\t\t}\n\t\t}\n\t}\n\n\t// 縦方向の辺 [(i, j) - (i+1, j)] をグラフに追加\n\tfor (int i = 1; i <= H - 1; i++) {\n\t\tfor (int j = 1; j <= W; j++) {\n\t\t\tint idx1 = i * W + j; // 頂点 (i, j) の頂点番号\n\t\t\tint idx2 = (i + 1) * W + j; // 頂点 (i+1, j) の頂点番号\n\t\t\tif (c[i][j] == '.' && c[i + 1][j] == '.') {\n\t\t\t\tG[idx1].push_back(idx2);\n\t\t\t\tG[idx2].push_back(idx1);\n\t\t\t}\n\t\t}\n\t}\n\n\t// 幅優先探索の初期化\n\tfor (int i = 1; i <= H * W; i++) dist[i] = -1;\n\tqueue<int> Q;\n\tQ.push(start); dist[start] = 0;\n\n\t// 幅優先探索\n\twhile (!Q.empty()) {\n\t\tint pos = Q.front();\n\t\tQ.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\tcout << dist[goal] << endl;\n\treturn 0;\n}\n",
    "Python": "# 入力\nH, W = map(int, input().split())\nsx, sy = map(int, input().split())\nsx -= 1\nsy -= 1\ngx, gy = map(int, input().split())\ngx -= 1\ngy -= 1\nS = [input() for _ in range(H)]\n\nINF = 1 << 61\n# Python では多次元配列は 1 次元に flatten した方が速い (ここでは使わない)\ncost = [[INF] * W for _ in range(H)]\n\nq = [] # queue は list で再現できる\n# マスに訪れる部分を関数に切り出すと良い\ndef push(x: int, y: int, c: int):\n    if S[x][y] == '#':\n        return\n    if cost[x][y] <= c:\n        return\n    cost[x][y] = c\n    q.append((x, y))\n\n# 幅優先探索\npush(sx, sy, 0)\nfor x, y in q:\n    c2 = cost[x][y] + 1\n    push(x - 1, y, c2)\n    push(x, y - 1, c2)\n    push(x + 1, y, c2)\n    push(x, y + 1, c2)\n\nprint(cost[gx][gy])\n"
  },
  {
    "id": 53,
    "name": "B064",
    "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// 答えの復元（Place は現在の位置：ゴールから出発）\n\tvector<int> Answer;\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\tfor (int i = 0; i < G[Place].size(); i++) {\n\t\t\tint nex = G[Place][i].first;\n\t\t\tint cost = G[Place][i].second;\n\t\t\tif (cur[nex] + cost == cur[Place]) {\n\t\t\t\tPlace = nex;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\treverse(Answer.begin(), Answer.end());\n \n\t// 出力\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": "from heapq import heappush, heappop\n\nN, M = map(int, input().split())\ng = [[] for _ in range(N)]\nfor _ in range(M):\n    A, B, C = map(int, input().split())\n    A -= 1\n    B -= 1\n    g[A].append((B, C))\n    g[B].append((A, C))\n\nINF = 1 << 61\ncost = [INF] * N\nback = [-1] * N\nq = []\n\n# 頂点に訪れる部分を関数に切り出す\ndef push(prev: int, i: int, c: int):\n    if cost[i] <= c:\n        return\n    cost[i] = c\n    back[i] = prev\n    heappush(q, (c, i))\n\n# 復元の都合上後ろから Dijkstra 法\npush(-1, N - 1, 0)\nwhile q:\n    c, x = heappop(q)\n    if cost[x] != c:\n        continue # 同じ頂点から複数回探索しない (worst Θ(N^2) 時間になります)\n    for j, d in g[x]:\n        push(x, j, c + d)\n\n# 最短経路を復元\nans = [0]\nwhile ans[-1] != N - 1:\n    ans.append(back[ans[-1]])\n\nfor x in ans:\n    print(x + 1)"
  },
  {
    "id": 54,
    "name": "B065",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\nusing namespace std;\n \n// 入力される変数・答え\nint N, T, A[100009], B[100009];\nint Answer[100009];\n \n// グラフ・深さ優先探索\nvector<int> G[100009];\nbool visited[100009];\n \n// 深さ優先探索を行う関数（pos は現在位置）\n// 返り値は社員 pos の階級\nint dfs(int pos) {\n\t// 最初、社員 pos の階級を 0 に設定する\n\tvisited[pos] = true;\n\tAnswer[pos] = 0;\n \n\t// 探索をする\n\tfor (int i = 0; i < G[pos].size(); i++) {\n\t\tint nex = G[pos][i];\n\t\tif (visited[nex] == false) {\n\t\t\tint ret = dfs(nex);\n\t\t\tAnswer[pos] = max(Answer[pos], ret + 1); // 階級を更新する\n\t\t}\n\t}\n \n\t// 値を返す\n\treturn Answer[pos];\n}\n \nint main() {\n\t// 入力\n\tcin >> N >> T;\n\tfor (int i = 1; i <= N - 1; 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\tdfs(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": "import sys\nsys.setrecursionlimit(1 << 30)  # 再帰上限をなくす\n\nN, T = map(int, input().split())\nT -= 1\ng = [[] for _ in range(N)]\nfor _ in range(N - 1):\n    A, B = map(int, input().split())\n    A -= 1\n    B -= 1\n    g[A].append(B)\n    g[B].append(A)\n\nrank = [0] * N\n\n# 深さ優先探索\ndef dfs(parent: int, i: int) -> int:\n    for j in g[i]:\n        if j == parent:\n            continue\n        r = dfs(i, j) + 1\n        if rank[i] < r:\n            rank[i] = r\n    return rank[i]\ndfs(-1, T)\n\nprint(*rank)\n"
  },
  {
    "id": 55,
    "name": "B066",
    "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 \n// 入力で与えられる変数・答え\nint N, M, A[100009], B[100009];\nint Q, QueryType[100009], x[100009], u[100009], v[100009];\nstring Answer[100009];\n \n// その他の変数\nUnionFind UF;\nbool cancelled[100009];\n \nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= M; i++) cin >> A[i] >> B[i];\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\tif (QueryType[i] == 2) cin >> u[i] >> v[i];\n\t}\n \n\t// 最初に運休になっている路線を求める\n\tfor (int i = 1; i <= M; i++) cancelled[i] = false;\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 1) cancelled[x[i]] = true;\n\t}\n \n\t// Union-Find の初期化（その日の最後の状態にする）\n\tUF.init(N);\n\tfor (int i = 1; i <= M; i++) {\n\t\tif (cancelled[i] == false && UF.same(A[i], B[i]) == false) {\n\t\t\tUF.unite(A[i], B[i]);\n\t\t}\n\t}\n \n\t// クエリを逆から処理\n\tfor (int i = Q; i >= 1; i--) {\n\t\tif (QueryType[i] == 1) {\n\t\t\t// 駅 A[x[i]] と駅 B[x[i]] を結ぶ路線が開通\n\t\t\tif (UF.same(A[x[i]], B[x[i]]) == false) UF.unite(A[x[i]], B[x[i]]);\n\t\t}\n\t\tif (QueryType[i] == 2) {\n\t\t\tif (UF.same(u[i], v[i]) == true) Answer[i] = \"Yes\";\n\t\t\telse Answer[i] = \"No\";\n\t\t}\n\t}\n \n\t// 出力\n\tfor (int i = 1; i <= Q; i++) {\n\t\tif (QueryType[i] == 2) cout << Answer[i] << endl;\n\t}\n\treturn 0;\n}\n",
    "Python": "# 辺を減らしながら連結性を答えるのは難しいので、クエリを逆向きにして辺を増やしながら答える\n\nN, M = map(int, input().split())\n\nedge = []\nfor _ in range(M):\n    A, B = map(int, input().split())\n    A -= 1\n    B -= 1\n    edge.append((A, B))\n\n# 最後まである辺を求める\nQ = int(input())\nquery = [list(map(int, input().split())) for _ in range(Q)]\nlast = [True] * M\nfor q in query:\n    if q[0] == 1:\n        q[1] -= 1\n        last[q[1]] = False\n    else:\n        q[1] -= 1\n        q[2] -= 1\n\n# union-find\nuf = [-1] * N\ndef root(i: int) -> int:\n    # path halving\n    while True:\n        if uf[i] < 0:\n            return i\n        if uf[uf[i]] < 0:\n            return uf[i]\n        uf[i] = uf[uf[i]]\n        i = uf[i]\ndef unite(i: int, j: int):\n    i = root(i)\n    j = root(j)\n    if i == j:\n        return\n    # マージテク (union by size)\n    if uf[i] > uf[j]:\n        i, j = j, i\n    uf[i] += uf[j]\n    uf[j] = i\n\nans = []\nfor i in range(M):\n    if last[i]:\n        A, B = edge[i]\n        unite(A, B)\n\nfor q in reversed(query):\n    if q[0] == 1:\n        A, B = edge[q[1]]\n        unite(A, B)\n    else:\n        _, U, V = q\n        ans.append(\"Yes\" if root(U) == root(V) else \"No\")\n\nfor s in reversed(ans):\n    print(s)\n"
  },
  {
    "id": 56,
    "name": "B067",
    "Cpp": "#include <iostream>\n#include <vector>\n#include <algorithm>\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 \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\treverse(EdgeList.begin(), EdgeList.end()); // 問題 A67 と異なる唯一の部分\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": "N, M = map(int, input().split())\n\nedge = []\nfor _ in range(M):\n    A, B, C = map(int, input().split())\n    A -= 1\n    B -= 1\n    edge.append((A, B, C))\n\n# 長さの逆順でソート\nedge.sort(key=lambda e: -e[2])\n\n# union-find\nuf = [-1] * N\ndef root(i: int) -> int:\n    # path halving\n    while True:\n        if uf[i] < 0:\n            return i\n        if uf[uf[i]] < 0:\n            return uf[i]\n        uf[i] = uf[uf[i]]\n        i = uf[i]\ndef unite(i: int, j: int) -> bool:\n    i = root(i)\n    j = root(j)\n    if i == j:\n        return False\n    # マージテク (union by size)\n    if uf[i] > uf[j]:\n        i, j = j, i\n    uf[i] += uf[j]\n    uf[j] = i\n    return True\n\n# クラスカル法\nans = 0\nfor A, B, C in edge:\n    if unite(A, B):\n        ans += C\n\nprint(ans)\n"
  },
  {
    "id": 57,
    "name": "B068",
    "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, P[159];\nint M, A[159], B[159];\nMaximumFlow Z;\n \nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= N; i++) cin >> P[i];\n\tfor (int i = 1; i <= M; i++) cin >> A[i] >> B[i];\n \n\t// グラフを作る（前半パート）\n\tint Offset = 0;\n\tZ.init(N);\n\tfor (int i = 1; i <= N; i++) {\n\t\t// 効果が正の場合は、特急駅にしない場合（始点→i）のコストを P[i] に設定\n\t\tif (P[i] >= 0) {\n\t\t\tZ.add_edge(N + 1, i, P[i]);\n\t\t\tOffset += P[i];\n\t\t}\n\t\t// 効果が負の場合は、特急駅にする場合（i→終点）のコストを -P[i] に設定\n\t\tif (P[i] < 0) {\n\t\t\tZ.add_edge(i, N + 2, -P[i]);\n\t\t}\n\t}\n \n\t// グラフを作る（後半パート）\n\tfor (int i = 1; i <= M; i++) {\n\t\tZ.add_edge(A[i], B[i], 1000000000);\n\t}\n \n\t// 答えを求める\n\tint Answer = Offset - Z.max_flow(N + 1, N + 2);\n\tcout << Answer << endl;\n\treturn 0;\n}\n",
    "Python": "INF = 1 << 61\nclass Edge:\n    def __init__(self, to, cap, rev):\n        self.to = to\n        self.cap = cap\n        self.rev = rev\n\nclass FordFulkerson:\n    def __init__(self, N):\n        self.size = N\n        self.g = [[] for _ in range(N)]\n\n    def add_edge(self, a, b, c):\n        g = self.g\n        e = Edge(b, c, None)\n        rev = Edge(a, 0, e)\n        e.rev = rev\n        g[a].append(e)\n        g[b].append(rev)\n\n    def dfs(self, i, goal, F):\n        # ゴールに到着\n        if i == goal:\n            return F\n\n        self.visited[i] = True\n\n        for e in self.g[i]:\n            # 容量 0 の辺は使えない\n            if e.cap == 0:\n                continue\n            # 既に訪問した頂点に行かない\n            if self.visited[e.to]:\n                continue\n            # 目的地までのパスを探す\n            flow = self.dfs(e.to, goal, min(F, e.cap))\n            # フローを流せる場合、残余グラフの容量を flow だけ増減させる\n            if flow:\n                e.cap -= flow\n                e.rev.cap += flow\n                return flow\n        # すべての辺を探索しても見つからなかった\n        return 0\n\n    def max_flow(self, s, t):\n        ans = 0\n        while True:\n            self.visited = [False] * self.size\n            F = self.dfs(s, t, INF)\n\n            # フローを流せなくなったら操作終了\n            if F == 0:\n                break\n            ans += F\n        return ans\n\nN, M = map(int, input().split())\nP = list(map(int, input().split()))\n\n# グラフを構築\nS = N\nT = N + 1\ng = FordFulkerson(T + 1)\noffset = 0\nfor i in range(N):\n    if P[i] >= 0:\n        # 特急駅にしない場合のコスト\n        offset += P[i]\n        g.add_edge(S, i, P[i])\n    else:\n        # 特急駅にする場合のコスト\n        g.add_edge(i, T, -P[i])\n\nfor _ in range(M):\n    A, B = map(int, input().split())\n    A -= 1\n    B -= 1\n    g.add_edge(A, B, INF)\n\nprint(offset - g.max_flow(S, T))\n"
  },
  {
    "id": 58,
    "name": "B069",
    "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;\nchar C[59][24];\nMaximumFlow Z;\n \nint main() {\n\t// 入力\n\tcin >> N >> M;\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 0; j <= 23; j++) cin >> C[i][j];\n\t}\n \n\t// グラフを作る（前半パート）\n\tZ.init(N + 26);\n\tfor (int i = 1; i <= N; i++) {\n\t\tZ.add_edge(N + 25, i, 10); // 従業員は 10 時間までしか働けない\n\t}\n\tfor (int i = 0; i <= 23; i++) {\n\t\tZ.add_edge(N + i, N + 26, M); // シフトは M 人以上欲しい\n\t}\n \n\t// グラフを作る（後半パート）\n\tfor (int i = 1; i <= N; i++) {\n\t\tfor (int j = 0; j <= 23; j++) {\n\t\t\tif (C[i][j] == '1') Z.add_edge(i, N + j, 1);\n\t\t}\n\t}\n \n\t// 答えを求める\n\tint Answer = Z.max_flow(N + 25, N + 26);\n\tif (Answer == 24 * M) cout << \"Yes\" << endl;\n\telse cout << \"No\" << endl;\n\treturn 0;\n}\n",
    "Python": "INF = 1 << 61\nclass Edge:\n    def __init__(self, to, cap, rev):\n        self.to = to\n        self.cap = cap\n        self.rev = rev\n\nclass FordFulkerson:\n    def __init__(self, N):\n        self.size = N\n        self.g = [[] for _ in range(N)]\n\n    def add_edge(self, a, b, c):\n        g = self.g\n        e = Edge(b, c, None)\n        rev = Edge(a, 0, e)\n        e.rev = rev\n        g[a].append(e)\n        g[b].append(rev)\n\n    def dfs(self, i, goal, F):\n        # ゴールに到着\n        if i == goal:\n            return F\n\n        self.visited[i] = True\n\n        for e in self.g[i]:\n            # 容量 0 の辺は使えない\n            if e.cap == 0:\n                continue\n            # 既に訪問した頂点に行かない\n            if self.visited[e.to]:\n                continue\n            # 目的地までのパスを探す\n            flow = self.dfs(e.to, goal, min(F, e.cap))\n            # フローを流せる場合、残余グラフの容量を flow だけ増減させる\n            if flow:\n                e.cap -= flow\n                e.rev.cap += flow\n                return flow\n        # すべての辺を探索しても見つからなかった\n        return 0\n\n    def max_flow(self, s, t):\n        ans = 0\n        while True:\n            self.visited = [False] * self.size\n            F = self.dfs(s, t, INF)\n\n            # フローを流せなくなったら操作終了\n            if F == 0:\n                break\n            ans += F\n        return ans\n\nN, M = map(int, input().split())\n\n# グラフを構築 (二部マッチング)\nS = N + 24\nT = S + 1\ng = FordFulkerson(T + 1)\n\nfor i in range(N):\n    C = input()\n    g.add_edge(S, i, 10)\n    for j, c in enumerate(C):\n        if c == '1':\n            g.add_edge(i, N + j, 1)\nfor j in range(24):\n    g.add_edge(N + j, T, M)\n\nprint(\"Yes\" if g.max_flow(S, T) == M * 24 else \"No\")\n"
  }
]