testcase-data/eval/To-fix-wrong-code.json

[
    {
        "code_id": 2,
        "code": "print(1)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "Fraction of Fractal 分形之分数",
        "query": "# Fraction of Fractal 分形之分数\n题目描述\\r\n\r\nSnuke 从他的母亲那里得到了生日礼物——一个网格。网格有 $H$ 行 $W$ 列。每个单元格都是黑色或白色。所有黑色单元格都是四联通的，也就是说，只做水平或垂直移动且只经过黑色单元格即可从任何黑色单元格移动到任何其他黑色单元格。\r\n\r\n第 $i$ 行第 $j$ 列（$1\\le i\\le H,1\\le j\\le W$）的单元格的颜色由字符 $s_{ij}$ 表示。如果 $s_{ij}$ 是 `#`，该单元格为黑色；如果 $s_{ij}$ 是 `.`，该单元格为白色。至少一个单元格是黑色的。\r\n\r\n我们定义「分形」如下：$0$ 级分形是一个 $1\\times 1$ 的黑色单元格。$k+1$ 级分形由 $H$ 行 $W$ 列较小一级的分形按照 Snuke 的网格的样式拼成：与 Snuke 网格中的黑色单元格对应的位置是一个 $k$ 级分形；与 Snuke 网格中的白色单元格对应的位置是一个单元格全部为白色，尺寸与 $k$ 级分形相同的网格。\r\n\r\n您将得到 Snuke 的网格的描述和整数 $K$。请求出 $K$ 级分形中黑色单元格组成的连通分量数，模 $10^9+7$。\n## 输入格式\n输入从标准输入流按以下形式给出：\r\n\r\n> $H$　$W$　$K$  \r\n> $s_{11}\\cdots s_{1W}$  \r\n> $\\vdots$  \r\n> $s_{H1}\\cdots s_{HW}$\n## 输出格式\n输出 $K$ 级分形中黑色单元格组成的连通分量数，模 $10^9+7$。\n## 样例\n### 样例 1\n输入:\n3 3 3\n.#.\n###\n#.#\n输出:\n20\n\n本测试点中 3 级分形如下，共有 20 个黑色单元格组成的连通分量：\n```plain\n.............#.............\n............###............\n............#.#............\n..........#..#..#..........\n.........#########.........\n.........#.##.##.#.........\n..........#.....#..........\n.........###...###.........\n.........#.#...#.#.........\n....#........#........#....\n...###......###......###...\n...#.#......#.#......#.#...\n.#..#..#..#..#..#..#..#..#.\n###########################\n#.##.##.##.##.##.##.##.##.#\n.#.....#..#.....#..#.....#.\n###...######...######...###\n#.#...#.##.#...#.##.#...#.#\n....#.................#....\n...###...............###...\n...#.#...............#.#...\n.#..#..#...........#..#..#.\n#########.........#########\n#.##.##.#.........#.##.##.#\n.#.....#...........#.....#.\n###...###.........###...###\n#.#...#.#.........#.#...#.#\n```\n### 样例 2\n输入:\n3 3 3\n###\n#.#\n###\n输出:\n1\n\n\n### 样例 3\n输入:\n11 15 1000000000000000000\n.....#.........\n....###........\n....####.......\n...######......\n...#######.....\n..##.###.##....\n..##########...\n.###.....####..\n.####...######.\n###############\n#.##..##..##..#\n输出:\n301811921\n\n\n## 数据范围与提示\n对于所有数据：\r\n\r\n* $1\\le H,W\\le 1000$  \r\n* $0\\le K\\le 10^{18}$  \r\n* 每个 $s_{ij}$ 是 `#` 或 `.`  \r\n* 网格中所有黑色单元格四联通  \r\n* 网格中至少有一个黑色单元格",
        "sample": {
            "input": "3 3 3\n.#.\n###\n#.#",
            "output": "20"
        }
    },
    {
        "code_id": 2,
        "code": "a, b = input().split()\n\n# dp[0] 表示只有个位时的 windy 数\ndp = [[0] * 10 for _ in range(len(b))]\ndp[0] = [1] * 10\n\n\ndef search(i, digit, uplim=10):\n    ''' i: 本位所在的数位\n        digit: 本位的数字\n        uplim: 下位的数字限制'''\n    dolim = min((uplim, max((digit - 1, 0))))\n    return sum(dp[i - 1][:dolim]) + sum(dp[i - 1][digit + 2: uplim])\n\n\n# 枚举数位: 从低位到高位\nfor i in range(1, len(b)):\n    # 枚举本位的数字\n    for j in range(10):\n        dp[i][j] = search(i, j)\n# print(*dp, sep='\\n')\n\n\ndef solve(n):\n    length = len(n)\n    n = list(map(int, n))\n    # 进行等价处理: 5678 等价于 5497\n    for i in range(1, length):\n        if n[i - 1] + 2 > n[i]:\n            if n[i - 1] - 2 < n[i]:\n                n[i] = n[i - 1] - 2\n                # 修改后续数位的上限\n                for j in range(i + 1, length): n[j] = 9\n    # print(n)\n    n.reverse()\n    # 对于 465: 拆分为 0~399, 400~459, 460~465\n    # 预计算 0~399 的部分\n    ret = sum(dp[length - 1][1: n[-1]]) + sum(sum(dp[i][1:]) for i in range(length - 1))\n    # print(ret)\n    # 限定最高位为最大值, 计算其它部分\n    for i in range(length - 1, 0, -1):\n        if n[i] < 0: break\n        ret += search(i, n[i], uplim=n[i - 1] + (i == 1))\n    #     print(ret)\n    # print(ret)\n    # print()\n    return ret\n\n\nprint(solve(b) - solve(str(int(a) - 1)))\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "Windy 数",
        "query": "# Windy 数\n## 题目描述\n\nWindy 定义了一种 Windy 数：不含前导零且相邻两个数字之差至少为 $2$ 的正整数被称为 Windy 数。\n\nWindy 想知道，在 $A$ 和 $B$ 之间，包括 $A$ 和 $B$，总共有多少个 Windy 数？\n## 输入格式\n一行两个数，分别为 $A,B$。\n## 输出格式\n输出一个整数，表示答案。\n## 样例\n### 样例 1\n输入:\n1 10\n输出:\n9\n\n\n### 样例 2\n输入:\n25 50\n输出:\n20\n\n\n## 数据范围与提示\n$100\\%$ 的数据，满足 $1\\le A\\le B\\le 2\\times 10^9$。\n",
        "sample": {
            "input": "1 10",
            "output": "9"
        }
    },
    {
        "code_id": 3,
        "code": "\n\nimport java.io.BufferedReader;\nimport java.io.IOException;\nimport java.io.InputStreamReader;\nimport java.io.OutputStreamWriter;\nimport java.io.PrintWriter;\nimport java.io.StreamTokenizer;\n\npublic class Main {\n\n\tpublic static int MAXN = 10001;\n\n\tpublic static long[] arr = new long[MAXN];\n\n\tpublic static int n;\n\n\tpublic static int k;\n\n\tpublic static boolean zero;\n\n\t// 利用高斯消元生成异或空间线性基\n\tpublic static void basis() {\n\t\tlong max = arr[1];\n\t\tfor (int i = 2; i <= n; i++) {\n\t\t\tmax = Math.max(max, arr[i]);\n\t\t}\n\t\tint m = 0;\n\t\twhile ((max >> (m + 1)) != 0) {\n\t\t\tm++;\n\t\t}\n\t\tk = 1;\n\t\tfor (long i = 1L << m; i != 0; i >>= 1) {\n\t\t\tfor (int j = k; j <= n; j++) {\n\t\t\t\tif ((arr[j] & i) != 0) {\n\t\t\t\t\tswap(j, k);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ((arr[k] & i) != 0) {\n\t\t\t\tfor (int j = 1; j <= n; j++) {\n\t\t\t\t\tif (j != k && (arr[j] & i) != 0) {\n\t\t\t\t\t\tarr[j] ^= arr[k];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tk++;\n\t\t\t}\n\t\t}\n\t\tk--;\n\t\tzero = k != n;\n\t}\n\n\tpublic static void swap(int a, int b) {\n\t\tlong tmp = arr[a];\n\t\tarr[a] = arr[b];\n\t\tarr[b] = tmp;\n\t}\n\n\tpublic static long query(long kth) {\n\t\tlong ans = 0;\n\t\tif (zero) {\n\t\t\tkth--;\n\t\t}\n\t\tif (kth == 0) {\n\t\t\treturn 0;\n\t\t}\n\t\tfor (int i = k; i >= 1; i--) {\n\t\t\tif ((kth & 1) != 0) {\n\t\t\t\tans ^= arr[i];\n\t\t\t}\n\t\t\tkth >>= 1;\n\t\t}\n\t\tif (kth > 0) {\n\t\t\treturn -1;\n\t\t}\n\t\treturn ans;\n\t}\n\n\tpublic static void main(String[] args) throws IOException {\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\tStreamTokenizer in = new StreamTokenizer(br);\n\t\tPrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));\n\t\tin.nextToken();\n\t\tn = (int) in.nval;\n\t\tfor (int i = 1; i <= n; i++) {\n\t\t\tin.nextToken();\n\t\t\tarr[i] = (long) in.nval;\n\t\t}\n\t\tbasis();\n\t\tin.nextToken();\n\t\tint q = (int) in.nval;\n\t\tfor (int i = 1; i <= q; i++) {\n\t\t\tin.nextToken();\n\t\t\tlong kth = (long) in.nval;\n\t\t\tout.println(query(kth));\n\t\t}\n\t\tout.flush();\n\t\tout.close();\n\t\tbr.close();\n\t}\n\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "k 大异或和",
        "query": "# k 大异或和\n## 题目描述\n\r\n\r\n给由 $ n $ 个数组成的一个可重集 $ S $，每次给定一个数 $ k $，求一个集合 $ T \\subseteq S $，使得集合 $ T $ 在 $ S $ 的所有非空子集的不同的异或和中，其异或和 $ T_1 \\mathbin{\\text{xor}} T_2 \\mathbin{\\text{xor}} \\ldots \\mathbin{\\text{xor}} T_{|T|} $ 是第 $ k $ 小的。\n## 输入格式\n第一行一个数 $ n $。  \r\n第二行 $ n $ 个数，表示集合 $ S $。  \r\n第三行一个数 $ m $，表示询问次数。  \r\n第四行 $ m $ 个数，表示每一次询问的 $ k $。\n## 输出格式\n输出 $ m $ 行，对应每一次询问的答案，第 $ k $ 小的异或和。如果集合 $ S $ 的所有非空子集中，不同的异或和数量不足 $ k $，输出 $ -1 $。\n## 样例\n输入:\n3\n1 2 3\n5\n1 2 3 4 5\n输出:\n0\n1\n2\n3\n-1\n\n\n## 数据范围与提示\n$ 1 \\leq n, m \\leq 10 ^ 5, 0 \\leq S_i \\leq 2 ^ {50} $",
        "sample": {
            "input": "3\n1 2 3\n5\n1 2 3 4 5",
            "output": "0\n1\n2\n3\n-1"
        }
    },
    {
        "code_id": 6,
        "code": "\n// 第k小的异或和\n// 给定一个长度为n的数组arr，arr中都是long类型的非负数，可能有重复值\n// 在这些数中选取任意个，至少要选一个数字\n// 可以得到很多异或和，假设异或和的结果去重\n// 返回第k小的异或和\n// 1 <= n <= 10^5\n// 0 <= arr[i] <= 2^50\n// 1 <= k <= 2^50\n// 测试链接 : https://loj.ac/p/114\n// 提交以下的code，提交时请把类名改成\"\"，可以通过所有测试用例\n\nimport java.io.BufferedReader;\nimport java.io.IOException;\nimport java.io.InputStreamReader;\nimport java.io.OutputStreamWriter;\nimport java.io.PrintWriter;\nimport java.io.StreamTokenizer;\n\npublic class  Main{\n\n\tpublic static int MAXN = 100001;\n\n\tpublic static int BIT = 50;\n\n\tpublic static long[] arr = new long[MAXN];\n\n\tpublic static int len;\n\n\tpublic static boolean zero;\n\n\tpublic static int n;\n\n\t// 高斯消元\n\tpublic static void compute() {\n\t\tlen = 1;\n\t\tfor (long i = BIT; i >= 0; i--) {\n\t\t\tfor (int j = len; j <= n; j++) {\n\t\t\t\tif ((arr[j] & (1L << i)) != 0) {\n\t\t\t\t\tswap(j, len);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif ((arr[len] & (1L << i)) != 0) {\n\t\t\t\tfor (int j = 1; j <= n; j++) {\n\t\t\t\t\tif (j != len && (arr[j] & (1L << i)) != 0) {\n\t\t\t\t\t\tarr[j] ^= arr[len];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tlen++;\n\t\t\t}\n\t\t}\n\t\tlen--;\n\t\tzero = len != n;\n\t}\n\n\tpublic static void swap(int a, int b) {\n\t\tlong tmp = arr[a];\n\t\tarr[a] = arr[b];\n\t\tarr[b] = tmp;\n\t}\n\n\t// 返回第k小的异或和\n\tpublic static long query(long k) {\n\t\tif (zero && k == 1) {\n\t\t\treturn 0;\n\t\t}\n\t\tif (zero) {\n\t\t\tk--;\n\t\t}\n\t\tif (k >= 1L << len) {\n\t\t\treturn -1;\n\t\t}\n\t\tlong ans = 0;\n\t\tfor (int i = len, j = 0; i >= 1; i--, j++) {\n\t\t\tif ((k & (1L << j)) != 0) {\n\t\t\t\tans ^= arr[i];\n\t\t\t}\n\t\t}\n\t\treturn ans;\n\t}\n\n\tpublic static void main(String[] args) throws IOException {\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\tStreamTokenizer in = new StreamTokenizer(br);\n\t\tPrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));\n\t\tin.nextToken();\n\t\tn = (int) in.nval;\n\t\tfor (int i = 1; i <= n; i++) {\n\t\t\tin.nextToken();\n\t\t\tarr[i] = (long) in.nval;\n\t\t}\n\t\tcompute();\n\t\tin.nextToken();\n\t\tint q = (int) in.nval;\n\t\tfor (int i = 1; i <= q; i++) {\n\t\t\tin.nextToken();\n\t\t\tlong k = (long) in.nval;\n\t\t\tout.println(query(k));\n\t\t}\n\t\tout.flush();\n\t\tout.close();\n\t\tbr.close();\n\t}\n\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "k 大异或和",
        "query": "# k 大异或和\n## 题目描述\n\r\n\r\n给由 $ n $ 个数组成的一个可重集 $ S $，每次给定一个数 $ k $，求一个集合 $ T \\subseteq S $，使得集合 $ T $ 在 $ S $ 的所有非空子集的不同的异或和中，其异或和 $ T_1 \\mathbin{\\text{xor}} T_2 \\mathbin{\\text{xor}} \\ldots \\mathbin{\\text{xor}} T_{|T|} $ 是第 $ k $ 小的。\n## 输入格式\n第一行一个数 $ n $。  \r\n第二行 $ n $ 个数，表示集合 $ S $。  \r\n第三行一个数 $ m $，表示询问次数。  \r\n第四行 $ m $ 个数，表示每一次询问的 $ k $。\n## 输出格式\n输出 $ m $ 行，对应每一次询问的答案，第 $ k $ 小的异或和。如果集合 $ S $ 的所有非空子集中，不同的异或和数量不足 $ k $，输出 $ -1 $。\n## 样例\n输入:\n3\n1 2 3\n5\n1 2 3 4 5\n输出:\n0\n1\n2\n3\n-1\n\n\n## 数据范围与提示\n$ 1 \\leq n, m \\leq 10 ^ 5, 0 \\leq S_i \\leq 2 ^ {50} $",
        "sample": {
            "input": "3\n1 2 3\n5\n1 2 3 4 5",
            "output": "0\n1\n2\n3\n-1"
        }
    },
    {
        "code_id": 5,
        "code": "\nimport java.io.*;\nimport java.util.*;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n@SuppressWarnings({\"unused\", \"unchecked\"})\npublic class Main { // See rules of OJ at the bottom\n\n  private static final PrintStream OUT = System.out;\n\n  public static void main(String[] args) throws IOException {\n\n    // io.getInt(), io.getLine(), io.getWord()\n    Main main = new Main();\n    try (IO io = new IO(System.in, System.out)) {\n      final int N = io.getInt(), M = io.getInt(), S = io.getInt() - 1, \n      T = io.getInt() - 1, G = io.getInt(), Q = io.getInt();\n      int[] H = new int[N], L = new int[N];\n      for (int i = 0; i != N; i++) {\n        H[i] = io.getInt();\n        L[i] = io.getInt();\n      }\n      int[][] raws = new int[M][3];\n      for (int i = 0; i != M; i++) {\n        raws[i][0] = io.getInt() - 1;\n        raws[i][1] = io.getInt() - 1;\n        raws[i][2] = io.getInt();\n      }\n      io.println(main.solve(N, M, S, T, G, Q, H, L, raws));\n    }\n\n  }\n\n  private static final int oo = Integer.MAX_VALUE;\n  private static final long MOD = (long) 1e9 + 7;\n  private static final String IMP = \"wtnap wa kotori no oyatsu desu!\";\n  private String solve(final int N, final int M, final int S, final int T, \n      final int G, final long Q, final int[] H, final int[] L, int[][]raws\n  ) {\n    if (S == T) return \"0\";\n    if (H[S] > L[S]) return IMP;\n\n    List<List<int[]>> g = new ArrayList<>(N);\n    for (int i = 0; i != N; i++)\n      g.add(new ArrayList<>());\n    for (int[] each : raws) {\n      g.get(each[0]).add(each);\n      g.get(each[1]).add(each);\n    }\n    int[] best = new int[N];\n    Arrays.fill(best, oo);\n    best[S] = 0;\n    boolean[] vis = new boolean[N];\n    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);\n    pq.offer(new int[] {S, 0});\n    while (!pq.isEmpty()) {\n      final int pair[] = pq.poll(), at = pair[0], clock = pair[1];\n      if (vis[at])\n        continue;\n      vis[at] = true;\n      if (at == T)\n        break;\n      for (int[] each : g.get(at)) {\n        final int next = at ^ each[0] ^ each[1];\n        if (vis[next])\n          continue;\n        final int finish = clock + each[2];\n        if (finish >= best[next])\n          continue;\n        long wouldthick = finish * Q + H[next];\n        if (wouldthick > L[next])\n          continue;\n        best[next] = finish;\n        pq.offer(new int[] {next, finish});\n      }\n    }\n    return best[T] <= G ? Integer.toString(best[T]) : IMP;\n  }\n\n\n  ////////////////\n\n  // @formatter:off\n  private void debug(Object... o) { OUT.println(Arrays.deepToString(o)); }\n  // to detect input EOF example\n  // String line = null;  while ((line = io.getLine()) != null) { /* parse line and do your computation */ }\n  private static class IO extends PrintWriter {\n    public IO(InputStream i) { this(i, System.out); }\n    public IO(InputStream i, OutputStream o) { super(new BufferedOutputStream(o)); r = new BufferedReader(new InputStreamReader(i)); }\n    public boolean hasMoreTokens() { return peekToken() != null; }\n    public int getInt() { return Integer.parseInt(nextToken()); }\n    public int[] getArray(final int N) { int[] nums = new int[N]; for (int i = 0; i != N; i++) nums[i] = getInt(); return nums; }\n    public int[][] getMatrix(final int R, final int C) {\n      int[][] mat = new int[R][C]; for (int r = 0; r != R; r++) for (int c = 0; c != C; c++) mat[r][c] = getInt(); return mat; }\n    public double getDouble() { return Double.parseDouble(nextToken()); }\n    public float getFloat() { return Float.parseFloat(nextToken()); }\n    public long getLong() { return Long.parseLong(nextToken()); }\n    public String getWord() { return nextToken(); }\n    public String getLine() { try { return r.readLine(); } catch (IOException e) { return null; } }\n    private BufferedReader r; private StringTokenizer st = new StringTokenizer(\"\"); private String token;\n    private String peekToken() {\n      if (token == null) try { while (!st.hasMoreTokens()) {\n      String line = r.readLine(); if (line == null) return null; st = new StringTokenizer(line);\n      } token = st.nextToken(); } catch (IOException e) {}\n      return token;\n    }\n    private String nextToken() { String ans = peekToken(); token = null; return ans; }\n  }\n  // @formatter:on\n\n  // atcoder require no package of a class named: Main\n  // Google code jam requires no package of a class named: Solution\n  // Kattis click submit from the problem, paste code in, and specify Main class as Main\n  // CodeForce LightOJ LibreOJ click submit from the problem, paste code in.\n  // USACO see docs/usaco/AlmostSubmitable.txt\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "ことりのおやつ",
        "query": "ことりのおやつ\n题目描述\n> 这是 2017 年的冬天。（又到了白色相簿的季节 2333）  \r\n> 滑完雪之后， ことり 突然想吃点心啦！wtnap 收到短信时正好在甜品店，于是 wtnap 决定买好了带去给她。不幸的是，日本的冬天经常下雪，今天也不例外。\r\n\r\n秋叶原共有 $n$ 个地点，分别编号为 $1,2,\\ldots,n$ 。点心店所在地点的编号是 $s$，ことり家的编号是 $t$ 。  \r\n有 $m$ 条道路连接这些地点，它们的长度分别为 $w_i\\:\\textrm{m}$ 。为了便于绘制地图，秋叶原的道路规划保证每条道路严格地连接两个不同的地点，并且不会有两条道路连接的两个地点相同。  \r\n雪太大，公共交通系统已经停摆了，所以你得走路过去。你的走路速度是 $1\\:\\textrm{m/s}$ 。  \r\n开始时，地点 $i$ 的积雪深度为 $h_i\\:\\textrm{mm}$ 。每秒钟地面上积雪的厚度会增加 $q\\:\\textrm{mm}$。每个地点都有一个步行的极限雪深 $l_i\\:\\textrm{mm}$ ，如果到达此地时此地的雪深 $> l_i$，wtnap 会被困在这个点，无法成功地走到 ことり 家。  \r\n不考虑点心店和 ことり 家的雪。ことり 想在 $g$ 秒内吃到点心， wtnap 要越快越好。如果在 $g$ 秒之内， wtnap 无法到达 ことり 的家，或者 wtnap 被困在路上了，那么 ことり 会把 wtnap 变成她的点心。\n输入格式\n第 $1$ 行 $6$ 个整数，空格隔开，分别代表 $n,m,s,t,g,q$ 。  \r\n以下 $n$ 行，每行 $2$ 个整数，空格隔开，分别表示这个地点的 $h_i$ 和 $l_i$ 。  \r\n以下 $m$ 行，每行 $3$ 个整数，空格隔开，分别表示这条路连接的两个地点 $u, v$ 和这条路的长度 $w_i$ 。\n输出格式\n如果 wtnap 变成了 ことり 的点心那么输出一行字符串 $\\texttt{wtnap wa kotori no oyatsu desu!}$ 。  \r\n否则输出一行一个整数，表示到达ことり家的最短用时。\n样例 1\n输入:\n2 1 1 2 10 1\n1 10\n3 10\n1 2 6\n输出:\n6\n\n\n样例 2\n输入:\n5 6 2 5 10 1\n1 10\n1 10\n1 10\n1 10\n1 10\n1 5 9\n1 3 9\n2 4 1\n2 5 9\n3 4 1\n3 5 6\n输出:\n8\n\n\n样例 3\n输入:\n5 6 2 5 10 1\n1 10\n1 10\n10 10\n1 10\n1 10\n1 5 9\n1 3 9\n2 4 1\n2 5 11\n3 4 1\n3 5 6\n输出:\nwtnap wa kotori no oyatsu desu!\n\n\n数据范围与提示\n  \r\n对于所有数据，$1 \\le s, t \\le n , 0 \\le g, q \\le 10^9 , 0 \\le w_i \\le l_i \\le 10^9$ 。\r\n\r\n#### 数据范围\r\n\r\n| 测试点编号       | $n$          | $m$          | 其它约定                            |  \r\n| ----------- | ------------ | ------------ | ------------------------------- |  \r\n| $1$-$4$     | $\\le 10$     | $\\le 20$     | 对于编号为奇数的测试点 $q=0$ ， $h_i < l_i$ |  \r\n| $5$-$8$     | $\\le 100$    | $\\le 200$    | 对于编号为奇数的测试点 $q=0$ ， $h_i < l_i$ |  \r\n| $9$-$12$  | $\\le 1000$   | $\\le 2000$   | 对于编号为奇数的测试点 $q=0​$              |  \r\n| $13$-$16$ | $\\le 10^4$  | $\\le 2\\times 10^4$  | 对于编号为奇数的测试点 $q=0$               |  \r\n| $17$-$20$ | $\\le 10^5$ | $\\le 5\\times 10^5$ | 无                               |",
        "sample": {
            "input": "2 1 1 2 10 1\n1 10\n3 10\n1 2 6",
            "output": "6"
        }
    },
    {
        "code_id": 9,
        "code": "\nimport java.io.*;\nimport java.util.*;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n@SuppressWarnings({\"unused\", \"unchecked\"})\npublic class Main { // See rules of OJ at the bottom\n\n  private static final PrintStream OUT = System.out;\n\n  public static void main(String[] args) throws IOException {\n\n    // io.getInt(), io.getLine(), io.getWord()\n    Main main = new Main();\n    try (IO io = new IO(System.in, System.out)) {\n    // try (IO io = new IO(new FileInputStream(\"/Volumes/UNTITLED/Deletable/junk/oyatsu19.in\"), System.out)) {\n      final int N = io.getInt(), M = io.getInt(), S = io.getInt() - 1, \n      T = io.getInt() - 1, G = io.getInt(), Q = io.getInt();\n      int[] ALLOWED = new int[N]; // allowed snow depth\n      for (int i = 0; i != N; i++)\n        ALLOWED[i] = - io.getInt() + io.getInt(); \n      int[][] raws = new int[M][3];\n      for (int i = 0; i != M; i++) {\n        raws[i][0] = io.getInt() - 1;\n        raws[i][1] = io.getInt() - 1;\n        raws[i][2] = io.getInt();\n      }\n      io.println(main.solve(N, M, S, T, G, Q, ALLOWED, raws));\n    }\n\n  }\n\n  private static final int oo = Integer.MAX_VALUE;\n  private static final String IMP = \"wtnap wa kotori no oyatsu desu!\";\n  private String solve(final int N, final int M, final int S, final int T, \n      final int G, final long Q, final int[] ALLOWED, int[][]raws\n  ) {\n    if (S == T) return \"0\";\n    if (ALLOWED[S] < 0) return IMP;\n\n    List<List<int[]>> g = new ArrayList<>(N);\n    for (int i = 0; i != N; i++)\n      g.add(new ArrayList<>());\n    for (int[] each : raws) {\n      g.get(each[0]).add(each);\n      g.get(each[1]).add(each);\n    }\n    int[] best = new int[N];\n    Arrays.fill(best, oo);\n    best[S] = 0;\n    boolean[] vis = new boolean[N];\n    PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]);\n    pq.offer(new int[] {S, 0});\n    while (!pq.isEmpty()) {\n      final int pair[] = pq.poll(), at = pair[0], clock = pair[1];\n      if (vis[at])\n        continue;\n      vis[at] = true;\n      if (at == T)\n        break;\n      for (int[] each : g.get(at)) {\n        final int next = at ^ each[0] ^ each[1];\n        if (vis[next])\n          continue;\n        if (ALLOWED[next] < each[2] * Q)\n          continue;\n        final int finish = clock + each[2];\n         if (finish >= best[next])\n          continue;\n        best[next] = finish;\n        pq.offer(new int[] {next, finish});\n      }\n    }\n\n    return best[T] <= G ? Integer.toString(best[T]) : IMP;\n  }\n\n\n  ////////////////\n\n  // @formatter:off\n  private void debug(Object... o) { OUT.println(Arrays.deepToString(o)); }\n  // to detect input EOF example\n  // String line = null;  while ((line = io.getLine()) != null) { /* parse line and do your computation */ }\n  private static class IO extends PrintWriter {\n    public IO(InputStream i, OutputStream o) { super(new BufferedOutputStream(o)); r = new BufferedReader(new InputStreamReader(i)); }\n    public boolean hasMoreTokens() { return peekToken() != null; }\n    public int getInt() { return Integer.parseInt(nextToken()); }\n    private BufferedReader r; private StringTokenizer st = new StringTokenizer(\"\"); private String token;\n    private String peekToken() {\n      if (token == null) try { while (!st.hasMoreTokens()) {\n      String line = r.readLine(); if (line == null) return null; st = new StringTokenizer(line);\n      } token = st.nextToken(); } catch (IOException e) {}\n      return token;\n    }\n    private String nextToken() { String ans = peekToken(); token = null; return ans; }\n  }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "ことりのおやつ",
        "query": "ことりのおやつ\n题目描述\n> 这是 2017 年的冬天。（又到了白色相簿的季节 2333）  \r\n> 滑完雪之后， ことり 突然想吃点心啦！wtnap 收到短信时正好在甜品店，于是 wtnap 决定买好了带去给她。不幸的是，日本的冬天经常下雪，今天也不例外。\r\n\r\n秋叶原共有 $n$ 个地点，分别编号为 $1,2,\\ldots,n$ 。点心店所在地点的编号是 $s$，ことり家的编号是 $t$ 。  \r\n有 $m$ 条道路连接这些地点，它们的长度分别为 $w_i\\:\\textrm{m}$ 。为了便于绘制地图，秋叶原的道路规划保证每条道路严格地连接两个不同的地点，并且不会有两条道路连接的两个地点相同。  \r\n雪太大，公共交通系统已经停摆了，所以你得走路过去。你的走路速度是 $1\\:\\textrm{m/s}$ 。  \r\n开始时，地点 $i$ 的积雪深度为 $h_i\\:\\textrm{mm}$ 。每秒钟地面上积雪的厚度会增加 $q\\:\\textrm{mm}$。每个地点都有一个步行的极限雪深 $l_i\\:\\textrm{mm}$ ，如果到达此地时此地的雪深 $> l_i$，wtnap 会被困在这个点，无法成功地走到 ことり 家。  \r\n不考虑点心店和 ことり 家的雪。ことり 想在 $g$ 秒内吃到点心， wtnap 要越快越好。如果在 $g$ 秒之内， wtnap 无法到达 ことり 的家，或者 wtnap 被困在路上了，那么 ことり 会把 wtnap 变成她的点心。\n输入格式\n第 $1$ 行 $6$ 个整数，空格隔开，分别代表 $n,m,s,t,g,q$ 。  \r\n以下 $n$ 行，每行 $2$ 个整数，空格隔开，分别表示这个地点的 $h_i$ 和 $l_i$ 。  \r\n以下 $m$ 行，每行 $3$ 个整数，空格隔开，分别表示这条路连接的两个地点 $u, v$ 和这条路的长度 $w_i$ 。\n输出格式\n如果 wtnap 变成了 ことり 的点心那么输出一行字符串 $\\texttt{wtnap wa kotori no oyatsu desu!}$ 。  \r\n否则输出一行一个整数，表示到达ことり家的最短用时。\n样例 1\n输入:\n2 1 1 2 10 1\n1 10\n3 10\n1 2 6\n输出:\n6\n\n\n样例 2\n输入:\n5 6 2 5 10 1\n1 10\n1 10\n1 10\n1 10\n1 10\n1 5 9\n1 3 9\n2 4 1\n2 5 9\n3 4 1\n3 5 6\n输出:\n8\n\n\n样例 3\n输入:\n5 6 2 5 10 1\n1 10\n1 10\n10 10\n1 10\n1 10\n1 5 9\n1 3 9\n2 4 1\n2 5 11\n3 4 1\n3 5 6\n输出:\nwtnap wa kotori no oyatsu desu!\n\n\n数据范围与提示\n  \r\n对于所有数据，$1 \\le s, t \\le n , 0 \\le g, q \\le 10^9 , 0 \\le w_i \\le l_i \\le 10^9$ 。\r\n\r\n#### 数据范围\r\n\r\n| 测试点编号       | $n$          | $m$          | 其它约定                            |  \r\n| ----------- | ------------ | ------------ | ------------------------------- |  \r\n| $1$-$4$     | $\\le 10$     | $\\le 20$     | 对于编号为奇数的测试点 $q=0$ ， $h_i < l_i$ |  \r\n| $5$-$8$     | $\\le 100$    | $\\le 200$    | 对于编号为奇数的测试点 $q=0$ ， $h_i < l_i$ |  \r\n| $9$-$12$  | $\\le 1000$   | $\\le 2000$   | 对于编号为奇数的测试点 $q=0​$              |  \r\n| $13$-$16$ | $\\le 10^4$  | $\\le 2\\times 10^4$  | 对于编号为奇数的测试点 $q=0$               |  \r\n| $17$-$20$ | $\\le 10^5$ | $\\le 5\\times 10^5$ | 无                               |",
        "sample": {
            "input": "2 1 1 2 10 1\n1 10\n3 10\n1 2 6",
            "output": "6"
        }
    },
    {
        "code_id": 0,
        "code": "import sys\r\n# import requests,time\r\ntry:\r\n\tsys.stdin = open('in.in','r')\r\n\tsys.stdout = open('out.out','w')\r\nexcept: pass\r\n\r\n\"\"\"headers = {\r\n\t'Host': 'lydsy.com',\r\n\t'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0',\r\n\t'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',\r\n\t'Accept-Language': 'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',\r\n\t'Accept-Encoding': 'gzip, deflate, br',\r\n\t'Referer': 'https://lydsy.com/JudgeOnline/submitpage.php?id=1000',\r\n\t'Connection': 'keep-alive',\r\n\t'Cookie': 'lastlang=1; PHPSESSID=jautvumo334ntnq4gogktru2a2',\r\n\t'Upgrade-Insecure-Requests': '1'\r\n}\r\n\r\ncookies = {\r\n\t'PHPSESSID': 'jautvumo334ntnq4gogktru2a2',\r\n\t'lastlang': '1'\r\n}\r\n\r\ndata = {\r\n\t'id': 3935,\r\n\t'language': 1,\r\n\t'source': 'int main(){ while(1); }'\r\n}\r\n\r\nfor i in range(100):\r\n\tprint('%d times'%i)\r\n\tr = requests.post('https://lydsy.com/JudgeOnline/submit.php',cookies=cookies,data=data,headers=headers)\r\n\tprint(r.status_code)\r\n\tprint(r.text)\r\n\ttime.sleep(10.5)\r\n\"\"\"\r\n\r\nt = int(input())\r\nqs = [ (int(input()),i) for i in range(t) ]\r\nqs.sort()\r\nansl = [ 0 for i in range(t) ]\r\n\r\nb1 = 1; b2 = 2; ub = 2\r\nfor (n,id) in qs:\r\n\tif n <= 3:\r\n\t\tif n == 1: ansl[id] = 1\r\n\t\tif n == 2: ansl[id] = 3\r\n\t\tif n == 3: ansl[id] = 5\r\n\t\tcontinue\r\n\twhile ub < n:\r\n\t\tb3 = pow(2,ub) + b1\r\n\t\tb1 = b2\r\n\t\tb2 = b3\r\n\t\tub += 1\r\n\tansl[id] = b3\r\n\r\nfor i in ansl: print(i)\r\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "九连环",
        "query": "# 九连环\n## 题目描述\n九连环是一种源于中国的传统智力游戏。如图所示，九个圆环套在一把“剑”上，并且互相牵连。游戏的目标是把九个圆环从“剑”上卸下。  \r\n\r\n圆环的装卸需要遵守两个规则。   \r\n1. 第一个（最右边）环任何时候都可以装上或卸下。\r\n2. 如果第 $k$ 个环没有被卸下，且第 $k$ 个环右边的所有环都被卸下，则第 $k+1$ 个环（第 $k$ 个环左边相邻的环）可以任意装上或卸下。  \r\n\r\n与魔方的千变万化不同，解九连环的最优策略是唯一的。为简单起见，我们以“四连环”为例，演示这一过程。这里用 ```1``` 表示环在“剑”上， ```0``` 表示环已经卸下。  \r\n\r\n初始状态为 ```1111``` ，每部的操作如下：  \r\n1.  ```1101``` （根据规则 $2$ ，卸下第 $2$ 个环）\r\n2.  ```1100``` （根据规则 $1$ ，卸下第 $1$ 个环）\r\n3.  ```0100``` （根据规则 $2$ ，卸下第 $4$ 个环）\r\n4.  ```0101``` （根据规则 $1$ ，装上第 $1$ 个环）\r\n5.  ```0111``` （根据规则 $2$ ，装上第 $2$ 个环）\r\n6.  ```0110``` （根据规则 $1$ ，卸下第 $1$ 个环）\r\n7.  ```0010``` （根据规则 $2$ ，卸下第 $3$ 个环）\r\n8.  ```0011``` （根据规则 $1$ ，装上第 $1$ 个环）\r\n9.  ```0001``` （根据规则 $2$ ，卸下第 $2$ 个环）\r\n10.  ```0000``` （根据规则 $1$ ，卸下第 $1$ 个环）\r\n\r\n由此可见，卸下“四连环”至少需要 $10$ 步。随着环数增加，需要的步数也会随之增多。例如卸下九连环，就至少需要 $341$ 步。  \r\n请你计算，有 $n$ 个环的情况下，按照规则，全部卸下至少需要多少步。\n## 输入格式\n输入第一行为一个整数 $m$ ，表示测试点数目。  \r\n接下来 $m$ 行，每行一个整数 $n$ 。\n## 输出格式\n输出共 $m$ 行，对应每个测试点的计算结果。\n## 样例\n输入:\n3\n3\n5\n9\n输出:\n5\n21\n341\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据， $1 \\le n \\le 10^5 , 1 \\le m \\le 10$ 。",
        "sample": {
            "input": "3\n3\n5\n9",
            "output": "5\n21\n341"
        }
    },
    {
        "code_id": 1,
        "code": "import sys\r\n# import requests,time\r\ntry:\r\n\tsys.stdin = open('in.in','r')\r\n\tsys.stdout = open('out.out','w')\r\nexcept: pass\r\n\r\n\"\"\"headers = {\r\n\t'Host': 'lydsy.com',\r\n\t'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0',\r\n\t'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',\r\n\t'Accept-Language': 'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',\r\n\t'Accept-Encoding': 'gzip, deflate, br',\r\n\t'Referer': 'https://lydsy.com/JudgeOnline/submitpage.php?id=1000',\r\n\t'Connection': 'keep-alive',\r\n\t'Cookie': 'lastlang=1; PHPSESSID=jautvumo334ntnq4gogktru2a2',\r\n\t'Upgrade-Insecure-Requests': '1'\r\n}\r\n\r\ncookies = {\r\n\t'PHPSESSID': 'jautvumo334ntnq4gogktru2a2',\r\n\t'lastlang': '1'\r\n}\r\n\r\ndata = {\r\n\t'id': 3935,\r\n\t'language': 1,\r\n\t'source': 'int main(){ while(1); }'\r\n}\r\n\r\nfor i in range(100):\r\n\tprint('%d times'%i)\r\n\tr = requests.post('https://lydsy.com/JudgeOnline/submit.php',cookies=cookies,data=data,headers=headers)\r\n\tprint(r.status_code)\r\n\tprint(r.text)\r\n\ttime.sleep(10.5)\r\n\"\"\"\r\n\r\nt = int(input())\r\nqs = [ int(input()) for i in range(t) ]\r\nqs.sort()\r\nb1 = 1; b2 = 2; ub = 2\r\nfor n in qs:\r\n\tif n <= 3:\r\n\t\tif n == 1: print(1)\r\n\t\tif n == 2: print(3)\r\n\t\tif n == 3: print(5)\r\n\t\tcontinue\r\n\twhile ub < n:\r\n\t\tb3 = pow(2,ub) + b1\r\n\t\tb1 = b2\r\n\t\tb2 = b3\r\n\t\tub += 1\r\n\tprint(b3)\r\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "九连环",
        "query": "# 九连环\n## 题目描述\n九连环是一种源于中国的传统智力游戏。如图所示，九个圆环套在一把“剑”上，并且互相牵连。游戏的目标是把九个圆环从“剑”上卸下。  \r\n\r\n圆环的装卸需要遵守两个规则。   \r\n1. 第一个（最右边）环任何时候都可以装上或卸下。\r\n2. 如果第 $k$ 个环没有被卸下，且第 $k$ 个环右边的所有环都被卸下，则第 $k+1$ 个环（第 $k$ 个环左边相邻的环）可以任意装上或卸下。  \r\n\r\n与魔方的千变万化不同，解九连环的最优策略是唯一的。为简单起见，我们以“四连环”为例，演示这一过程。这里用 ```1``` 表示环在“剑”上， ```0``` 表示环已经卸下。  \r\n\r\n初始状态为 ```1111``` ，每部的操作如下：  \r\n1.  ```1101``` （根据规则 $2$ ，卸下第 $2$ 个环）\r\n2.  ```1100``` （根据规则 $1$ ，卸下第 $1$ 个环）\r\n3.  ```0100``` （根据规则 $2$ ，卸下第 $4$ 个环）\r\n4.  ```0101``` （根据规则 $1$ ，装上第 $1$ 个环）\r\n5.  ```0111``` （根据规则 $2$ ，装上第 $2$ 个环）\r\n6.  ```0110``` （根据规则 $1$ ，卸下第 $1$ 个环）\r\n7.  ```0010``` （根据规则 $2$ ，卸下第 $3$ 个环）\r\n8.  ```0011``` （根据规则 $1$ ，装上第 $1$ 个环）\r\n9.  ```0001``` （根据规则 $2$ ，卸下第 $2$ 个环）\r\n10.  ```0000``` （根据规则 $1$ ，卸下第 $1$ 个环）\r\n\r\n由此可见，卸下“四连环”至少需要 $10$ 步。随着环数增加，需要的步数也会随之增多。例如卸下九连环，就至少需要 $341$ 步。  \r\n请你计算，有 $n$ 个环的情况下，按照规则，全部卸下至少需要多少步。\n## 输入格式\n输入第一行为一个整数 $m$ ，表示测试点数目。  \r\n接下来 $m$ 行，每行一个整数 $n$ 。\n## 输出格式\n输出共 $m$ 行，对应每个测试点的计算结果。\n## 样例\n输入:\n3\n3\n5\n9\n输出:\n5\n21\n341\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据， $1 \\le n \\le 10^5 , 1 \\le m \\le 10$ 。",
        "sample": {
            "input": "3\n3\n5\n9",
            "output": "5\n21\n341"
        }
    },
    {
        "code_id": 5,
        "code": "import java.io.*;\nimport java.util.*;\npublic class noipclassroom {\n    public static void main(String[] args) throws IOException {\n        long[] diffArray = new long[1000010];\n        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));\n        StringTokenizer st = new StringTokenizer(f.readLine());\n        long n = Long.parseLong(st.nextToken());\n        long m = Long.parseLong(st.nextToken());\n        long[] classrooms = new long[(int)(n + 2)];\n        st = new StringTokenizer(f.readLine());\n\n        for (long i = 1; i <= n; i ++)\n            classrooms[(int) i] = Long.parseLong(st.nextToken());\n\n        long[][] requests = new long[(int)(m + 2)][3];\n\n        for (long i = 1; i <= m; i ++) {\n            st = new StringTokenizer(f.readLine());\n            requests[(int) i][0] = Long.parseLong(st.nextToken());\n            requests[(int) i][1] = Long.parseLong(st.nextToken());\n            requests[(int) i][2] = Long.parseLong(st.nextToken());\n        }\n\n        if (okay(diffArray, m, n, m, classrooms, requests))\n        {\n            System.out.println(0);\n            return;\n        }\n\n        long low = 0;\n        long high = m;\n\n        while (low < high) {\n            long mid = (low + high + 1) / 2;\n\n            if (okay(diffArray, mid, n, m, classrooms, requests))\n                low = mid;\n            else\n                high = mid - 1;\n        }\n        System.out.println(\"-1\" + \"\\n\" + (low + 1));\n    }\n\n    static boolean okay(long[] diffArray, long check, long n, long m, long[] classrooms, long[][] requests) {\n        Arrays.fill(diffArray, 0);\n\n        for (long i = 1; i <= check; i ++) {\n            diffArray[(int) requests[(int) i][1]] += requests[(int) i][0];\n            diffArray[(int)(requests[(int) i][2] + 1)] -= requests[(int) i][0];\n        }\n\n        long prefix = 0;\n\n        for (long i = 1; i <= n; i ++) {\n            prefix += diffArray[(int) i];\n\n            if (prefix > classrooms[(int) i])\n                return false;\n        }\n\n        return true;\n    }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "借教室",
        "query": "# 借教室\n## 题目描述\n在大学期间，经常需要租借教室。大到院系举办活动，小到学习小组自习讨论，都需要向学校申请借教室。教室的大小功能不同，借教室人的身份不同，借教室的手续也不一样。\r\n\r\n面对海量租借教室的信息，我们自然希望编程解决这个问题。\r\n\r\n我们需要处理接下来 $n$ 天的借教室信息，其中第 $i$ 天学校有 $r_i$ 个教室可供租借。共有 $m$ 份订单，每份订单用三个正整数描述，分别为 $d_j$，$s_j$，$t_j$，表示某租借者需要从第 $s_j$ 天到第 $t_j$ 天租借教室（包括第 $s_j$ 天和第 $t_j$ 天），每天需要租借 $d_j$ 个教室。\r\n\r\n我们假定，租借者对教室的大小、地点没有要求。即对于每份订单，我们只需要每天提供 $d_j$ 个教室，而它们具体是哪些教室，每天是否是相同的教室则不用考虑。\r\n\r\n借教室的原则是先到先得，也就是说我们要按照订单的先后顺序依次为每份订单分配教室。如果在分配的过程中遇到一份订单无法完全满足，则需要停止教室的分配，通知当前申请人修改订单。这里的无法满足指从第 $s_j$ 天到第 $t_j$ 天中有至少一天剩余的教室数量不足 $d_j$ 个。\r\n\r\n现在我们需要知道，是否会有订单无法完全满足。如果有，需要通知哪一个申请人修改订单。\n## 输入格式\n第一行包含两个正整数 $n$，$m$，表示天数和订单的数量。\r\n\r\n第二行包含 $n$ 个正整数，其中第 $i$ 个数为 $r_i$，表示第 $i$ 天可用于租借的教室数量。\r\n\r\n接下来有 $m$ 行，每行包含三个正整数 $d_j$，$s_j$，$t_j$，表示租借的数量，租借开始、结束分别在第几天。每行相邻的两个数之间均用一个空格隔开。天数与订单均用从 $1$ 开始的整数编号。\n## 输出格式\n如果所有订单均可满足，则输出只有一行，包含一个整数 $0$。\r\n\r\n否则（订单无法完全满足）输出两行，第一行输出一个负整数 $-1$，第二行输出需要修改订单的申请人编号。\n## 样例\n输入:\n4 3\n2 5 4 3\n2 1 3\n3 2 4\n4 2 4\n输出:\n-1\n2\n\n第 1 份订单满足后，4 天剩余的教室数分别为 0，3，2，3。第 2 份订单要求第 2 天到第 4 天每天提供 3 个教室，而第 3 天剩余的教室数为 2，因此无法满足。分配停止，通知第 2 个申请人修改订单。\n## 数据范围与提示\n对于 100% 的数据，有 $1 \\leq n, m \\leq 10^6$，$0 \\leq r_i, d_j \\leq 10^9$，$1 \\leq s_j \\leq t_j \\leq n$。",
        "sample": {
            "input": "4 3\n2 5 4 3\n2 1 3\n3 2 4\n4 2 4",
            "output": "-1\n2"
        }
    },
    {
        "code_id": 12,
        "code": "import java.io.*;\nimport java.util.*;\npublic class noipclassroom {\n\tpublic static void main(String[] args) throws IOException {\n\t\tBufferedReader f = new BufferedReader(new InputStreamReader(System.in));\n\t\tStringTokenizer st = new StringTokenizer(f.readLine());\n\t\tint n = Integer.parseInt(st.nextToken());\n\t\tint m = Integer.parseInt(st.nextToken());\n\t\tint[] classrooms = new int[n];\n\t\tst = new StringTokenizer(f.readLine());\n\t\tfor(int i = 0; i < n; i ++) classrooms[i] = Integer.parseInt(st.nextToken());\n\t\tint[][] requests = new int[m][3];\n\t\tfor(int i = 0; i < m; i ++) {\n\t\t\tst = new StringTokenizer(f.readLine());\n\t\t\trequests[i][0] = Integer.parseInt(st.nextToken());\n\t\t\trequests[i][1] = Integer.parseInt(st.nextToken()) - 1;\n\t\t\trequests[i][2] = Integer.parseInt(st.nextToken()) - 1;\n\t\t}\n\t\tint low = 0;\n\t\tint high = n;\n\t\twhile(low < high) {\n\t\t\tint mid = (low + high) / 2;\n\t\t\tif(okay(mid, n, m, classrooms, requests)) low = mid + 1;\n\t\t\telse high = mid;\n\t\t}\n\t\tif(low + 1 != m) System.out.println(\"-1\" + \"\\n\" + (low + 1));\n\t\telse System.out.println(0);\n\t}\n\t\t\n\tstatic boolean okay(int check, int n, int m, int[] classrooms, int[][] requests) {\n\t\tint[] diffArray = new int[n];\n\t\tfor(int i = 0; i <= check; i ++) {\n\t\t\tdiffArray[requests[i][1]] += requests[i][0];\n\t\t\tdiffArray[requests[i][2]] -= requests[i][0];\n\t\t}\n\t\tint prefix = 0;\n\t\tfor(int i = 0; i < n; i ++) {\n\t\t\tif(prefix > classrooms[i]) return false;\n\t\t\tprefix += diffArray[i];\n\t\t}\n\t\treturn true;\n\t}\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "借教室",
        "query": "# 借教室\n## 题目描述\n在大学期间，经常需要租借教室。大到院系举办活动，小到学习小组自习讨论，都需要向学校申请借教室。教室的大小功能不同，借教室人的身份不同，借教室的手续也不一样。\r\n\r\n面对海量租借教室的信息，我们自然希望编程解决这个问题。\r\n\r\n我们需要处理接下来 $n$ 天的借教室信息，其中第 $i$ 天学校有 $r_i$ 个教室可供租借。共有 $m$ 份订单，每份订单用三个正整数描述，分别为 $d_j$，$s_j$，$t_j$，表示某租借者需要从第 $s_j$ 天到第 $t_j$ 天租借教室（包括第 $s_j$ 天和第 $t_j$ 天），每天需要租借 $d_j$ 个教室。\r\n\r\n我们假定，租借者对教室的大小、地点没有要求。即对于每份订单，我们只需要每天提供 $d_j$ 个教室，而它们具体是哪些教室，每天是否是相同的教室则不用考虑。\r\n\r\n借教室的原则是先到先得，也就是说我们要按照订单的先后顺序依次为每份订单分配教室。如果在分配的过程中遇到一份订单无法完全满足，则需要停止教室的分配，通知当前申请人修改订单。这里的无法满足指从第 $s_j$ 天到第 $t_j$ 天中有至少一天剩余的教室数量不足 $d_j$ 个。\r\n\r\n现在我们需要知道，是否会有订单无法完全满足。如果有，需要通知哪一个申请人修改订单。\n## 输入格式\n第一行包含两个正整数 $n$，$m$，表示天数和订单的数量。\r\n\r\n第二行包含 $n$ 个正整数，其中第 $i$ 个数为 $r_i$，表示第 $i$ 天可用于租借的教室数量。\r\n\r\n接下来有 $m$ 行，每行包含三个正整数 $d_j$，$s_j$，$t_j$，表示租借的数量，租借开始、结束分别在第几天。每行相邻的两个数之间均用一个空格隔开。天数与订单均用从 $1$ 开始的整数编号。\n## 输出格式\n如果所有订单均可满足，则输出只有一行，包含一个整数 $0$。\r\n\r\n否则（订单无法完全满足）输出两行，第一行输出一个负整数 $-1$，第二行输出需要修改订单的申请人编号。\n## 样例\n输入:\n4 3\n2 5 4 3\n2 1 3\n3 2 4\n4 2 4\n输出:\n-1\n2\n\n第 1 份订单满足后，4 天剩余的教室数分别为 0，3，2，3。第 2 份订单要求第 2 天到第 4 天每天提供 3 个教室，而第 3 天剩余的教室数为 2，因此无法满足。分配停止，通知第 2 个申请人修改订单。\n## 数据范围与提示\n对于 100% 的数据，有 $1 \\leq n, m \\leq 10^6$，$0 \\leq r_i, d_j \\leq 10^9$，$1 \\leq s_j \\leq t_j \\leq n$。",
        "sample": {
            "input": "4 3\n2 5 4 3\n2 1 3\n3 2 4\n4 2 4",
            "output": "-1\n2"
        }
    },
    {
        "code_id": 4,
        "code": "var\r\n    n,i,u,v,cnt,m:longint;\r\n    f:array[0..10010,0..2] of longint;\r\n    c,head,e,next:array[0..10010] of longint;\r\nprocedure add(u,v:longint);\r\nbegin\r\n    inc(cnt);\r\n    e[cnt]:=v;\r\n    next[cnt]:=head[u];\r\n    head[u]:=cnt;\r\nend;\r\nfunction min(a,b:longint):longint;\r\nbegin\r\n    if a<b then exit(a) else exit(b);\r\nend;\r\nprocedure dp(u,fa:longint);\r\nvar\r\n    i,v:longint;\r\nbegin\r\n    i:=head[u];inc(f[u,1]);inc(f[u,0]);\r\n    while i>0 do\r\n        begin\r\n            v:=e[i];\r\n            if v<>fa then \r\n                begin\r\n                    dp(v,u);\r\n                    inc(f[u,0],min(f[v,0]-1,min(f[v,1],f[v,2])));\r\n                    inc(f[u,1],min(f[v,0],min(f[v,1]-1,f[v,2])));\r\n                    inc(f[u,2],min(f[v,0],min(f[v,1],f[v,2])));\r\n                end;\r\n            i:=next[i];\r\n        end;\r\nend;\r\nbegin\r\n    readln(m,n);\r\n    for i:=1 to n do \r\n        begin \r\n            readln(c[i]);\r\n            f[i,c[i] xor 1]:=100000000;f[i,2]:=100000000;\r\n        end;\r\n    for i:=1 to m-1 do\r\n        begin\r\n            readln(u,v);\r\n            add(u,v);add(v,u);\r\n        end;\r\n    dp(m,0);\r\n    writeln(min(f[m,0],min(f[m,1],f[m,2])));\r\nend.",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "叶子的染色",
        "query": "# 叶子的染色\n## 题目描述\n给一棵有 $m$ 个节点的无根树，你可以选择一个度数大于 $1$ 的节点作为根，然后给一些节点（根、内部节点、叶子均可）着以黑色或白色。你的着色方案应保证根节点到各叶子节点的简单路径上都包含一个有色节点，哪怕是叶子本身。\r\n\r\n对于每个叶子节点 $u$，定义 $c_u$ 为从根节点到 $u$ 的简单路径上最后一个有色节点的颜色。给出每个 $c_u$ 的值，设计着色方案使得着色节点的个数尽量少。\n## 输入格式\n第一行包括两个数 $m,n$，依次表示节点总数和叶子个数，节点编号依次为 $1$ 至 $m$。\r\n\r\n接下来 $n$ 行每行一个 $0$ 或 $1$ 的数，其中 $0$ 表示黑色，$1$ 表示白色，依次为 $c_1,c_2,\\cdots ,c_n$ 的值。\r\n\r\n接下来 $m-1$ 行每行两个整数 $a,b$，表示节点 $a$ 与 $b$ 有边相连。\n## 输出格式\n输出仅一个数，表示着色节点数的最小值。\n## 样例\n输入:\n5 3\n0\n1\n0\n1 4\n2 5\n4 5\n3 5\n输出:\n2\n\n\n## 数据范围与提示\n$m\\leq10000m,n\\leq5021$",
        "sample": {
            "input": "5 3\n0\n1\n0\n1 4\n2 5\n4 5\n3 5",
            "output": "2"
        }
    },
    {
        "code_id": 4,
        "code": "{$define longint int64}\nconst NN=500010;MO=1000000007;\nvar n,i,r,p:longint;\n    a,b:array[0..NN]of longint;\nbegin\n    read(n);a[0]:=1;r:=1;\n    for i:=1 to n do\n        read(a[i]);\n    for i:=1 to n do\n        read(b[i]);\n    for i:=1 to n do\n        if a[i]=1 then\n            inc(r,b[i]);\n    for i:=1 to n do\n        if (a[i]>1) and ((r+b[p])*a[i]<(r+b[i])*a[p]) then\n            p:=i;\n    r:=(r+b[p]) mod MO;\n    for i:=1 to n do\n        if (a[i]>1) and (i<>p) then\n            r:=r*a[i] mod MO;\n    writeln(r);\nend.\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "吃",
        "query": "# 吃\n## 题目描述\n小 A 很喜欢吃东西。\n\n小 A 面前有 $n$ 份食物，第 $i$ 份有参数 $a_i$ 和 $b_i$。小 A 可以按照**任意顺序**吃掉这 $n$ 份食物。当她吃掉编号为 $i$ 的食物时，她可以选择将自己的体重乘以 $a_i$ 或者将自己的体重加上 $b_i$。每份食物只能吃恰好一次。\n\n小 A 的初始体重为 $1$，请求出她吃完 $n$ 份食物后能达到的**最大**体重。答案可能很大，你只需要输出其对 $({10}^9 + 7)$ 取模后的结果。\n\n**注意：你需要最大化体重并将该最大值对 $\\boldsymbol{({10}^9 + 7)}$ 取模，而非最大化体重对 $\\boldsymbol{({10}^9 + 7)}$ 取模的结果。**\n## 输入格式\n第一行输入一个整数 $n$ 表示食物的数量。第二行 $n$ 个整数 $a_1, a_2, \\ldots, a_n$，第三行 $n$ 个整数 $b_1, b_2, \\ldots, b_n$，表示每份食物的参数。\n## 输出格式\n输出一个整数，表示小 A 可以得到的最大体重对 $({10}^9 + 7)$ 取模后的结果。\n## 样例\n### 样例 1\n输入:\n5\n1 2 3 4 5\n100 200 300 400 500\n\n输出:\n18060\n\n\n以下方案可以达到最大体重：\n\n- 吃掉第一份食物并选择将体重增加 $100$，体重变为 $101$；\n- 吃掉第二份食物并选择将体重增加 $200$，体重变为 $301$；\n- 吃掉第三份食物并选择将体重乘 $3$，体重变为 $903$；\n- 吃掉第四份食物并选择将体重乘 $4$，体重变为 $3612$；\n- 吃掉第五份食物并选择将体重乘 $5$，体重变为 $18060$。\n## 数据范围与提示\n对于 $100 \\%$ 的测试数据，$1 \\le n \\le 5 \\times {10}^5$，$1 \\le a_i, b_i \\le {10}^6$。\n\n",
        "sample": {
            "input": "5\n1 2 3 4 5\n100 200 300 400 500\n",
            "output": "18060\n"
        }
    },
    {
        "code_id": 4,
        "code": "import java.io.OutputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.io.OutputStream;\nimport java.util.Arrays;\nimport java.io.IOException;\nimport java.lang.reflect.Field;\nimport java.util.function.IntPredicate;\nimport java.nio.charset.StandardCharsets;\nimport java.util.ArrayList;\nimport java.io.UncheckedIOException;\nimport java.util.List;\nimport java.io.Closeable;\nimport java.util.Comparator;\nimport java.io.InputStream;\n\n/**\n * Built using CHelper plug-in\n * Actual solution is at the top\n */\npublic class Main {\n    public static void main(String[] args) throws Exception {\n        new TaskAdapter().run();\n    }\n\n    static class TaskAdapter implements Runnable {\n        @Override\n        public void run() {\n            InputStream inputStream = System.in;\n            OutputStream outputStream = System.out;\n            FastInput in = new FastInput(inputStream);\n            FastOutput out = new FastOutput(outputStream);\n            SCOI2015 solver = new SCOI2015();\n            solver.solve(1, in, out);\n            out.close();\n        }\n    }\n\n    static class SCOI2015 {\n        public void solve(int testNumber, FastInput in, FastOutput out) {\n            int n = in.ri();\n            int m = in.ri();\n            List<Interval> qs = new ArrayList<>(n);\n            List<Interval> intervalList = new ArrayList<>(n * 3);\n            for (int i = 0; i < n; i++) {\n                int c = in.ri() - 1;\n                int d = in.ri() - 1;\n                if (c > d) {\n                    d += m;\n                }\n                d--;\n                Interval interval = new Interval(c, d);\n                qs.add(interval);\n                intervalList.add(interval);\n                while (interval.r + m < 3L * m) {\n                    interval = new Interval(interval.l + m, interval.r + m);\n                    intervalList.add(interval);\n                }\n            }\n            if (n == 1) {\n                out.println(1);\n                return;\n            }\n            intervalList.sort(Comparator.comparingLong(x -> x.l));\n            Interval[] intervals = intervalList.toArray(new Interval[0]);\n            for (int i = 0, p = 0; i < intervals.length; i++) {\n                Interval cur = intervals[i];\n                cur.id = i;\n                while (p + 1 < intervals.length && intervals[p + 1].l <= cur.r + 1) {\n                    p++;\n                }\n                cur.p = intervals[p];\n                if (cur.p == cur) {\n                    cur.p = null;\n                }\n            }\n            int N = intervals.length;\n            ParentOnTree pot = new ParentOnTreeByFunction(N, i -> {\n                Interval interval = intervals[i];\n                if (interval.p == null) {\n                    return -1;\n                }\n                return interval.p.id;\n            });\n            DepthOnTree dot = new DepthOnTreeByParent(N, pot);\n            CompressedBinaryLift cbl = new CompressedBinaryLift(N, dot, pot);\n            for (Interval q : qs) {\n                //one side\n                long to = q.l + m - 1;\n                Interval start = q.p;\n                int first = cbl.firstTrue(start.id, i -> intervals[i].r >= to);\n                int ans = 1 + (dot.depth(q.p.id) - dot.depth(first) + 1);\n                out.append(ans).append(' ');\n            }\n        }\n\n    }\n\n    static interface DepthOnTree {\n        public int depth(int node);\n\n    }\n\n    static class DepthOnTreeByParent implements DepthOnTree {\n        ParentOnTree pot;\n        int[] depth;\n\n        public DepthOnTreeByParent(int n, ParentOnTree pot) {\n            this.pot = pot;\n            depth = new int[n];\n            Arrays.fill(depth, -1);\n            for (int i = 0; i < n; i++) {\n                consider(i);\n            }\n        }\n\n        private int consider(int root) {\n            if (root == -1) {\n                return -1;\n            }\n            if (depth[root] == -1) {\n                depth[root] = consider(pot.parent(root)) + 1;\n            }\n            return depth[root];\n        }\n\n        public int depth(int node) {\n            return depth[node];\n        }\n\n    }\n\n    static class FastOutput implements AutoCloseable, Closeable, Appendable {\n        private static final int THRESHOLD = 32 << 10;\n        private OutputStream writer;\n        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);\n        private static Field stringBuilderValueField;\n        private char[] charBuf = new char[THRESHOLD * 2];\n        private byte[] byteBuf = new byte[THRESHOLD * 2];\n\n        static {\n            try {\n                stringBuilderValueField = StringBuilder.class.getSuperclass().getDeclaredField(\"value\");\n                stringBuilderValueField.setAccessible(true);\n            } catch (Exception e) {\n                stringBuilderValueField = null;\n            }\n            stringBuilderValueField = null;\n        }\n\n        public FastOutput append(CharSequence csq) {\n            cache.append(csq);\n            return this;\n        }\n\n        public FastOutput append(CharSequence csq, int start, int end) {\n            cache.append(csq, start, end);\n            return this;\n        }\n\n        private void afterWrite() {\n            if (cache.length() < THRESHOLD) {\n                return;\n            }\n            flush();\n        }\n\n        public FastOutput(OutputStream writer) {\n            this.writer = writer;\n        }\n\n        public FastOutput append(char c) {\n            cache.append(c);\n            afterWrite();\n            return this;\n        }\n\n        public FastOutput append(int c) {\n            cache.append(c);\n            afterWrite();\n            return this;\n        }\n\n        public FastOutput println(int c) {\n            return append(c).println();\n        }\n\n        public FastOutput println() {\n            return append('\\n');\n        }\n\n        public FastOutput flush() {\n            try {\n                if (stringBuilderValueField != null) {\n                    try {\n                        byte[] value = (byte[]) stringBuilderValueField.get(cache);\n                        writer.write(value, 0, cache.length());\n                    } catch (Exception e) {\n                        stringBuilderValueField = null;\n                    }\n                }\n                if (stringBuilderValueField == null) {\n                    int n = cache.length();\n                    if (n > byteBuf.length) {\n                        //slow\n                        writer.write(cache.toString().getBytes(StandardCharsets.UTF_8));\n//                writer.append(cache);\n                    } else {\n                        cache.getChars(0, n, charBuf, 0);\n                        for (int i = 0; i < n; i++) {\n                            byteBuf[i] = (byte) charBuf[i];\n                        }\n                        writer.write(byteBuf, 0, n);\n                    }\n                }\n                writer.flush();\n                cache.setLength(0);\n            } catch (IOException e) {\n                throw new UncheckedIOException(e);\n            }\n            return this;\n        }\n\n        public void close() {\n            flush();\n            try {\n                writer.close();\n            } catch (IOException e) {\n                throw new UncheckedIOException(e);\n            }\n        }\n\n        public String toString() {\n            return cache.toString();\n        }\n\n    }\n\n    static class Interval {\n        long l;\n        long r;\n        int id;\n        Interval p;\n\n        public Interval(long l, long r) {\n            this.l = l;\n            this.r = r;\n        }\n\n        public String toString() {\n            return \"Interval{\" +\n                    \"l=\" + l +\n                    \", r=\" + r +\n                    \", id=\" + id +\n                    '}';\n        }\n\n    }\n\n    static class FastInput {\n        private final InputStream is;\n        private byte[] buf = new byte[1 << 13];\n        private int bufLen;\n        private int bufOffset;\n        private int next;\n\n        public FastInput(InputStream is) {\n            this.is = is;\n        }\n\n        private int read() {\n            while (bufLen == bufOffset) {\n                bufOffset = 0;\n                try {\n                    bufLen = is.read(buf);\n                } catch (IOException e) {\n                    bufLen = -1;\n                }\n                if (bufLen == -1) {\n                    return -1;\n                }\n            }\n            return buf[bufOffset++];\n        }\n\n        public void skipBlank() {\n            while (next >= 0 && next <= 32) {\n                next = read();\n            }\n        }\n\n        public int ri() {\n            return readInt();\n        }\n\n        public int readInt() {\n            boolean rev = false;\n\n            skipBlank();\n            if (next == '+' || next == '-') {\n                rev = next == '-';\n                next = read();\n            }\n\n            int val = 0;\n            while (next >= '0' && next <= '9') {\n                val = val * 10 - next + '0';\n                next = read();\n            }\n\n            return rev ? val : -val;\n        }\n\n    }\n\n    static class CompressedBinaryLift implements LcaOnTree, KthAncestor {\n        ParentOnTree pot;\n        DepthOnTree dot;\n        int[] jump;\n\n        private void consider(int root) {\n            if (root == -1 || jump[root] != -1) {\n                return;\n            }\n            int p = pot.parent(root);\n            consider(p);\n            addLeaf(root, p);\n        }\n\n        public CompressedBinaryLift(int n, DepthOnTree dot, ParentOnTree pot) {\n            this.dot = dot;\n            this.pot = pot;\n            jump = new int[n];\n            Arrays.fill(jump, -1);\n            for (int i = 0; i < n; i++) {\n                consider(i);\n            }\n        }\n\n        private void addLeaf(int leaf, int pId) {\n            if (pId == -1) {\n                jump[leaf] = leaf;\n            } else if (dot.depth(pId) - dot.depth(jump[pId]) == dot.depth(jump[pId]) - dot.depth(jump[jump[pId]])) {\n                jump[leaf] = jump[jump[pId]];\n            } else {\n                jump[leaf] = pId;\n            }\n        }\n\n        public int firstTrue(int node, IntPredicate predicate) {\n            while (!predicate.test(node)) {\n                if (predicate.test(jump[node])) {\n                    node = pot.parent(node);\n                } else {\n                    if (node == jump[node]) {\n                        return -1;\n                    }\n                    node = jump[node];\n                }\n            }\n            return node;\n        }\n\n    }\n\n    static interface IntToIntegerFunction {\n        int apply(int x);\n\n    }\n\n    static interface ParentOnTree {\n        int parent(int node);\n\n    }\n\n    static interface KthAncestor {\n    }\n\n    static class ParentOnTreeByFunction implements ParentOnTree {\n        int[] p;\n\n        public ParentOnTreeByFunction(int n, IntToIntegerFunction pFunc) {\n            p = new int[n];\n            for (int i = 0; i < n; i++) {\n                p[i] = pFunc.apply(i);\n            }\n        }\n\n        public int parent(int node) {\n            return p[node];\n        }\n\n    }\n\n    static interface LcaOnTree {\n    }\n}\n\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "国旗计划",
        "query": "# 国旗计划\n## 题目描述\nA 国正在开展一项伟大的计划——国旗计划。这项计划的内容是边防战士手举国旗环绕边境线奔袭一圈。这项计划需要多名边防战士以接力的形式共同完成，为此，国土安全局已经挑选了 $ N $ 名优秀的边防战士作为这项计划的候选人。\r\n\r\nA 国幅员辽阔，边境线上设有 $ M $ 个边防站，顺时针编号 $ 1 $ 至 $ M $。每名边防战士常驻两个边防站，并且善于在这两个边防站之间长途奔袭，我们称这两个边防站之间的路程是这个边防战士的奔袭区间。$ N $ 名边防战士都是精心挑选的，身体素质极佳，所以每名边防战士的奔袭区间都不会被其他边防战士的奔袭区间所包含。\r\n\r\n现在，国土安全局局长希望知道，至少需要多少名边防战士，才能使得他们的奔袭区间覆盖全部的边境线，从而顺利地完成国旗计划。不仅如此，安全局局长还希望知道更详细的信息：对于每一名边防战士，在他必须参加国旗计划的前提下，至少需要多少名边防战士才能覆盖全部边境线，从而顺利地完成国旗计划。\n## 输入格式\n第一行，包含两个正整数 $ N, M $，分别表示边防战士数量和边防站数量。\r\n\r\n随后 $ N $ 行，每行包含两个正整数。其中第 $ i $ 行包含的两个正整数 $ C_i $、$ D_i $ 分别表示 $ i $ 号边防战士常驻的两个边防站编号，$ C_i $ 号边防站沿顺时针方向至 $ D_i $ 号边防站为他的奔袭区间。数据保证整个边境线都是可被覆盖的。\n## 输出格式\n输出数据仅 $ 1 $ 行，需要包含 $ N $ 个正整数。其中，第 $ j $ 个正整数表示 $ j $ 号边防战士必须参加的前提下至少需要多少名边防战士才能顺利地完成国旗计划。\n## 样例\n输入:\n4 8\n2 5\n4 7\n6 1\n7 3\n输出:\n3 3 4 3\n\n\n## 数据范围与提示\n$ N \\leq 2 \\times 10 ^ 5, M < 10 ^ 9, 1 \\leq C_i, D_i \\leq M $",
        "sample": {
            "input": "4 8\n2 5\n4 7\n6 1\n7 3",
            "output": "3 3 4 3"
        }
    },
    {
        "code_id": 1,
        "code": "import java.io.*;\r\nimport java.math.BigDecimal;\r\nimport java.math.BigInteger;\r\nimport java.util.*;\r\npublic class Main {\r\n    public static void main(String[] args) throws Exception {\r\n        new Main().run();}\r\n\r\n    int getLca(int u,int v){\r\n        while (top[u] != top[v]) {\r\n            if (dis[top[u]] < dis[top[v]])\r\n                v = pa[top[v]];\r\n            else\r\n                u = pa[top[u]];\r\n        }\r\n        if (dis[u] > dis[v])\r\n            return v;\r\n        else return u;\r\n    }\r\n\r\n    int stk[];\r\n    int ct = 0;\r\n    void add(int u,int v){\r\n        to[ct] = v;\r\n        ne[ct] = h[u];\r\n        h[u] = ct++;\r\n    }\r\n    int pa[];\r\n    int size[];\r\n    int top[];\r\n    int son[];\r\n    int h[],to[],ne[];\r\n    int dis[];\r\n    int num[];\r\n    int time[];\r\n    int clock =0;\r\n    int vale[][];\r\n    int vals[][];\r\n    int valerm[][];\r\n    int valsrm[][];\r\n    int ups[];\r\n    int res[];\r\n    int downs[];\r\n    int cnt_up[];\r\n    int cnt_down[];\r\n    int myup[];\r\n    int mydown[];\r\n    int fa[];\r\n\r\n    int root(int x){\r\n        if(fa[x]==x){\r\n            return x;\r\n        }else{\r\n            return fa[x] = root(fa[x]);\r\n        }\r\n    }\r\n\r\n    void dfs(int rt){\r\n\r\n        int p = 0;\r\n        stk[p++] = 0;\r\n        while(p>0){\r\n            rt = stk[--p];\r\n            if(rt>=0){\r\n                stk[p++] = ~rt;\r\n                cnt_up[rt] = ups[myup[rt]];\r\n                cnt_down[rt] = downs[mydown[rt]];\r\n                for(int i=h[rt];i!=-1;i=ne[i]){\r\n                    int v =to[i];\r\n                    if(v==pa[rt]) continue;\r\n                    stk[p++] = v;\r\n                }\r\n            }else{\r\n                rt = ~rt;\r\n                for(int cao:vals[rt]){\r\n                    ups[cao]++;\r\n                }\r\n                for(int cao:vale[rt]){\r\n                    downs[cao]++;\r\n                }\r\n                for(int cao:valerm[rt]){\r\n                    downs[cao]--;\r\n                }\r\n                res[rt] += ups[myup[rt]]-cnt_up[rt] + downs[mydown[rt]]-cnt_down[rt];\r\n                for(int cao:valsrm[rt]){\r\n                    ups[cao]--;\r\n                }\r\n            }\r\n        }\r\n\r\n    }\r\n\r\n    int n = 0;\r\n    void solve() {\r\n        n  = ni();\r\n        int m  = ni();\r\n        int es = 2*(n-1);\r\n        pa = new int[n];\r\n        fa = new int[n];\r\n        ups = new int[2*n+1];\r\n        downs = new int[2*n+1];\r\n        size =new int[n];\r\n        top =new int[n];\r\n        son =new int[n];\r\n        Arrays.fill(son,-1);\r\n        h = new int[n];\r\n        dis = new int[n];\r\n        stk = new int[n];\r\n        num = new int[n];\r\n        Arrays.fill(h,-1);\r\n        to = new int[es];\r\n        ne = new int[es];\r\n        time = new int[n];\r\n        res = new int[n];\r\n        myup = new int[n];\r\n        mydown = new int[n];\r\n        cnt_up = new int[n];\r\n        cnt_down = new int[n];\r\n\r\n        for(int i=0;i<n-1;++i){\r\n            int u = ni()-1;\r\n            int v = ni()-1;\r\n            add(u,v);\r\n            add(v,u);\r\n        }\r\n        for(int i=0;i<n;++i){\r\n            time[i] = ni();\r\n        }\r\n\r\n\r\n\r\n\r\n        int u[] = new int[m];\r\n        int v[] = new int[m];\r\n        int le[]  = new int[n];\r\n        int ls[]  = new int[n];\r\n        int q[] = new int[n];\r\n        for(int i=0;i<m;++i) {\r\n            u[i] = ni() - 1;\r\n            v[i] = ni() - 1;\r\n            le[v[i]]++;\r\n            ls[u[i]]++;\r\n            q[v[i]]++;\r\n            q[u[i]]++;\r\n        }\r\n        int qy[][] = new int[n][];\r\n        for(int i=0;i<n;++i){\r\n            qy[i] = new int[q[i]];\r\n        }\r\n        int oq[] = q.clone();\r\n        for(int i=0;i<m;++i) {\r\n            qy[u[i]][--q[u[i]]] = v[i];\r\n            qy[v[i]][--q[v[i]]] = u[i];\r\n        }\r\n\r\n\r\n        int rt = 0;\r\n        int p = 1;\r\n\r\n        boolean vis[] = new boolean[n];\r\n        stk[0] = 0;\r\n        while(p>0) {\r\n            rt = stk[--p];\r\n            if(rt>=0) {\r\n                stk[p++] = ~rt;\r\n                fa[rt] = rt;\r\n                for (int i = h[rt]; i != -1; i = ne[i]) {\r\n                    int vv = to[i];\r\n                    if (pa[rt] == vv) continue;\r\n                    pa[vv] = rt;\r\n                    dis[vv] = 1 + dis[rt];\r\n                    stk[p++] = vv;\r\n                }\r\n            }else{\r\n                rt = ~rt;\r\n                vis[rt] = true;\r\n                for (int i = 0 ;i < qy[rt].length;++i) {\r\n                         if (vis[qy[rt][i]]) {\r\n                             qy[rt][i] = root(qy[rt][i]);\r\n                         }else{\r\n                             qy[rt][i] = -1;\r\n                         }\r\n                }\r\n                fa[rt] = pa[rt];\r\n            }\r\n        }\r\n\r\n        for(int i=0;i<n;++i){\r\n            myup[i] = dis[i]+time[i];\r\n            mydown[i] = time[i]-dis[i]+n;\r\n        }\r\n\r\n\r\n        int lca[] = new int[m];\r\n        int v1[] = new int[m];\r\n        int lcas[] = new int[n];\r\n        int lcae[] = new int[n];\r\n\r\n        for(int i=0;i<m;++i){\r\n            int c1 = qy[u[i]][--oq[u[i]]];\r\n            int c2 = qy[v[i]][--oq[v[i]]];\r\n            if(c1!=-1){\r\n                lca[i] = c1;\r\n            }else{\r\n                lca[i] = c2;\r\n            }\r\n            v1[i] = dis[u[i]]-(dis[lca[i]]<<1)+n;\r\n            lcas[lca[i]]++;\r\n            lcae[lca[i]]++;\r\n        }\r\n\r\n        vale = new int[n][];\r\n        vals = new int[n][];\r\n        valsrm = new int[n][];\r\n        valerm = new int[n][];\r\n\r\n        for(int i=0;i<n;++i){\r\n            vale[i] = new int[le[i]];\r\n            vals[i] = new int[ls[i]];\r\n            valsrm[i] = new int[lcas[i]];\r\n            valerm[i] = new int[lcae[i]];\r\n        }\r\n\r\n        for(int i=0;i<m;++i) {\r\n            valerm[lca[i]][--lcae[lca[i]]] = vale[v[i]][--le[v[i]]] = v1[i];\r\n            valsrm[lca[i]][--lcas[lca[i]]] = vals[u[i]][--ls[u[i]]] = dis[u[i]];\r\n        }\r\n\r\n        dfs(0);\r\n        for(int i=0;i<n;++i){\r\n            print(res[i]+\" \");\r\n        }\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n    }\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n//    int []h,to,ne,wt;\r\n\r\n    long t1[];\r\n    //    long t2[];\r\n    void update(long[] t,int i,long v){\r\n        for(;i<t.length;i+=(i&-i)){\r\n            t[i] += v;\r\n        }\r\n    }\r\n    long get(long[] t,int i){\r\n        long s = 0;\r\n        for(;i>0;i-=(i&-i)){\r\n            s += t[i];\r\n        }\r\n        return s;\r\n    }\r\n\r\n    int equal_bigger(long t[],long v){\r\n        int s=0,p=0;\r\n        for(int i=Integer.numberOfTrailingZeros(Integer.highestOneBit(t.length));i>=0;--i) {\r\n            if(p+(1<<i)< t.length && s + t[p+(1<<i)] < v){\r\n                v -= t[p+(1<<i)];\r\n                p |= 1<<i;\r\n            }\r\n        }\r\n        return p+1;\r\n    }\r\n\r\n\r\n    int gcd(int a,int b){ return b==0?a: gcd(b,a%b);}\r\n    InputStream is;PrintWriter out;\r\n    void run() throws Exception {is = System.in;\r\n        //is = new FileInputStream(\"C:\\\\Users\\\\Luqi\\\\Downloads\\\\P2680_3.in\");\r\n\r\n        out = new PrintWriter(System.out);solve();out.flush();}\r\n    private byte[] inbuf = new byte[2];\r\n    public int lenbuf = 0, ptrbuf = 0;\r\n    private int readByte() {\r\n        if (lenbuf == -1) throw new InputMismatchException();\r\n        if (ptrbuf >= lenbuf) {\r\n            ptrbuf = 0;\r\n            try {lenbuf = is.read(inbuf);} catch (IOException e) {throw new InputMismatchException();}\r\n            if (lenbuf <= 0) return -1;\r\n        }\r\n        return inbuf[ptrbuf++];}\r\n    private boolean isSpaceChar(int c) {return !(c >= 33 && c <= 126);}\r\n    private int skip() {int b;while((b = readByte()) != -1 && isSpaceChar(b));return b;}\r\n    private double nd() {return Double.parseDouble(ns());}\r\n    private char nc() {return (char) skip();}\r\n    private char ncc() {int b;while((b = readByte()) != -1 && !(b >= 32 && b <= 126));return (char)b;}\r\n    private String ns() {int b = skip();StringBuilder sb = new StringBuilder();\r\n        while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')\r\n            sb.appendCodePoint(b);b = readByte(); }\r\n        return sb.toString();}\r\n    private char[] ns(int n) {char[] buf = new char[n];int b = skip(), p = 0;\r\n        while (p < n && !(isSpaceChar(b))) { buf[p++] = (char) b;b = readByte(); }\r\n        return n == p ? buf : Arrays.copyOf(buf, p);}\r\n    private String nline() {int b = skip();StringBuilder sb = new StringBuilder();\r\n        while (!isSpaceChar(b) || b == ' ') { sb.appendCodePoint(b);b = readByte(); }\r\n        return sb.toString();}\r\n    private char[][] nm(int n, int m) {char[][] a = new char[n][];for (int i = 0; i < n; i++) a[i] = ns(m);return a;}\r\n    private int[] na(int n) {int[] a = new int[n];for (int i = 0; i < n; i++) a[i] = ni();return a;}\r\n    private long[] nal(int n) { long[] a = new long[n];for (int i = 0; i < n; i++) a[i] = nl();return a;}\r\n    private int ni() { int num = 0, b; boolean minus = false;\r\n        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')){};\r\n        if (b == '-') { minus = true; b = readByte(); }\r\n        while (true) {\r\n            if (b >= '0' && b <= '9') num = (num << 3) + (num << 1) + (b - '0');\r\n            else return minus ? -num : num;\r\n            b = readByte();}}\r\n    private long nl() { long num = 0; int b;\r\n        boolean minus = false;\r\n        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')){};\r\n        if (b == '-') { minus = true; b = readByte(); }\r\n        while (true) {\r\n            if (b >= '0' && b <= '9')  num = num * 10 + (b - '0');\r\n            else return minus ? -num : num;\r\n            b = readByte();}}\r\n    void print(Object obj){out.print(obj);}\r\n    void println(Object obj){out.println(obj);}\r\n    void println(){out.println();}\r\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "天天爱跑步",
        "query": "# 天天爱跑步\n## 题目描述\n小 C 同学认为跑步非常有趣，于是决定制作一款叫做《天天爱跑步》的游戏。《天天爱跑步》是一个养成类游戏，需要玩家每天按时上线，完成打卡任务。\r\n\r\n这个游戏的地图可以看作一棵包含 $ n $ 个结点和 $ n - 1 $ 条边的树，每条边连接两个结点，且任意两个结点存在一条路径互相可达。树上结点编号为从 $ 1 $ 到 $ n $ 的连续正整数。\r\n\r\n现在有 $ m $ 个玩家，第 $ i $ 个玩家的起点为 $ S_i $，终点为 $ T_i $。每天打卡任务开始时，所有玩家在第 $ 0 $  秒同时从自己的起点出发，以每秒跑一条边的速度，不间断地沿着最短路径向着自己的终点跑去，跑到终点后该玩家就算完成了打卡任务。（由于地图是一棵树，所以每个人的路径是唯一的）\r\n\r\n小 C 想知道游戏的活跃度，所以在每个结点上都放置了一个观察员。在结点 $ j $ 的观察员会选择在第 $ W_j $ 秒观察玩家，一个玩家能被这个观察员观察到当且仅当该玩家在第 $ W_j $ 秒也正好到达了结点 $ j $。小 C 想知道每个观察员会观察到多少人？\r\n\r\n注意：我们认为一个玩家到达自己的终点后该玩家就会结束游戏，他不能等待一段时间后再被观察员观察到。即对于把结点 $ j $ 作为终点的玩家：若他在第 $ W_j $ 秒前到达终点，则在结点 $ j $ 的观察员不能观察到该玩家；若他正好在第 $ W_j $ 秒到达终点，则在结点 $ j $ 的观察员可以观察到这个玩家。\n## 输入格式\n第一行有两个整数 $ n $ 和 $ m $。其中 $ n $ 代表树的结点数量，同时也是观察员的数量，$ m $ 代表玩家的数量。\r\n\r\n接下来 $ n - 1 $ 行每行两个整数 $ u $ 和 $ v $，表示结点 $ u $ 到结点 $ v $ 有一条边。\r\n\r\n接下来一行 $ n $ 个整数，其中第 $ i $ 个整数为 $ W_i $，表示结点 $ i $ 出现观察员的时间。\r\n\r\n接下来 $ m $ 行，每行两个整数 $ S_i $ 和 $ T_i $，表示一个玩家的起点和终点。\r\n\r\n对于所有的数据，保证 $ 1 \\leq S_i, T_i \\leq n, 0 \\leq W_j \\leq n $。\n## 输出格式\n输出一行 $ n $ 个整数，第 $ j $ 个整数表示结点 $ j $ 的观察员可以观察到多少人。\n## 样例\n### 样例 1\n输入:\n6 3\n2 3\n1 2\n1 4\n4 5\n4 6\n0 2 5 1 2 3\n1 5\n1 3\n2 6\n输出:\n2 0 0 1 1 1\n\n对于 $ 1 $ 号点，$ W_1 = 0 $，故只有起点为 $ 1 $ 号点的玩家才会被观察到，所以玩家 1 和玩家 2 被观察到，共 $ 2 $ 人被观察到。\n对于 $ 2 $ 号点，没有玩家在第 $ 2 $ 秒时在此结点，共 $ 0 $ 人被观察到。\n对于 $ 3 $ 号点，没有玩家在第 $ 5 $ 秒时在此结点，共 $ 0 $ 人被观察到。\n对于 $ 4 $ 号点，玩家 $ 1 $ 被观察到，共 $ 1 $ 人被观察到。\n对于 $ 5 $ 号点，玩家 $ 1 $ 被观察到，共 $ 1 $ 人被观察到。\n对于 $ 6 $ 号点，玩家 $ 3 $ 被观察到，共 $ 1 $ 人被观察到。\n### 样例 2\n输入:\n5 3\n1 2\n2 3\n2 4\n1 5\n0 1 0 3 0\n3 1\n1 4\n5 5\n输出:\n1 2 1 0 1\n\n\n## 数据范围与提示\n$ n,m \\leq 300000 $。",
        "sample": {
            "input": "6 3\n2 3\n1 2\n1 4\n4 5\n4 6\n0 2 5 1 2 3\n1 5\n1 3\n2 6",
            "output": "2 0 0 1 1 1"
        }
    },
    {
        "code_id": 4,
        "code": "from math import *\r\na = int(input())\r\nprint(a + (1 << (1 + int(log2(a - 2)))))",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "天气之子 Tenki",
        "query": "# 天气之子 Tenki\n## 题目描述\n> 高中一年级的夏天，少年帆高离家出走，由小岛去到东京。\r\n>\r\n> 但他生活极之贫困，孤独度日，终于找到的一份工，却只是为一本古怪的「神秘学杂志」写稿。\r\n>\r\n> 跟着连日滂沱大雨，像是来映衬他的失落。 在纷纭杂沓的大都会一角，帆高遇上了一个可爱的少女阳菜。\r\n>\r\n> 阳菜和弟弟相依为命，个性坚强、开朗，但心中隐藏一个重大秘密── \r\n>\r\n> 她拥有一股不可思议的力量，她说：「现在开始天晴了！」 \r\n>\r\n> 然后，雨渐渐停下来，美丽的阳光洒落到街上。 那原来是能让天空放晴的超能力……\r\n\r\n有 $n$ 个人依次进入观影厅，观看 *Weathering with You*。\r\n\r\n观影厅只有一排座位，第 $1$ 个人进入时，会选择第 $1$ 个座位坐下。\r\n\r\n由于观影厅空调坏掉了，十分炎热，之后的每个人进入时，他会选择一个离最近的已经坐下的人尽可能远的空位。\r\n\r\n如果有多个空位使得离最近的人同样远，则他会从其中随机选取一个。\r\n\r\n若有两个人选择的位置相邻，他们就会不满意。\r\n\r\n为了让所有人都满意，观影厅至少需要有几个座位呢？\n## 输入格式\n包含一行，仅一个正整数 $n$，表示前来观影的人数。\n## 输出格式\n包含一行，仅一个正整数，表示至少需要的座位数目。\n## 样例\n输入:\n4\n输出:\n8\n\n观影厅只有 $7$ 个位置时，前 $3$ 个人会依次选择 $1,7,4$ 这 $3$ 个位置，第 $4$ 个人无论选哪个空位，都会与其他人相邻。\n\n观影厅有 $8$ 个位置时，他们依次选取的位置可能是 $1,8,4,6$ 与 $1,8,5,3$ 两种情况，都是合法的。\n## 数据范围与提示\n对于 $100\\%$ 的数据, $n\\le 10^{1000}$。",
        "sample": {
            "input": "4",
            "output": "8"
        }
    },
    {
        "code_id": 6,
        "code": "def fail(sub_string):\n    ans = [0] * (len(sub_string) + 1)\n    for i in range(1, len(sub_string)):\n        j = ans[i]\n        while j > 0 and sub_string[i] != sub_string[j]:\n            j = ans[j]\n        if sub_string[i] == sub_string[j]:\n            ans[i + 1] = j + 1\n        else:\n            ans[i + 1] = 0\n    return ans\n\n\ndef count_substring(string, sub_string):\n    next = fail(sub_string)\n    cnt = 0\n    start = 0\n    length = len(string) - len(sub_string)\n    i = 0\n    while i <= length:\n        while start < len(sub_string) and string[i + start] == sub_string[start]:\n            start = start + 1\n        if start == len(sub_string):\n            cnt = cnt + 1\n        i = i + start - next[start]\n        if next[start] == 0:\n            i = i + 1\n        start = next[start]\n    return cnt\n\n\nif __name__ == \"__main__\":\n    string = input().strip()\n    sub_string = input().strip()\n    count = count_substring(string, sub_string)\n    print(count)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "子串查找",
        "query": "# 子串查找\n## 题目描述\n\r\n\r\n给定一个字符串 $ A $ 和一个字符串 $ B $，求 $ B $ 在 $ A $ 中的出现次数。$A$ 和 $B$ 中的字符均为英语大写字母或小写字母。\r\n\r\n$ A $ 中不同位置出现的 $ B $ 可重叠。\n## 输入格式\n输入共两行，分别是字符串 $ A $ 和字符串 $ B $。\n## 输出格式\n输出一个整数，表示 $ B $ 在 $ A $ 中的出现次数。\n## 样例\n输入:\nzyzyzyz\nzyz\n输出:\n3\n\n\n## 数据范围与提示\n$ 1 \\leq  A, B$ 的长度 $ \\leq 10 ^ 6 $，$ A $、$ B $ 仅包含大小写字母。",
        "sample": {
            "input": "zyzyzyz\nzyz",
            "output": "3"
        }
    },
    {
        "code_id": 0,
        "code": "# pollard p-1\r\n\r\nfrom fractions import gcd\r\n\r\ndef primes(n):\r\n\tps = []\r\n\tsieve = [True] * n\r\n\tfor p in range(2,n):\r\n\t\tif sieve[p]:\r\n\t\t\tps.append(p)\r\n\t\t\tfor i in range(p*p,n,p):\r\n\t\t\t\tsieve[i] = False\r\n\treturn ps\r\n\r\ndef pminus1(n, b):\r\n\tc = 2\r\n\tfor p in primes(b):\r\n\t\tpp = p\r\n\t\twhile pp < b:\r\n\t\t\tc = pow(c, p, n)\r\n\t\t\tpp = pp * p\r\n\tg = gcd(c-1, n)\r\n\tif 1 < g < n:\r\n\t\treturn g\r\n\treturn 0\r\n\r\ndef exgcd(a, b):\r\n\tif b:\r\n\t\ts = exgcd(b, a%b)\r\n\t\treturn (s[1], s[0]-a/b*s[1])\r\n\treturn (1, 0)\r\n\r\ne, n, c = map(int, raw_input().split())\r\np = pminus1(n, 100000)\r\nr = (p-1)*(n/p-1)\r\nd = (exgcd(e, r)[0]+r)%r\r\nprint d, pow(c, d, n)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "密钥破解",
        "query": "# 密钥破解\n## 题目描述\n一种非对称加密算法的密钥生成过程如下：\r\n1. 任选两个不同的质数 $p, q$；\r\n2. 计算 $N = pq, r=(p-1)(q-1)$；\r\n3. 选取小于 $r$，且与 $r$ 互质的整数 $e$；\r\n4. 计算整数 $d$，使得 $ed \\equiv 1 \\pmod r$；\r\n5. 二元组 $(N, e)$ 称为**公钥**，二元组 $(N, d)$ 称为**私钥**。\r\n\r\n当需要加密消息 $n$ 时（假设 $n$ 是一个小于 $N$ 的整数，因为任何格式的消息都可转为整数表示），使用公钥 $(N, e)$，按照\r\n$$n^e \\equiv c \\pmod N$$\r\n运算，可得到密文 $c$。\r\n\r\n对密文 $c$ 解密时，用私钥 $(N, d)$，按照\r\n$$c^d \\equiv n \\pmod N$$\r\n运算，可得到原文 $n$。算法正确性证明省略。\r\n\r\n由于用公钥加密的密文仅能用对应的私钥解密，而不能用公钥解密，因此称为非对称加密算法。通常情况下，公钥由消息的接收方公开，而私钥由消息的接收方自己持有。这样任何发送消息的人都可以用公钥对消息加密，而只有消息的接收方自己能够解密消息。\r\n\r\n现在，你的任务是寻找一种可行的方法来破解这种加密算法，即根据公钥破解出私钥，并据此解密密文。\n## 输入格式\n输入文件内容只有一行，为空格分隔的三个正整数 $e, N, c$。\n## 输出格式\n输出文件内容只有一行，为空格分隔的两个整数 $d, n$。\n## 样例\n输入:\n3 187 45\n输出:\n107 12\n\n样例中 $p = 11, q = 17$。\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1 \\leq e, N, c \\leq 2^{62}, c < N$。",
        "sample": {
            "input": "3 187 45",
            "output": "107 12"
        }
    },
    {
        "code_id": 4,
        "code": "# pollard p-1\r\n\r\nfrom fractions import gcd\r\n\r\ndef primes(n):\r\n\tps = []\r\n\tsieve = [True] * n\r\n\tfor p in range(2,n):\r\n\t\tif sieve[p]:\r\n\t\t\tps.append(p)\r\n\t\t\tfor i in range(p*p,n,p):\r\n\t\t\t\tsieve[i] = False\r\n\treturn ps\r\n\r\ndef pminus1(n, b):\r\n\tc = 2\r\n\tfor p in primes(b):\r\n\t\tpp = p\r\n\t\twhile pp < b:\r\n\t\t\tc = pow(c, p, n)\r\n\t\t\tpp = pp * p\r\n\tg = gcd(c-1, n)\r\n\tif 1 < g < n:\r\n\t\treturn g\r\n\treturn 0\r\n\r\ndef exgcd(a, b):\r\n\tif b:\r\n\t\ts = exgcd(b, a%b)\r\n\t\treturn (s[1], s[0]-a/b*s[1])\r\n\treturn (1, 0)\r\n\r\ne, n, c = map(int, raw_input().split())\r\np = pminus1(n, int(n**.25+.5)*2)\r\nr = (p-1)*(n/p-1)\r\nd = (exgcd(e, r)[0]+r)%r\r\nprint d, pow(c, d, n)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "密钥破解",
        "query": "# 密钥破解\n## 题目描述\n一种非对称加密算法的密钥生成过程如下：\r\n1. 任选两个不同的质数 $p, q$；\r\n2. 计算 $N = pq, r=(p-1)(q-1)$；\r\n3. 选取小于 $r$，且与 $r$ 互质的整数 $e$；\r\n4. 计算整数 $d$，使得 $ed \\equiv 1 \\pmod r$；\r\n5. 二元组 $(N, e)$ 称为**公钥**，二元组 $(N, d)$ 称为**私钥**。\r\n\r\n当需要加密消息 $n$ 时（假设 $n$ 是一个小于 $N$ 的整数，因为任何格式的消息都可转为整数表示），使用公钥 $(N, e)$，按照\r\n$$n^e \\equiv c \\pmod N$$\r\n运算，可得到密文 $c$。\r\n\r\n对密文 $c$ 解密时，用私钥 $(N, d)$，按照\r\n$$c^d \\equiv n \\pmod N$$\r\n运算，可得到原文 $n$。算法正确性证明省略。\r\n\r\n由于用公钥加密的密文仅能用对应的私钥解密，而不能用公钥解密，因此称为非对称加密算法。通常情况下，公钥由消息的接收方公开，而私钥由消息的接收方自己持有。这样任何发送消息的人都可以用公钥对消息加密，而只有消息的接收方自己能够解密消息。\r\n\r\n现在，你的任务是寻找一种可行的方法来破解这种加密算法，即根据公钥破解出私钥，并据此解密密文。\n## 输入格式\n输入文件内容只有一行，为空格分隔的三个正整数 $e, N, c$。\n## 输出格式\n输出文件内容只有一行，为空格分隔的两个整数 $d, n$。\n## 样例\n输入:\n3 187 45\n输出:\n107 12\n\n样例中 $p = 11, q = 17$。\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1 \\leq e, N, c \\leq 2^{62}, c < N$。",
        "sample": {
            "input": "3 187 45",
            "output": "107 12"
        }
    },
    {
        "code_id": 4,
        "code": "import java.io.*;\nimport java.util.Arrays;\n\npublic class Main {\n\n  private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(\n      new InputStreamReader(System.in)));\n  private static PrintWriter out = new PrintWriter(\n      new OutputStreamWriter(System.out));\n\n  public static int nextInt() throws Exception {\n    in.nextToken();\n    return (int) in.nval;\n  }\n\n  public static int currentInt() throws Exception {\n    return (int) in.nval;\n  }\n\n  public static double nextDouble() throws Exception {\n    in.nextToken();\n    return in.nval;\n  }\n\n  public static String next() throws Exception {\n    in.nextToken();\n    return in.sval;\n  }\n\n  public static boolean isEOF() throws Exception {\n    return in.nextToken() == StreamTokenizer.TT_EOF;\n  }\n\n  public static void main(String[] args) throws Exception {\n    String str = next();\n    int n = str.length();\n    int[] a = new int[n+1];\n    for (int i = 0; i < n; ++ i) a[ i ] = str.charAt(i);\n    DC3 dc3 = new DC3(a, 255);\n    long ans = dc3.getAns();\n    out.println(ans);\n    out.flush();\n  }\n\n  static class DC3 {\n\n    public int[] sa;\n\n    public int[] rank;\n\n    public int[] height;\n\n    // 构造方法的约定:\n    // 数组叫nums&#xff0c;如果你是字符串&#xff0c;请转成整型数组nums\n    // 数组中&#xff0c;最小值>=1\n    // 如果不满足&#xff0c;处理成满足的&#xff0c;也不会影响使用\n    // max, nums里面最大值是多少\n    public DC3(int[] nums, int max) {\n      sa = sa(nums, max);\n      rank = rank();\n      height = height(nums);\n      adjust();\n    }\n\n    public void adjust() {\n      int n = height.length-1;\n      for (int i = 1; i <= n; ++ i) ++ sa[ i ];\n      for (int i = 1; i <= n; ++ i) rank[sa[ i ]] = i;\n      sa[0] = rank[0] = 0;\n    }\n\n    private int[] sa(int[] nums, int max) {\n      int n = nums.length;\n      int[] arr = new int[n + 3];\n      for (int i = 0; i < n; i++) {\n        arr[i] = nums[i];\n      }\n      return skew(arr, n, max);\n    }\n\n    private int[] skew(int[] nums, int n, int K) {\n      int n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;\n      int[] s12 = new int[n02 + 3], sa12 = new int[n02 + 3];\n      for (int i = 0, j = 0; i < n + (n0 - n1); ++i) {\n        if (0 != i % 3) {\n          s12[j++] = i;\n        }\n      }\n      radixPass(nums, s12, sa12, 2, n02, K);\n      radixPass(nums, sa12, s12, 1, n02, K);\n      radixPass(nums, s12, sa12, 0, n02, K);\n      int name = 0, c0 = -1, c1 = -1, c2 = -1;\n      for (int i = 0; i < n02; ++i) {\n        if (c0 != nums[sa12[i]] || c1 != nums[sa12[i] + 1] || c2 != nums[sa12[i] + 2]) {\n          name++;\n          c0 = nums[sa12[i]];\n          c1 = nums[sa12[i] + 1];\n          c2 = nums[sa12[i] + 2];\n        }\n        if (1 == sa12[i] % 3) {\n          s12[sa12[i] / 3] = name;\n        } else {\n          s12[sa12[i] / 3 + n0] = name;\n        }\n      }\n      if (name < n02) {\n        sa12 = skew(s12, n02, name);\n        for (int i = 0; i < n02; i++) {\n          s12[sa12[i]] = i + 1;\n        }\n      } else {\n        for (int i = 0; i < n02; i++) {\n          sa12[s12[i] - 1] = i;\n        }\n      }\n      int[] s0 = new int[n0], sa0 = new int[n0];\n      for (int i = 0, j = 0; i < n02; i++) {\n        if (sa12[i] < n0) {\n          s0[j++] = 3 * sa12[i];\n        }\n      }\n      radixPass(nums, s0, sa0, 0, n0, K);\n      int[] sa = new int[n];\n      for (int p = 0, t = n0 - n1, k = 0; k < n; k++) {\n        int i = sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2;\n        int j = sa0[p];\n        if (sa12[t] < n0 ? leq(nums[i], s12[sa12[t] + n0], nums[j], s12[j / 3])\n            : leq(nums[i], nums[i + 1], s12[sa12[t] - n0 + 1], nums[j], nums[j + 1], s12[j / 3 + n0])) {\n          sa[k] = i;\n          t++;\n          if (t == n02) {\n            for (k++; p < n0; p++, k++) {\n              sa[k] = sa0[p];\n            }\n          }\n        } else {\n          sa[k] = j;\n          p++;\n          if (p == n0) {\n            for (k++; t < n02; t++, k++) {\n              sa[k] = sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2;\n            }\n          }\n        }\n      }\n      return sa;\n    }\n\n    private void radixPass(int[] nums, int[] input, int[] output, int offset, int n, int k) {\n      int[] cnt = new int[k + 1];\n      for (int i = 0; i < n; ++i) {\n        cnt[nums[input[i] + offset]]++;\n      }\n      for (int i = 0, sum = 0; i < cnt.length; ++i) {\n        int t = cnt[i];\n        cnt[i] = sum;\n        sum += t;\n      }\n      for (int i = 0; i < n; ++i) {\n        output[cnt[nums[input[i] + offset]]++] = input[i];\n      }\n    }\n\n    private boolean leq(int a1, int a2, int b1, int b2) {\n      return a1 < b1 || (a1 == b1 && a2 <= b2);\n    }\n\n    private boolean leq(int a1, int a2, int a3, int b1, int b2, int b3) {\n      return a1 < b1 || (a1 == b1 && leq(a2, a3, b2, b3));\n    }\n\n    private int[] rank() {\n      int n = sa.length;\n      int[] ans = new int[n];\n      for (int i = 0; i < n; i++) {\n        ans[sa[i]] = i;\n      }\n      return ans;\n    }\n\n    private int[] height(int[] s) {\n      int n = s.length;\n      int[] ans = new int[n];\n      for (int i = 0, k = 0; i < n; ++i) {\n        if (rank[i] != 0) {\n          if (k > 0) {\n            --k;\n          }\n          int j = sa[rank[i] - 1];\n          while (i + k < n && j + k < n && s[i + k] == s[j + k]) {\n            ++k;\n          }\n          ans[rank[i]] = k;\n        }\n      }\n      return ans;\n    }\n\n    public long getAns() {\n      int n = sa.length-1;\n      long ans = 0;\n      int nodePos = 0;\n      Node[] nodes = new Node[n+1];\n      for (int i = 2; i <= n; ++ i) {\n        int leftPos = i;\n        while (nodePos > 0 && height[i] < nodes[nodePos-1].val) {\n          Node node = nodes[nodePos-1];\n          leftPos = node.leftPos;\n          int pos = node.pos;\n          ans += (long) node.val * (i - pos) * (pos - leftPos + 1);\n          -- nodePos;\n        }\n        nodes[nodePos++] = new Node(height[i], i, leftPos);\n      }\n\n      while (nodePos > 0) {\n        Node node = nodes[nodePos-1];\n        int leftPos = node.leftPos;\n        int pos = node.pos;\n        ans += (long) node.val * (n - pos + 1) * (pos - leftPos + 1);\n        -- nodePos;\n      }\n      long nn = n;\n      return (nn-1) * (nn * (nn+1) >> 1) - (ans << 1);\n    }\n  }\n\n  static class Node {\n    int val;\n    int leftPos;\n\n    int pos;\n\n    public Node(int val, int pos, int leftPos) {\n      this.val = val;\n      this.pos = pos;\n      this.leftPos = leftPos;\n    }\n  }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "差异",
        "query": "# 差异\n## 题目描述\n给定一个长度为 $n$ 的字符串 $S$ ，令 $T_i$ 表示它从第 $i$ 个字符开始的后缀，求：\r\n$$\\sum_{1 \\le i < j \\le n} \\operatorname{len}(T_i)+\\operatorname{len}(T_j)-2\\operatorname{lcp}(T_i,T_j)$$\n## 输入格式\n一行，一个字符串 $S$ 。\n## 输出格式\n一行，一个整数，表示所求值。\n## 样例\n输入:\nababc\n输出:\n54\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据， $2 \\le n \\le 500000$。",
        "sample": {
            "input": "ababc",
            "output": "54"
        }
    },
    {
        "code_id": 8,
        "code": "\n\nimport java.io.*;\n\npublic class Main {\n\n  private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(\n      new InputStreamReader(System.in)));\n  private static PrintWriter out = new PrintWriter(\n      new OutputStreamWriter(System.out));\n\n  public static int nextInt() throws Exception {\n    in.nextToken();\n    return (int) in.nval;\n  }\n\n  public static int currentInt() throws Exception {\n    return (int) in.nval;\n  }\n\n  public static double nextDouble() throws Exception {\n    in.nextToken();\n    return in.nval;\n  }\n\n  public static String next() throws Exception {\n    in.nextToken();\n    return in.sval;\n  }\n\n  public static boolean isEOF() throws Exception {\n    return in.nextToken() == StreamTokenizer.TT_EOF;\n  }\n\n  public static void main(String[] args) throws Exception {\n    String str = next();\n    int n = str.length();\n    int[] a = new int[n+1];\n    for (int i = 0; i < n; ++ i) a[ i ] = str.charAt(i);\n    DC3 dc3 = new DC3(a, 200);\n    long ans = dc3.getAns();\n    out.println(ans);\n    out.flush();\n  }\n\n  static class DC3 {\n\n    public int[] sa;\n\n    public int[] rank;\n\n    public int[] height;\n\n    // 构造方法的约定:\n    // 数组叫nums&#xff0c;如果你是字符串&#xff0c;请转成整型数组nums\n    // 数组中&#xff0c;最小值>=1\n    // 如果不满足&#xff0c;处理成满足的&#xff0c;也不会影响使用\n    // max, nums里面最大值是多少\n    public DC3(int[] nums, int max) {\n      sa = sa(nums, max);\n      rank = rank();\n      height = height(nums);\n      adjust();\n    }\n\n    public void adjust() {\n      int n = height.length-1;\n      for (int i = 1; i <= n; ++ i) ++ sa[ i ];\n      for (int i = 1; i <= n; ++ i) rank[sa[ i ]] = i;\n      sa[0] = rank[0] = 0;\n    }\n\n    private int[] sa(int[] nums, int max) {\n      int n = nums.length;\n      int[] arr = new int[n + 3];\n      for (int i = 0; i < n; i++) {\n        arr[i] = nums[i];\n      }\n      return skew(arr, n, max);\n    }\n\n    private int[] skew(int[] nums, int n, int K) {\n      int n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;\n      int[] s12 = new int[n02 + 3], sa12 = new int[n02 + 3];\n      for (int i = 0, j = 0; i < n + (n0 - n1); ++i) {\n        if (0 != i % 3) {\n          s12[j++] = i;\n        }\n      }\n      radixPass(nums, s12, sa12, 2, n02, K);\n      radixPass(nums, sa12, s12, 1, n02, K);\n      radixPass(nums, s12, sa12, 0, n02, K);\n      int name = 0, c0 = -1, c1 = -1, c2 = -1;\n      for (int i = 0; i < n02; ++i) {\n        if (c0 != nums[sa12[i]] || c1 != nums[sa12[i] + 1] || c2 != nums[sa12[i] + 2]) {\n          name++;\n          c0 = nums[sa12[i]];\n          c1 = nums[sa12[i] + 1];\n          c2 = nums[sa12[i] + 2];\n        }\n        if (1 == sa12[i] % 3) {\n          s12[sa12[i] / 3] = name;\n        } else {\n          s12[sa12[i] / 3 + n0] = name;\n        }\n      }\n      if (name < n02) {\n        sa12 = skew(s12, n02, name);\n        for (int i = 0; i < n02; i++) {\n          s12[sa12[i]] = i + 1;\n        }\n      } else {\n        for (int i = 0; i < n02; i++) {\n          sa12[s12[i] - 1] = i;\n        }\n      }\n      int[] s0 = new int[n0], sa0 = new int[n0];\n      for (int i = 0, j = 0; i < n02; i++) {\n        if (sa12[i] < n0) {\n          s0[j++] = 3 * sa12[i];\n        }\n      }\n      radixPass(nums, s0, sa0, 0, n0, K);\n      int[] sa = new int[n];\n      for (int p = 0, t = n0 - n1, k = 0; k < n; k++) {\n        int i = sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2;\n        int j = sa0[p];\n        if (sa12[t] < n0 ? leq(nums[i], s12[sa12[t] + n0], nums[j], s12[j / 3])\n            : leq(nums[i], nums[i + 1], s12[sa12[t] - n0 + 1], nums[j], nums[j + 1], s12[j / 3 + n0])) {\n          sa[k] = i;\n          t++;\n          if (t == n02) {\n            for (k++; p < n0; p++, k++) {\n              sa[k] = sa0[p];\n            }\n          }\n        } else {\n          sa[k] = j;\n          p++;\n          if (p == n0) {\n            for (k++; t < n02; t++, k++) {\n              sa[k] = sa12[t] < n0 ? sa12[t] * 3 + 1 : (sa12[t] - n0) * 3 + 2;\n            }\n          }\n        }\n      }\n      return sa;\n    }\n\n    private void radixPass(int[] nums, int[] input, int[] output, int offset, int n, int k) {\n      int[] cnt = new int[k + 1];\n      for (int i = 0; i < n; ++i) {\n        cnt[nums[input[i] + offset]]++;\n      }\n      for (int i = 0, sum = 0; i < cnt.length; ++i) {\n        int t = cnt[i];\n        cnt[i] = sum;\n        sum += t;\n      }\n      for (int i = 0; i < n; ++i) {\n        output[cnt[nums[input[i] + offset]]++] = input[i];\n      }\n    }\n\n    private boolean leq(int a1, int a2, int b1, int b2) {\n      return a1 < b1 || (a1 == b1 && a2 <= b2);\n    }\n\n    private boolean leq(int a1, int a2, int a3, int b1, int b2, int b3) {\n      return a1 < b1 || (a1 == b1 && leq(a2, a3, b2, b3));\n    }\n\n    private int[] rank() {\n      int n = sa.length;\n      int[] ans = new int[n];\n      for (int i = 0; i < n; i++) {\n        ans[sa[i]] = i;\n      }\n      return ans;\n    }\n\n    private int[] height(int[] s) {\n      int n = s.length;\n      int[] ans = new int[n];\n      for (int i = 0, k = 0; i < n; ++i) {\n        if (rank[i] != 0) {\n          if (k > 0) {\n            --k;\n          }\n          int j = sa[rank[i] - 1];\n          while (i + k < n && j + k < n && s[i + k] == s[j + k]) {\n            ++k;\n          }\n          ans[rank[i]] = k;\n        }\n      }\n      return ans;\n    }\n\n    public long getAns() {\n      int n = sa.length-1;\n      long ans = 0;\n      int nodePos = 0;\n      Node[] nodes = new Node[n+1];\n      for (int i = 2; i <= n; ++ i) {\n        int leftPos = i;\n        while (nodePos > 0 && height[i] < nodes[nodePos-1].val) {\n          Node node = nodes[nodePos-1];\n          leftPos = node.leftPos;\n          int pos = node.pos;\n          ans += (long) node.val * (i - pos) * (pos - leftPos + 1);\n          -- nodePos;\n        }\n        nodes[nodePos++] = new Node(height[i], i, leftPos);\n      }\n\n      while (nodePos > 0) {\n        Node node = nodes[nodePos-1];\n        int leftPos = node.leftPos;\n        int pos = node.pos;\n        ans += (long) node.val * (n - pos + 1) * (pos - leftPos + 1);\n        -- nodePos;\n      }\n      long nn = n;\n      return (nn-1) * (nn * (nn+1) >> 1) - (ans << 1);\n    }\n  }\n\n  static class Node {\n    int val;\n    int leftPos;\n\n    int pos;\n\n    public Node(int val, int pos, int leftPos) {\n      this.val = val;\n      this.pos = pos;\n      this.leftPos = leftPos;\n    }\n  }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "差异",
        "query": "# 差异\n## 题目描述\n给定一个长度为 $n$ 的字符串 $S$ ，令 $T_i$ 表示它从第 $i$ 个字符开始的后缀，求：\r\n$$\\sum_{1 \\le i < j \\le n} \\operatorname{len}(T_i)+\\operatorname{len}(T_j)-2\\operatorname{lcp}(T_i,T_j)$$\n## 输入格式\n一行，一个字符串 $S$ 。\n## 输出格式\n一行，一个整数，表示所求值。\n## 样例\n输入:\nababc\n输出:\n54\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据， $2 \\le n \\le 500000$。",
        "sample": {
            "input": "ababc",
            "output": "54"
        }
    },
    {
        "code_id": 2,
        "code": "import copy\nfrom io import BytesIO, IOBase\nimport math\nimport random\nimport os\nimport bisect\nimport typing\nfrom copy import deepcopy\nfrom heapq import merge, heapify, heappop, heappush, heappushpop, nlargest, nsmallest\nfrom itertools import accumulate, combinations, permutations, count, groupby\nfrom operator import add, iand, ior, itemgetter, mul, xor\nfrom string import ascii_lowercase, ascii_uppercase, ascii_letters\nfrom typing import *\nfrom collections import Counter, defaultdict, deque\nfrom functools import cmp_to_key, lru_cache, reduce\nimport sys\n\ninput = lambda: sys.stdin.readline().strip()\ninf = float('inf')\n\n\ndef I():\n    return input()\n\n\ndef II():\n    return int(input())\n\n\ndef MII():\n    return map(int, input().split())\n\n\ndef LI():\n    return list(input().split())\n\n\ndef LII():\n    return list(map(int, input().split()))\n\n\n# mod = 998244353\nmod = 10 ** 9 + 7\n\ndef main():\n    n = II()\n    g = [[] for _ in range(n)]\n    for _ in range(n - 1):\n        tmp = LII()\n        ln = len(tmp)\n        for i in range(2, ln):\n            g[tmp[0]].append(tmp[i])\n    dp = [[0] * 2 for _ in range(n)]\n\n    def dfs(root):\n        dp[root][1] = 1\n        if len(g[root]) == 0:\n            return\n        for nxt in g[root]:\n            dfs(nxt)\n            dp[root][0] += dp[nxt][1]\n            dp[root][1] += min(dp[nxt][0], dp[nxt][1])\n\n    dfs(0)\n    return min(dp[0][0], dp[0][1])\n\n\ntt = 1\nfor ii in range(tt):\n    print(main())\n    # main()\n\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "战略游戏",
        "query": "# 战略游戏\n## 题目描述\nBob 喜欢玩电脑游戏，特别是战略游戏。但是他经常无法找到快速玩过游戏的方法。现在他有个问题。\r\n\r\n现在他有座古城堡，古城堡的路形成一棵树。他要在这棵树的节点上放置最少数目的士兵，使得这些士兵能够瞭望到所有的路。\r\n\r\n注意：某个士兵在一个节点上时，与该节点相连的所有边都将能被瞭望到。\r\n\r\n请你编一个程序，给定一棵树，帮 Bob 计算出他最少要放置的士兵数。\n## 输入格式\n输入数据表示一棵树，描述如下。\r\n\r\n第一行一个数 $N$ ，表示树中节点的数目。\r\n\r\n第二到第 $N+1$ 行，每行描述每个节点信息，依次为该节点编号 $i$，数值 $k$，$k$ 表示后面有 $k$ 条边与节点 $i$ 相连，接下来 $k$ 个数，分别是每条边的所连节点编号 $r_1,r_2,\\cdots ,r_k$。\r\n\r\n对于一个有 $N$ 个节点的树，节点标号在 $0$ 到 $N-1$ 之间，且在输入文件中每条边仅出现一次。\n## 输出格式\n输出仅包含一个数，为所求的最少士兵数。\n## 样例\n输入:\n4\n0 1 1\n1 2 2 3\n2 0\n3 0\n输出:\n1\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，有 $0\\lt N\\le 1500$。",
        "sample": {
            "input": "4\n0 1 1\n1 2 2 3\n2 0\n3 0",
            "output": "1"
        }
    },
    {
        "code_id": 3,
        "code": "def C(n):\n\treturn n * (n - 1) * (n - 2) / 6\n\ndef gcd(a, b):\n\tm = a % b\n\twhile m != 0:\n\t\ta = b\n\t\tb = m\n\t\tm = a % b\n\treturn b\n\nn, m = map(int, input().split())\nn = n + 1\nm = m + 1\nans = C(n * m) - n * C(m) - m * C(n)\nfor i in range(2, n + 1):\n\tfor j in range(2, m + 1):\n\t\td = gcd(i - 1, j - 1) + 1\n\t\tif d >= 3:\n\t\t\tans = ans - (n - i + 1) * (m - j + 1) * (d - 2) * 2\nprint(int(ans))",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "数三角形",
        "query": "# 数三角形\n## 题目描述\n给定一个 $n \\times m$ 的网格，请计算三点都在格点上的三角形共有多少个。下图为 $4 \\times 4$ 的网格上的一个三角形。\r\n\r\n<img src=\"https://ooo.0o0.ooo/2017/05/03/59091867eebda.png\">\r\n\r\n**注意**：三角形的三点不能共线。\n## 输入格式\n输入一行，包含两个空格分隔的正整数 $m$ 和 $n$。\n## 输出格式\n输出一个正整数，为所求三角形数量。\n## 样例\n输入:\n2 2\n输出:\n76\n\n\n## 数据范围与提示\n对于所有数据，$1 \\leq m,n \\leq 1000$。",
        "sample": {
            "input": "2 2",
            "output": "76"
        }
    },
    {
        "code_id": 0,
        "code": "uses math;\r\nvar\r\n  n,m,i,j,x,y,maxx:longint;\r\n  f:array[0..100000,0..20] of longint;\r\nbegin\r\n  readln(n,m);\r\n  for i:=1 to n do\r\n    read(f[i,0]);\r\n  readln;\r\n  for j:=1 to 20 do\r\n    for i:=1 to n-1 shl j do\r\n      f[i,j]:=max(f[i,j-1],f[i+1 shl (j-1),j-1]);\r\n  for i:=1 to m do begin\r\n    readln(x,y);\r\n    maxx:=0;\r\n    for j:=20 downto 0 do\r\n      if x+1 shl j-1<=y then begin\r\n                             maxx:=max(maxx,f[x,j]);\r\n                             x:=x+1 shl j;\r\n                           end;\r\n    writeln(maxx);\r\n  end;\r\nend.",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "数列区间最大值",
        "query": "# 数列区间最大值\n## 题目描述\n输入一串数字，给你 $M$ 个询问，每次询问就给你两个数字 $X, Y$，要求你说出 $X$ 到 $Y$ 这段区间内的最大数。\n## 输入格式\n第一行两个整数 $N,M$ 表示数字的个数和要询问的次数；  \r\n接下来一行为 $N$ 个数；  \r\n接下来 $M$ 行，每行都有两个整数 $X,Y$。\n## 输出格式\n输出共 $M$ 行，每行输出一个数。\n## 样例\n输入:\n10 2\n3 2 4 5 6 8 1 2 9 7\n1 4\n3 8\n输出:\n5\n8\n\n\n## 数据范围与提示\n对于全部数据，$1\\le N\\le 10^5,1\\le M\\le 10^6,1\\le X\\le Y\\le N$。数字不超过 `C/C++` 的 `int` 范围。",
        "sample": {
            "input": "10 2\n3 2 4 5 6 8 1 2 9 7\n1 4\n3 8",
            "output": "5\n8"
        }
    },
    {
        "code_id": 3,
        "code": "A = int(input(\"\"))\r\nB = int(input(\"\"))\r\nwhile A%B!=0 and B%A!=0 :\r\n\tif A>B : A%=B\r\n\telse: B%=A\r\n\r\nif A==0 : print(B)\r\nelse: print(A)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大公约数",
        "query": "# 最大公约数\n## 题目描述\n给出两个正整数 $A,B$，求它们的最大公约数。\n## 输入格式\n输入共两行，第一行一个正整数 $A$，第二行一个正整数 $B$。\n## 输出格式\n在第一行输出一个整数，表示 $A,B$ 的最大公约数。\n## 样例\n输入:\n18\n24\n输出:\n6\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1\\le A,B\\le 10^{3000}$。",
        "sample": {
            "input": "18\n24",
            "output": "6"
        }
    },
    {
        "code_id": 5,
        "code": "import java.util.Scanner;\nimport java.math.*;\n\npublic class Main {\n\tpublic static void main(String[] args) {\n\t\tScanner read = new Scanner(System.in);\n\t\t\n\t\t//输入\n\t\tBigInteger A = new BigInteger(read.next());\n\t\tBigInteger B = new BigInteger(read.next());\n\t\t\n\t\t//确定较大的值\n\t\tif(A.compareTo(B) == 1) {\n\t\t\tBigInteger temp = A;\n\t\t\tA = B;\n\t\t\tB = A;\n\t\t}\n\t\t\n\t\tBigInteger res = B.divideAndRemainder(A)[1];\n\t\twhile(res.compareTo(new BigInteger(\"0\")) != 0) {\n\t\t\tB = A;\n\t\t\tA = res;\n\t\t\tres = B.divideAndRemainder(A)[1];\n\t\t}\n\t\t\n\t\tSystem.out.println(A);\n\t}\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大公约数",
        "query": "# 最大公约数\n## 题目描述\n给出两个正整数 $A,B$，求它们的最大公约数。\n## 输入格式\n输入共两行，第一行一个正整数 $A$，第二行一个正整数 $B$。\n## 输出格式\n在第一行输出一个整数，表示 $A,B$ 的最大公约数。\n## 样例\n输入:\n18\n24\n输出:\n6\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1\\le A,B\\le 10^{3000}$。",
        "sample": {
            "input": "18\n24",
            "output": "6"
        }
    },
    {
        "code_id": 1,
        "code": "import java.util.*;\nimport java.io.*;\nimport java.math.BigInteger;\n\nclass Node{\n\tint l,r,v;\n}\npublic class Main{\n\tstatic class FastScanner{\n\t\tBufferedReader br;\n\t\tStringTokenizer st;\n\t\tpublic FastScanner(InputStream in) {\n\t\t\tbr=new BufferedReader( new InputStreamReader(System.in));\n\t\t\teat(\"\");\n\t\t}\n\t\tpublic void eat(String s) {\n\t\t\tst=new StringTokenizer(s);\n\t\t}\n\t\n\t\tpublic String nextLine() {\n\t\t\ttry {\n\t\t\t\treturn br.readLine();\n\t\t\t}catch(IOException e) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t}\n\t\t\n\t\tpublic boolean hasNext() {\n\t\t\twhile(!st.hasMoreTokens()) {\n\t\t\t\tString s=nextLine();\n\t\t\t\tif(s==null)return false;\n\t\t\t\teat(s);\n\t\t\t}\n\t\t\t\n\t\t\treturn true;\n\t\t}\n\t\t\n\t\tpublic String next() {\n\t\t\thasNext();\n\t\t\treturn st.nextToken();\n\t\t}\n\t\t\n\t\tpublic int nextInt() {\n\t\t\treturn Integer.parseInt(next());\n\t\t}\n\t\t\n\t\tpublic long nextLong() {\n\t\t\treturn Long.parseLong(next());\n\t\t}\n\t\t\n\t\tpublic double nextDouble() {\n\t\t\treturn Double.parseDouble(next());\n\t\t}\n\t}\n\t\n\tstatic FastScanner cin=new FastScanner(System.in);\n\tstatic PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));\n\n\tstatic int m,p,N=200010;\n\tstatic Node tr[]=new Node[N*4];\n\tpublic static void main(String[] args) {\n\t\tint n=0,last=0;\n\t\t\n\t\tfor(int i=0;i<N*4;i++) tr[i]=new Node();\n\t\t\n\t\tint m=cin.nextInt(),p=cin.nextInt();\n\t\t\n\t\tbuild(1,1,m);\n\t\tint x=0;\n\t\t\n\t\twhile(m-->0) {\n\t\t\tString op=cin.next();\n\t\t\tx=cin.nextInt();\n\t\t\t\n\t\t\tif(op.equals(\"Q\")) {\n\t\t\t\tlast=query(1,n-x+1,n);\n\t\t\t\tout.println(last);\n\t\t\t\tout.flush();\n\t\t\t}else {\n\t\t\t\tmodify(1,n+1,(last+x)%p);\n\t\t\t\tn++;\n\t\t\t}\n\t\t\t\t\t\n\t\t}\n\t\tout.flush();\n\t}\n\tprivate static void modify(int u, int x, int v) {\n\t\t// TODO Auto-generated method stub\n\t\tif(tr[u].l==x&&tr[u].r==x)tr[u].v=v;\n\t\telse {\n\t\t\tint mid=tr[u].l+tr[u].r>>1;\n\t\t\tif(x<=mid)modify(u<<1,x,v);\n\t\t\telse modify(u<<1|1,x,v);\n\t\t\tpushup(u);\n\t\t}\n\t}\n\tprivate static void pushup(int u) {\n\t\t// TODO Auto-generated method stub\n\t\ttr[u].v=Math.max(tr[u<<1].v,tr[u<<1|1].v);\n\t}\n\tprivate static int query(int u, int l, int r) {\n\t\t// TODO Auto-generated method stub\n\t\tif(tr[u].l>=l&&tr[u].r<=r)return tr[u].v;\n\t\t\n\t\tint mid=(tr[u].l+tr[u].r)>>1;\n\t\tint v=0;\n\t\tif(l>mid)return query(u<<1|1,l,r);\n\t\telse if(r<=mid)return query(u<<1,l,r);\n\t\telse {\n\t\t\tint a=query(u<<1,l,r);\n\t\t\tint b=query(u<<1|1,l,r);\n\t\t\treturn Math.max(a, b);\n\t\t}\n\t}\n\tprivate static void build(int u, int l, int r) {\n\t\t// TODO Auto-generated method stub\n\t\ttr[u].l=l;tr[u].r=r;\n\t\tif(l==r)return;\n\t\tint mid=(l+r)>>1;\n\t\t\n\t\tbuild(u<<1,l,mid);\n\t\tbuild(u<<1|1,mid+1,r);\n\t}\n\n}\n\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大数",
        "query": "# 最大数\n## 题目描述\n\n给定一个正整数数列 $a_1, a_2, a_3, \\cdots , a_n$，每一个数都在 $0\\sim p – 1$ 之间。可以对这列数进行两种操作：\n+ 添加操作：向序列后添加一个数，序列长度变成 $n + 1$；\n+ 询问操作：询问这个序列中最后 $L$ 个数中最大的数是多少。\n\n程序运行的最开始，整数序列为空。写一个程序，读入操作的序列，并输出询问操作的答案。\n## 输入格式\n第一行有两个正整数 $m,p$，意义如题目描述；\n\n接下来 $m$ 行，每一行表示一个操作。如果该行的内容是 `Q L`，则表示这个操作是询问序列中最后 $L$ 个数的最大数是多少；如果是 `A t`，则表示向序列后面加一个数，加入的数是 $(t+a)\\bmod p$。其中，$t$ 是输入的参数，$a$ 是在这个添加操作之前最后一个询问操作的答案（如果之前没有询问操作，则 $a = 0$）。\n\n第一个操作一定是添加操作。对于询问操作，$L\\gt 0$ 且不超过当前序列的长度。\n## 输出格式\n对于每一个询问操作，输出一行。该行只有一个数，即序列中最后 $L$ 个数的最大数。\n## 样例\n输入:\n10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99\n输出:\n97\n97\n97\n60\n60\n97\n\n最后的序列是 $97,14,60,96$。\n## 数据范围与提示\n对于全部数据，$1\\le m\\le 2\\times 10^5,1\\le p\\le 2\\times 10^9,0\\le t\\lt p$。\n",
        "sample": {
            "input": "10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99",
            "output": "97\n97\n97\n60\n60\n97"
        }
    },
    {
        "code_id": 3,
        "code": "import java.util.*;\nimport java.io.*;\nimport java.math.BigInteger;\n\nclass Node{\n\tint l,r,v;\n}\npublic class Main{\n\tstatic class FastScanner{\n\t\tBufferedReader br;\n\t\tStringTokenizer st;\n\t\tpublic FastScanner(InputStream in) {\n\t\t\tbr=new BufferedReader( new InputStreamReader(System.in));\n\t\t\teat(\"\");\n\t\t}\n\t\tpublic void eat(String s) {\n\t\t\tst=new StringTokenizer(s);\n\t\t}\n\t\n\t\tpublic String nextLine() {\n\t\t\ttry {\n\t\t\t\treturn br.readLine();\n\t\t\t}catch(IOException e) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t}\n\t\t\n\t\tpublic boolean hasNext() {\n\t\t\twhile(!st.hasMoreTokens()) {\n\t\t\t\tString s=nextLine();\n\t\t\t\tif(s==null)return false;\n\t\t\t\teat(s);\n\t\t\t}\n\t\t\t\n\t\t\treturn true;\n\t\t}\n\t\t\n\t\tpublic String next() {\n\t\t\thasNext();\n\t\t\treturn st.nextToken();\n\t\t}\n\t\t\n\t\tpublic int nextInt() {\n\t\t\treturn Integer.parseInt(next());\n\t\t}\n\t\t\n\t\tpublic long nextLong() {\n\t\t\treturn Long.parseLong(next());\n\t\t}\n\t\t\n\t\tpublic double nextDouble() {\n\t\t\treturn Double.parseDouble(next());\n\t\t}\n\t}\n\t\n\tstatic FastScanner cin=new FastScanner(System.in);\n\tstatic PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));\n\n\tstatic int m,p,N=200010;\n\tstatic Node tr[]=new Node[N*4];\n\tpublic static void main(String[] args) {\n\t\tint n=0,last=0;\n\t\t\n\t\tfor(int i=0;i<N*4;i++) tr[i]=new Node();\n\t\t\n\t\tint m=cin.nextInt(),p=cin.nextInt();\n\t\t\n\t\tbuild(1,1,m);\n\t\tint x=0;\n\t\t\n\t\twhile(m-->0) {\n\t\t\tString op=cin.next();\n\t\t\tx=cin.nextInt();\n//\t\t\tSystem.out.println(x);\n\t\t\tif(op.equals(\"Q\")) {\n\t\t\t\tlast=query(1,n-x+1,n);\n\t\t\t\tout.println(last);\n\t\t\t\tout.flush();\n\t\t\t}else {\n\t\t\t\tint ff=(int) ((long)((long)last+(long)x)%p);\n\t\t\t\tmodify(1,n+1,ff);\n\t\t\t\tn++;\n\t\t\t}\n\t\t\t\t\t\n\t\t}\n\t\tout.flush();\n\t}\n\tprivate static void modify(int u, int x, int v) {\n\t\t// TODO Auto-generated method stub\n\t\tif(tr[u].l==x&&tr[u].r==x)tr[u].v=v;\n\t\telse {\n\t\t\tint mid=tr[u].l+tr[u].r>>1;\n\t\t\tif(x<=mid)modify(u<<1,x,v);\n\t\t\telse modify(u<<1|1,x,v);\n\t\t\tpushup(u);\n\t\t}\n\t}\n\tprivate static void pushup(int u) {\n\t\t// TODO Auto-generated method stub\n\t\ttr[u].v=Math.max(tr[u<<1].v,tr[u<<1|1].v);\n\t}\n\tprivate static int query(int u, int l, int r) {\n\t\t// TODO Auto-generated method stub\n\t\tif(tr[u].l>=l&&tr[u].r<=r)return tr[u].v;\n\t\t\n\t\tint mid=(tr[u].l+tr[u].r)>>1;\n\t\tint v=0;\n\t\tif(l>mid)return query(u<<1|1,l,r);\n\t\telse if(r<=mid)return query(u<<1,l,r);\n\t\telse {\n\t\t\tint a=query(u<<1,l,r);\n\t\t\tint b=query(u<<1|1,l,r);\n\t\t\treturn Math.max(a, b);\n\t\t}\n\t}\n\tprivate static void build(int u, int l, int r) {\n\t\t// TODO Auto-generated method stub\n\t\ttr[u].l=l;tr[u].r=r;\n\t\tif(l==r)return;\n\t\tint mid=(l+r)>>1;\n\t\t\n\t\tbuild(u<<1,l,mid);\n\t\tbuild(u<<1|1,mid+1,r);\n\t}\n\n}\n\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大数",
        "query": "# 最大数\n## 题目描述\n\n给定一个正整数数列 $a_1, a_2, a_3, \\cdots , a_n$，每一个数都在 $0\\sim p – 1$ 之间。可以对这列数进行两种操作：\n+ 添加操作：向序列后添加一个数，序列长度变成 $n + 1$；\n+ 询问操作：询问这个序列中最后 $L$ 个数中最大的数是多少。\n\n程序运行的最开始，整数序列为空。写一个程序，读入操作的序列，并输出询问操作的答案。\n## 输入格式\n第一行有两个正整数 $m,p$，意义如题目描述；\n\n接下来 $m$ 行，每一行表示一个操作。如果该行的内容是 `Q L`，则表示这个操作是询问序列中最后 $L$ 个数的最大数是多少；如果是 `A t`，则表示向序列后面加一个数，加入的数是 $(t+a)\\bmod p$。其中，$t$ 是输入的参数，$a$ 是在这个添加操作之前最后一个询问操作的答案（如果之前没有询问操作，则 $a = 0$）。\n\n第一个操作一定是添加操作。对于询问操作，$L\\gt 0$ 且不超过当前序列的长度。\n## 输出格式\n对于每一个询问操作，输出一行。该行只有一个数，即序列中最后 $L$ 个数的最大数。\n## 样例\n输入:\n10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99\n输出:\n97\n97\n97\n60\n60\n97\n\n最后的序列是 $97,14,60,96$。\n## 数据范围与提示\n对于全部数据，$1\\le m\\le 2\\times 10^5,1\\le p\\le 2\\times 10^9,0\\le t\\lt p$。\n",
        "sample": {
            "input": "10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99",
            "output": "97\n97\n97\n60\n60\n97"
        }
    },
    {
        "code_id": 5,
        "code": "\n\nimport java.util.*;\nimport java.io.*;\n\npublic class Main {\n\t\n\tpublic static class Node{\n\t\tint l;\n\t\tint r;\n\t\tint w;\n\t\tpublic Node(int l, int r) {\n\t\t\tthis.l = l;\n\t\t\tthis.r = r;\n\t\t}\n\t}\n\t\n\tstatic Node[] tree;\n\t\n\tpublic static void main(String[] args) throws IOException {\n\t\tBufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n\t\tStringTokenizer st = new StringTokenizer(in.readLine());\n\t\tint m = Integer.parseInt(st.nextToken());\n\t\tint p = Integer.parseInt(st.nextToken());\n\t\ttree = new Node[4 * m + 1];\n\t\tbuild(1, m, 1);\n\t\t\n\t\tint cnt = 0;\n\t\tint ans = 0;\n\t\tfor(int i=0; i<m; i++) {\n\t\t\tst = new StringTokenizer(in.readLine());\n\t\t\tString option = st.nextToken();\n\t\t\tint n = Integer.parseInt(st.nextToken());\n\t\t\tif(option.equals(\"A\")) {\n\t\t\t\tcnt++;\n\t\t\t\tchangePoint(1, cnt, (n+ans) % p);\n\t\t\t}else {\n\t\t\t\tans = queryInterval(1, cnt - n + 1, cnt);\n\t\t\t\tSystem.out.println(ans);\n\t\t\t}\t\t\n\t\t}\n\t}\n\t\n\tstatic void build(int l, int r, int k) {\n\t\ttree[k] = new Node(l, r);\n\t\tif(tree[k].l == tree[k].r) {\n\t\t\ttree[k].w = 0;\n\t\t\treturn;\n\t\t}\n\t\tint mid = (l + r) >> 1;\n\t\tbuild(l, mid, k<<1);\n\t\tbuild(mid+1, r, k<<1|1);\n\t}\n\t\n\tstatic void changePoint(int k, int x, int c) { // k: current node id\n\t\tif(tree[k].l == tree[k].r) {\n\t\t\ttree[k].w += c;\n\t\t\treturn;\n\t\t}\n\t\tint mid = (tree[k].l + tree[k].r) >> 1;\n\t\tif(x <= mid) {\n\t\t\tchangePoint(k<<1, x, c);\n\t\t}else {\n\t\t\tchangePoint(k<<1|1, x, c);\n\t\t}\n\t\ttree[k].w = Math.max(tree[k<<1].w, tree[k<<1|1].w);\n\t}\n\n\tstatic int queryInterval(int k, int L, int R) {\n\t\tif(tree[k].l>=L&&tree[k].r<=R) {\n\t\t\treturn tree[k].w;\n\t\t}\n\t\tint mid=(tree[k].l+tree[k].r)>>1;\n\t\tif(R<=mid) {\n\t\t\treturn queryInterval(k<<1, L, R);\n\t\t}\n\t\tif(L>mid) {\n\t\t\treturn queryInterval(k<<1|1, L, R);\n\t\t}\n\t\treturn Math.max(queryInterval(k<<1, L, mid), queryInterval(k<<1|1, mid+1, R));\n\t}\n\t\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大数",
        "query": "# 最大数\n## 题目描述\n\n给定一个正整数数列 $a_1, a_2, a_3, \\cdots , a_n$，每一个数都在 $0\\sim p – 1$ 之间。可以对这列数进行两种操作：\n+ 添加操作：向序列后添加一个数，序列长度变成 $n + 1$；\n+ 询问操作：询问这个序列中最后 $L$ 个数中最大的数是多少。\n\n程序运行的最开始，整数序列为空。写一个程序，读入操作的序列，并输出询问操作的答案。\n## 输入格式\n第一行有两个正整数 $m,p$，意义如题目描述；\n\n接下来 $m$ 行，每一行表示一个操作。如果该行的内容是 `Q L`，则表示这个操作是询问序列中最后 $L$ 个数的最大数是多少；如果是 `A t`，则表示向序列后面加一个数，加入的数是 $(t+a)\\bmod p$。其中，$t$ 是输入的参数，$a$ 是在这个添加操作之前最后一个询问操作的答案（如果之前没有询问操作，则 $a = 0$）。\n\n第一个操作一定是添加操作。对于询问操作，$L\\gt 0$ 且不超过当前序列的长度。\n## 输出格式\n对于每一个询问操作，输出一行。该行只有一个数，即序列中最后 $L$ 个数的最大数。\n## 样例\n输入:\n10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99\n输出:\n97\n97\n97\n60\n60\n97\n\n最后的序列是 $97,14,60,96$。\n## 数据范围与提示\n对于全部数据，$1\\le m\\le 2\\times 10^5,1\\le p\\le 2\\times 10^9,0\\le t\\lt p$。\n",
        "sample": {
            "input": "10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99",
            "output": "97\n97\n97\n60\n60\n97"
        }
    },
    {
        "code_id": 6,
        "code": "\nimport java.io.BufferedReader;\nimport java.io.IOException;\nimport java.io.InputStreamReader;\nimport java.util.StringTokenizer;\n\npublic class Main {\n\t\n\tstatic Node[] tree;\n\t\n   static class Node {\n        int l, r;\n        long w;\n\n        public Node(int l, int r, long w) {\n            this.l = l;\n            this.r = r;\n            this.w = w;\n\n        }\n    }\n   \n   static void changePoint(int k, int x, long l) {\n       if (tree[k].l == tree[k].r) {\n           tree[k].w += l;\n           return;\n       }\n       int mid = tree[k].l + tree[k].r >> 1;\n       int lc = k<<1, rc = lc + 1;\n       if (x <= mid)\n           changePoint(lc, x, l);\n       else\n           changePoint(rc, x, l);\n       tree[k].w = Math.max(tree[lc].w, tree[rc].w);\n   }\n\n\t\n  static long sum(int k, int a, int b) {\n        if (a <= tree[k].l && tree[k].r <= b) {\n            return tree[k].w;\n        }\n        int mid = (tree[k].l+tree[k].r) >> 1;\n        long ans = 0;\n        if (a <= mid) {\n        \tans = Math.max(ans, sum(k<<1, a, b));\n        }\n        if (b > mid) {\n            ans = Math.max(ans,sum(k<<1 | 1, a, b));\n        }\n        return ans;\n    }\n  \n  static void build(int l, int r, int k) {\n        tree[k].l = l;\n        tree[k].r = r;\n        if (l == r) {\n            tree[k].w = 0;\n            return;\n        }\n        int mid = (l+r) >> 1;\n        build(l, mid, k<<1);\n        build(mid+1, r, k<<1 | 1);\n        tree[k].w = tree[k<<1].w+tree[k<<1 | 1].w;\n    }\n  \n\tpublic static void main(String[] args) throws IOException {\n\t\t// TODO Auto-generated method stub\n\t\t BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n        StringTokenizer st = new StringTokenizer(in.readLine());\n        int n = Integer.parseInt(st.nextToken());\n        int q = Integer.parseInt(st.nextToken());\n        int cntAdd=0;\n        long last=0;\n        tree = new Node[4*n+1];\n        for (int i = 0; i < 4*n+1; i++) {\n            tree[i] = new Node(0, 0, 0);\n        }\n        build(1, n, 1);\n\n        for (int i = 0; i < n; i++) {\n            st = new StringTokenizer(in.readLine());\n            String tmp = st.nextToken();\n            if(tmp.equals(\"A\")) {\n            \tint a = Integer.parseInt(st.nextToken());\n            \tcntAdd++;\n            \tchangePoint(1, cntAdd, (a+last)%q);\n            \t\n            }\n            else {\n            \tint a = Integer.parseInt(st.nextToken());\n            \tSystem.out.println(sum(1, cntAdd-a+1, cntAdd));\n            \tlast= sum(1, cntAdd-a+1, cntAdd);\n            }\n        }\n\t}\n\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大数",
        "query": "# 最大数\n## 题目描述\n\n给定一个正整数数列 $a_1, a_2, a_3, \\cdots , a_n$，每一个数都在 $0\\sim p – 1$ 之间。可以对这列数进行两种操作：\n+ 添加操作：向序列后添加一个数，序列长度变成 $n + 1$；\n+ 询问操作：询问这个序列中最后 $L$ 个数中最大的数是多少。\n\n程序运行的最开始，整数序列为空。写一个程序，读入操作的序列，并输出询问操作的答案。\n## 输入格式\n第一行有两个正整数 $m,p$，意义如题目描述；\n\n接下来 $m$ 行，每一行表示一个操作。如果该行的内容是 `Q L`，则表示这个操作是询问序列中最后 $L$ 个数的最大数是多少；如果是 `A t`，则表示向序列后面加一个数，加入的数是 $(t+a)\\bmod p$。其中，$t$ 是输入的参数，$a$ 是在这个添加操作之前最后一个询问操作的答案（如果之前没有询问操作，则 $a = 0$）。\n\n第一个操作一定是添加操作。对于询问操作，$L\\gt 0$ 且不超过当前序列的长度。\n## 输出格式\n对于每一个询问操作，输出一行。该行只有一个数，即序列中最后 $L$ 个数的最大数。\n## 样例\n输入:\n10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99\n输出:\n97\n97\n97\n60\n60\n97\n\n最后的序列是 $97,14,60,96$。\n## 数据范围与提示\n对于全部数据，$1\\le m\\le 2\\times 10^5,1\\le p\\le 2\\times 10^9,0\\le t\\lt p$。\n",
        "sample": {
            "input": "10 100\nA 97\nQ 1\nQ 1\nA 17\nQ 2\nA 63\nQ 1\nQ 1\nQ 3\nA 99",
            "output": "97\n97\n97\n60\n60\n97"
        }
    },
    {
        "code_id": 0,
        "code": "\nimport java.util.*;\n\npublic class Main {\n    /**\n     * 给你一个数组，求长度不超过 m 的所有子数组中的最大和\n     * 先求前缀和，对于 i ,问题转化为求一个下标 j ,   0 <= i - j < m\n     * 使得 s[i + 1] - s[j] 的值最大,对于一个固定的 i ,其 s[i + 1] 的值是固定的，\n     * 所以要使 s[j] 尽可能小，使用 单调队列 维护前缀和的值，队头的 s[j] 的值最小\n     */\n    public static void main(String[] args) {\n        Scanner sc = new Scanner(System.in);\n        int n = sc.nextInt(), m = sc.nextInt();\n        int[] a = new int[n];\n        for (int i = 0; i < n; i++) {\n            a[i] = sc.nextInt();\n        }\n        int[] ps = new int[n + 1];\n        for (int i = 1; i <= n; i++) {\n            ps[i] = ps[i - 1] + a[i - 1];\n        }\n        int[] q = new int[n];\n        int h = 0, t = -1;\n        q[++t] = -1;\n        int ans = -10000;\n        for (int i = 0; i < n; i++) {\n            while (h <= t && i - q[h] > m) h++;\n            ans = Math.max(ans, ps[i + 1] - ps[q[h] + 1]);\n            while (h <= t && ps[i + 1] <= ps[q[t] + 1]) t--;\n            q[++t] = i;\n        }\n        System.out.println(ans);\n\n    }\n\n\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最大连续和",
        "query": "# 最大连续和\n## 题目描述\n给你一个长度为 $n$ 的整数序列 $\\{A_1,A_2,\\cdots ,A_n\\}$，要求从中找出一段连续的长度不超过 $m$ 的非空子序列，使得这个序列的和最大。\n## 输入格式\n第一行为两个整数 $n,m$；\n\n第二行为 $n$ 个用空格分开的整数序列，每个数的绝对值都小于 $1000$。\n## 输出格式\n仅一个整数，表示连续长度不超过 $m$ 的最大非空子序列和。\n## 样例\n输入:\n6 4\n1 -3 5 1 -2 3\n输出:\n7\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1\\le n,m\\le 2\\times 10^5$。\n",
        "sample": {
            "input": "6 4\n1 -3 5 1 -2 3",
            "output": "7"
        }
    },
    {
        "code_id": 1,
        "code": "\r\n\r\nimport java.io.FileInputStream;\r\nimport java.io.IOException;\r\nimport java.io.InputStream;\r\nimport java.io.OutputStream;\r\nimport java.nio.charset.Charset;\r\nimport java.util.*;\r\n\r\npublic class Main {\r\n    public static void main(String[] args) throws Exception {\r\n        boolean local = false;\r\n        boolean async = false;\r\n\r\n        Charset charset = Charset.forName(\"ascii\");\r\n\r\n        FastIO io = local ? new FastIO(new FileInputStream(\"D:\\\\DATABASE\\\\TESTCASE\\\\Code.in\"), System.out, charset) : new FastIO(System.in, System.out, charset);\r\n        Task task = new Task(io, new Debug(local));\r\n\r\n        if (async) {\r\n            Thread t = new Thread(null, task, \"dalt\", 1 << 27);\r\n            t.setPriority(Thread.MAX_PRIORITY);\r\n            t.start();\r\n            t.join();\r\n        } else {\r\n            task.run();\r\n        }\r\n\r\n        if (local) {\r\n            io.cache.append(\"\\n\\n--memory -- \\n\" + ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) >> 20) + \"M\");\r\n        }\r\n\r\n        io.flush();\r\n    }\r\n\r\n    public static class Task implements Runnable {\r\n        final FastIO io;\r\n        final Debug debug;\r\n        int inf = (int) 1e8;\r\n\r\n        public Task(FastIO io, Debug debug) {\r\n            this.io = io;\r\n            this.debug = debug;\r\n        }\r\n\r\n        @Override\r\n        public void run() {\r\n            solve();\r\n        }\r\n\r\n        public void solve() {\r\n            int n = io.readInt();\r\n            int m = io.readInt();\r\n            int r = io.readInt() - 1;\r\n            DirectMinSpanningTree tree = new DirectMinSpanningTree(n);\r\n            for (int i = 0; i < m; i++) {\r\n                int u = io.readInt() - 1;\r\n                int v = io.readInt() - 1;\r\n                int w = io.readInt();\r\n                tree.addEdge(u, v, w);\r\n            }\r\n\r\n            tree.contract();\r\n            List<DirectMinSpanningTree.Edge> edges = tree.dismantle(r);\r\n            long sum = 0;\r\n            for (DirectMinSpanningTree.Edge edge : edges) {\r\n                if (edge.weight == Long.MAX_VALUE) {\r\n                    io.cache.append(-1);\r\n                    return;\r\n                }\r\n                sum += edge.weight;\r\n            }\r\n            io.cache.append(sum);\r\n        }\r\n    }\r\n\r\n    public static class FastIO {\r\n        public final StringBuilder cache = new StringBuilder();\r\n        private final InputStream is;\r\n        private final OutputStream os;\r\n        private final Charset charset;\r\n        private StringBuilder defaultStringBuf = new StringBuilder(1 << 8);\r\n        private byte[] buf = new byte[1 << 13];\r\n        private int bufLen;\r\n        private int bufOffset;\r\n        private int next;\r\n\r\n        public FastIO(InputStream is, OutputStream os, Charset charset) {\r\n            this.is = is;\r\n            this.os = os;\r\n            this.charset = charset;\r\n        }\r\n\r\n        public FastIO(InputStream is, OutputStream os) {\r\n            this(is, os, Charset.forName(\"ascii\"));\r\n        }\r\n\r\n        private int read() {\r\n            while (bufLen == bufOffset) {\r\n                bufOffset = 0;\r\n                try {\r\n                    bufLen = is.read(buf);\r\n                } catch (IOException e) {\r\n                    throw new RuntimeException(e);\r\n                }\r\n                if (bufLen == -1) {\r\n                    return -1;\r\n                }\r\n            }\r\n            return buf[bufOffset++];\r\n        }\r\n\r\n        public void skipBlank() {\r\n            while (next >= 0 && next <= 32) {\r\n                next = read();\r\n            }\r\n        }\r\n\r\n        public int readInt() {\r\n            int sign = 1;\r\n\r\n            skipBlank();\r\n            if (next == '+' || next == '-') {\r\n                sign = next == '+' ? 1 : -1;\r\n                next = read();\r\n            }\r\n\r\n            int val = 0;\r\n            if (sign == 1) {\r\n                while (next >= '0' && next <= '9') {\r\n                    val = val * 10 + next - '0';\r\n                    next = read();\r\n                }\r\n            } else {\r\n                while (next >= '0' && next <= '9') {\r\n                    val = val * 10 - next + '0';\r\n                    next = read();\r\n                }\r\n            }\r\n\r\n            return val;\r\n        }\r\n\r\n        public long readLong() {\r\n            int sign = 1;\r\n\r\n            skipBlank();\r\n            if (next == '+' || next == '-') {\r\n                sign = next == '+' ? 1 : -1;\r\n                next = read();\r\n            }\r\n\r\n            long val = 0;\r\n            if (sign == 1) {\r\n                while (next >= '0' && next <= '9') {\r\n                    val = val * 10 + next - '0';\r\n                    next = read();\r\n                }\r\n            } else {\r\n                while (next >= '0' && next <= '9') {\r\n                    val = val * 10 - next + '0';\r\n                    next = read();\r\n                }\r\n            }\r\n\r\n            return val;\r\n        }\r\n\r\n        public double readDouble() {\r\n            boolean sign = true;\r\n            skipBlank();\r\n            if (next == '+' || next == '-') {\r\n                sign = next == '+';\r\n                next = read();\r\n            }\r\n\r\n            long val = 0;\r\n            while (next >= '0' && next <= '9') {\r\n                val = val * 10 + next - '0';\r\n                next = read();\r\n            }\r\n            if (next != '.') {\r\n                return sign ? val : -val;\r\n            }\r\n            next = read();\r\n            long radix = 1;\r\n            long point = 0;\r\n            while (next >= '0' && next <= '9') {\r\n                point = point * 10 + next - '0';\r\n                radix = radix * 10;\r\n                next = read();\r\n            }\r\n            double result = val + (double) point / radix;\r\n            return sign ? result : -result;\r\n        }\r\n\r\n        public String readString(StringBuilder builder) {\r\n            skipBlank();\r\n\r\n            while (next > 32) {\r\n                builder.append((char) next);\r\n                next = read();\r\n            }\r\n\r\n            return builder.toString();\r\n        }\r\n\r\n        public String readString() {\r\n            defaultStringBuf.setLength(0);\r\n            return readString(defaultStringBuf);\r\n        }\r\n\r\n        public int readLine(char[] data, int offset) {\r\n            int originalOffset = offset;\r\n            while (next != -1 && next != '\\n') {\r\n                data[offset++] = (char) next;\r\n                next = read();\r\n            }\r\n            return offset - originalOffset;\r\n        }\r\n\r\n        public int readString(char[] data, int offset) {\r\n            skipBlank();\r\n\r\n            int originalOffset = offset;\r\n            while (next > 32) {\r\n                data[offset++] = (char) next;\r\n                next = read();\r\n            }\r\n\r\n            return offset - originalOffset;\r\n        }\r\n\r\n        public int readString(byte[] data, int offset) {\r\n            skipBlank();\r\n\r\n            int originalOffset = offset;\r\n            while (next > 32) {\r\n                data[offset++] = (byte) next;\r\n                next = read();\r\n            }\r\n\r\n            return offset - originalOffset;\r\n        }\r\n\r\n        public char readChar() {\r\n            skipBlank();\r\n            char c = (char) next;\r\n            next = read();\r\n            return c;\r\n        }\r\n\r\n        public void flush() throws IOException {\r\n            os.write(cache.toString().getBytes(charset));\r\n            os.flush();\r\n            cache.setLength(0);\r\n        }\r\n\r\n        public boolean hasMore() {\r\n            skipBlank();\r\n            return next != -1;\r\n        }\r\n    }\r\n\r\n    public static class Debug {\r\n        private boolean allowDebug;\r\n\r\n        public Debug(boolean allowDebug) {\r\n            this.allowDebug = allowDebug;\r\n        }\r\n\r\n        public void assertTrue(boolean flag) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            if (!flag) {\r\n                fail();\r\n            }\r\n        }\r\n\r\n        public void fail() {\r\n            throw new RuntimeException();\r\n        }\r\n\r\n        public void assertFalse(boolean flag) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            if (flag) {\r\n                fail();\r\n            }\r\n        }\r\n\r\n        private void outputName(String name) {\r\n            System.out.print(name + \" = \");\r\n        }\r\n\r\n        public void debug(String name, int x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n\r\n            outputName(name);\r\n            System.out.println(\"\" + x);\r\n        }\r\n\r\n        public void debug(String name, long x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(\"\" + x);\r\n        }\r\n\r\n        public void debug(String name, double x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(\"\" + x);\r\n        }\r\n\r\n        public void debug(String name, int[] x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(Arrays.toString(x));\r\n        }\r\n\r\n        public void debug(String name, long[] x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(Arrays.toString(x));\r\n        }\r\n\r\n        public void debug(String name, double[] x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(Arrays.toString(x));\r\n        }\r\n\r\n        public void debug(String name, Object x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(\"\" + x);\r\n        }\r\n\r\n        public void debug(String name, Object... x) {\r\n            if (!allowDebug) {\r\n                return;\r\n            }\r\n            outputName(name);\r\n            System.out.println(Arrays.deepToString(x));\r\n        }\r\n    }\r\n\r\n    public static class LeftSideTree<K> {\r\n        public static final LeftSideTree NIL = new LeftSideTree<>(null);\r\n\r\n        static {\r\n            NIL.left = NIL;\r\n            NIL.right = NIL;\r\n            NIL.dist = -1;\r\n        }\r\n\r\n        LeftSideTree<K> left = NIL;\r\n        LeftSideTree<K> right = NIL;\r\n        int dist;\r\n        K key;\r\n\r\n\r\n        public LeftSideTree(K key) {\r\n            this.key = key;\r\n        }\r\n\r\n        public static <K> LeftSideTree<K> createFromCollection(Collection<LeftSideTree<K>> trees, Comparator<K> cmp) {\r\n            return createFromDeque(new ArrayDeque<>(trees), cmp);\r\n        }\r\n\r\n        public static <K> LeftSideTree<K> createFromDeque(Deque<LeftSideTree<K>> deque, Comparator<K> cmp) {\r\n            while (deque.size() > 1) {\r\n                deque.addLast(merge(deque.removeFirst(), deque.removeFirst(), cmp));\r\n            }\r\n            return deque.removeLast();\r\n        }\r\n\r\n        public static <K> LeftSideTree<K> merge(LeftSideTree<K> a, LeftSideTree<K> b, Comparator<K> cmp) {\r\n            if (a == NIL) {\r\n                return b;\r\n            } else if (b == NIL) {\r\n                return a;\r\n            }\r\n            if (cmp.compare(a.key, b.key) > 0) {\r\n                LeftSideTree<K> tmp = a;\r\n                a = b;\r\n                b = tmp;\r\n            }\r\n            a.right = merge(a.right, b, cmp);\r\n            if (a.left.dist < a.right.dist) {\r\n                LeftSideTree<K> tmp = a.left;\r\n                a.left = a.right;\r\n                a.right = tmp;\r\n            }\r\n            a.dist = a.right.dist + 1;\r\n            return a;\r\n        }\r\n\r\n        public boolean isEmpty() {\r\n            return this == NIL;\r\n        }\r\n\r\n        public K peek() {\r\n            return key;\r\n        }\r\n\r\n        public static <K> LeftSideTree<K> pop(LeftSideTree<K> root, Comparator<K> cmp) {\r\n            return merge(root.left, root.right, cmp);\r\n        }\r\n\r\n        private void toStringDfs(StringBuilder builder) {\r\n            if (this == NIL) {\r\n                return;\r\n            }\r\n            builder.append(key).append(' ');\r\n            left.toStringDfs(builder);\r\n            right.toStringDfs(builder);\r\n        }\r\n\r\n        @Override\r\n        public String toString() {\r\n            StringBuilder builder = new StringBuilder();\r\n            toStringDfs(builder);\r\n            return builder.toString();\r\n        }\r\n    }\r\n\r\n    public static class DirectMinSpanningTree {\r\n        long inf = Long.MAX_VALUE;\r\n        int now;\r\n        Node top;\r\n\r\n        public static class Edge {\r\n            Node src;\r\n            Node dst;\r\n            long weight;\r\n\r\n            public static final Comparator<Edge> SORT_BY_WEIGHT =\r\n                    new Comparator<Edge>() {\r\n                        @Override\r\n                        public int compare(Edge o1, Edge o2) {\r\n                            return Long.compare(o1.weight, o2.weight);\r\n                        }\r\n                    };\r\n\r\n            @Override\r\n            public String toString() {\r\n                return \"(\" + src + \",\" + dst + \")\";\r\n            }\r\n        }\r\n\r\n        public static class Node {\r\n            int id = -1;\r\n            List<Edge> outEdges = new ArrayList<>(2);\r\n            List<Edge> inEdges = new ArrayList<>(2);\r\n            LeftSideTree<Edge> queue = LeftSideTree.NIL;\r\n            Node parent;\r\n            Edge out;\r\n            Node outNode;\r\n            int visited;\r\n\r\n\r\n\r\n            Node circleP = this;\r\n            int circleRank;\r\n\r\n            Node proxy = this;\r\n\r\n            Node findCircle() {\r\n                return circleP.circleP == circleP ? circleP : (circleP = circleP.findCircle());\r\n            }\r\n\r\n            static void mergeCircle(Node a, Node b) {\r\n                a = a.findCircle();\r\n                b = b.findCircle();\r\n                if (a == b) {\r\n                    return;\r\n                }\r\n                if (a.circleRank == b.circleRank) {\r\n                    a.circleRank++;\r\n                }\r\n                if (a.circleRank > b.circleRank) {\r\n                    b.circleP = a;\r\n                    a.queue = LeftSideTree.merge(a.queue, b.queue, Edge.SORT_BY_WEIGHT);\r\n                } else {\r\n                    a.circleP = b;\r\n                    b.queue = LeftSideTree.merge(a.queue, b.queue, Edge.SORT_BY_WEIGHT);\r\n                }\r\n            }\r\n\r\n            @Override\r\n            public String toString() {\r\n                return \"\" + id;\r\n            }\r\n        }\r\n\r\n        public List<Edge> dismantle(int rootId) {\r\n            if (nodes.length == 1) {\r\n                return Collections.emptyList();\r\n            }\r\n\r\n            now++;\r\n            Node root = nodes[rootId];\r\n            List<Edge> result = new ArrayList<>();\r\n            dfs(root, result);\r\n            return result;\r\n        }\r\n\r\n        private void dfs(Node root, List<Edge> result) {\r\n            if (root == top || root.visited == now) {\r\n                return;\r\n            }\r\n            root.visited = now;\r\n            Node trace = root;\r\n            while (true) {\r\n                Node bottom = trace.out.dst;\r\n                Node next = trace.outNode;\r\n                if (next == root) {\r\n                    break;\r\n                }\r\n                result.add(trace.out);\r\n                next.visited = now;\r\n                dfs(bottom, result);\r\n                trace = next;\r\n            }\r\n\r\n            dfs(root.parent, result);\r\n        }\r\n\r\n        public void contract() {\r\n            now++;\r\n            Deque<LeftSideTree<Edge>> deque = new ArrayDeque<>();\r\n            for (Node node : nodes) {\r\n                for (Edge edge : node.inEdges) {\r\n                    deque.addLast(new LeftSideTree<Edge>(edge));\r\n                }\r\n                node.queue = LeftSideTree.createFromDeque(deque, Edge.SORT_BY_WEIGHT);\r\n            }\r\n\r\n            int remain = nodes.length;\r\n            Deque<Node> stack = new ArrayDeque<>();\r\n            stack.addLast(nodes[0]);\r\n            stack.peekFirst().visited = now;\r\n            while (remain > 1) {\r\n                Node tail = stack.peekLast().findCircle();\r\n                Edge out = null;\r\n                while (out == null) {\r\n                    Edge min = tail.queue.peek();\r\n                    tail.queue = LeftSideTree.pop(tail.queue, Edge.SORT_BY_WEIGHT);\r\n                    //self loop\r\n                    if (min.src.findCircle() == min.dst.findCircle()) {\r\n                        continue;\r\n                    }\r\n                    out = min;\r\n                }\r\n\r\n                Node src = out.src.findCircle().proxy;\r\n                //No loop\r\n                if (src.visited != now) {\r\n                    src.visited = now;\r\n                    src.out = out;\r\n                    stack.addLast(src);\r\n                    continue;\r\n                }\r\n                //Find loop, merge them together\r\n                Node proxy = new Node();\r\n                proxy.visited = now;\r\n                proxy.out = src.out;\r\n                src.out = out;\r\n                Node last = src;\r\n                while (true) {\r\n                    Node trace = stack.removeLast().findCircle().proxy;\r\n                    merge(proxy, trace);\r\n                    trace.parent = proxy;\r\n                    last.outNode = trace;\r\n                    remain--;\r\n                    last = trace;\r\n                    if (trace == src) {\r\n                        break;\r\n                    }\r\n                }\r\n                proxy.findCircle().proxy = proxy;\r\n                stack.addLast(proxy);\r\n                remain++;\r\n            }\r\n            top = stack.removeLast();\r\n        }\r\n\r\n        public void merge(Node a, Node b) {\r\n            Node.mergeCircle(a, b);\r\n        }\r\n\r\n        private Node[] nodes;\r\n\r\n        public void addEdge(int s, int t, long weight) {\r\n            Edge edge = new Edge();\r\n            edge.src = nodes[s];\r\n            edge.dst = nodes[t];\r\n            edge.weight = weight;\r\n            edge.src.outEdges.add(edge);\r\n            edge.dst.inEdges.add(edge);\r\n        }\r\n\r\n        public DirectMinSpanningTree(int n) {\r\n            nodes = new Node[n];\r\n            for (int i = 0; i < n; i++) {\r\n                nodes[i] = new Node();\r\n                nodes[i].id = i;\r\n            }\r\n            for (int i = 0; i < n; i++) {\r\n                addEdge(i, (i + 1) % n, inf);\r\n            }\r\n        }\r\n    }\r\n}\r\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最小树形图",
        "query": "# 最小树形图\n## 题目描述\n\r\n\r\n给定包含 $n$ 个结点， $m$ 条有向边的一个图。试求一棵以结点 $r$ 为根的最小树形图，并输出最小树形图每条边的权值之和，如果没有以 $r$ 为根的最小树形图，输出 $-1$。\n## 输入格式\n第一行包含三个整数 $n,m,r$，意义同题目所述。\r\n\r\n接下来 $m$ 行，每行包含三个整数 $u,v,w$，表示图中存在一条从 $u$ 指向 $v$ 的权值为 $w$ 的有向边。\n## 输出格式\n如果原图中存在以 $r$ 为根的最小树形图，就输出最小树形图每条边的权值之和，否则输出 $-1$。\n## 样例\n输入:\n4 6 1\n1 2 3\n1 3 1\n4 1 2\n4 2 2\n3 2 1\n3 4 1\n\n输出:\n3\n\n输入:\n4 6 3\n1 2 3\n1 3 1\n4 1 2\n4 2 2\n3 2 1\n3 4 1\n\n输出:\n4\n\n输入:\n4 6 2\n1 2 3\n1 3 1\n4 1 2\n4 2 2\n3 2 1\n3 4 1\n\n输出:\n-1\n\n#### 样例输入1\r\n```plain\r\n4 6 1\r\n1 2 3\r\n1 3 1\r\n4 1 2\r\n4 2 2\r\n3 2 1\r\n3 4 1\r\n```\r\n\r\n#### 样例输出 1\r\n```plain \r\n3\r\n```\r\n\r\n#### 样例解释 1\r\n最小树形图中包含第 $2$， $5$， $6$  三条边，总权值为 $1 + 1 + 1 = 3$\r\n\r\n#### 样例输入 2\r\n```plain\r\n4 6 3\r\n1 2 3\r\n1 3 1\r\n4 1 2\r\n4 2 2\r\n3 2 1\r\n3 4 1\r\n```\r\n\r\n#### 样例输出 2\r\n```plain\r\n4\r\n```\r\n\r\n#### 样例输出 2\r\n最小树形图中包含第 $3$， $5$， $6$  三条边，总权值为 $2 + 1 + 1 = 4$\r\n\r\n#### 样例输入 3\r\n```plain\r\n4 6 2\r\n1 2 3\r\n1 3 1\r\n4 1 2\r\n4 2 2\r\n3 2 1\r\n3 4 1\r\n```\r\n\r\n#### 样例输出 3\r\n```plain\r\n-1\r\n```\r\n\r\n#### 样例解释 3\r\n无法构成最小树形图，故输出 $-1$ 。\n## 数据范围与提示\n对于所有数据，$1 \\leq u, v \\leq n \\leq 100,$ $1 \\leq m \\leq 10^4,$ $1 \\leq w \\leq 10^6$。",
        "sample": {
            "input": "4 6 1\n1 2 3\n1 3 1\n4 1 2\n4 2 2\n3 2 1\n3 4 1",
            "output": "3"
        }
    },
    {
        "code_id": 7,
        "code": "import java.io.OutputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.util.Arrays;\nimport java.util.PriorityQueue;\nimport java.util.AbstractQueue;\nimport java.util.ArrayList;\nimport java.util.AbstractCollection;\nimport java.io.OutputStreamWriter;\nimport java.io.OutputStream;\nimport java.io.IOException;\nimport java.io.UncheckedIOException;\nimport java.util.List;\nimport java.io.Closeable;\nimport java.io.Writer;\nimport java.io.InputStream;\n\n/**\n * Built using CHelper plug-in\n * Actual solution is at the top\n */\npublic class Main {\n    public static void main(String[] args) throws Exception {\n        new TaskAdapter().run();\n    }\n\n    static class TaskAdapter implements Runnable {\n        @Override\n        public void run() {\n            InputStream inputStream = System.in;\n            OutputStream outputStream = System.out;\n            FastInput in = new FastInput(inputStream);\n            FastOutput out = new FastOutput(outputStream);\n            Task solver = new Task();\n            solver.solve(1, in, out);\n            out.close();\n        }\n    }\n\n    static class Task {\n        public void solve(int testNumber, FastInput in, FastOutput out) {\n            int n = in.readInt();\n            int m = in.readInt();\n            int s = 1;\n            int t = n;\n\n            List<MinCostFlowPolynomial.Edge>[] mcmf = MinCostFlowPolynomial.createGraph(n + 1);\n            for (int i = 0; i < m; i++) {\n                int u = in.readInt();\n                int v = in.readInt();\n                int c = in.readInt();\n                int w = in.readInt();\n                MinCostFlowPolynomial.addEdge(mcmf, u, v, c, w);\n            }\n            long[] ans = MinCostFlowPolynomial.minCostFlow(mcmf, s, t, Integer.MAX_VALUE / 2);\n            out.append(ans[0]).append(' ').append(ans[1]).println();\n        }\n\n    }\n\n    static class FastInput {\n        private final InputStream is;\n        private byte[] buf = new byte[1 << 20];\n        private int bufLen;\n        private int bufOffset;\n        private int next;\n\n        public FastInput(InputStream is) {\n            this.is = is;\n        }\n\n        private int read() {\n            while (bufLen == bufOffset) {\n                bufOffset = 0;\n                try {\n                    bufLen = is.read(buf);\n                } catch (IOException e) {\n                    bufLen = -1;\n                }\n                if (bufLen == -1) {\n                    return -1;\n                }\n            }\n            return buf[bufOffset++];\n        }\n\n        public void skipBlank() {\n            while (next >= 0 && next <= 32) {\n                next = read();\n            }\n        }\n\n        public int readInt() {\n            int sign = 1;\n\n            skipBlank();\n            if (next == '+' || next == '-') {\n                sign = next == '+' ? 1 : -1;\n                next = read();\n            }\n\n            int val = 0;\n            if (sign == 1) {\n                while (next >= '0' && next <= '9') {\n                    val = val * 10 + next - '0';\n                    next = read();\n                }\n            } else {\n                while (next >= '0' && next <= '9') {\n                    val = val * 10 - next + '0';\n                    next = read();\n                }\n            }\n\n            return val;\n        }\n\n    }\n\n    static class MinCostFlowPolynomial {\n        public static List<MinCostFlowPolynomial.Edge>[] createGraph(int n) {\n            List<MinCostFlowPolynomial.Edge>[] graph = new List[n];\n            for (int i = 0; i < n; i++)\n                graph[i] = new ArrayList<>();\n            return graph;\n        }\n\n        public static void addEdge(List<MinCostFlowPolynomial.Edge>[] graph, int s, int t, long cap, long cost) {\n            graph[s].add(new MinCostFlowPolynomial.Edge(t, cap, cost, graph[t].size()));\n            graph[t].add(new MinCostFlowPolynomial.Edge(s, 0, -cost, graph[s].size() - 1));\n        }\n\n        static void bellmanFord(List<MinCostFlowPolynomial.Edge>[] graph, int s, long[] dist) {\n            int n = graph.length;\n            Arrays.fill(dist, Integer.MAX_VALUE);\n            dist[s] = 0;\n            boolean[] inqueue = new boolean[n];\n            int[] q = new int[n];\n            int qt = 0;\n            q[qt++] = s;\n            for (int qh = 0; (qh - qt) % n != 0; qh++) {\n                int u = q[qh % n];\n                inqueue[u] = false;\n                for (int i = 0; i < graph[u].size(); i++) {\n                    MinCostFlowPolynomial.Edge e = graph[u].get(i);\n                    if (e.cap <= e.f)\n                        continue;\n                    int v = e.to;\n                    long ndist = dist[u] + e.cost;\n                    if (dist[v] > ndist) {\n                        dist[v] = ndist;\n                        if (!inqueue[v]) {\n                            inqueue[v] = true;\n                            q[qt++ % n] = v;\n                        }\n                    }\n                }\n            }\n        }\n\n        public static long[] minCostFlow(List<MinCostFlowPolynomial.Edge>[] graph, int s, int t, long maxf) {\n            int n = graph.length;\n            long[] prio = new long[n];\n            long[] curflow = new long[n];\n            int[] prevedge = new int[n];\n            int[] prevnode = new int[n];\n            long[] pot = new long[n];\n\n            // bellmanFord invocation can be skipped if edges costs are non-negative\n            bellmanFord(graph, s, pot);\n            long flow = 0;\n            long flowCost = 0;\n\n            PriorityQueue<MinCostFlowPolynomial.State> q = new PriorityQueue<>();\n            while (flow < maxf) {\n                q.clear();\n                q.add(new MinCostFlowPolynomial.State(0, s));\n                Arrays.fill(prio, Integer.MAX_VALUE);\n                prio[s] = 0;\n                boolean[] finished = new boolean[n];\n                curflow[s] = Integer.MAX_VALUE;\n                while (!finished[t] && !q.isEmpty()) {\n                    MinCostFlowPolynomial.State cur = q.remove();\n                    int u = cur.u;\n                    long priou = cur.priou;\n                    if (priou != prio[u])\n                        continue;\n                    finished[u] = true;\n                    for (int i = 0; i < graph[u].size(); i++) {\n                        MinCostFlowPolynomial.Edge e = graph[u].get(i);\n                        if (e.f >= e.cap)\n                            continue;\n                        int v = e.to;\n                        long nprio = prio[u] + e.cost + pot[u] - pot[v];\n                        if (prio[v] > nprio) {\n                            prio[v] = nprio;\n                            q.add(new MinCostFlowPolynomial.State(nprio, v));\n                            prevnode[v] = u;\n                            prevedge[v] = i;\n                            curflow[v] = Math.min(curflow[u], e.cap - e.f);\n                        }\n                    }\n                }\n                if (prio[t] == Integer.MAX_VALUE)\n                    break;\n                for (int i = 0; i < n; i++)\n                    if (finished[i])\n                        pot[i] += prio[i] - prio[t];\n                long df = Math.min(curflow[t], maxf - flow);\n                flow += df;\n                for (int v = t; v != s; v = prevnode[v]) {\n                    MinCostFlowPolynomial.Edge e = graph[prevnode[v]].get(prevedge[v]);\n                    e.f += df;\n                    graph[v].get(e.rev).f -= df;\n                    flowCost += df * e.cost;\n                }\n            }\n            return new long[]{flow, flowCost};\n        }\n\n        public static class Edge {\n            public int to;\n            public int rev;\n            long f;\n            long cap;\n            long cost;\n\n            Edge(int v, long cap, long cost, int rev) {\n                this.to = v;\n                this.cap = cap;\n                this.cost = cost;\n                this.rev = rev;\n            }\n\n        }\n\n        public static class State implements Comparable<MinCostFlowPolynomial.State> {\n            long priou;\n            int u;\n\n            public State(long priou, int u) {\n                this.priou = priou;\n                this.u = u;\n            }\n\n            public int compareTo(MinCostFlowPolynomial.State o) {\n                return priou == o.priou ? Integer.compare(u, o.u) : Long.compare(priou, o.priou);\n            }\n\n        }\n\n    }\n\n    static class FastOutput implements AutoCloseable, Closeable, Appendable {\n        private StringBuilder cache = new StringBuilder(10 << 20);\n        private final Writer os;\n\n        public FastOutput append(CharSequence csq) {\n            cache.append(csq);\n            return this;\n        }\n\n        public FastOutput append(CharSequence csq, int start, int end) {\n            cache.append(csq, start, end);\n            return this;\n        }\n\n        public FastOutput(Writer os) {\n            this.os = os;\n        }\n\n        public FastOutput(OutputStream os) {\n            this(new OutputStreamWriter(os));\n        }\n\n        public FastOutput append(char c) {\n            cache.append(c);\n            return this;\n        }\n\n        public FastOutput append(long c) {\n            cache.append(c);\n            return this;\n        }\n\n        public FastOutput println() {\n            cache.append(System.lineSeparator());\n            return this;\n        }\n\n        public FastOutput flush() {\n            try {\n                os.append(cache);\n                os.flush();\n                cache.setLength(0);\n            } catch (IOException e) {\n                throw new UncheckedIOException(e);\n            }\n            return this;\n        }\n\n        public void close() {\n            flush();\n            try {\n                os.close();\n            } catch (IOException e) {\n                throw new UncheckedIOException(e);\n            }\n        }\n\n        public String toString() {\n            return cache.toString();\n        }\n\n    }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "最小费用流",
        "query": "最小费用流\n题目描述\n。\r\n\r\n给定一个图，每条边有容量和费用，使用每条边的单位流量需要支付特定的费用。给定源点 $ 1 $ 和汇点 $ n $，求图的最大流和最大流需要支付的最小费用。\n输入格式\n第一行两个整数 $ n $、$ m $，表示有 $ n $ 个点 $ m $ 条边。\r\n\r\n从第二行开始的之后 $ m $ 行，每行四个整数 $ s_i $、$ t_i $、$ c_i $、$ w_i $ 表示一条从 $ s_i $ 到 $ t_i $ 的边，容量为 $ c_i $，单位流量需要支付的费用为 $ w_i $。\n输出格式\n一行两个整数，分别表示最大流和最大流需要支付的最小费用。\n样例\n输入:\n8 23\n2 3 2147483647 1\n1 3 1 1\n2 4 2147483647 2\n1 4 1 2\n2 8 2 0\n3 5 2147483647 3\n1 5 1 3\n3 6 2147483647 4\n1 6 1 4\n3 8 2 0\n3 2 2147483647 0\n4 6 2147483647 5\n1 6 1 5\n4 7 2147483647 6\n1 7 1 6\n4 8 2 0\n4 2 2147483647 0\n5 8 0 0\n5 2 2147483647 0\n6 8 0 0\n6 2 2147483647 0\n7 8 0 0\n7 2 2147483647 0\n输出:\n6 24\n\n\n数据范围与提示\n$1 \\leq n \\leq 400, 0 \\leq m \\leq 15000, w_i\\geq 0 $，保证输入数据、中间结果以及答案在 32 位有符号整数范围内。",
        "sample": {
            "input": "8 23\n2 3 2147483647 1\n1 3 1 1\n2 4 2147483647 2\n1 4 1 2\n2 8 2 0\n3 5 2147483647 3\n1 5 1 3\n3 6 2147483647 4\n1 6 1 4\n3 8 2 0\n3 2 2147483647 0\n4 6 2147483647 5\n1 6 1 5\n4 7 2147483647 6\n1 7 1 6\n4 8 2 0\n4 2 2147483647 0\n5 8 0 0\n5 2 2147483647 0\n6 8 0 0\n6 2 2147483647 0\n7 8 0 0\n7 2 2147483647 0",
            "output": "6 24"
        }
    },
    {
        "code_id": 5,
        "code": "import java.io.PrintWriter;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic class Main {\n\n    public static void main(String args[]){\n        new Main().solve();\n    }\n    Scanner in;\n    PrintWriter out;\n    public void solve(){\n        in = new Scanner(System.in);\n        out = new PrintWriter(System.out);\n        go();\n    }\n\n\n    int s[];\n    int ll[];\n    int rr[];\n    int setv[];\n    void build(int id,int left,int right){\n        if(left==right){\n            s[id] = 1;\n            ll[id] = rr[id] = wt[pt[left]];\n            setv[id] = -1;\n            return;\n        }\n        int mid = (left+right)/2;\n        build(id*2,left,mid);\n        build(id*2+1,mid+1,right);\n        s[id] = s[id*2] + s[id*2+1];\n        if(rr[id*2]==ll[id*2+1]){\n            s[id]--;\n        }\n        rr[id] = rr[id*2+1];\n        ll[id] = ll[id*2];\n        setv[id] = -1;\n\n    }\n\n    int[] qry(int id,int left,int right,int l,int r){\n        if(left>=l&&right<=r){\n            return new int[]{s[id],ll[id],rr[id]};\n        }else if(left>r||right<l){\n            return new int[]{0,-1,-1};\n        }\n        int mid = (left+right)/2;\n\n        if(setv[id]!=-1){\n            setv[id*2] = setv[id*2+1] =  setv[id];\n            ll[id*2]=rr[id*2]=ll[id*2+1]=rr[id*2+1] = setv[id];\n            s[id*2] = s[id*2+1] = 1;\n            setv[id] = -1;\n        }\n\n\n        int v1[] = qry(id*2,left,mid,l,r);\n        int v2[] = qry(id*2+1,mid+1,right,l,r);\n        s[id] = s[id*2] + s[id*2+1];\n        if(rr[id*2]==ll[id*2+1]){\n            s[id]--;\n        }\n        rr[id] = rr[id*2+1];\n        ll[id] = ll[id*2];\n        if(v1[0]==0){\n            return v2;\n        }else if(v2[0]==0){\n            return v1;\n        }\n\n\n        int add = 0;\n        if(v1[2]==v2[1]){\n            add = -1;\n        }\n        int le = v1[1];\n        int ri = v2[2];\n\n        return new int[]{v1[0]+v2[0]+add, le, ri};\n    }\n\n//    void update(int id,int left,int right,int l,long val){\n//        if(left>l||right<l){\n//            return;\n//        }else if(left==right){\n//            s[id] += val;\n//            return;\n//        }\n//        int mid = (left+right)/2;\n//        if(mx[id]!=0){\n//            mx[id*2] += mx[id];\n//            mx[id*2+1] += mx[id];\n//\n//            s[id*2] += mx[id]*(mid-left+1);\n//            s[id*2+1] += mx[id]*(right-(mid+1)+1);\n//\n//\n//            mx[id] = 0;\n//        }\n//\n//        update(id*2,left,mid,l,val);\n//        update(id*2+1,mid+1,right,l,val);\n//        s[id] = s[id*2] + s[id*2+1];\n//\n//    }\n\n    void update(int id,int left,int right,int l,int r,int val){\n        if(left>r||right<l){\n            return;\n        }else if(left>=l&&right<=r){\n            setv[id] = val;\n            ll[id]  = val;\n            rr[id]  = val;\n            s[id] = 1;\n            return;\n        }\n        int mid = (left+right)/2;\n        if(setv[id]!=-1){\n            setv[id*2] = setv[id*2+1] =  setv[id];\n            ll[id*2]=rr[id*2]=ll[id*2+1]=rr[id*2+1] = setv[id];\n            s[id*2] = s[id*2+1] = 1;\n            setv[id] = -1;\n        }\n\n        update(id*2,left,mid,l,r,val);\n        update(id*2+1,mid+1,right,l,r,val);\n        s[id] = s[id*2] + s[id*2+1];\n        if(rr[id*2]==ll[id*2+1]){\n            s[id]--;\n        }\n        rr[id] = rr[id*2+1];\n        ll[id] = ll[id*2];\n\n    }\n\n\n\n    int h[],ne[],to[],wt[];\n    int ct = 0;\n    void add(int u,int v){\n        to[ct] = v;\n        ne[ct] = h[u];\n        h[u] = ct++;\n    }\n    int n;\n    void go(){\n        n = in.nextInt();\n        int q = in.nextInt();\n        h = new int[n];\n        Arrays.fill(h,-1);\n        ne = new int[2*(n-1)];\n        to = new int[2*(n-1)];\n        wt = new int[n];\n\n        fa = new int[n];\n        dep = new int[n];\n        top = new int[n];\n        son = new int[n];\n        sz = new int[n];\n        Arrays.fill(sz,1);\n        dfn = new int[n];\n        pt = new int[n];\n        gpt = new int[n];\n        stk = new int[n];\n        \n\n        for(int i= 0;i<n;++i){\n            wt[i] = in.nextInt();\n        }\n\n\n        for(int i=0;i<n-1;++i){\n            int u = in.nextInt()-1;\n            int v = in.nextInt()-1;\n            add(u,v);\n            add(v,u);\n        }\n\n\n\n\n     //   dfs1(0);\n     //   dfs2(0);\n        treeLink(0);\n\n      \n        s = new int[n*4];\n        ll = new int[n*4];\n        rr = new int[n*4];\n        setv = new int[n*4];\n     //   Arrays.fill(setv,-1);\n\n        build(1,0,n-1);\n\n        for(int i=0;i<q;++i){\n            String c = in.next();\n\n            if(\"C\".equals(c)){\n                int u = in.nextInt()-1;\n                int v = in.nextInt()-1;\n                int w = in.nextInt();\n                while(top[u]!=top[v]){\n                    if(dep[top[u]]>=dep[top[v]]){\n                        update(1,0,n-1,dfn[top[u]],dfn[u],w);\n                        u = fa[top[u]];\n                    }else{\n                        update(1,0,n-1,dfn[top[v]],dfn[v],w);\n                        v = fa[top[v]];\n                    }\n                }\n\n                if(dep[u]>=dep[v]){\n                    update(1,0,n-1,dfn[v],dfn[u],w);\n                }else{\n                    update(1,0,n-1,dfn[u],dfn[v],w);\n                }\n            }else{\n                int u = in.nextInt()-1;\n                int v = in.nextInt()-1;\n                int lu = -1;\n                int lv = -1;\n                int r= 0;\n                while(top[u]!=top[v]){\n                    if(dep[top[u]]>=dep[top[v]]){\n                        int p[] = qry(1,0,n-1,dfn[top[u]],dfn[u]);\n                        r += p[0];\n                        if(lu==p[2]){\n                            r--;\n                        }\n                        u = fa[top[u]];\n                        lu = p[1];\n                    }else{\n                        int p[] = qry(1,0,n-1,dfn[top[v]],dfn[v]);\n                        r += p[0];\n                        if(lv==p[2]){\n                            r--;\n                        }\n                        v = fa[top[v]];\n                        lv = p[1];\n                    }\n                }\n                if(dep[u]>=dep[v]){\n                    int p[] = qry(1,0,n-1,dfn[v],dfn[u]);\n                    r += p[0];\n\n                        if (p[1] == lv) {\n                            r--;\n                        }\n                        if (p[2] == lu) {\n                            r--;\n                        }\n\n                }else{\n                    int p[] = qry(1,0,n-1,dfn[u],dfn[v]);\n                    r += p[0];\n\n                        if (p[1] == lu) {\n                            r--;\n                        }\n                        if (p[2] == lv) {\n                            r--;\n                        }\n\n\n\n                }\n                out.println(r);\n\n            }\n        }\n        out.close();\n\n    }\n\n    int fa[],dep[],top[],son[],sz[],dfn[],pt[],gpt[],stk[];\n    void dfs1(int rt){\n        sz[rt] = 1;\n        for(int i=h[rt];i!=-1;i=ne[i]){\n            int v = to[i];\n            if(v==fa[rt]) continue;\n            fa[v] = rt;\n            dep[v] = dep[rt] + 1;\n            dfs1(v);\n            sz[rt] += sz[v];\n            if(son[rt]==0||sz[son[rt]]<sz[v]){\n                son[rt] = v;\n            }\n        }\n    }\n    int id = 0;\n    void dfs2(int rt){\n        dfn[rt] = id;\n        pt[id++] = rt;\n        if(son[rt]!=0){\n            top[son[rt]] = top[rt];\n            dfs2(son[rt]);\n        }\n        for(int i=h[rt];i!=-1;i=ne[i]){\n            int v = to[i];\n            if(v==fa[rt]||v==son[rt]) continue;\n            top[v] = v;\n            dfs2(v);\n        }\n    }\n\n    public void treeLink(int ort){\n        int p = 0;\n        stk[p++] = ort;\n        int clock = 0;\n        int rt = -1;\n        while(p>0) {\n            rt = stk[--p];\n            gpt[clock++] = rt;\n            for (int i = h[rt]; i != -1; i = ne[i]) {\n                int v = to[i];\n                if (fa[rt] == v) continue;\n                fa[v] = rt;\n                dep[v] = dep[rt] + 1;\n                stk[p++] = v;\n            }\n        }\n        for(int i=n-1;i>0;--i){\n            int cur = gpt[i];\n            int fat = fa[cur];\n            sz[fat] += sz[cur];\n            if (son[fat]== 0 || sz[cur] > sz[son[fat]]) {\n                son[fat] = cur;\n            }\n        }\n       // for (int i = 1; i < n; i++) top[gpt[i]] = gpt[i] == son[fa[gpt[i]]] ? top[fa[gpt[i]]] : gpt[i];\n        p = 0;\n        stk[p++] = ort;\n        while(p>0) {\n            rt = stk[--p];\n            dfn[rt] = id;\n            pt[id++] = rt;\n            for (int i = h[rt]; i != -1; i = ne[i]) {\n                int v = to[i];\n                if (fa[rt] == v || v == son[rt]) continue;\n                top[v] = v;\n                stk[p++] = v;\n            }\n            if(son[rt]!=0) {\n                top[son[rt]] = top[rt];\n                stk[p++] = son[rt];\n            }\n        }\n\n\n    }\n\n\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "染色",
        "query": "# 染色\n## 题目描述\n为了报答小 C 的苹果, 小 G 打算送给热爱美术的小 C 一块画布, \r\n这块画布可以抽象为一个长度为 $N$ 的序列, 每个位置都可以被染成 $M$ 种颜色中的某一种.\r\n\r\n然而小 C 只关心序列的 $N$ 个位置中出现次数恰好为 $S$ 的颜色种数,\r\n如果恰好出现了 $S$ 次的颜色有 $K$ 种, 则小C会产生 $W_k$ 的愉悦度.\r\n\r\n小 C 希望知道对于所有可能的染色方案, 他能获得的愉悦度的和对 $1004535809$ 取模的结果是多少.\n## 输入格式\n第一行三个整数 $N, M, S$.\r\n\r\n接下来一行 $M + 1$ 个整数, 第 $i$ 个数表示 $W_{i-1}$.\n## 输出格式\n输出一行一个整数表示答案．\n## 样例\n输入:\n8 8 3\n3999 8477 9694 8454 3308 8961 3018 2255 4910\n输出:\n524070430\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$N \\le 10^7, M \\le 10^5, S \\le 150, 0 \\le W_i < 1004535809$。",
        "sample": {
            "input": "6 5\n2 2 1 2 1 1\n1 2\n1 3\n2 4\n2 5\n2 6\nQ 3 5\nC 2 1 1\nQ 3 5\nC 5 1 2\nQ 3 5",
            "output": "3\n1\n2"
        }
    },
    {
        "code_id": 18,
        "code": "import java.io.PrintWriter;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic class Main {\n\n    public static void main(String args[]){\n        new Main().solve();\n        \n    }\n    Scanner in;\n    PrintWriter out;\n    public void solve(){\n        in = new Scanner(System.in);\n        out = new PrintWriter(System.out);\n        go();\n    }\n\n\n    int s[];\n    int ll[];\n    int rr[];\n    int setv[];\n    void build(int id,int left,int right){\n        if(left==right){\n            s[id] = 1;\n            ll[id] = rr[id] = wt[pt[left]];\n            setv[id] = -1;\n            return;\n        }\n        int mid = (left+right)/2;\n        build(id*2,left,mid);\n        build(id*2+1,mid+1,right);\n        s[id] = s[id*2] + s[id*2+1];\n        if(rr[id*2]==ll[id*2+1]){\n            s[id]--;\n        }\n        rr[id] = rr[id*2+1];\n        ll[id] = ll[id*2];\n        setv[id] = -1;\n\n    }\n\n    int[] qry(int id,int left,int right,int l,int r){\n        if(left>=l&&right<=r){\n            return new int[]{s[id],ll[id],rr[id]};\n        }else if(left>r||right<l){\n            return new int[]{0,-1,-1};\n        }\n        int mid = (left+right)/2;\n\n        if(setv[id]!=-1){\n            setv[id*2] = setv[id*2+1] =  setv[id];\n            ll[id*2]=rr[id*2]=ll[id*2+1]=rr[id*2+1] = setv[id];\n            s[id*2] = s[id*2+1] = 1;\n            setv[id] = -1;\n        }\n\n\n        int v1[] = qry(id*2,left,mid,l,r);\n        int v2[] = qry(id*2+1,mid+1,right,l,r);\n        s[id] = s[id*2] + s[id*2+1];\n        if(rr[id*2]==ll[id*2+1]){\n            s[id]--;\n        }\n        rr[id] = rr[id*2+1];\n        ll[id] = ll[id*2];\n        if(v1[0]==0){\n            return v2;\n        }else if(v2[0]==0){\n            return v1;\n        }\n\n\n        int add = 0;\n        if(v1[2]==v2[1]){\n            add = -1;\n        }\n        int le = v1[1];\n        int ri = v2[2];\n\n        return new int[]{v1[0]+v2[0]+add, le, ri};\n    }\n\n//    void update(int id,int left,int right,int l,long val){\n//        if(left>l||right<l){\n//            return;\n//        }else if(left==right){\n//            s[id] += val;\n//            return;\n//        }\n//        int mid = (left+right)/2;\n//        if(mx[id]!=0){\n//            mx[id*2] += mx[id];\n//            mx[id*2+1] += mx[id];\n//\n//            s[id*2] += mx[id]*(mid-left+1);\n//            s[id*2+1] += mx[id]*(right-(mid+1)+1);\n//\n//\n//            mx[id] = 0;\n//        }\n//\n//        update(id*2,left,mid,l,val);\n//        update(id*2+1,mid+1,right,l,val);\n//        s[id] = s[id*2] + s[id*2+1];\n//\n//    }\n\n    void update(int id,int left,int right,int l,int r,int val){\n        if(left>r||right<l){\n            return;\n        }else if(left>=l&&right<=r){\n            setv[id] = val;\n            ll[id]  = val;\n            rr[id]  = val;\n            s[id] = 1;\n            return;\n        }\n        int mid = (left+right)/2;\n        if(setv[id]!=-1){\n            setv[id*2] = setv[id*2+1] =  setv[id];\n            ll[id*2]=rr[id*2]=ll[id*2+1]=rr[id*2+1] = setv[id];\n            s[id*2] = s[id*2+1] = 1;\n            setv[id] = -1;\n        }\n\n        update(id*2,left,mid,l,r,val);\n        update(id*2+1,mid+1,right,l,r,val);\n        s[id] = s[id*2] + s[id*2+1];\n        if(rr[id*2]==ll[id*2+1]){\n            s[id]--;\n        }\n        rr[id] = rr[id*2+1];\n        ll[id] = ll[id*2];\n\n    }\n\n\n\n    int h[],ne[],to[],wt[];\n    int ct = 0;\n    void add(int u,int v){\n        to[ct] = v;\n        ne[ct] = h[u];\n        h[u] = ct++;\n    }\n    int n;\n    void go(){\n        n = in.nextInt();\n        int q = in.nextInt();\n        h = new int[n];\n        Arrays.fill(h,-1);\n        ne = new int[2*(n-1)];\n        to = new int[2*(n-1)];\n        wt = new int[n];\n\n        fa = new int[n];\n        dep = new int[n];\n        top = new int[n];\n        son = new int[n];\n        sz = new int[n];\n        Arrays.fill(sz,1);\n        dfn = new int[n];\n        pt = new int[n];\n        gpt = new int[n];\n        stk = new int[n];\n        \n\n        for(int i= 0;i<n;++i){\n            wt[i] = in.nextInt();\n        }\n\n\n        for(int i=0;i<n-1;++i){\n            int u = in.nextInt()-1;\n            int v = in.nextInt()-1;\n            add(u,v);\n            add(v,u);\n        }\n\n\n\n\n     //   dfs1(0);\n     //   dfs2(0);\n        treeLink(0);\n\n      \n        s = new int[n*4];\n        ll = new int[n*4];\n        rr = new int[n*4];\n        setv = new int[n*4];\n     //   Arrays.fill(setv,-1);\n\n        build(1,0,n-1);\n\n        for(int i=0;i<q;++i){\n            String c = in.next();\n\n            if(\"C\".equals(c)){\n                int u = in.nextInt()-1;\n                int v = in.nextInt()-1;\n                int w = in.nextInt();\n                while(top[u]!=top[v]){\n                    if(dep[top[u]]>=dep[top[v]]){\n                        update(1,0,n-1,dfn[top[u]],dfn[u],w);\n                        u = fa[top[u]];\n                    }else{\n                        update(1,0,n-1,dfn[top[v]],dfn[v],w);\n                        v = fa[top[v]];\n                    }\n                }\n\n                if(dep[u]>=dep[v]){\n                    update(1,0,n-1,dfn[v],dfn[u],w);\n                }else{\n                    update(1,0,n-1,dfn[u],dfn[v],w);\n                }\n            }else{\n                int u = in.nextInt()-1;\n                int v = in.nextInt()-1;\n                int lu = -1;\n                int lv = -1;\n                int r= 0;\n                while(top[u]!=top[v]){\n                    if(dep[top[u]]>=dep[top[v]]){\n                        int p[] = qry(1,0,n-1,dfn[top[u]],dfn[u]);\n                        r += p[0];\n                        if(lu==p[2]){\n                            r--;\n                        }\n                        u = fa[top[u]];\n                        lu = p[1];\n                    }else{\n                        int p[] = qry(1,0,n-1,dfn[top[v]],dfn[v]);\n                        r += p[0];\n                        if(lv==p[2]){\n                            r--;\n                        }\n                        v = fa[top[v]];\n                        lv = p[1];\n                    }\n                }\n                if(dep[u]>=dep[v]){\n                    int p[] = qry(1,0,n-1,dfn[v],dfn[u]);\n                    r += p[0];\n\n                        if (p[1] == lv) {\n                            r--;\n                        }\n                        if (p[2] == lu) {\n                            r--;\n                        }\n\n                }else{\n                    int p[] = qry(1,0,n-1,dfn[u],dfn[v]);\n                    r += p[0];\n\n                        if (p[1] == lu) {\n                            r--;\n                        }\n                        if (p[2] == lv) {\n                            r--;\n                        }\n\n\n\n                }\n                out.println(r);\n\n            }\n        }\n        out.close();\n\n    }\n\n    int fa[],dep[],top[],son[],sz[],dfn[],pt[],gpt[],stk[];\n    void dfs1(int rt){\n        sz[rt] = 1;\n        for(int i=h[rt];i!=-1;i=ne[i]){\n            int v = to[i];\n            if(v==fa[rt]) continue;\n            fa[v] = rt;\n            dep[v] = dep[rt] + 1;\n            dfs1(v);\n            sz[rt] += sz[v];\n            if(son[rt]==0||sz[son[rt]]<sz[v]){\n                son[rt] = v;\n            }\n        }\n    }\n    int id = 0;\n    void dfs2(int rt){\n        dfn[rt] = id;\n        pt[id++] = rt;\n        if(son[rt]!=0){\n            top[son[rt]] = top[rt];\n            dfs2(son[rt]);\n        }\n        for(int i=h[rt];i!=-1;i=ne[i]){\n            int v = to[i];\n            if(v==fa[rt]||v==son[rt]) continue;\n            top[v] = v;\n            dfs2(v);\n        }\n    }\n\n    public void treeLink(int ort){\n        int p = 0;\n        stk[p++] = ort;\n        int clock = 0;\n        int rt = -1;\n        while(p>0) {\n            rt = stk[--p];\n            gpt[clock++] = rt;\n            for (int i = h[rt]; i != -1; i = ne[i]) {\n                int v = to[i];\n                if (fa[rt] == v) continue;\n                fa[v] = rt;\n                dep[v] = dep[rt] + 1;\n                stk[p++] = v;\n            }\n        }\n        for(int i=n-1;i>0;--i){\n            int cur = gpt[i];\n            int fat = fa[cur];\n            sz[fat] += sz[cur];\n            if (son[fat]== 0 || sz[cur] > sz[son[fat]]) {\n                son[fat] = cur;\n            }\n        }\n       // for (int i = 1; i < n; i++) top[gpt[i]] = gpt[i] == son[fa[gpt[i]]] ? top[fa[gpt[i]]] : gpt[i];\n        p = 0;\n        stk[p++] = ort;\n        while(p>0) {\n            rt = stk[--p];\n            dfn[rt] = id;\n            pt[id++] = rt;\n            for (int i = h[rt]; i != -1; i = ne[i]) {\n                int v = to[i];\n                if (fa[rt] == v || v == son[rt]) continue;\n                top[v] = v;\n                stk[p++] = v;\n            }\n            if(son[rt]!=0) {\n                top[son[rt]] = top[rt];\n                stk[p++] = son[rt];\n            }\n        }\n\n\n    }\n\n\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "染色",
        "query": "# 染色\n## 题目描述\n为了报答小 C 的苹果, 小 G 打算送给热爱美术的小 C 一块画布, \r\n这块画布可以抽象为一个长度为 $N$ 的序列, 每个位置都可以被染成 $M$ 种颜色中的某一种.\r\n\r\n然而小 C 只关心序列的 $N$ 个位置中出现次数恰好为 $S$ 的颜色种数,\r\n如果恰好出现了 $S$ 次的颜色有 $K$ 种, 则小C会产生 $W_k$ 的愉悦度.\r\n\r\n小 C 希望知道对于所有可能的染色方案, 他能获得的愉悦度的和对 $1004535809$ 取模的结果是多少.\n## 输入格式\n第一行三个整数 $N, M, S$.\r\n\r\n接下来一行 $M + 1$ 个整数, 第 $i$ 个数表示 $W_{i-1}$.\n## 输出格式\n输出一行一个整数表示答案．\n## 样例\n输入:\n8 8 3\n3999 8477 9694 8454 3308 8961 3018 2255 4910\n输出:\n524070430\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$N \\le 10^7, M \\le 10^5, S \\le 150, 0 \\le W_i < 1004535809$。",
        "sample": {
            "input": "6 5\n2 2 1 2 1 1\n1 2\n1 3\n2 4\n2 5\n2 6\nQ 3 5\nC 2 1 1\nQ 3 5\nC 5 1 2\nQ 3 5",
            "output": "3\n1\n2"
        }
    },
    {
        "code_id": 2,
        "code": "import java.io.*;\nimport java.util.StringTokenizer;\n\npublic class Main {\n\tstatic int n, m;\n\tstatic int[] Tr, Tl;\n\n\tstatic int lowbit(int x) {\n\t\treturn x & (-x);\n\t}\n\n\tstatic void update(int x, int v, int[] c) {\n\t\tfor (int i = x; i <= m; i += lowbit(i))\n\t\t\tc[i] += v;\n\t}\n\n\tstatic int getSum(int x, int[] c) {\n\t\tint ans = 0;\n\t\tfor (int i = x; i > 0; i -= lowbit(i))\n\t\t\tans += c[i];\n\t\treturn ans;\n\t}\n\n\tpublic static void main(String[] args) throws IOException {\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\tStringTokenizer st = new StringTokenizer(br.readLine());\n\t\tn = Integer.parseInt(st.nextToken());\n\t\tm = Integer.parseInt(st.nextToken());\n\t\tTr = new int[m+1];\n\t\tTl = new int[m+1];\n\n\t\tfor (int i = 1; i <= m; i++) {\n\t\t\tst = new StringTokenizer(br.readLine());\n\t\t\tint k = Integer.parseInt(st.nextToken());\n\t\t\tint l = Integer.parseInt(st.nextToken());\n\t\t\tint r = Integer.parseInt(st.nextToken());\n\t\t\t\n\t\t\tif (k==1) {\n\t\t\t\tupdate(r,1,Tr);\n\t\t\t\tupdate(l,1,Tl);\n\t\t\t} else {\n\t\t\t\tint ans = getSum(r,Tl) - getSum(l-1, Tr);\n\t\t\t\tSystem.out.println(ans);\n\t\t\t}\n\t\t}\n\t}\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "校门外的树",
        "query": "# 校门外的树\n## 题目描述\n校门外有很多树，学校决定在某个时刻在某一段种上一种树，保证任一时刻不会出现两段相同种类的树，现有两种操作：  \r\n\r\n+ $K=1$，读入 $l,r$ 表示在 $l$ 到 $r$ 之间种上一种树，每次操作种的树的种类都不同；\r\n+ $K=2$，读入 $l,r$ 表示询问 $l$ 到 $r$ 之间有多少种树。\r\n\r\n注意：每个位置都可以重复种树。\n## 输入格式\n第一行 $n,m$ 表示道路总长为 $n$，共有 $m$ 个操作；  \r\n接下来 $m$ 行为 $m$ 个操作。\n## 输出格式\n对于每个 $k=2$ 输出一个答案。\n## 样例\n输入:\n5 4\n1 1 3\n2 2 5\n1 2 4\n2 3 5\n输出:\n1\n2\n\n\n数据范围与提示\r\n对于 $100\\%$ 的数据，$1\\le n,m\\le 5\\times 10^4$，保证 $l,r\\gt 0$。",
        "sample": {
            "input": "5 4\n1 1 3\n2 2 5\n1 2 4\n2 3 5",
            "output": "1\n2"
        }
    },
    {
        "code_id": 6,
        "code": "//\n//  10000.swift\n//  LibreOJ\n//\n//  Created by Louis Shen on 2021/2/8.\n//\n\nimport Foundation\n\nstruct _10000 {\n    public static func main() {\n        var len : CInt = 0\n        _ = withUnsafeMutablePointer(to: &len) { ptr in\n            withVaList([ptr]) { vaList in\n                vscanf(\"%d\", vaList)\n            }\n        }\n        var array = [_10000Event]()\n        let bitset = UnsafeMutablePointer<CBool>.allocate(capacity: 1998)\n        for _ in 0 ..< len {\n            var s : CInt = 0\n            var f : CInt = 0\n            _ = withUnsafeMutablePointer(to: &s) { ptr in\n                withVaList([ptr]) { vaList in\n                    vscanf(\"%d\", vaList)\n                }\n            }\n            _ = withUnsafeMutablePointer(to: &f) { ptr in\n                withVaList([ptr]) { vaList in\n                    vscanf(\"%d\", vaList)\n                }\n            }\n            array.append(_10000Event(s: s, f: f))\n        }\n        var heap = _10000BinaryHeap<_10000Event>(array: array)\n        heap.heapSort()\n        array = heap.getHeap()\n        var maximum : CInt = 0\n        for i in 0 ..< len {\n            maximum = max(maximum, max(array[Int(i)].s, array[Int(i)].f))\n        }\n        var cnt = 0\n        var ans = 0\n        var isUsed = false\n        for i in 0 ..< len {\n            for j in 0 ... maximum {\n                bitset[Int(j)] = false\n            }\n            for j in array[Int(i)].s ... array[Int(i)].f {\n                bitset[Int(j)] = true\n            }\n            cnt = 0\n            for j in 0 ..< len {\n                isUsed = false\n                if i == j {\n                    continue\n                }\n                for k in array[Int(j)].s + 1 ..< array[Int(j)].f {\n                    if bitset[Int(k)] == true {\n                        isUsed = true\n                        break\n                    }\n                }\n                if isUsed == false {\n                    cnt += 1\n                    for k in array[Int(j)].s ... array[Int(j)].f {\n                        bitset[Int(k)] = true\n                    }\n                }\n            }\n            ans = max(ans, cnt)\n        }\n        print(ans + 1)\n    }\n}\n\nstruct _10000Event : _10000Constructable, Comparable {\n    public var s : CInt\n    public var f : CInt\n    \n    init() {\n        s = 0\n        f = 0\n    }\n    \n    init(s : CInt,\n         f : CInt) {\n        self.s = s\n        self.f = f\n    }\n    \n    static func < (lhs: _10000Event, rhs: _10000Event) -> Bool {\n        return lhs.f < rhs.f\n    }\n}\n\nstruct _10000BinaryHeap<T : Comparable & _10000Constructable> {\n    private var array : UnsafeMutablePointer<T>\n    private var count : Int\n    private var size : Int\n    \n    init() {\n        array = UnsafeMutablePointer<T>.allocate(capacity: 1)\n        count = 0\n        size = 0\n        array[0] = T()\n    }\n    \n    init(array : [T]) {\n        self.array = UnsafeMutablePointer<T>.allocate(capacity: array.count + 1)\n        count = array.count\n        size = count\n        self.array[0] = T()\n        for i in 1 ... array.count {\n            self.array[i] = array[i - 1]\n        }\n        \n        for i in (1 ... (count >> 1)).reversed() {\n            maxHeapify(i)\n        }\n    }\n    \n    public mutating func getHeap() -> [T] {\n        var res = [T]()\n        for i in 1 ... size {\n            res.append(array[i])\n        }\n        \n        return res\n    }\n    \n    private func parent(_ index : Int) -> Int {\n        return index >> 1\n    }\n    \n    private func left(_ index : Int) -> Int {\n        return index << 1\n    }\n    \n    private func right(_ index : Int) -> Int {\n        return (index << 1) + 1\n    }\n    \n    private mutating func maxHeapify(_ index : Int) {\n        let l = left(index)\n        let r = right(index)\n        var largest = 0\n        \n        if l <= count && array[l] > array[index] {\n            largest = l\n        } else {\n            largest = index\n        }\n        \n        if r <= count && array[r] > array[largest] {\n            largest = r\n        }\n        \n        if largest != index {\n            let delta = array[index]\n            array[index] = array[largest]\n            array[largest] = delta\n            maxHeapify(largest)\n        }\n    }\n    \n    public mutating func heapSort() {\n        for i in (2 ... count).reversed() {\n            let delta = array[1]\n            array[1] = array[i]\n            array[i] = delta\n            count -= 1\n            maxHeapify(1)\n        }\n    }\n}\n\nprotocol _10000Constructable {\n    init()\n}\n\n_10000.main()",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "活动安排",
        "query": "# 活动安排\n## 题目描述\n设有 $n$ 个活动的集合 $E=\\{1,2,..,n\\}$，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。每个活动 $i$ 都有一个要求使用该资源的起始时间 $s_i$ 和一个结束时间 $f_i$，且 $s_i<f_i$。如果选择了活动 $i$ ，则它在时间区间 $[s_i,f_i)$ 内占用资源。若区间 $[s_i,f_i)$ 与区间 $[s_j,f_j)$ 不相交，则称活动 $i$ 与活动 $j$ 是相容的。也就是说，当 $f_i \\leq s_j$ 或 $f_j \\leq s_i$ 时，活动 $i$ 与活动 $j$ 相容。选择出由互相兼容的活动组成的最大集合。\n## 输入格式\n第一行一个整数 $n$；\r\n\r\n接下来的 $n$ 行，每行两个整数 $s_i$ 和 $f_i$。\n## 输出格式\n输出互相兼容的最大活动个数。\n## 样例\n输入:\n4\n1 3\n4 6\n2 5\n1 7\n输出:\n2\n\n\n## 数据范围与提示\n$1 \\leq n \\leq 1000$",
        "sample": {
            "input": "4\n1 3\n4 6\n2 5\n1 7",
            "output": "2"
        }
    },
    {
        "code_id": 0,
        "code": "\nimport java.io.BufferedReader;\nimport java.io.IOException;\nimport java.io.InputStreamReader;\nimport java.util.StringTokenizer;\n\n/**\n * https://loj.ac/p/10094\n *\n * 有向图的强连通分量,缩点后是一个DAG\n * 只需要给入度为0的点传消息即可\n */\npublic class Main {\n    public static void main(String[] args) throws IOException {\n        n = nextInt();\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                g[i][j] = nextInt();\n            }\n        }\n        for (int i = 0; i < n; i++) {\n            if (dfn[i] == 0) tarjan(i);\n        }\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < n; j++) {\n                if (g[i][j] == 1) {\n                    int a = id[i], b = id[j];\n                    if (a != b) {\n                        in[b]++;\n                    }\n                }\n            }\n        }\n\n        for (int i = 1; i <= sccCnt; i++) {\n            if(in[i]==0) ans++;\n        }\n        System.out.println(ans);\n    }\n\n    static void tarjan(int u) {\n        dfn[u] = low[u] = ++time;\n        stk[++top] = u;\n        in_stk[u] = true;\n        for (int j = 0; j < n; j++) {\n            if (g[u][j] == 1) {\n                if (dfn[j] == 0) {\n                    tarjan(j);\n                    low[u] = Math.min(low[u], low[j]);\n                } else if (in_stk[j]) {\n                    low[u] = Math.min(low[u], dfn[j]);\n                }\n            }\n        }\n        if (low[u] == dfn[u]) {\n            int y;\n            sccCnt++;\n            do {\n                y = stk[top--];\n                in_stk[y] = false;\n                id[y] = sccCnt;\n            } while (y != u);\n        }\n    }\n\n    static int n, ans, N = 1010, time, top, sccCnt;\n    static int[][] g = new int[N][N];\n    static int[] stk = new int[N], in = new int[N], id = new int[N], dfn = new int[N], low = new int[N];\n    static boolean[] in_stk = new boolean[N];\n    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n    static StringTokenizer sk = new StringTokenizer(\"\");\n\n    static int nextInt() throws IOException {\n        while (!sk.hasMoreTokens()) {\n            sk = new StringTokenizer(br.readLine());\n        }\n        return Integer.parseInt(sk.nextToken());\n    }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "消息的传递",
        "query": "# 消息的传递\n## 题目描述\n我们的郭嘉大大在曹操这过得逍遥自在，但是有一天曹操给了他一个任务，在建邺城内有 $N$ 个袁绍的奸细，将他们从 $1$ 到 $N$ 进行编号，同时他们之间存在一种传递关系，即若$C_{i,j}=1$，则奸细 $i$ 能将消息直接传递给奸细 $j$。\r\n\r\n现在曹操要发布一个假消息，需要传达给所有奸细，而我们的郭嘉大大则需要传递给尽量少的奸细使所有的奸细都知道这一个消息，问我们至少要传给几个奸细？\n## 输入格式\n文件的第一行为 $N$，第二行至第 $N+1$ 行为 $N \\times N$ 的矩阵（若第 $I$ 行第 $J$ 列为 $1$，则奸细 $I$ 能将消息直接传递给奸细 $J$，若第 $I$ 行第 $J$ 列为 $0$，则奸细 $I$ 不能将消息直接传递给奸细 $J$）。\n## 输出格式\n输出文件只有一行：即我们的郭嘉大大首先至少要传递的奸细个数。\n## 样例\n输入:\n8\n0 0 1 0 0 0 0 0\n1 0 0 1 0 0 0 0\n0 1 0 1 1 0 0 0\n0 0 0 0 0 1 0 0\n0 0 0 1 0 0 0 0\n0 0 0 1 0 0 0 0\n0 0 0 1 0 0 0 1\n0 0 0 0 0 0 1 0\n输出:\n2\n\n\n## 数据范围与提示\n$N \\le 1000$",
        "sample": {
            "input": "8\n0 0 1 0 0 0 0 0\n1 0 0 1 0 0 0 0\n0 1 0 1 1 0 0 0\n0 0 0 0 0 1 0 0\n0 0 0 1 0 0 0 0\n0 0 0 1 0 0 0 0\n0 0 0 1 0 0 0 1\n0 0 0 0 0 0 1 0",
            "output": "2"
        }
    },
    {
        "code_id": 4,
        "code": "var\r\nc:array[0..100000] of longint;\r\nn,m,i,p,k:longint;\r\nch:char;\r\nfunction lowbit(x:longint):longint;\r\nbegin\r\n  lowbit:=x and -x;\r\nend;\r\nprocedure add(i,x:longint);\r\nbegin\r\n  while i<=n do\r\n  begin\r\n    inc(c[i],x);\r\n    i:=i+lowbit(i);\r\n  end;\r\nend;\r\nfunction get(x:longint):longint;\r\nbegin\r\n  get:=0;\r\n  while x>=1 do\r\n  begin\r\n     get:=get+c[x];\r\n     x:=x-lowbit(x);\r\n  end;\r\nend;\r\nbegin\r\n  readln(n,k);\r\n  for i:=1 to k do\r\n  begin\r\n    read(ch);\r\n    case ch of\r\n    'A':\r\n     begin\r\n       readln(m);\r\n       writeln(get(m));\r\n     end;\r\n    'B':\r\n    begin\r\n      readln(m,p);\r\n      add(m,p);\r\n    end;\r\n    'C':\r\n    begin\r\n      readln(m,p);\r\n      add(m,-p);\r\n    end;\r\n   end; \r\n end;\r\nend.",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "清点人数",
        "query": "# 清点人数\n## 题目描述\nNK 中学组织同学们去五云山寨参加社会实践活动，按惯例要乘坐火车去。由于 NK 中学的学生很多，在火车开之前必须清点好人数。 \r\n\r\n初始时，火车上没有学生。当同学们开始上火车时，年级主任从第一节车厢出发走到最后一节车厢，每节车厢随时都有可能有同学上下。年级主任走到第 $m$ 节车厢时，他想知道前 $m$ 节车厢上一共有多少学生，但是他没有调头往回走的习惯。也就是说每次当他提问时，$m$ 总会比前一次大。\n## 输入格式\n第一行两个整数 $n,k$，表示火车共有 $n$ 节车厢以及 $k$ 个事件。\r\n\r\n接下来有 $k$ 行，按时间先后给出 $k$ 个事件，每行开头都有一个字母 `A`，`B` 或 `C`。\r\n+ 如果字母为 `A`，接下来是一个数 $m$，表示年级主任现在在第 $m$ 节车厢；\r\n+ 如果字母为 `B`，接下来是两个数 $m,p$，表示在第 $m$ 节车厢有 $p$ 名学生上车；\r\n+ 如果字母为 `C`，接下来是两个数 $m,p$，表示在第 $m$ 节车厢有 $p$ 名学生下车。\r\n\r\n学生总人数不会超过 $10^5$。\n## 输出格式\n对于每个 `A` ，输出一行，一个整数，表示年级主任的问题的答案。\n## 样例\n输入:\n10 7\nA 1\nB 1 1\nB 3 1\nB 4 1\nA 2\nA 3\nA 10\n输出:\n0\n1\n2\n3\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1\\le n\\le 5\\times 10^5,1\\le k\\le 10^5$，至少有 $3\\times 10^4$ 个 `A`。",
        "sample": {
            "input": "10 7\nA 1\nB 1 1\nB 3 1\nB 4 1\nA 2\nA 3\nA 10",
            "output": "0\n1\n2\n3"
        }
    },
    {
        "code_id": 1,
        "code": "var n,m,i,j,k,head,tail:longint;\r\na,q:array[0..1000005] of longint;\r\n\r\nbegin\r\nreadln(n,m);\r\nfor i:=1 to n do read(a[i]);\r\nhead:=1;tail:=1;q[1]:=a[1];\r\nfor i:=2 to n do begin\r\n\twhile (head<tail)and(q[head]<=i-m) do inc(head);\r\n\twhile (a[q[tail]]>a[i])and(tail>=head) do dec(tail);\r\n\tinc(tail);\r\n\tq[tail]:=i;\r\n\tif i-m>=0 then write(a[q[head]],' ');\r\n\tend;\r\nwriteln;\r\nhead:=1;tail:=1;q[1]:=a[1];\r\nfor i:=2 to n do begin\r\n\twhile (head<tail)and(q[head]<=i-m) do inc(head);\r\n\twhile (a[q[tail]]<a[i])and(tail>=head)do dec(tail);\r\n\tinc(tail);\r\n\tq[tail]:=i;\r\n\tif i-m>=0 then write(a[q[head]],' ');\r\n\tend;\r\nwriteln;\r\nend.\r\n\r\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "滑动窗口",
        "query": "# 滑动窗口\n## 题目描述\n给一个长度为 $N$ 的数组，一个长为 $K$ 的滑动窗体从最左端移至最右端，你只能看到窗口中的 $K$ 个数，每次窗体向右移动一位，如下图：\r\n\r\n|窗口位置|最小值|最大值|\r\n|:-:|:-:|:-:|\r\n|$\\texttt{[1  3  -1] -3  5  3  6  7}$|$-1$|$3$|\r\n|$ \\ \\texttt{ 1 [3  -1  -3] 5  3  6  7}$|$-3$|$3$|\r\n|$ \\ \\texttt{ 1  3 [-1  -3  5] 3  6  7}$|$-3$|$5$|\r\n|$ \\ \\texttt{ 1  3  -1 [-3  5  3] 6  7}$|$-3$|$5$|\r\n|$ \\ \\texttt{ 1  3  -1  -3 [5  3  6] 7}$|$3$|$6$|\r\n|$ \\ \\texttt{ 1  3  -1  -3  5 [3  6  7]}$|$3$|$7$|\r\n\r\n你的任务是找出窗体在各个位置时的最大值和最小值。\n## 输入格式\n第 1 行：两个整数 $N$ 和 $K$；  \r\n第 2 行：$N$ 个整数，表示数组的 $N$ 个元素($≤2\\times 10^9$)；\n## 输出格式\n第一行为滑动窗口从左向右移动到每个位置时的最小值，每个数之间用一个空格分开；  \r\n第二行为滑动窗口从左向右移动到每个位置时的最大值，每个数之间用一个空格分开。\n## 样例\n输入:\n8 3\n1 3 -1 -3 5 3 6 7\n输出:\n-1 -3 -3 -3 3 3\n3 3 5 5 6 7\n\n\n数据范围与提示 \r\n对于 $100\\%$ 的数据，$K≤N≤10^6$。",
        "sample": {
            "input": "8 3\n1 3 -1 -3 5 3 6 7",
            "output": "-1 -3 -3 -3 3 3\n3 3 5 5 6 7"
        }
    },
    {
        "code_id": 5,
        "code": "var n,m,i,j,k,head,tail:longint;\r\na,q:array[0..10000005] of longint;\r\n\r\nbegin\r\nreadln(n,m);\r\nfor i:=1 to n do read(a[i]);\r\nhead:=1;tail:=1;q[1]:=a[1];\r\nfor i:=2 to n do begin\r\n\twhile (head<tail)and(q[head]<=i-m) do inc(head);\r\n\twhile (a[q[tail]]>a[i])and(tail>=head) do dec(tail);\r\n\tinc(tail);\r\n\tq[tail]:=i;\r\n\tif i-m>=0 then write(a[q[head]],' ');\r\n\tend;\r\nwriteln;\r\nhead:=1;tail:=1;q[1]:=a[1];\r\nfor i:=2 to n do begin\r\n\twhile (head<tail)and(q[head]<=i-m) do inc(head);\r\n\twhile (a[q[tail]]<a[i])and(tail>=head)do dec(tail);\r\n\tinc(tail);\r\n\tq[tail]:=i;\r\n\tif i-m>=0 then write(a[q[head]],' ');\r\n\tend;\r\nwriteln;\r\nend.\r\n\r\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "滑动窗口",
        "query": "# 滑动窗口\n## 题目描述\n给一个长度为 $N$ 的数组，一个长为 $K$ 的滑动窗体从最左端移至最右端，你只能看到窗口中的 $K$ 个数，每次窗体向右移动一位，如下图：\r\n\r\n|窗口位置|最小值|最大值|\r\n|:-:|:-:|:-:|\r\n|$\\texttt{[1  3  -1] -3  5  3  6  7}$|$-1$|$3$|\r\n|$ \\ \\texttt{ 1 [3  -1  -3] 5  3  6  7}$|$-3$|$3$|\r\n|$ \\ \\texttt{ 1  3 [-1  -3  5] 3  6  7}$|$-3$|$5$|\r\n|$ \\ \\texttt{ 1  3  -1 [-3  5  3] 6  7}$|$-3$|$5$|\r\n|$ \\ \\texttt{ 1  3  -1  -3 [5  3  6] 7}$|$3$|$6$|\r\n|$ \\ \\texttt{ 1  3  -1  -3  5 [3  6  7]}$|$3$|$7$|\r\n\r\n你的任务是找出窗体在各个位置时的最大值和最小值。\n## 输入格式\n第 1 行：两个整数 $N$ 和 $K$；  \r\n第 2 行：$N$ 个整数，表示数组的 $N$ 个元素($≤2\\times 10^9$)；\n## 输出格式\n第一行为滑动窗口从左向右移动到每个位置时的最小值，每个数之间用一个空格分开；  \r\n第二行为滑动窗口从左向右移动到每个位置时的最大值，每个数之间用一个空格分开。\n## 样例\n输入:\n8 3\n1 3 -1 -3 5 3 6 7\n输出:\n-1 -3 -3 -3 3 3\n3 3 5 5 6 7\n\n\n数据范围与提示 \r\n对于 $100\\%$ 的数据，$K≤N≤10^6$。",
        "sample": {
            "input": "8 3\n1 3 -1 -3 5 3 6 7",
            "output": "-1 -3 -3 -3 3 3\n3 3 5 5 6 7"
        }
    },
    {
        "code_id": 2,
        "code": "\nimport java.io.*;\nimport java.util.InputMismatchException;\nimport java.util.PriorityQueue;\n\npublic class Main {\n    /**\n     * 数据结构优化 dp 之 堆优化 Dp\n     * 如果状态转移方程刑如： f[i] = max(f[l<=j<=r]) + w[i]\n     * 也就是当前状态由之前一个区间的状态转移获得，就可以使用单调队列来维护区间最值，\n     * 从而优化决策\n     **/\n    public static void main(String[] args) {\n        InputStream inputStream = System.in;\n        OutputStream outputStream = System.out;\n        InputReader sc = new InputReader(inputStream);\n        OutputWriter out = new OutputWriter(outputStream);\n        int n = sc.nextInt(), m = sc.nextInt();\n        int[] a = new int[n + 1];\n        for (int i = 1; i <= n; i++) {\n            a[i] = sc.nextInt();\n        }\n        int[] f = new int[n + 1];\n        //f[i] = 点燃第 i 个烽火台的合法方案中的最小代价\n        //两个烽火台之间的距离不能超过 m ，如果点燃 i,那么在区间 [i - m,i - 1] 内至少要有一个烽火台也得点燃\n        //所以有 f[i] = min(f[j]) + a[i],其中 j ∈ [i-m,i-1]\n        //边界 f[0] = 0 表示没有烽火台，代价为 0\n        //答案 min(f[n- m + 1] ~ f[n])\n        //队列内元素从左到右是单调递增的，队头元素最小\n        PriorityQueue<int[]> p = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);//index val\n        int ans = (int) 2e9;\n        for (int i = 1; i <= m; i++) {\n            f[i] = a[i];\n            p.offer(new int[]{i, f[i]});\n          //  if (i > n - m) ans = Math.min(ans, f[i]);\n        }\n\n        for (int i = m + 1; i <= n; i++) {\n            //[i-m,i-1]\n            while (!p.isEmpty() && p.peek()[0] < i - m) p.poll();\n            int[] t = p.peek();\n            f[i] = a[i] + t[1];\n            p.offer(new int[]{i, f[i]});\n            if (i > n - m) ans = Math.min(ans, f[i]);\n        }\n\n        out.println(ans);\n        out.close();\n\n    }\n\n    static class OutputWriter {\n        private final PrintWriter writer;\n\n        public OutputWriter(OutputStream outputStream) {\n            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));\n        }\n\n        public OutputWriter(Writer writer) {\n            this.writer = new PrintWriter(writer);\n        }\n\n        public void close() {\n            writer.close();\n        }\n\n        public OutputWriter println(long i) {\n            writer.println(i);\n            return this;\n        }\n        public OutputWriter println(double i) {\n            writer.println(i);\n            return this;\n        }\n        public OutputWriter println(String i) {\n            writer.println(i);\n            return this;\n        }\n        public OutputWriter println() {\n            writer.println();\n            return this;\n        }\n        public OutputWriter print(String i) {\n            writer.print(i);\n            return this;\n        }\n        public OutputWriter print(long i) {\n            writer.print(i);\n            return this;\n        }\n        public OutputWriter print(char i) {\n            writer.print(i);\n            return this;\n        }\n    }\n\n    static class InputReader {\n        private InputStream stream;\n        private byte[] buf = new byte[1024];\n        private int curChar;\n        private int numChars;\n        private InputReader.SpaceCharFilter filter;\n\n        public InputReader(InputStream stream) {\n            this.stream = stream;\n        }\n\n        public double[] nextDoubleArray(int size) {\n            double[] array = new double[size];\n            for (int i = 0; i < size; i++) {\n                array[i] = readDouble();\n            }\n            return array;\n        }\n\n        private int read() {\n            if (numChars == -1) {\n                throw new InputMismatchException();\n            }\n            if (curChar >= numChars) {\n                curChar = 0;\n                try {\n                    numChars = stream.read(buf);\n                } catch (IOException e) {\n                    throw new InputMismatchException();\n                }\n                if (numChars <= 0) {\n                    return -1;\n                }\n            }\n            return buf[curChar++];\n        }\n\n        public int nextInt() {\n            return Integer.parseInt(this.next(), 10);\n        }\n\n        public long nextLong() {\n            return Long.parseLong(this.next(), 10);\n        }\n\n        public String next() {\n            int c = read();\n            while (isSpaceChar(c)) {\n                c = read();\n            }\n            StringBuilder res = new StringBuilder();\n            do {\n                if (Character.isValidCodePoint(c)) {\n                    res.appendCodePoint(c);\n                }\n                c = read();\n            } while (!isSpaceChar(c));\n            return res.toString();\n        }\n\n        private boolean isSpaceChar(int c) {\n            if (filter != null) {\n                return filter.isSpaceChar(c);\n            }\n            return isWhitespace(c);\n        }\n\n        private static boolean isWhitespace(int c) {\n            return c == ' ' || c == '\\n' || c == '\\r' || c == '\\t' || c == -1;\n        }\n\n        public double readDouble() {\n            int c = read();\n            while (isSpaceChar(c)) {\n                c = read();\n            }\n            int sgn = 1;\n            if (c == '-') {\n                sgn = -1;\n                c = read();\n            }\n            double res = 0;\n            while (!isSpaceChar(c) && c != '.') {\n                if (c == 'e' || c == 'E') {\n                    return res * Math.pow(10, nextInt());\n                }\n                if (c < '0' || c > '9') {\n                    throw new InputMismatchException();\n                }\n                res *= 10;\n                res += c - '0';\n                c = read();\n            }\n            if (c == '.') {\n                c = read();\n                double m = 1;\n                while (!isSpaceChar(c)) {\n                    if (c == 'e' || c == 'E') {\n                        return res * Math.pow(10, nextInt());\n                    }\n                    if (c < '0' || c > '9') {\n                        throw new InputMismatchException();\n                    }\n                    m /= 10;\n                    res += (c - '0') * m;\n                    c = read();\n                }\n            }\n            return res * sgn;\n        }\n\n        public interface SpaceCharFilter {\n            public boolean isSpaceChar(int ch);\n\n        }\n\n    }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "烽火传递",
        "query": "# 烽火传递\n## 题目描述\r\n\r\n烽火台是重要的军事防御设施，一般建在交通要道或险要处。一旦有军情发生，则白天用浓烟，晚上有火光传递军情。\r\n\r\n在某两个城市之间有 $n$ 座烽火台，每个烽火台发出信号都有一定的代价。为了使情报准确传递，在连续 $m$ 个烽火台中至少要有一个发出信号。现在输入 $n,m$ 和每个烽火台的代价，请计算总共最少的代价在两城市之间来准确传递情报。\n## 输入格式\n第一行是 $n,m$，表示 $n$ 个烽火台和连续烽火台数 $m$；\r\n\r\n第二行 $n$ 个整数表示每个烽火台的代价 $a_i$。\n## 输出格式\n输出仅一个整数，表示最小代价。\n## 样例\n输入:\n5 3\n1 2 5 6 2\n输出:\n4\n\n在第 $2,5$ 号烽火台上发信号。\n## 数据范围与提示\n对于全部数据，$1\\le n,m\\le 2\\times 10^5,1\\le a_i\\le 1000$。",
        "sample": {
            "input": "5 3\n1 2 5 6 2",
            "output": "4"
        }
    },
    {
        "code_id": 6,
        "code": "import java.io.*;\n\npublic class Main {\n    static PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));\n    static BufferedReader re=new BufferedReader(new InputStreamReader(System.in));\n    static StreamTokenizer st=new StreamTokenizer(re);\n    static void read() throws IOException{\n        st.nextToken();\n    }\n\n    static int[] ans=new int[(int)1e7+10];\n\n    public static void main(String[] args) throws Exception {\n        read();\n        int n=(int)st.nval;\n        read();\n        int m=(int)st.nval;\n        int[] a=new int[(int)2e5+10];\n        int[] f=new int[(int)2e5+10];\n        int[] q=new int[(int)2e5+10];\n        for(int i=1;i<=n;i++){\n            read();\n            a[i]=(int)st.nval;\n        }\n        int h=1,t=0,ans=(int)2e9;\n        for(int i=1;i<=n;i++){\n            while(h<=t&&f[q[t]]>f[i-1]) t--;\n            q[++t]=i-1;\n            if(q[h]<i-m) h++;\n            f[i]=f[q[h]]+a[i];\n            if(i>n-m) ans=Math.min(ans,f[i]);\n        }\n        pw.println(ans);\n        pw.flush();\n    }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "烽火传递",
        "query": "# 烽火传递\n## 题目描述\r\n\r\n烽火台是重要的军事防御设施，一般建在交通要道或险要处。一旦有军情发生，则白天用浓烟，晚上有火光传递军情。\r\n\r\n在某两个城市之间有 $n$ 座烽火台，每个烽火台发出信号都有一定的代价。为了使情报准确传递，在连续 $m$ 个烽火台中至少要有一个发出信号。现在输入 $n,m$ 和每个烽火台的代价，请计算总共最少的代价在两城市之间来准确传递情报。\n## 输入格式\n第一行是 $n,m$，表示 $n$ 个烽火台和连续烽火台数 $m$；\r\n\r\n第二行 $n$ 个整数表示每个烽火台的代价 $a_i$。\n## 输出格式\n输出仅一个整数，表示最小代价。\n## 样例\n输入:\n5 3\n1 2 5 6 2\n输出:\n4\n\n在第 $2,5$ 号烽火台上发信号。\n## 数据范围与提示\n对于全部数据，$1\\le n,m\\le 2\\times 10^5,1\\le a_i\\le 1000$。",
        "sample": {
            "input": "5 3\n1 2 5 6 2",
            "output": "4"
        }
    },
    {
        "code_id": 1,
        "code": "import math, sys\r\n\r\nN = int(input())\r\n# N = 120\r\n\r\nif N&1:\r\n\tprint(0)\r\n\tsys.exit(0)\r\nN //= 2\r\n\r\ndef DecideD(n,m):\r\n\tif n >= m: return\r\n\tif math.gcd(n,m) != 1: return\r\n\tif (n&1) == (m&1): return\r\n\td = N // ((n+m)*m)\r\n\ta = sorted([(m*m-n*n)*d,2*n*m*d,(m*m+n*n)*d])\r\n\tprint(a[0],a[1],a[2])\r\n\r\ndef DecideN(m):\r\n\tdivres = N//m\r\n\tsqt = int(math.sqrt(divres))\r\n\t# print('divres',divres)\r\n\t# print('m',m)\r\n\tfor nplusm in range(2,sqt+1):\r\n\t\tif divres%nplusm != 0: continue\r\n\t\tif nplusm > m:\r\n\t\t\tDecideD(nplusm-m,m)\r\n\t\tif nplusm*nplusm != divres and divres//nplusm > m:\r\n\t\t\tDecideD(divres//nplusm-m,m)\r\n\r\ndef DecideM():\r\n\tsqt = int(math.sqrt(N))\r\n\tfor m in range(2,sqt+1):\r\n\t\tif N%m != 0: continue\r\n\t\tDecideN(m)\r\n\t\tif m*m != N:\r\n\t\t\tDecideN(N//m)\r\n\r\nDecideM()\r\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "特殊勾股数",
        "query": "# 特殊勾股数\n## 题目描述\n一组勾股数由三个自然数组成，$a < b < c$，且\r\n\r\n$$a^2 + b^2 = c^2$$\r\n\r\n例如，$3^2 + 4^2 = 9 + 16 = 25 = 5^2$。\r\n\r\n给出 $N$，请输出所有满足 $a + b + c = N$ 的勾股数。\n## 输入格式\n只有一行，一个整数 $N$。\n## 输出格式\n多行，每行三个整数，$a, b, c$，表示答案。\n## 样例\n### 样例 1\n输入:\n12\n输出:\n3 4 5\n\n\n### 样例 2\n输入:\n120\n输出:\n30 40 50\n20 48 52\n24 45 51\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$N \\leq 10^{12}$。",
        "sample": {
            "input": "12",
            "output": "3 4 5"
        }
    },
    {
        "code_id": 6,
        "code": "mod oiread {\n    use std::{\n        io::{stdin, Read},\n        ops::{Add, Mul, Neg},\n    };\n\n    pub fn next() -> u8 {\n        let mut a = stdin().lock();\n        let mut c = [0u8];\n        match a.read(&mut c) {\n            Ok(0) => b'\\n', // End Of File\n            Ok(1) => c[0],\n            _ => panic!(),\n        }\n    }\n    pub fn get_char() -> char {\n        next().into()\n    }\n    pub fn read_inum<T>() -> T\n    where\n        T: Add<Output = T> + Mul<Output = T> + From<u8> + Neg<Output = T>,\n    {\n        let mut ans: T = T::from(0);\n        let mut flag = false;\n        let mut c = next();\n        while c < b'0' || c > b'9' {\n            if c == b'-' {\n                flag = true;\n            }\n            c = next();\n        }\n        while c >= b'0' && c <= b'9' {\n            ans = ans * T::from(10) + T::from(c - b'0');\n            c = next();\n        }\n        if flag {\n            -ans\n        } else {\n            ans\n        }\n    }\n    pub fn read_unum<T>() -> T\n    where\n        T: Add<Output = T> + Mul<Output = T> + From<u8>,\n    {\n        let mut ans: T = T::from(0);\n        let mut c = next();\n        while c < b'0' || c > b'9' {\n            c = next();\n        }\n        while c >= b'0' && c <= b'9' {\n            ans = ans * T::from(10) + T::from(c - b'0');\n            c = next();\n        }\n        ans\n    }\n    pub fn read_i64() -> i64 {\n        read_inum::<i64>()\n    }\n    pub fn read_str() -> String {\n        let mut res = String::new();\n        let mut c = next();\n        while c == b' ' || c == b'\\n' || c == b'\\r' {\n            c = next();\n        }\n        while c != b' ' && c != b'\\n' && c != b'\\r' {\n            res.push(c as char);\n            c = next();\n        }\n        res\n    }\n    pub fn read_u8s() -> Vec<u8> {\n        let mut res = Vec::new();\n        let mut c = next();\n        while c == b' ' || c == b'\\n' || c == b'\\r' {\n            c = next();\n        }\n        while c != b' ' && c != b'\\n' && c != b'\\r' {\n            res.push(c);\n            c = next();\n        }\n        res\n    }\n}\n\nuse std::collections::VecDeque;\nuse std::fmt;\nuse std::fmt::Display;\nuse std::mem::swap;\nuse std::process::exit;\n\nuse oiread::read_i64 as read;\nuse oiread::read_str;\n\n#[derive(PartialEq, Eq, Clone, Copy)]\nenum BaseType {\n    Atk,\n    Def,\n    Peach,\n}\nimpl From<String> for BaseType {\n    fn from(value: String) -> Self {\n        match value.as_str() {\n            \"P\" => BaseType::Peach,\n            \"K\" => BaseType::Atk,\n            \"D\" => BaseType::Def,\n            x => panic!(\"Base Card Type Error : {}\", x),\n        }\n    }\n}\nimpl Display for BaseType {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        write!(\n            f,\n            \"{}\",\n            match *self {\n                BaseType::Atk => \"K\",\n                BaseType::Def => \"D\",\n                BaseType::Peach => \"P\",\n            }\n        )\n    }\n}\n\n#[derive(PartialEq, Eq, Clone, Copy)]\nenum SkillType {\n    Fight,\n    ReqAtk,\n    ReqDef,\n    Cancel,\n}\nimpl From<String> for SkillType {\n    fn from(value: String) -> Self {\n        match value.as_str() {\n            \"F\" => SkillType::Fight,\n            \"N\" => SkillType::ReqAtk,\n            \"W\" => SkillType::ReqDef,\n            \"J\" => SkillType::Cancel,\n            x => panic!(\"Skill Card Type Error : {}\", x),\n        }\n    }\n}\nimpl Display for SkillType {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        write!(\n            f,\n            \"{}\",\n            match *self {\n                SkillType::Fight => \"F\",\n                SkillType::ReqAtk => \"N\",\n                SkillType::ReqDef => \"W\",\n                SkillType::Cancel => \"J\",\n            }\n        )\n    }\n}\n\n#[derive(PartialEq, Eq, Clone, Copy)]\nenum CardType {\n    Base(BaseType),\n    Skill(SkillType),\n    Equip,\n}\nimpl From<String> for CardType {\n    fn from(value: String) -> Self {\n        match value.as_str() {\n            \"P\" | \"K\" | \"D\" => CardType::Base(value.into()),\n            \"F\" | \"N\" | \"W\" | \"J\" => CardType::Skill(value.into()),\n            \"Z\" => CardType::Equip,\n            x => panic!(\"Card Type Error : {}\", x),\n        }\n    }\n}\nimpl Display for CardType {\n    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n        match *self {\n            CardType::Base(card) => write!(f, \"{}\", card),\n            CardType::Skill(card) => write!(f, \"{}\", card),\n            CardType::Equip => write!(f, \"Z\"),\n        }\n    }\n}\n\n#[derive(PartialEq, Debug, Clone, Copy)]\nenum Identity {\n    MainPig,\n    ZhongPig,\n    FanPig,\n}\nimpl From<String> for Identity {\n    fn from(value: String) -> Self {\n        match value.as_str() {\n            \"MP\" => Self::MainPig,\n            \"ZP\" => Self::ZhongPig,\n            \"FP\" => Self::FanPig,\n            x => panic!(\"Error Pig Identity: {}\", x),\n        }\n    }\n}\n\n#[derive(Clone, Copy, PartialEq, Eq)]\nenum ActType {\n    None,\n    Zhong,\n    Fan,\n}\n\n#[derive(PartialEq, Eq, Clone, Copy)]\nenum State {\n    None,\n    SimFan,\n    Fan,\n    Zhong,\n}\n\n#[derive(Clone, Copy)]\nstruct Act {\n    tp: ActType,\n    card: CardType,\n    src: usize,\n    dst: Option<usize>,\n}\nimpl Act {\n    fn new(tp: ActType, card: CardType, src: usize, dst: Option<usize>) -> Self {\n        Self { tp, card, src, dst }\n    }\n}\n\nstruct Pig {\n    tp: Identity,\n    hp: isize,\n    pos: usize,\n    state: State,\n    cards: Vec<CardType>,\n    equip: bool,\n    alive: bool,\n    attacked: bool,\n}\nimpl Pig {\n    const MAX_HP: isize = 4;\n    fn new(pos: usize) -> Self {\n        let tp = Identity::from(read_str());\n        if pos == 0 {\n            assert_eq!(tp, Identity::MainPig);\n        }\n        let mut cards = Vec::new();\n        for _ in 0..4 {\n            cards.push(CardType::from(read_str()));\n        }\n        Self {\n            tp,\n            hp: Self::MAX_HP,\n            state: State::None,\n            cards,\n            pos,\n            equip: false,\n            alive: true,\n            attacked: false,\n        }\n    }\n\n    fn is_known(&self) -> bool {\n        self.tp == Identity::MainPig || self.state == State::Zhong || self.state == State::Fan\n    }\n\n    fn get_card(&mut self, pool: &mut Pool, cnt: usize) {\n        for _ in 0..cnt {\n            if let Some(c) = pool.get() {\n                self.cards.push(c);\n            }\n        }\n    }\n\n    fn get_enemy(&self, players: &Vec<Pig>) -> Option<usize> {\n        if Identity::FanPig == self.tp {\n            return Some(0);\n        }\n        // [self.pos+1, self.pos+2, ... n-1, 0, 1, 2, ... self.pos-1 ]\n        let mut range = (0..players.len()).collect::<Vec<usize>>();\n        range.rotate_left(self.pos + 1);\n        for i in range {\n            if i == self.pos || !players[i].alive {\n                continue;\n            }\n            let pig = &players[i];\n            match self.tp {\n                Identity::MainPig => {\n                    if let State::Fan | State::SimFan = pig.state {\n                        return Some(i);\n                    }\n                }\n                Identity::ZhongPig => {\n                    if State::Fan == pig.state {\n                        return Some(i);\n                    }\n                }\n                Identity::FanPig => unreachable!(),\n            }\n        }\n        None\n    }\n\n    fn get_enemy_dis1(&self, players: &Vec<Pig>) -> Option<usize> {\n        // [self.pos+1, self.pos+2, ... n-1, 0, 1, 2, ... self.pos-1 ]\n        let mut range = (0..players.len()).collect::<Vec<_>>();\n        range.rotate_left(self.pos + 1);\n        for i in range {\n            if i == self.pos || !players[i].alive {\n                continue;\n            }\n            let pig = &players[i];\n            match self.tp {\n                Identity::MainPig => {\n                    if let State::Fan | State::SimFan = pig.state {\n                        return Some(i);\n                    }\n                }\n                Identity::ZhongPig => {\n                    if State::Fan == pig.state {\n                        return Some(i);\n                    }\n                }\n                Identity::FanPig => {\n                    if State::Zhong == pig.state || pig.pos == 0 {\n                        return Some(i);\n                    }\n                }\n            }\n            break;\n        }\n        None\n    }\n\n    fn ask(&self, asked_card: CardType) -> Option<usize> {\n        for (i, card) in self.cards.iter().enumerate() {\n            if *card == asked_card {\n                return Some(i);\n            }\n        }\n        None\n    }\n\n    fn try_act(&self, players: &Vec<Pig>) -> Option<(usize, Act)> {\n        for i in 0..self.cards.len() {\n            let card = &self.cards[i];\n            match card {\n                CardType::Equip => {\n                    return Some((i, Act::new(ActType::None, CardType::Equip, self.pos, None)));\n                }\n\n                CardType::Base(card) => match card {\n                    BaseType::Atk => {\n                        if !self.equip && self.attacked {\n                            continue;\n                        }\n                        let enemy = self.get_enemy_dis1(players);\n                        if enemy.is_some() {\n                            return Some((\n                                i,\n                                Act::new(\n                                    match self.tp {\n                                        Identity::MainPig => ActType::None,\n                                        Identity::ZhongPig => ActType::Zhong,\n                                        Identity::FanPig => ActType::Fan,\n                                    },\n                                    CardType::Base(BaseType::Atk),\n                                    self.pos,\n                                    enemy,\n                                ),\n                            ));\n                        }\n                    }\n                    BaseType::Def => {}\n                    BaseType::Peach => {\n                        if self.hp != Self::MAX_HP {\n                            return Some((\n                                i,\n                                Act::new(\n                                    ActType::None,\n                                    CardType::Base(BaseType::Peach),\n                                    self.pos,\n                                    Some(self.pos),\n                                ),\n                            ));\n                        }\n                    }\n                },\n                CardType::Skill(card) => match card {\n                    SkillType::Fight => {\n                        let enemy = self.get_enemy(players);\n                        if enemy.is_some() {\n                            return Some((\n                                i,\n                                Act::new(\n                                    match self.tp {\n                                        Identity::MainPig => ActType::None,\n                                        Identity::ZhongPig => ActType::Zhong,\n                                        Identity::FanPig => ActType::Fan,\n                                    },\n                                    CardType::Skill(SkillType::Fight),\n                                    self.pos,\n                                    enemy,\n                                ),\n                            ));\n                        }\n                    }\n                    SkillType::ReqAtk => {\n                        return Some((\n                            i,\n                            Act::new(\n                                ActType::None,\n                                CardType::Skill(SkillType::ReqAtk),\n                                self.pos,\n                                None,\n                            ),\n                        ))\n                    }\n                    SkillType::ReqDef => {\n                        return Some((\n                            i,\n                            Act::new(\n                                ActType::None,\n                                CardType::Skill(SkillType::ReqDef),\n                                self.pos,\n                                None,\n                            ),\n                        ))\n                    }\n                    SkillType::Cancel => {}\n                },\n            }\n        }\n        None\n    }\n}\n\nfn main() {\n    let (n, m) = (read() as usize, read() as usize);\n    let mut players = Vec::new();\n    for i in 0..n {\n        players.push(Pig::new(i));\n    }\n    let mut pool = Pool::new(m);\n\n    // game start\n    loop {\n        for now_pig_id in 0..players.len() {\n            if !players[now_pig_id].alive {\n                continue;\n            }\n            // turn start\n            players[now_pig_id].attacked = false;\n            players[now_pig_id].get_card(&mut pool, 2);\n            loop {\n                if !players[now_pig_id].alive {\n                    break;\n                }\n                let act = players[now_pig_id].try_act(&players);\n                if act.is_none() {\n                    break;\n                }\n                let (card_id, act) = act.unwrap();\n                players[now_pig_id].cards.remove(card_id);\n                assert_eq!(act.src, now_pig_id);\n                // use card\n                match act.tp {\n                    ActType::None => {}\n                    ActType::Zhong => players[now_pig_id].state = State::Zhong,\n                    ActType::Fan => players[now_pig_id].state = State::Fan,\n                }\n                match act.card {\n                    CardType::Base(card) => match card {\n                        BaseType::Atk => {\n                            assert!(act.dst.is_some());\n                            players[now_pig_id].attacked = true;\n                            let d = act.dst.unwrap();\n                            let t = players[d].ask(CardType::Base(BaseType::Def));\n                            if let Some(card_id) = t {\n                                players[d].cards.remove(card_id);\n                            } else {\n                                players[d].hp -= 1;\n                                check_dead(&mut players, &mut pool, now_pig_id, d);\n                            }\n                        }\n                        BaseType::Peach => {\n                            assert!(players[now_pig_id].hp < Pig::MAX_HP);\n                            players[now_pig_id].hp += 1;\n                        }\n                        BaseType::Def => unreachable!(),\n                    },\n                    CardType::Skill(card) => match card {\n                        SkillType::Fight => {\n                            // check Cancel\n                            assert!(act.dst.is_some());\n                            let effect = check_cancel(act, &mut players);\n                            if effect {\n                                let mut wait = now_pig_id;\n                                let mut now = act.dst.unwrap();\n                                loop {\n                                    if wait == 0 && players[now].tp == Identity::ZhongPig {\n                                        break;\n                                    }\n                                    let t = players[now].ask(CardType::Base(BaseType::Atk));\n                                    if t.is_none() {\n                                        break;\n                                    };\n                                    players[now].cards.remove(t.unwrap());\n                                    swap(&mut now, &mut wait);\n                                }\n                                players[now].hp -= 1;\n                                check_dead(&mut players, &mut pool, wait, now);\n                            }\n                        }\n                        SkillType::ReqAtk => {\n                            // loop every pig, check Cancel, req atk\n                            let s = now_pig_id;\n                            // s+1, s+2 .. n-1 0 1 .. s-1\n                            let mut range = (0..players.len()).collect::<Vec<_>>();\n                            range.rotate_left(s + 1);\n                            for i in range {\n                                if !players[i].alive || i == s {\n                                    continue;\n                                }\n                                let effect = check_cancel(\n                                    Act::new(\n                                        ActType::None,\n                                        CardType::Skill(SkillType::ReqAtk),\n                                        s,\n                                        Some(i),\n                                    ),\n                                    &mut players,\n                                );\n                                if !effect {\n                                    continue;\n                                }\n                                let t = players[i].ask(CardType::Base(BaseType::Atk));\n                                if let Some(card_id) = t {\n                                    players[i].cards.remove(card_id);\n                                } else {\n                                    players[i].hp -= 1;\n                                    check_dead(&mut players, &mut pool, s, i);\n                                }\n                            }\n                        }\n                        SkillType::ReqDef => {\n                            // same as before\n                            let s = now_pig_id;\n                            // s+1, s+2 .. n-1 0 1 .. s-1\n                            let mut range = (0..players.len()).collect::<Vec<_>>();\n                            range.rotate_left(s + 1);\n                            for i in range {\n                                if !players[i].alive || i == s {\n                                    continue;\n                                }\n                                let effect = check_cancel(\n                                    Act::new(\n                                        ActType::None,\n                                        CardType::Skill(SkillType::ReqDef),\n                                        s,\n                                        Some(i),\n                                    ),\n                                    &mut players,\n                                );\n                                if !effect {\n                                    continue;\n                                }\n                                let t = players[i].ask(CardType::Base(BaseType::Def));\n                                if let Some(card_id) = t {\n                                    players[i].cards.remove(card_id);\n                                } else {\n                                    players[i].hp -= 1;\n                                    check_dead(&mut players, &mut pool, s, i);\n                                }\n                            }\n                        }\n                        SkillType::Cancel => unreachable!(),\n                    },\n                    CardType::Equip => {\n                        players[now_pig_id].equip = true;\n                    }\n                }\n                // end card\n                //println!(\"use card : {} to {:?}\", act.card, act.dst);\n            }\n            // end turn\n            //println!(\"end turn.------------------------\");\n            //out_result(&players);\n        }\n    }\n}\n\nfn check_cancel(act: Act, players: &mut Vec<Pig>) -> bool {\n    let mut now_act = act;\n    let mut effect = true;\n    loop {\n        let res = who_use_cancel(now_act, players);\n        if res.is_none() {\n            break;\n        }\n        let (i, j, tp) = res.unwrap();\n        players[i].cards.remove(j);\n        effect = !effect;\n        now_act = Act::new(tp, CardType::Skill(SkillType::Cancel), i, Some(now_act.src));\n    }\n    effect\n}\n\nfn who_use_cancel(act: Act, players: &mut Vec<Pig>) -> Option<(usize, usize, ActType)> {\n    assert!(act.dst.is_some());\n    let s = act.src;\n    let t = act.dst.unwrap();\n    if !players[t].is_known() && !players[s].is_known() {\n        // both unknown\n        return None;\n    }\n    // s, s+1, ..., n-1, 0, 1, ..., s-1\n    let mut range = (0..players.len()).collect::<Vec<_>>();\n    range.rotate_left(s);\n    for i in range {\n        if !players[i].alive {\n            continue;\n        }\n        match players[i].tp {\n            Identity::MainPig | Identity::ZhongPig => {\n                if (players[t].state == State::Zhong || players[t].tp == Identity::MainPig)\n                    || act.tp == ActType::Fan\n                {\n                    for j in 0..players[i].cards.len() {\n                        if players[i].cards[j] == CardType::Skill(SkillType::Cancel) {\n                            if players[i].tp != Identity::MainPig {\n                                players[i].state = State::Zhong;\n                            }\n                            return Some((i, j, ActType::Zhong));\n                        }\n                    }\n                }\n            }\n            Identity::FanPig => {\n                if players[t].state == State::Fan || act.tp == ActType::Zhong {\n                    for j in 0..players[i].cards.len() {\n                        if players[i].cards[j] == CardType::Skill(SkillType::Cancel) {\n                            players[i].state = State::Fan;\n                            return Some((i, j, ActType::Fan));\n                        }\n                    }\n                }\n            }\n        }\n    }\n    None\n}\n\nfn check_dead(players: &mut Vec<Pig>, pool: &mut Pool, src: usize, dst: usize) {\n    if players[dst].tp == Identity::MainPig && players[src].state == State::None {\n        players[src].state = State::SimFan;\n    }\n    if players[dst].hp <= 0 {\n        let t = players[dst].ask(CardType::Base(BaseType::Peach));\n        if let Some(card_id) = t {\n            players[dst].cards.remove(card_id);\n            players[dst].hp += 1;\n        } else {\n            players[dst].alive = false;\n            players[dst].cards.clear();\n            players[dst].equip = false;\n            // check result\n            check_game_over(players);\n            if players[dst].tp == Identity::FanPig {\n                players[src].get_card(pool, 3);\n            } else if players[dst].tp == Identity::ZhongPig && src == 0 {\n                players[0].cards.clear();\n                players[0].equip = false;\n            }\n        }\n    }\n}\n\nfn check_game_over(players: &Vec<Pig>) {\n    if !players[0].alive {\n        // game over; FP win\n        println!(\"FP\");\n        out_result(players);\n        exit(0);\n    }\n    for pig in players {\n        if pig.tp == Identity::FanPig && pig.alive {\n            return;\n        }\n    }\n    // game over; MP win\n    println!(\"MP\");\n    out_result(players);\n    exit(0);\n}\n\nfn out_result(players: &Vec<Pig>) {\n    for pig in players {\n        if pig.alive {\n            println_card(&pig.cards);\n        } else {\n            println!(\"DEAD\");\n        }\n    }\n}\n\nfn println_card(cards: &Vec<CardType>) {\n    for (i, card) in cards.iter().enumerate() {\n        print!(\"{}\", card);\n        if i < cards.len() - 1 {\n            print!(\" \");\n        }\n    }\n    println!(\"\");\n}\n\nstruct Pool {\n    pool: VecDeque<CardType>,\n    last: Option<CardType>,\n}\nimpl Pool {\n    fn new(cnt: usize) -> Self {\n        let mut pool = VecDeque::new();\n        for _ in 0..cnt {\n            pool.push_back(CardType::from(read_str()));\n        }\n        Self { pool, last: None }\n    }\n    // data is wrong.\n    // if pool is empty, return the last card.\n    fn get(&mut self) -> Option<CardType> {\n        if !self.pool.is_empty() {\n            self.last = self.pool.pop_front();\n        }\n        return self.last;\n    }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "猪国杀",
        "query": "# 猪国杀\n## 题目描述\n### 游戏背景\n\n《猪国杀》是一种多猪牌类回合制游戏，一共有 $3$ 种角色：主猪，忠猪，反猪。每局游戏主猪有且只有 $1$ 只，忠猪和反猪可以有多只，每只猪扮演 $1 $ 种角色。\n\n### 游戏目的\n\n主猪 / $\\texttt{MP}$：自己存活的情况下消灭所有的反猪。  \n忠猪 / $\\texttt{ZP}$：不惜一切保护主猪，胜利条件与主猪相同。  \n反猪 / $\\texttt{FP}$：杀死主猪。\n\n### 游戏过程\n\n游戏开始时，每个玩家手里都会有 $4$ 张牌，且体力上限和初始体力都是 $4$ 。\n\n开始游戏时，从主猪开始，按照逆时针方向（数据中就是按照编号从 $ 1 , 2, 3 \\ldots n , 1 \\ldots $ 的顺序）依次行动。\n\n每个玩家自己的回合可以分为 $2$ 个阶段：\n\n* 摸牌阶段：从牌堆顶部摸 $2$ 张牌，依次放到手牌的最右边；  \n* 出牌阶段：你可以使用任意张牌，每次使用牌的时候都使用最靠左的能够使用的牌。当然，要满足如下规则：\n  1. 如果没有猪哥连弩，每个出牌阶段只能使用 $1$ 次「杀」来攻击；\n  2. 任何牌被使用后被弃置（武器是装备上）；被弃置的牌以后都不能再用，即与游戏无关。\n\n### 各种牌介绍\n\n每张手牌用 $1$ 个字母表示，字母代表牌的种类。\n\n#### 基本牌\n\n- 『桃 / $\\texttt{P}$』在自己的回合内，如果自己的体力值不等于体力上限，那么使用 $1$ 个桃可以为自己补充 $1$ 点体力，否则不能使用桃；桃只能对自己使用；在自己的回合外，如果自己的血变为 $0$ 或者更低，那么也可以使用。\n\n- 『杀 / $\\texttt{K}$』在自己的回合内，对攻击范围内除自己以外的 $1$ 名角色使用。如果没有被『闪』抵消，则造成 $1$ 点伤害。无论有无武器，杀的攻击范围都是 $1$。\n\n- 『闪 / $\\texttt{D}$』当你受到杀的攻击时，可以弃置 $1$ 张闪来抵消杀的效果。\n\n#### 锦囊牌\n\n- 『决斗 / $\\texttt{F}$』出牌阶段，对除自己以外任意 $1$ 名角色使用，由目标角色先开始，自己和目标角色轮流弃置 $1$ 张杀，首先没有杀可弃的一方受到 $1$ 点伤害，另一方视为此伤害的来源。\n\n- 『南猪入侵 / $\\texttt{N}$』出牌阶段，对除你以外所有角色使用，按逆时针顺序从使用者下家开始依次结算，除非弃置 $1$ 张杀，否则受到 $1$ 点伤害。\n\n- 『万箭齐发 / $\\texttt{W}$』和南猪入侵类似，不过要弃置的不是杀而是闪。\n\n- 『无懈可击 / $\\texttt{J}$』在目标锦囊生效前抵消其效果。每次有 $1$ 张锦囊即将生效时，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到使用无懈可击的机会；效果：用于决斗时，决斗无效并弃置；用于南猪入侵或万箭齐发时，当结算到某个角色时才能使用，当前角色不需弃置牌并且不会受到伤害（仅对 $1$ 个角色产生效果）；用于无懈可击时，成为目标的无懈可击被无效。\n\n#### 装备牌\n\n- 『猪哥连弩 / $\\texttt{Z}$』武器，攻击范围 $1$ ，出牌阶段你可以使用任意张杀; 同一时刻最多只能装 $1$ 把武器；如果先前已经有了 $1$ 把武器，那么之后再装武器的话，会弃置以前的武器来装现在的武器。\n\n### 特殊事件及概念解释\n\n* 伤害来源：杀、南猪入侵、万箭齐发的伤害来源均是使用该牌的猪，决斗的伤害来源如上；\n\n* 距离：两只猪的距离定义为沿着逆时针方向间隔的猪数 $+1$ 。即初始时 $1$ 和 $2$ 的距离为 $1$ ，但是 $2$ 和 $1$ 的距离就是 $n-1$ 。注意一个角色的死亡会导致一些猪距离的改变；\n\n* 玩家死亡：如果该玩家的体力降到 $0$ 或者更低，并且自己手中没有足够的桃使得自己的体力值回到 $1$ ，那么就死亡了，死亡后所有的牌（装备区，手牌区）被弃置；\n\n* 奖励与惩罚：反猪死亡时，最后一个伤害来源处（即使是反猪）立即摸 $3$ 张牌。忠猪死亡时，如果最后一个伤害来源是主猪，那么主猪所有装备牌、手牌被弃置。\n\n**注意：** 一旦达成胜利条件，游戏立刻结束，因此即使会摸 $3$ 张牌或者还有牌可以用也不用执行了。\n\n现在，我们已经知道每只猪的角色、手牌，还有牌堆初始情况，并且假设每个角色会按照如下的行为准则进行游戏，你需要做的就是告诉小猪 iPig 最后的结果。\n\n### 几种行为\n\n* 献殷勤：使用无懈可击挡下南猪入侵、万箭齐发、决斗；使用无懈可击抵消表敌意；  \n* 表敌意：对某个角色使用杀、决斗；使用无懈可击抵消献殷勤；  \n* 跳忠：即通过行动表示自己是忠猪。跳忠行动就是对主猪或对某只已经跳忠的猪献殷勤，或者对某只已经跳反的猪表敌意；  \n* 跳反：即通过行动表示自己是反猪。跳反行动就是对主猪或对某只已经跳忠的猪表敌意，或者对某只已经跳反的猪献殷勤。\n\n**注意：** 忠猪不会跳反，反猪也不会跳忠；不管是忠猪还是反猪，能够跳必然跳。\n\n### 行动准则\n\n#### 共性\n\n* 每个角色如果手里有桃且生命值未满，那么必然吃掉；\n* 有南猪入侵、万箭齐发、必然使用；有装备必然装上；\n* 受到杀时，有闪必然弃置；\n* 响应南猪入侵或者万箭齐发时候，有杀 / 闪必然弃置；\n* 不会对未表明身份的猪献殷勤（**包括自己**）。\n\n#### 特性\n\n - 主猪：\n  + 主猪会认为「没有跳身份，且用南猪入侵 / 万箭齐发对自己造成伤害的猪」是**类**反猪（没伤害到不算，注意类反猪并没有表明身份），如果之后跳了，那么主猪会重新认识这只猪；  \n  + 对于每种表敌意的方式，对逆时针方向能够执行到的第一只类反猪或者已跳反猪表；如果没有，那么就不表敌意；\n  + 决斗时会不遗余力弃置杀；\n  + 如果能对已经跳忠的猪或自己献殷勤，那么一定献；如果能够对已经跳反的猪表敌意，那么一定表。\n - 忠猪：\n  + 对于每种表敌意的方式，对「逆时针方向能够执行到的第一只已经跳反的猪」表，如果没有，那么就不表敌意；\n  + 决斗时，如果对方是主猪，那么不会弃置杀，否则，会不遗余力弃置杀；\n  + 如果有机会对主猪或者已经跳忠的猪献殷勤，那么一定献。\n - 反猪：\n  + 对于每种表敌意的方式，如果有机会则对主猪表，否则，对「逆时针方向能够执行到的第一只已经跳忠的猪」表，如果没有，那么就不表敌意；\n  + 决斗时会不遗余力弃置杀；\n  + 如果有机会对已经跳反的猪献殷勤，那么一定献。\n\n限于 iPig 只会用 P++ 语言写 A + B，他请你用 Pigcal (Pascal)、P (C) 或 P++ (C++) 语言来帮他预测最后的结果。\n## 输入格式\n输入文件第一行包含两个正整数 $ n $ $ (2 \\leqslant n \\leqslant 10) $ 和 $m$ $ (m \\leqslant 2000) $，分别代表玩家数和牌堆中牌的数量。数据保证牌的数量够用。\r\n\r\n接下来 $n$ 行，每行 $5$ 个字符串，依次表示对第 $i$ 只猪的角色和初始 $4 $ 张手牌描述。编号为 $1$ 的肯定是主猪。\r\n\r\n再接下来一行，一共 $m$ 个字符串，按照从牌堆顶部到牌堆底部的顺序描述每张牌。\r\n\r\n**注意：** 所有的相邻的两个字符串都严格用 $1$ 个空格隔开，行尾没有多余空格。\n## 输出格式\n输出数据第一行包含一个字符串代表游戏结果。如果是主猪胜利，那么输出 $\\texttt{MP}$ ，否则输出 $\\texttt{FP}$ 。数据保证游戏总会结束。\r\n\r\n接下来 $n$ 行，第 $i$ 行是对第 $i$ 只猪的手牌描述（注意只需要输出手牌），按照手牌从左往右的顺序输出，相邻两张牌用 $1$ 个空格隔开，行末尾没有多余空格。如果这只猪已阵亡，那么只要输出 $\\texttt{DEAD}$ 即可。\r\n\r\n**注意：** 如果要输出手牌而没有手牌的话，那么只需输出 $1$ 个空行。\n## 样例\n输入:\n3 10\nMP D D F F\nZP N N N D\nFP J J J J\nF F D D J J F F K D\n输出:\nFP\nDEAD\nDEAD\nJ J J J J J D\n\n第一回合：\n* 主猪没有目标可以表敌意；\n* 接下来忠猪使用了 $3$ 张南猪入侵，主猪掉了 $3$ 点体力，并认为该角色为类反猪，$3$ 号角色尽管手里有无懈可击，但是因为自己未表明身份，所以同样不能对自己用，乖乖掉 $3$ 点体力；\n\n下一回合：\n* 反猪无牌可出；\n* 接下来主猪对着类反猪爆发，使用 $4$ 张决斗，忠猪死亡，结果主猪弃掉所有牌；\n* 下来反猪摸到 $1$ 张杀直接杀死主猪获胜。\n## 数据范围与提示\n一共 $20$ 组测试数据，每个点 $5$ 分。",
        "sample": {
            "input": "3 10\nMP D D F F\nZP N N N D\nFP J J J J\nF F D D J J F F K D",
            "output": "FP\nDEAD\nDEAD\nJ J J J J J D"
        }
    },
    {
        "code_id": 4,
        "code": "import java.util.Scanner;\n\npublic class Main {\n    public static void main(String[] args) {\n        final int MOD = 1000000007;\n        Scanner sc = new Scanner(System.in);\n        int n, p, m;\n        n = sc.nextInt();\n        p = sc.nextInt();\n        m = sc.nextInt();\n        //a矩阵 np\n        long[][]a = new long[n][p];\n        //b矩阵\n        long [][]b = new long[p][m];\n        //c矩阵\n        long [][]c = new long[n][m];\n\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < p; j++) {\n                a[i][j] = sc.nextInt();\n\n            }\n\n        }\n\n        for (int i = 0; i < p; i++) {\n            for (int j = 0; j < m; j++) {\n                b[i][j] = sc.nextInt();\n\n            }\n\n        }\n\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                for (int k = 0; k < p; k++) {\n                    c[i][j] += (a[i][k] * b[k][j]) % MOD;\n                    c[i][j] += MOD;\n                    c[i][j] %= MOD;\n\n                }\n\n            }\n\n        }\n\n        //输出\n        for (int i = 0; i < n; i++) {\n            for (int j = 0; j < m; j++) {\n                System.out.print(c[i][j] + \" \");\n\n            }\n\n            System.out.println();\n\n        }\n\n    }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "矩阵乘法",
        "query": "# 矩阵乘法\n## 题目描述\n\r\n\r\n分别给定 $ n \\times p $ 和 $ p \\times m $ 的两个矩阵 $ A $ 和 $ B $，求 $ A \\times B $。\n## 输入格式\n第一行三个正整数 $ n $、$ p $、$ m $，表示矩阵的长宽。  \r\n之后的 $ n $ 行，每行 $ p $ 个整数，表示矩阵 $ A $。  \r\n之后的 $ p $ 行，每行 $ m $ 个整数，表示矩阵 $ B $。\n## 输出格式\n输出 $ n $ 行，每行 $ m $ 个整数，表示矩阵 $ A \\times B $，每个数模 $ 10 ^ 9 + 7 $ 输出。\n## 样例\n输入:\n3 4 5\n-2 -8 -9 8\n-10 0 6 -8\n-10 -6 6 9\n4 -7 5 -5 9\n10 -2 -10 5 5\n-3 -7 -3 8 -2\n-6 7 7 3 -2\n输出:\n999999898 149 153 999999929 999999951\n999999997 999999979 999999883 74 999999921\n999999835 103 55 95 999999857\n\n\n## 数据范围与提示\n$ 1 \\leq n, p, m \\leq 500,\\ -10 ^ 9 \\leq A_{i, j}, B_{i, j} \\leq 10 ^ 9 $",
        "sample": {
            "input": "3 4 5\n-2 -8 -9 8\n-10 0 6 -8\n-10 -6 6 9\n4 -7 5 -5 9\n10 -2 -10 5 5\n-3 -7 -3 8 -2\n-6 7 7 3 -2",
            "output": "999999898 149 153 999999929 999999951\n999999997 999999979 999999883 74 999999921\n999999835 103 55 95 999999857"
        }
    },
    {
        "code_id": 7,
        "code": "import java.util.Scanner;\n\npublic class Test {\n    public static void main(String[] args) {\n        final int mod = 1000000007;\n        Scanner sc = new Scanner(System.in);\n        int n = sc.nextInt();\n        int p = sc.nextInt();\n        int m = sc.nextInt();\n        long[][] a = new long[n][p];\n        long[][] b = new long[p][m];\n        long[][] c = new long[n][m];\n        for (int i = 0; i <n ; i++) {\n            for (int j = 0; j <p ; j++) {\n                a[i][j] = sc.nextInt();\n            }\n        }\n        for (int i = 0; i <p; i++) {\n            for (int j = 0; j <m ; j++) {\n                b[i][j] = sc.nextInt();\n            }\n        }\n        //计算时 外两层，与C 统一起来\n        for (int i = 0; i <n ; i++) {\n            for (int j = 0; j <m ; j++) {\n                for (int k = 0; k <p ; k++) {\n                    c[i][j] += (a[i][k]*b[k][j])%mod;//取模， \n                    c[i][j]+=mod;\n                    c[i][j]%=mod;\n                }\n            }\n        }\n\n        for (int i = 0; i <n ; i++) {\n            for (int j = 0; j <m ; j++) {\n                System.out.print(c[i][j]+\" \");\n            }\n            System.out.println();\n        }\n\n    }\n}\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "矩阵乘法",
        "query": "# 矩阵乘法\n## 题目描述\n\r\n\r\n分别给定 $ n \\times p $ 和 $ p \\times m $ 的两个矩阵 $ A $ 和 $ B $，求 $ A \\times B $。\n## 输入格式\n第一行三个正整数 $ n $、$ p $、$ m $，表示矩阵的长宽。  \r\n之后的 $ n $ 行，每行 $ p $ 个整数，表示矩阵 $ A $。  \r\n之后的 $ p $ 行，每行 $ m $ 个整数，表示矩阵 $ B $。\n## 输出格式\n输出 $ n $ 行，每行 $ m $ 个整数，表示矩阵 $ A \\times B $，每个数模 $ 10 ^ 9 + 7 $ 输出。\n## 样例\n输入:\n3 4 5\n-2 -8 -9 8\n-10 0 6 -8\n-10 -6 6 9\n4 -7 5 -5 9\n10 -2 -10 5 5\n-3 -7 -3 8 -2\n-6 7 7 3 -2\n输出:\n999999898 149 153 999999929 999999951\n999999997 999999979 999999883 74 999999921\n999999835 103 55 95 999999857\n\n\n## 数据范围与提示\n$ 1 \\leq n, p, m \\leq 500,\\ -10 ^ 9 \\leq A_{i, j}, B_{i, j} \\leq 10 ^ 9 $",
        "sample": {
            "input": "3 4 5\n-2 -8 -9 8\n-10 0 6 -8\n-10 -6 6 9\n4 -7 5 -5 9\n10 -2 -10 5 5\n-3 -7 -3 8 -2\n-6 7 7 3 -2",
            "output": "999999898 149 153 999999929 999999951\n999999997 999999979 999999883 74 999999921\n999999835 103 55 95 999999857"
        }
    },
    {
        "code_id": 7,
        "code": "\r\nn,m=map(int,input().split());\r\na=[[0 for _ in range(n+5)] for _ in range(m+5)];\r\nf=[[[0 for _ in range(n+5)] for _ in range(m+5)] for _ in range(m+5)];\r\nfor i in range(1,n+1):\r\n  dat=list(map(int,input().split()));\r\n  for j in range(1,m+1):a[i][j]=dat[j-1];\r\nfor lin in range(1,n+1):\r\n  for L in range(m-1,0,-1):\r\n    i,j=1,L;\r\n    while j<=m:\r\n      f[lin][i][j]=max(f[lin][i-1][j]+(a[lin][i-1]<<m-L),f[lin][i][j+1]+(a[lin][j+1]<<m-L));\r\n      i,j=i+1,j+1;\r\nans=0;\r\nfor lin in range(1,n+1):\r\n  tmp=0;\r\n  for i in range(1,m+1):tmp=max(tmp,f[lin][i][i]+(a[lin][i]<<m));\r\n  ans+=tmp;\r\nprint(ans);",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "矩阵取数游戏",
        "query": "# 矩阵取数游戏\n## 题目描述\n帅帅经常和同学玩一个矩阵取数游戏：对于给定的 $n\\times m$ 的矩阵，矩阵中每个元素 $a_{ij}$ 均为非负整数。游戏规则如下：\r\n1. 每次取数时必须从每行各取走一个元素，共 $n$ 个，$m$ 次取完所有元素。\r\n2. 每次取走的各个元素只能是该元素所在行行首或行尾。\r\n3. 每次取数都有一个的分值，为每行取数得分之和，每行取数得分$=$被取走元素值$\\times 2^i$，其中 $i$ 表示第 $i$ 次取数，从 $1$ 开始计数。\r\n4. 游戏结束时，总得分为 $m$ 次取数得分之和。\r\n\r\n帅帅想让你帮忙写一个程序，对于任意矩阵，可以求出取数后的最大得分。\n## 输入格式\n输入包括 $n+1$ 行。\r\n第一行两个空格隔开的正整数 $n,m$\r\n接下来 $n$ 行每行 $m$ 个用空格隔开的整数。\n## 输出格式\n输出为一个整数，为所输入矩阵取数后的最大得分\n## 样例\n### 样例 1\n输入:\n2 3\n1 2 3\n3 4 2\n输出:\n82\n\n第一次：第一行取行首元素，第二行取行尾元素，本次得分为 $1\\times 2^1+2\\times 2^1=6$；\n第二次：两行均取行首元素，本次得分为 $2\\times 2^2+3\\times 2^2=20$；\n第三次：本次得分为 $3\\times 2^3+4\\times 2^3=56$，总得分为 $6+20+56=82$。\n### 样例 2\n输入:\n1 4\n4 5 0 5\n输出:\n122\n\n\n### 样例 3\n输入:\n2 10\n96 56 54 46 86 12 23 88 80 43\n16 95 18 29 30 53 88 83 64 67\n输出:\n316994\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$1\\le n,m\\le 80,0\\le a_{i,j}\\le 1000$。",
        "sample": {
            "input": "2 3\n1 2 3\n3 4 2",
            "output": "82"
        }
    },
    {
        "code_id": 7,
        "code": "from functools import lru_cache\nfrom math import inf\n\n\nn = int(input())\narr =list( map(int, input().split(' ')))\narr = arr*2\n@lru_cache(None)\ndef dp(i,j):\n    if i == j:\n        return 0,0\n    if i+1 == j:\n        return arr[i]+arr[j],arr[i]+arr[j]\n    minres , maxres = inf, -1\n    s = sum(arr[i:j+1])\n    for k in range(i,j):\n        min1,max1 = dp(i,k)\n        min2,max2 = dp(k+1,j)\n        minres = min(minres, min1+min2+s)\n        maxres = max(maxres,max1+max2+s)\n    return minres, maxres\nminres , maxres = inf,-1\nfor i in range(0,n):\n    mn, mx = dp(i,n+i-1)\n    minres = min(minres,mn)\n    maxres = max(maxres,mx)\nprint(minres)\nprint(maxres)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "石子合并",
        "query": "# 石子合并\n## 题目描述\n将 $n$ 堆石子绕圆形操场排放，现要将石子有序地合并成一堆。规定每次只能选相邻的两堆合并成新的一堆，并将新的一堆的石子数记做该次合并的得分。\r\n\r\n请编写一个程序，读入堆数 $n$ 及每堆的石子数，并进行如下计算：\r\n\r\n1. 选择一种合并石子的方案，使得做 $n-1$ 次合并得分总和最大。\r\n2. 选择一种合并石子的方案，使得做 $n-1$ 次合并得分总和最小。\n## 输入格式\n输入第一行一个整数 $n$，表示有 $n$ 堆石子。\r\n\r\n第二行 $n$ 个整数，表示每堆石子的数量。\n## 输出格式\n输出共两行：\r\n\r\n第一行为合并得分总和最小值，\r\n\r\n第二行为合并得分总和最大值。\n## 样例\n输入:\n4\n4 5 9 4\n输出:\n43\n54\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，有 $1\\le n \\le 200$。",
        "sample": {
            "input": "4\n4 5 9 4",
            "output": "43\n54"
        }
    },
    {
        "code_id": 0,
        "code": "var\r\nans:qword;\r\nb,c,bb:array[0..1000]of boolean;\r\nans1,anss,num,n,i,hh,max,inf,xx,x,y,hhh,s1,gds1:longint;\r\ndd,last,next,other,dnf,low,d,sum,gdsum,color:array[0..1000]of longint;\r\nprocedure add(x, y: longint);\r\nbegin\r\n  Inc(num);\r\n  other[num] := y;\r\n  Next[num] := last[x];\r\n  last[x] := num;\r\nend;\r\nprocedure tarjan(fa,x:longint);\r\nvar\r\ni,q,gs,gdgs,ii:longint;\r\nbegin\r\n  //writeln(fa,' ',x);\r\n  i:=last[x];\r\n  ii:=0;\r\n  while i<>0 do\r\n  begin\r\n    q:=other[i];\r\n    if q=fa then begin i:=next[i]; continue;end;\r\n    if dnf[q]<>0 then \r\n    begin\r\n      if c[q] then if dnf[q]<low[x] then low[x]:=dnf[q];\r\n    end\r\n    else\r\n    begin\r\n      inc(ii);\r\n      inc(inf);\r\n      dnf[q]:=inf;\r\n      low[q]:=inf;\r\n      c[q]:=true;\r\n      inc(xx);\r\n      d[xx]:=q;\r\n      tarjan(x,q);\r\n      if low[q]<low[x] then low[x]:=low[q];\r\n      if x<>1 then \r\n      begin\r\n        if (low[q]>=dnf[x]) then b[x]:=true;\r\n      end\r\n      else \r\n      begin\r\n        if ii>1 then b[x]:=true;\r\n      end;\r\n    end;\r\n    i:=next[i];\r\n  end;\r\n  if dnf[x]=low[x] then \r\n  begin\r\n    inc(hh);\r\n    gs:=0;\r\n    gdgs:=0;\r\n    repeat\r\n      color[d[xx]]:=hh;\r\n      inc(gs);\r\n      c[d[xx]]:=false;\r\n      if b[d[xx]] then inc(gdgs);\r\n      dec(xx);\r\n    until d[xx+1]=x;\r\n    \r\n    sum[hh]:=gs;\r\n    gdsum[hh]:=gdgs;\r\n  end;\r\nend;\r\nprocedure dfs(x:longint);\r\nvar\r\ni,q:longint;\r\nbegin\r\n  bb[x]:=true;\r\n  inc(s1);\r\n  if b[x] then begin inc(gds1);exit;end;\r\n  i:=last[x];\r\n  while i<>0 do\r\n  begin\r\n    if not bb[other[i]] then \r\n    dfs(other[i]);\r\n    i:=next[i];\r\n  end;\r\nend;\r\nbegin\r\n  read(n);\r\n  while n<>0 do\r\n  begin\r\n    max:=0;\r\n    fillchar(other,sizeof(other),0);\r\n    fillchar(last,sizeof(last),0);\r\n    fillchar(next,sizeof(next),0);\r\n    num:=0;\r\n    fillchar(dd,sizeof(dd),0);\r\n    for i:=1 to n do\r\n    begin\r\n      read(x,y);\r\n      inc(dd[x]);\r\n      inc(dd[y]);\r\n      add(x,y);\r\n      add(y,x);\r\n      if x>max then max:=x;\r\n      if y>max then max:=y;\r\n    end;\r\n    fillchar(dnf,sizeof(dnf),0);\r\n    fillchar(low,sizeof(low),0);\r\n    xx:=0;\r\n    inf:=0;\r\n    hh:=0;\r\n    fillchar(b,sizeof(b),false);\r\n    fillchar(c,sizeof(c),false);\r\n    for i:=1 to max do\r\n    begin\r\n      if dnf[i]=0 then \r\n      begin\r\n        inc(inf);\r\n        dnf[i]:=inf;\r\n        low[i]:=inf;\r\n        c[i]:=true;\r\n        inc(xx);\r\n        d[xx]:=i;\r\n        tarjan(0,i);\r\n      end;  \r\n    end;\r\n    inc(hhh);\r\n    write('Case ',hhh,': ');\r\n    fillchar(bb,sizeof(bb),false);\r\n    anss:=0;\r\n    ans1:=0;\r\n    ans:=1;\r\n    for i:=1 to max do\r\n      if not bb[i] then \r\n      begin\r\n        inc(anss);\r\n        s1:=0;\r\n        gds1:=0;\r\n        dfs(i);\r\n        if gds1>=2 then continue;\r\n        if gds1=s1 then continue;\r\n        inc(ans1);\r\n        ans:=ans*(gds1-s1);\r\n      end;\r\n    if anss=1 then writeln(2,' ',max*(max-1)div 2)\r\n    else writeln(ans1,' ',ans);\r\n    read(n);\r\n  end;\r\nend.",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "矿场搭建",
        "query": "# 矿场搭建\n## 题目描述\n煤矿工地可以看成是由隧道连接挖煤点组成的无向图。为安全起见，希望在工地发生事故时所有挖煤点的工人都能有一条出路逃到救援出口处。于是矿主决定在某些挖煤点设立救援出口，使得无论哪一个挖煤点坍塌之后，其他挖煤点的工人都有一条道路通向救援出口。\r\n\r\n请写一个程序，用来计算至少需要设置几个救援出口，以及不同最少救援出口的设置方案总数。\n## 输入格式\n输入文件有若干组数据，每组数据的第一行是一个正整数 $N$，表示工地的隧道数，接下来的 $N$ 行每行是用空格隔开的两个整数 $S$ 和 $T$ ，表示挖煤点 $S$ 与挖煤点 $T$ 由隧道直接连接。输入数据以 $0$ 结尾。\n## 输出格式\n输入文件中有多少组数据，输出文件中就有多少行。每行对应一组输入数据的结果。\r\n\r\n其中第 $i$ 行以 `Case i:` 开始（注意大小写，`Case` 与 `i` 之间有空格，`i` 与 `:` 之间无空格，`:` 之后有空格），其后是用空格隔开的两个正整数，第一个正整数表示对于第 $i$ 组输入数据至少需要设置几个救援出口，第二个正整数表示对于第 $i$ 组输入数据不同最少救援出口的设置方案总数。\r\n\r\n输出格式参照以下输入输出样例。\n## 样例\n输入:\n9\n1 3\n4 1\n3 5\n1 2\n2 6\n1 5\n6 3\n1 6\n3 2\n6\n1 2\n1 3\n2 4\n2 5\n3 6\n3 7\n0\n输出:\nCase 1: 2 4\nCase 2: 4 1\n\n`Case 1` 的四组解分别是 $(2,4),(3,4),(4,5),(4,6)$；\n\n`Case 2` 的一组解为 $(4,5,6,7)$。\n## 数据范围与提示\n$N\\le 500$，输入数据保证答案小于 $2^{64}$。",
        "sample": {
            "input": "9\n1 3\n4 1\n3 5\n1 2\n2 6\n1 5\n6 3\n1 6\n3 2\n6\n1 2\n1 3\n2 4\n2 5\n3 6\n3 7\n0",
            "output": "Case 1: 2 4\nCase 2: 4 1"
        }
    },
    {
        "code_id": 10,
        "code": "import java.io.*;\nimport java.lang.reflect.Type;\nimport java.math.BigDecimal;\nimport java.math.BigInteger;\nimport java.math.RoundingMode;\nimport java.text.DecimalFormat;\nimport java.util.*;\nimport java.util.concurrent.ArrayBlockingQueue;\nimport java.util.concurrent.Future;\nimport java.util.concurrent.FutureTask;\nimport java.util.concurrent.locks.LockSupport;\n\npublic class Main {\n\n    static class Task {\n\n        public static String roundS(double result, int scale) {\n            String fmt = String.format(\"%%.%df\", scale);\n            return String.format(fmt, result);\n//        DecimalFormat df = new DecimalFormat(\"0.000000\");\n//        double result = Double.parseDouble(df.format(result));\n        }\n\n        int rt(int x) {\n            if (x != fa[x]) {\n                int to = rt(fa[x]);\n                dp[x] ^= dp[fa[x]];\n                fa[x] = to;\n                return to;\n            }\n            return x;\n        }\n\n        void combine(int x, int y, int val) {\n            int rt1 = rt(x);\n            int rt2 = rt(y);\n\n            if (rt1 == rt2) return;\n\n            fa[rt1] = rt2;\n            dp[rt1] = dp[x] ^ dp[y] ^ val;\n            g--;\n\n        }\n\n\n        int fa[], dp[];\n        int g;\n\n\n        static int MAXN = 10000;\n        static Random rd = new Random(348957438574659L);\n\n        static int[] ch[],val,size,rnd,cnt;\n        static int len=0,rt=0;\n\n        // return new node, the node below s\n        static int rotate(int s,int d){\n            // child\n            int x=ch[s][d^1];\n            // give me grandson\n            ch[s][d^1] = ch[x][d];\n            // child become father\n            ch[x][d]=s;\n            // update size, update new son first\n            update(s);\n            update(x);\n            return x;\n        }\n\n        static void update(int s){\n            size[s] = size[ch[s][0]] + size[ch[s][1]] + cnt[s];\n        }\n\n        // 0 for left, 1 for right\n        static int cmp(int x,int num) {\n            if (val[x] == num) return -1;\n            return num < val[x] ? 0 : 1;\n        }\n\n        static int insert(int s,int num) {\n            if(s==0){\n                s=++len;\n                val[s]=num;size[s]=1;rnd[s]=rd.nextInt();cnt[s] = 1;\n            }else{\n                int d=cmp(s,num);\n                if(d!=-1) {\n                    ch[s][d]=insert(ch[s][d],num);\n                    // father's random should be greater\n                    if(rnd[s]<rnd[ch[s][d]]) {\n                        s=rotate(s,d^1);\n                    }else {\n                        update(s);\n                    }\n                }else{\n                    ++cnt[s];++size[s];\n                }\n            }\n            return s;\n        }\n\n        static int del(int s,int num) {\n            int d = cmp(s, num);\n            if (d != -1) {\n                ch[s][d] = del(ch[s][d], num);\n                update(s);\n            }else if (ch[s][0] * ch[s][1] == 0) {\n                if(--cnt[s]==0){\n                    s = ch[s][0] + ch[s][1];\n                }\n            } else {\n                int k = rnd[ch[s][0]] < rnd[ch[s][1]] ? 0 : 1;\n                // k points to smaller random value,then bigger one up\n                s = rotate(s, k);\n                // now the node with value num become the child\n                ch[s][k] = del(ch[s][k], num);\n                update(s);\n            }\n            return s;\n        }\n\n        static int getKth(int s, int k){\n            int lz = size[ch[s][0]];\n            if(k>=lz+1&&k<=lz+cnt[s]){\n                return val[s];\n            }else if(k<=lz){\n                return getKth(ch[s][0], k);\n            }else{\n                return getKth(ch[s][1], k-lz-cnt[s]);\n            }\n        }\n\n        static int getRank(int s,int value){\n            if(s==0)return 1;\n            if(value==val[s])return size[ch[s][0]] + 1;\n            if(value<val[s])return getRank(ch[s][0],value);\n            return getRank(ch[s][1],value)+size[ch[s][0]] + cnt[s];\n        }\n\n\n        static int getPre(int data){\n            int ans= -1;\n            int p=rt;\n            while(p>0){\n                if(data>val[p]){\n                    if(ans==-1 || val[p]>val[ans])\n                        ans=p;\n                    p=ch[p][1];\n                }\n                else p=ch[p][0];\n            }\n            return ans!=-1?val[ans]:(-2147483647);\n        }\n\n        static int getNext(int data){\n            int ans= -1;\n            int p=rt;\n            while(p>0){\n                if(data<val[p]){\n                    if(ans==-1 || val[p]<val[ans])\n                        ans=p;\n                    p=ch[p][0];\n                }\n                else p=ch[p][1];\n            }\n\n            return ans!=-1?val[ans]:2147483647;\n        }\n\n\n        static boolean find(int s,int num){\n            while(s!=0){\n                int d=cmp(s,num);\n                if(d==-1) return true;\n                else s=ch[s][d];\n            }\n            return false;\n        }\n        static int ans = -10000000;\n        static boolean findX(int s,int num){\n            while(s!=0){\n                if(val[s]<=num){\n                    ans = num;\n                }\n                int d=cmp(s,num);\n                if(d==-1) return true;\n                else {\n                    s = ch[s][d];\n                }\n            }\n            return false;\n        }\n\n        long gcd(long a,long b){\n            if(b==0) return a;\n            return gcd(b,a%b);\n        }\n\n\n        void linear_sort(int arr[]){\n            int d =  65536;\n            ArrayDeque bucket[] = new ArrayDeque[d];\n            for(int j=0;j<d;++j){\n                bucket[j] = new ArrayDeque();\n            }\n            for(int u:arr){\n                bucket[u%d].offer(u);\n            }\n            int pos = 0;\n            for(int j=0;j<d;++j){\n                while(bucket[j].size()>0) {\n                    arr[pos++] = (int)bucket[j].pollFirst();\n                }\n            }\n            for(int u:arr){\n                bucket[u/d].offer(u);\n            }\n            pos = 0;\n            for(int j=0;j<d;++j){\n                while(bucket[j].size()>0) {\n                    arr[pos++] = (int)bucket[j].pollFirst();\n                }\n            }\n        }\n\n        int cur  = 0;\n        int h[];\n        int to[];\n        int ne[];\n        void add(int u,int v){\n            to[cur] = v;\n            ne[cur] = h[u];\n            h[u] = cur++;\n        }\n\n\n        public boolean dfs(String cur,HashMap<String,Integer> vis,Map<String,List<String>> list,int cl){\n\n            vis.put(cur,cl);\n\n            for(String hp:list.get(cur)){\n                if(vis.containsKey(hp)){\n                    if(vis.get(hp)==cl){\n                        return false;\n                    }\n\n                }else{\n                    if(!dfs(hp,vis,list,1-cl)){\n                        return false;\n                    }\n                }\n            }\n            return true;\n\n        }\n\n\n        public class MultiSet {\n\n            TreeMap<Integer,Integer> map;\n            int ct = 0;\n            MultiSet(){\n                map = new TreeMap<>();\n            }\n\n            public void remove(int key){\n                if(map.containsKey(key)){\n                    int times = map.get(key);\n                    if(times==1){\n                        map.remove(key);\n                    }else{\n                        map.put(key,times-1);\n                    }\n                    ct--;\n                }\n            }\n\n            public void add(int key){\n                map.put(key,map.getOrDefault(key,0)+1);\n                ct++;\n            }\n\n            public int last(){\n                return map.lastKey();\n            }\n\n            public int first(){\n                return map.firstKey();\n            }\n\n            public int size(){\n                return ct;\n            }\n\n        }\n\n        BigInteger dp1[][];\n        int x[][];\n        BigInteger s(int l,int r,BigInteger a[]){\n            if(l>=r) return BigInteger.ZERO;\n            if(l+1==r){\n                x[l][r] = l;\n                return (a[l].add(a[r])).multiply(a[l]);\n            }\n            if(!dp1[l][r].equals(BigInteger.valueOf(-1))){\n                return dp1[l][r];\n            }\n            BigInteger ans  = BigInteger.valueOf(Long.MIN_VALUE);\n            for(int j=l;j<r;++j){\n                BigInteger tp =  (a[l].add(a[r])).multiply(a[j]).add(s(l,j,a)).add(s(j+1,r,a));\n                if(tp.compareTo(ans)>0){\n                    ans = tp;\n                    x[l][r] = j;\n                }\n            }\n            return dp1[l][r] = ans;\n        }\n        TreeMap<Integer,ArrayList<Integer>> mp = new TreeMap<>();\n        void ss(int l,int r,int dep){\n            if(l==r)return;\n            int sp = x[l][r];\n            ArrayList<Integer> li = mp.getOrDefault(dep,new ArrayList<>());\n            li.add(sp+1);\n            mp.put(dep,li);\n\n            ss(l,sp,dep+1);\n            ss(sp+1,r,dep+1);\n        }\n\n        int color[],dfn[],low[],stack[];\n        int sccno[];\n\n        boolean iscut[];\n        int time = 0,top = 0;\n        int scc_cnt;\n        int  dcc_cnt;\n        List<Integer> dcc[];\n        int root = 0;\n        //  无向图的强连通分量\n        void tarjanNonDirect(int u) {\n            low[u] = dfn[u]= ++time;\n            stack[top++] = u;\n            int child = 0;\n            for(int i=h[u];i!=-1;i=ne[i]) {\n                int v = to[i];\n                if(dfn[v]==0) {\n                    tarjanNonDirect(v);\n                    low[u]=Math.min(low[u],low[v]);\n                    if(low[v]>=dfn[u]){\n                        if(u!=root||++child>1){     // 不是root，直接记为cut，是root，判断是否有两个儿子\n                            iscut[u] = true;\n                        }\n                        ++dcc_cnt;\n                        // 一个割点可能会被多个点双共享\n                        int z = -1;\n                        do {\n                            z = stack[--top];\n                            //dcc[dcc_cnt].add(z);\n                        } while(z != v);\n                        //dcc[dcc_cnt].add(u);\n                    }\n                } else {\n                    low[u] = Math.min(low[u],dfn[v]);\n                    // 没有特判是否直接指向父亲\n                    // 回边，使用dfn【v】更新low【u】,因为可能是指向父亲，而父亲的low可能比较小\n                }\n            }\n        }\n\n        long dp11[][];\n        public long s(int l,int r,int a[]){\n            if(l>r) return 0;\n            if(dp11[l][r]!=0){\n                return dp11[l][r];\n            }\n            if(l==r){\n                return dp11[l][r] = a[l];\n            }\n            return dp11[l][r] = Math.max((long)a[l] - s(l+1,r,a) , (long)a[r] - s(l, r-1,a));\n        }\n\n        Set<Long> li = new TreeSet<>();\n        HashMap<Long,Boolean> chked= new HashMap<>();\n        void dfs(long s,long ans,int prime[],int cur){\n            if(s==1){\n                li.add(ans);\n                return;\n            }\n            if(cur==p) return;\n            long f = 1;\n            long g = prime[cur];\n\n            long ss = s-1;\n            if(ss>=prime[cur]) {\n\n                boolean ok = true;\n                if(ss<=prime[p-1]){\n                    ok = !visit[(int)ss];\n                }else {\n\n                    if(chked.containsKey(ss)){\n                        ok =  chked.get(ss);\n                    }else {\n\n                        for (long j = 2; j <= ss/j; ++j) {\n                            if (ss % j == 0) {\n                                ok = false;\n                                break;\n                            }\n                        }\n                        chked.put(ss, ok);\n                    }\n\n\n\n\n                }\n\n                if (ok) {\n                    li.add(ans * ss);\n                }\n            }\n\n            if(g*g+g+1>s) return;\n            for(int tm=1;tm<=30;tm++){\n                f += g;\n\n                if(f>s) break;\n                if(s%f==0){\n                    dfs(s/f,ans*g,prime,cur+1);\n                }\n                g *= prime[cur];\n            }\n            dfs(s,ans,prime,cur+1);\n\n\n        }\n        int p = 0;\n        boolean visit[];\n        public void solve(int testNumber, InputReader in, PrintWriter out) {\n\n//            int a[] = {4,3,2,45,1,2,3,4,56,7,2,1,2};\n//            linear_sort(a);\n//            for(int u:a){\n//                out.println(u);\n//            }\n\n                int maxn = 50000;\n                int prime[] = new int[maxn + 1];\n\n                visit = new boolean[maxn + 1];\n                visit[1] = true;\n\n\n                for (int i = 2; i <= maxn; ++i) {\n                    if (!visit[i]) {\n                        prime[p++] = i;\n\n\n                    }\n                    for (int j = 0; j < p; ++j) {\n                        int check = i * prime[j];\n                        if( check > maxn){\n                            break;\n                        }\n                        visit[check] = true;\n\n                        if (i % prime[j] == 0) {\n\n\n                            break;\n                        }\n\n                    }\n                }\n\n\n           for(;true;){\n               int s =-1;\n               li.clear();\n             //  chked.clear();\n               try {\n                   s = in.nextInt();\n               }catch (Exception e){\n                   break;\n               }\n               if(s==1){\n                   out.println(1);\n                   out.println(1);\n                   continue;\n               }\n\n                dfs(s,1L,prime,0);\n\n                out.println(li.size());\n                if(li.size()>0) {\n                    for (long u : li) {\n                        out.print(u + \" \");\n                    }\n                    out.println();\n                }\n\n\n           }\n\n\n\n//            boolean f[] = new boolean[n+1];\n//\n//            long r = 1;\n//            long mod = 1000000007;\n//            for(int j=2;j<=n;++j){\n//                if(!f[j]){\n//\n//                    for(int v=j*j;v<=n;v+=j){\n//                        f[j] = true;\n//                    }\n//                    int nn = n;\n//                    long s = 0;\n//                    while(nn>0){\n//                        s += nn/j;\n//                       // s %= mod;\n//                        nn /= j;\n//                    }\n//                    s *= 2;\n//                    s++;\n//                    s %= mod;\n//                    r *= s;\n//                    r %= mod;\n//                }\n//            }\n//            out.println(r);\n\n\n\n//            int t = 1;\n//\n//\n//            outer:for(int z=1;z<=t;++z) {\n//                int n = in.nextInt();\n//\n//                h = new int[n+1000000];\n//                Arrays.fill(h,-1);\n//                to = new int[10*(n+1000000)];\n//                ne = new int[10*(n+1000000)];\n//\n//\n//\n//                int a[] = in.nextArray(n);\n//\n//\n//                Arrays.sort(a);\n//                int x=  0;\n//                for(int i=0;i<n;++i){\n//                    if(i==0||a[i]!=a[i-1]){\n//                        a[x++] = a[i];\n//                    }\n//                }\n//\n//                int maxn = 10000000;\n//\n//                int tot[] = new int[maxn+1];\n//\n//                for(int u:a){\n//                    tot[u]++;\n//                }\n//\n//                int prime[] = new int[maxn + 1];\n//                int phi[] = new int[maxn+1];\n//                boolean visit[] = new boolean[maxn + 1];\n//                visit[1] = true;\n//                int minfactor[] = new int[maxn+1];\n//                minfactor[1] = 1;\n//                int mu[] = new int[maxn+1];\n//                mu[1]=1;\n//                int p = 0;\n//                for (int i = 2; i <= maxn; ++i) {\n//                    if (!visit[i]) {\n//                        prime[p++] = i;\n//                        // prime\n//                        phi[i] = i-1;\n//                        minfactor[i] = i;\n//                        mu[i] = -1;\n//                    }\n//                    for (int j = 0; j < p; ++j) {\n//                        int check = i * prime[j];\n//                        if( check > maxn){\n//                            break;\n//                        }\n//                        visit[check] = true;\n//                        minfactor[check] = prime[j];\n//                        if (i % prime[j] == 0) {\n//                            phi[ check ] = phi[i] * prime[j];\n//                            mu[ check ] = 0;\n//                            break;\n//                        }\n//                        mu[ check ] = -mu[i];\n//                        phi[ check ] = phi[i] * (prime[j] - 1);\n//                    }\n//                }\n//                int ct[] = new int[maxn+1];\n//                int id[] = new int[maxn+1];\n//                int from = 1;\n//\n//                Map<Integer,Integer> old = new HashMap<>();\n//                for(int i=0;i<x;++i){\n//                    ct[a[i]]++;\n//                    id[a[i]] = from++;\n//                    old.put(from-1,a[i]);\n//                }\n//\n//                for(int i=0;i<p;++i){\n//                    int v = prime[i];\n//                    int cur =  from++;\n//                    for(int j=v;j<=maxn;j+=v){\n//                        if(ct[j]>0){\n//                            add(cur,id[j]);\n//                            add(id[j],cur);\n//                        }\n//                    }\n//                }\n//                low =new int[from+1];\n//                dfn =new int[from+1];\n//                stack = new int[from+1];\n//                iscut = new boolean[from+1];\n//\n//\n//                for(int i=1;i<from;++i){\n//                    tarjanNonDirect(i);\n//                }\n//                int r = 0;\n//                for(int i=1;i<from;++i){\n//                    if(old.containsKey(i)&&iscut[i]&&tot[old.get(i)]==1){\n//                        r++;\n//                    }\n//                }\n//                out.println(r);\n//\n//\n//\n//\n//            }\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n//            while(true) {\n//                int n = in.nextInt();\n//\n//                int m  =in.nextInt();\n//\n//                fa = new int[n];\n//                dp = new int[n];\n//                for(int i=0;i<n;++i){\n//                    fa[i] = i;\n//                }\n//                g =  n;\n//                int c = 0;\n//                int as[] = new int[n];\n//                int bs[] = new int[n];\n//                char xs[] = new char[n];\n//\n//                int at = -1;\n//                Set<Integer> st = new HashSet<>();\n//\n//                for (int i = 0; i < n; ++i) {\n//                    String line = in.next();\n//                    int p = 0;\n//                    int a = 0;\n//                    while(Character.isDigit(line.charAt(p))){\n//                        a =  a*10 + (line.charAt(p)-'0'); p++;\n//                    }\n//                    char x = line.charAt(p++);\n//\n//                    int b = 0;\n//                    while(p<line.length()){\n//                        b =  b*10 + (line.charAt(p)-'0'); p++;\n//                    }\n//\n//                    as[i] = a;\n//                    xs[i] = x;\n//                    bs[i] = b;\n//\n//                    if(x=='='){\n//                        int r1 = rt(a); int r2 = rt(b);\n//                        if(r1==r2){\n//                            if(dp[a]!=dp[b]){\n//                                c++;\n//                                at = i;\n//                            }\n//                        }else {\n//                            combine(a, b, 0);\n//                        }\n//                    }else if(x=='<'){\n//                        int r1 = rt(a); int r2 = rt(b);\n//                        if(r1==r2){\n//                            if(dp[a]>=dp[b]){\n//                                c++;\n//                                at = i;\n//                            }\n//                        }else {\n//                            combine(a, b, -1);\n//                        }\n//                    }else{\n//                        int r1 = rt(a); int r2 = rt(b);\n//                        if(r1==r2){\n//                            if(dp[a]<=dp[b]){\n//                                c++;\n//                                at = i;\n//                            }\n//                        }else {\n//                            combine(a, b, 1);\n//                        }\n//                    }\n//\n//\n//                }\n//                if(g==1||c>=2){\n//                    out.println(\"Impossible\");\n//                    continue;\n//                }\n//\n//\n//                for(int xuan: st){\n//\n//\n//\n//\n//                }\n//\n//\n//\n//\n//\n//\n//            }\n\n\n\n\n\n\n        }\n\n\n        static long mul(long a, long b, long p)\n        {\n            long res=0,base=a;\n            while(b>0)\n            {\n                if((b&1L)>0)\n                    res=(res+base)%p;\n                base=(base+base)%p;\n                b>>=1;\n            }\n            return res;\n        }\n\n        static long mod_pow(long k,long n,long p){\n            long res = 1L;\n            long temp = k%p;\n            while(n!=0L){\n                if((n&1L)==1L){\n                    res = mul(res,temp,p);\n                }\n                temp = mul(temp,temp,p);\n                n = n>>1L;\n            }\n            return res%p;\n        }\n\n\n        public static double roundD(double result, int scale){\n            BigDecimal bg = new BigDecimal(result).setScale(scale, RoundingMode.UP);\n            return bg.doubleValue();\n        }\n\n\n\n    }\n    private static void solve() {\n        InputStream inputStream = System.in;\n//        InputStream inputStream  = null;\n//        try {\n//            inputStream = new FileInputStream(new File(\"D:\\\\chrome_download\\\\travel_restrictions_input.txt\"));\n//        } catch (FileNotFoundException e) {\n//            e.printStackTrace();\n//        }\n        OutputStream outputStream = System.out;\n//        OutputStream outputStream = null;\n//        File f = new File(\"D:\\\\chrome_download\\\\travel_restrictions_output.txt\");\n//        try {\n//            f.createNewFile();\n//        } catch (IOException e) {\n//            e.printStackTrace();\n//        }\n//        try {\n//            outputStream = new FileOutputStream(f);\n//        } catch (FileNotFoundException e) {\n//            e.printStackTrace();\n//        }\n        InputReader in = new InputReader(inputStream);\n        PrintWriter out = new PrintWriter(outputStream);\n        Task task = new Task();\n        task.solve(1, in, out);\n        out.close();\n    }\n    public static void main(String[] args) {\n         new Thread(null, () -> solve(), \"1\", (1 << 20 ) ).start();\n        //solve();\n    }\n    static class InputReader {\n        public BufferedReader reader;\n        public StringTokenizer tokenizer;\n        public InputReader(InputStream stream) {\n            reader = new BufferedReader(new InputStreamReader(stream), 32768);\n            tokenizer = null;\n        }\n        public String nextLine() {\n            String line = null;\n            try {\n                line = reader.readLine();\n            } catch (IOException e) {\n                throw new RuntimeException(e);\n            }\n            return line;\n        }\n        public String next() {\n            while (tokenizer == null || !tokenizer.hasMoreTokens()) {\n                try {\n                    tokenizer = new StringTokenizer(reader.readLine());\n                } catch (IOException e) {\n                    throw new RuntimeException(e);\n                }\n            }\n            return tokenizer.nextToken();\n        }\n        public int nextInt() {\n            return Integer.parseInt(next());\n        }\n        public char nextChar() {\n            return next().charAt(0);\n        }\n        public int[] nextArray(int n) {\n            int res[] = new int[n];\n            for (int i = 0; i < n; ++i) {\n                res[i] = nextInt();\n            }\n            return res;\n        }\n        public long nextLong() {\n            return Long.parseLong(next());\n        }\n        public double nextDouble() {\n            return Double.parseDouble(next());\n        }\n    }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "聪明的燕姿",
        "query": "# 聪明的燕姿\n## 题目描述\n城市中人们总是拿着号码牌，不停寻找，不断匹配，可是谁也不知道自己等的那个人是谁。  \r\n可是燕姿不一样，燕姿知道自己等的人是谁，因为燕姿数学学得好！燕姿发现了一个神奇的算法：假设自己的号码牌上写着数字 $S$，那么自己等的人手上的号码牌数字的所有正约数之和必定等于 $S$。  \r\n所以燕姿总是拿着号码牌在地铁和人海找数字（喂！这样真的靠谱吗）可是她忙着唱《绿光》，想拜托你写一个程序能够快速地找到所有自己等的人。\n## 输入格式\n输入包含 $k$ 组数据。  \r\n对于每组数据，输入包含一个号码牌$S$。\n## 输出格式\n对于每组数据，输出有两行，第一行包含一个整数 $m$，表示有 $m$ 个等的人。  \r\n第二行包含相应的 $m$ 个数，表示所有等的人的号码牌。\r\n\r\n**注意**：你输出的号码牌必须按照升序排列。\n## 样例\n输入:\n42\n输出:\n3\n20 26 41\n\n\n## 数据范围与提示\n对于 $100\\%$ 的数据，$k \\leq 100,\\ S \\leq 2 \\times 10^9$。",
        "sample": {
            "input": "42",
            "output": "3\n20 26 41"
        }
    },
    {
        "code_id": 2,
        "code": "import java.io.*;\nimport java.util.*;\n\npublic class Main{\n    static int N = 100010;\n    static int[] h = new int[N],e = new int[N],ne = new int[N],in = new int[N];\n    static int[] st = new int[N];\n    static int idx = 0;\n    public static void main(String[] args)throws IOException{\n        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));\n        \n        int t = Integer.parseInt(br.readLine());\n        while(--t>=0){\n            String[] d = br.readLine().split(\" \");\n            int n = Integer.parseInt(d[0]),\n            m = Integer.parseInt(d[1]);\n            Arrays.fill(h,-1);\n            Arrays.fill(in,0);\n            idx = 0;\n            List<Integer> ans = new ArrayList<>();\n            while(--m>=0){\n                d = br.readLine().split(\" \");\n                int a = Integer.parseInt(d[0]),\n                b = Integer.parseInt(d[1]);\n                add(b,a);\n                in[a]++;\n            }\n            \n            PriorityQueue<Integer> q = new PriorityQueue<>((o1,o2)->o2-o1);\n            for(int i = 1;i<=n;i++)\n                if(in[i] == 0) q.add(i);\n            \n            while(!q.isEmpty()){\n                var x = q.poll();\n                ans.add(x);\n                for(int i = h[x];i!=-1;i = ne[i]){\n                    int j = e[i];\n                    in[j] --;\n                    if(in[j] == 0) q.add(j);\n                }\n            }\n            if(ans.size()!=n)bw.write(\"Impossible!\");\n            else for(int i = ans.size()-1;i>=0;i--) bw.write(ans.get(i)+\" \");\n            bw.write(\"\\n\");\n        }\n        bw.flush();\n        bw.close();\n        br.close();\n    }\n    public static void add(int a,int b){\n        e[idx] = b;\n        ne[idx] = h[a];\n        h[a] = idx++;\n    }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "菜肴制作",
        "query": "# 菜肴制作\n## 题目描述\n知名美食家小 A 被邀请至 ATM 大酒店，为其品评菜肴。?\r\n\r\nATM 酒店为小 A 准备了 $N$ 道菜肴，酒店按照为菜肴预估的质量从高到低给予 $1$ 到 $N$ 的顺序编号，预估质量最高的菜肴编号为 $1$。由于菜肴之间口味搭配的问题，某些菜肴必须在另一些菜肴之前制作，具体的，一共有 $M$ 条形如「$i$ 号菜肴『必须』先于 $j$ 号菜肴制作”的限制」，我们将这样的限制简写为 $\\langle i,j \\rangle$。\r\n\r\n现在，酒店希望能求出一个最优的菜肴的制作顺序，使得小 A 能尽量先吃到质量高的菜肴：也就是说，\r\n\r\n1. 在满足所有限制的前提下，$1$ 号菜肴「尽量」优先制作；\r\n2. 在满足所有限制，$1$ 号菜肴「尽量」优先制作的前提下，$2$ 号菜肴「尽量」优先制作；\r\n3. 在满足所有限制，$1$ 号和 $2$ 号菜肴「尽量」优先的前提下，$3$ 号菜肴「尽量」优先制作；\r\n4. 在满足所有限制，$1$ 号和 $2$ 号和 $3$ 号菜肴「尽量」优先的前提下，4 号菜肴「尽量」优先制作；\r\n5. 以此类推。?\r\n\r\n例一：共四道菜肴，两条限制 $\\langle 3,1 \\rangle$、$\\langle 4,1 \\rangle$，那么制作顺序是 $3,4,1,2$。\r\n\r\n例二：共五道菜肴，两条限制 $\\langle 5,2 \\rangle$、$\\langle 4,3 \\rangle$，那么制作顺序是 $1,5,2,4,3$。\r\n\r\n例一里，首先考虑 $1$，因为有限制 $\\langle 3,1 \\rangle$ 和 $\\langle 4,1 \\rangle$，所以只有制作完 $3$ 和 $4$ 后才能制作 $1$，而根据(3)，$3$ 号又应「尽量」比 $4$ 号优先，所以当前可确定前三道菜的制作顺序是 $3,4,1$；接下来考虑 $2$，确定最终的制作顺序是 $3,4,1,2$。\r\n\r\n例二里，首先制作 $1$ 是不违背限制的；接下来考虑 $2$ 时有 $\\langle 5,2 \\rangle$ 的限制，所以接下来先制作 $5$ 再制作 $2$；接下来考虑 $3$ 时有 $\\langle 4,3 \\rangle$ 的限制，所以接下来先制作 $4$ 再制作 $3$，从而最终的顺序是 $1,5,2,4,3$。\r\n?\r\n现在你需要求出这个最优的菜肴制作顺序。无解输出“``Impossible!``” （不含引号，首字母大写，其余字母小写）\n## 输入格式\n第一行是一个正整数 $D$，表示数据组数。  \r\n接下来是 $D$ 组数据。?  \r\n对于每组数据：?  \r\n第一行两个用空格分开的正整数 $N$ 和 $M$，分别表示菜肴数目和制作顺序限制的条目数。  \r\n接下来 $M$ 行，每行两个正整数 $x,y$，表示「$x$ 号菜肴必须先于 $y$ 号菜肴制作」的限制。（注意：$M$ 条限制中可能存在完全相同的限制）\n## 输出格式\n输出文件仅包含 $D$ 行，每行 $N$ 个整数，表示最优的菜肴制作顺序，或者”``Impossible!``”表示无解（不含引号）。\n## 样例\n输入:\n3\n5 4\n5 4\n5 3\n4 2\n3 2\n3 3\n1 2\n2 3\n3 1\n5 2\n5 2\n4 3\n输出:\n1 5 3 4 2\nImpossible!\n1 5 2 4 3\n\n第二组数据同时要求菜肴 $1$ 先于菜肴 $2$ 制作，菜肴 $2$ 先于菜肴 $3$ 制作，菜肴 $3$ 先于菜肴 $1$ 制作，而这是无论如何也不可能满足的，从而导致无解。\n## 数据范围与提示\n对于$100 \\%$ 的数据，$N,M \\leq 100000,\\ D \\leq 3$。",
        "sample": {
            "input": "3\n5 4\n5 4\n5 3\n4 2\n3 2\n3 3\n1 2\n2 3\n3 1\n5 2\n5 2\n4 3",
            "output": "1 5 3 4 2\nImpossible!\n1 5 2 4 3"
        }
    },
    {
        "code_id": 2,
        "code": "N, M = int(3e6) + 5, 998244353\nfac, big = [0] * N, [0] * N\nfac[0] = big[1] = 1\nfor i in range(1, N - 1):\n\tfac[i] = fac[i - 1] * i % M\n\tbig[i + 1] = big[i] * fac[i] % M\n# print(big, fac)\nfor tc in range(int(input())):\n\tA, B, C = map(int, reversed(sorted(input().split())))\n\tA = min(A, B + C)\n\tp, q, r = A + B - C, A - B + C, -A + B + C\n\t# print(A, B, C, p, q, r)\n\tprint(p * q + q * r + r * p, 1 if B + C <= A else big[p + q + r] * big[p] * big[q] * big[r] * pow(big[p + q] * big[q + r] * big[r + p] % M, -1, M) % M)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "计算几何",
        "query": "# 计算几何\n## 题目描述\n九条可怜是一个喜欢计算几何的女孩子，她画了一个特别的平面坐标系，其中 $x$ 轴正半轴与 $y$ 轴正半轴夹角为 $60$ 度。\n\n从中，她取出所有横纵坐标不全为偶数，且满足 $-2 a + 1 \\le x \\le 2 a - 1$，$-2 b + 1 \\le y \\le 2 b - 1$，$-2 c + 1 \\le x + y \\le 2 c - 1$ 的整点。\n\n可怜想将其中一些点染色，但相邻的点不能同时染色。具体地，对于点 $(x, y)$，它和 $(x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y), (x + 1, y - 1), (x - 1, y + 1)$ 六个点相邻，可结合样例解释理解。\n\n可怜想知道在这个规则下最多能将多少点染色，以及染最多点的染色方案数。由于后者值可能很大，对于染色方案数，你只需要输出对 $998244353$ 取模后的结果。**注意不需要将最多染色点数取模。**\n## 输入格式\n第一行一个整数 $T$ 代表数据组数。\n\n接下来 $T$ 行，每行三个整数 $a, b, c$ 代表一组数据。\n## 输出格式\n输出共 $T$ 行，每行两个整数，代表最多能染的点数（**不取模**）和方案数对 $998244353$ 取模的结果。\n## 样例\n输入:\n6\n2 1 2\n1 1 137\n3 94 95\n3 1998 1996\n998244 353999 999999\n50 120 150\n\n输出:\n7 4\n4 1\n1124 31585548\n23951 33873190\n1289433675488 748596399\n23600 480090154\n\n\n## 数据范围与提示\n对于所有测试点：$1 \\le T \\le 10$，$1 \\le a, b, c \\le {10}^6$。\n\n",
        "sample": {
            "input": "6\n2 1 2\n1 1 137\n3 94 95\n3 1998 1996\n998244 353999 999999\n50 120 150\n",
            "output": "7 4\n4 1\n1124 31585548\n23951 33873190\n1289433675488 748596399\n23600 480090154\n"
        }
    },
    {
        "code_id": 8,
        "code": "import java.io.PrintWriter;\nimport java.util.*;\n\npublic class Main {\n    public static void main(String[] args) {\n        Scanner in = new Scanner(System.in);\n        PrintWriter out = new PrintWriter(System.out);\n        int K = in.nextInt(), N = in.nextInt();\n        int[] problemsPerPart = new int[K + 1];\n        for (int i = 1; i <= K; i++) problemsPerPart[i] = in.nextInt();\n        List<Node> nodeList = new ArrayList<>();\n        Node source = new Node(-1), sink = new Node(-2);\n        int idx = 0;\n        nodeList.add(source);\n        nodeList.add(sink);\n        Node[] left = new Node[N + 1], right = new Node[K + 1];\n        for (int i = 1; i <= N; i++) {\n            left[i] = new Node(++idx);\n            left[i].index = i;\n            nodeList.add(left[i]);\n            source.addEdge(left[i], 1);\n        }\n\n        for (int i = 1; i <= K; i++) {\n            right[i] = new Node(++idx);\n            right[i].index = i;\n            nodeList.add(right[i]);\n            right[i].addEdge(sink, problemsPerPart[i]);\n        }\n\n        for (int i = 1; i <= N; i++) {\n            int numPart = in.nextInt();\n            for (int j = 1; j <= numPart; j++) {\n                int currPart = in.nextInt();\n                left[i].addEdge(right[currPart], 1);\n            }\n        }\n\n        Graph graph = new Graph(nodeList, source, sink);\n        int maxFlow = MaxFlow.maximizeFlow(graph);\n        for (Edge e : sink.getEdges()) {\n            if (e.getBackwards().getResidual() > 0) {\n                out.println(\"No Solution!\");\n                out.flush();\n                return;\n            }\n        }\n        List<Integer> temp = new ArrayList<>();\n        for (int i = 1; i <= K; i++) {\n            out.print(String.format(\"%d: \", i));\n            temp = new ArrayList<>();\n            for (Edge edge : right[i].getEdges()) {\n                if (edge.getTo() == sink || edge.getBackwards().getFlow() == 0) continue;\n                temp.add(edge.getTo().index);\n            }\n            Collections.sort(temp);\n            for (Integer index : temp) out.print(index + \" \");\n            out.print(\"\\n\");\n        }\n        out.flush();\n    }\n}\n\nclass Graph {\n\n    private List<Node> nodes;\n\n    private Node source;\n\n    private Node sink;\n\n    public Graph(List<Node> nodes) {\n        this.nodes = nodes;\n        this.source = null;\n        this.sink = null;\n    }\n\n    public Graph(List<Node> nodes, Node source, Node sink) {\n        this.nodes = nodes;\n        this.source = source;\n        this.sink = sink;\n    }\n\n    public Node getSink() {\n        return sink;\n    }\n\n    public Node getSource() {\n        return source;\n    }\n\n    public List<Node> getNodes() {\n        return nodes;\n    }\n\n    public boolean equals(Object other) {\n        if (other instanceof Graph) {\n            Graph that = (Graph) other;\n            return this.nodes.equals(that.nodes);\n        }\n        return false;\n    }\n\n    public boolean hasCirculation() {\n        this.removeLowerBounds();\n        int D = this.removeSupplyDemand();\n        int x = MaxFlow.maximizeFlow(this);\n        return x == D;\n    }\n\n    private void removeLowerBounds() {\n        for (Node n : this.getNodes()) {\n            for (Edge e : n.edges) {\n                if (e.lower > 0) {\n                    e.capacity -= e.lower;\n                    e.backwards.capacity -= e.lower;\n                    e.backwards.flow -= e.lower;\n                    e.from.d += e.lower;\n                    e.to.d -= e.lower;\n                    e.lower = 0;\n                }\n            }\n        }\n    }\n\n    private int removeSupplyDemand() {\n        int Dplus = 0, Dmin = 0;\n        int maxId = 0;\n        for (Node n : this.getNodes()) {\n            maxId = Math.max(n.id, maxId);\n        }\n        Node newSource = new Node(maxId + 1, 0);\n        Node newSink = new Node(maxId + 2, 0);\n        for (Node n : this.getNodes()) {\n            if (n.d < 0) {\n                newSource.addEdge(n, 0, -n.d);\n                Dmin -= n.d;\n            } else if (n.d > 0) {\n                n.addEdge(newSink, 0, n.d);\n                Dplus += n.d;\n            }\n            n.d = 0;\n        }\n        if (Dmin != Dplus) {\n            throw new IllegalArgumentException(\"Demand and supply are not equal!\");\n        }\n        this.nodes.add(newSource);\n        this.nodes.add(newSink);\n        this.source = newSource;\n        this.sink = newSink;\n        return Dplus;\n    }\n}\n\nclass Node {\n\n    protected int id;\n\n    protected int d;\n    public int index;\n\n    protected Collection<Edge> edges;\n\n    /**\n     * Create a new node\n     *\n     * @param id: Id for the node.\n     */\n    public Node(int id) {\n        this(id, 0);\n    }\n\n    /**\n     * Create a new node\n     *\n     * @param id: Id for the node.\n     * @param d: demand for the node. Remember that supply is represented as a negative demand.\n     */\n    public Node(int id, int d) {\n        this.id = id;\n        this.d = d;\n        this.edges = new ArrayList<Edge>();\n    }\n\n    public void addEdge(Node destination, int capacity) {\n        this.addEdge(destination, 0, capacity);\n    }\n\n    public void addEdge(Node to, int lower, int upper) {\n        Edge e = new Edge(lower, upper, this, to);\n        edges.add(e);\n        to.getEdges().add(e.getBackwards());\n    }\n\n    public Collection<Edge> getEdges() {\n        return edges;\n    }\n\n    public int getId() {\n        return id;\n    }\n\n    public boolean equals(Object other) {\n        if (other instanceof Node) {\n            Node that = (Node) other;\n            if (id == that.getId()) return edges.equals(that.getEdges());\n        }\n        return false;\n    }\n\n    public String toString() {\n        StringBuilder sb = new StringBuilder();\n        sb.append(this.getId());\n        sb.append(\" \");\n        sb.append(this.getEdges().size());\n        sb.append(\":\");\n        for (Edge e : this.getEdges()) {\n            sb.append(\"(\");\n            sb.append(e.from.getId());\n            sb.append(\" --[\");\n            sb.append(e.lower);\n            sb.append(',');\n            sb.append(e.capacity);\n            sb.append(\"]-> \");\n            sb.append(e.to.getId());\n            sb.append(\")\");\n        }\n        return sb.toString();\n    }\n}\n\nclass Edge {\n\n    protected int lower;\n\n    protected int capacity;\n\n    protected int flow;\n\n    protected Node from;\n\n    protected Node to;\n\n    protected Edge backwards;\n\n    private Edge(Edge e) {\n        this.lower = 0;\n        this.flow = e.getCapacity();\n        this.capacity = e.getCapacity();\n        this.from = e.getTo();\n        this.to = e.getFrom();\n        this.backwards = e;\n    }\n\n    protected Edge(int lower, int capacity, Node from, Node to) {\n        this.lower = lower;\n        this.capacity = capacity;\n        this.from = from;\n        this.to = to;\n        this.flow = 0;\n        this.backwards = new Edge(this);\n    }\n\n    public void augmentFlow(int add) {\n        assert (flow + add <= capacity);\n        flow += add;\n        backwards.setFlow(getResidual());\n    }\n\n    public Edge getBackwards() {\n        return backwards;\n    }\n\n    public int getCapacity() {\n        return capacity;\n    }\n\n    public int getFlow() {\n        return flow;\n    }\n\n    public Node getFrom() {\n        return from;\n    }\n\n    public int getResidual() {\n        return capacity - flow;\n    }\n\n    public Node getTo() {\n        return to;\n    }\n\n    private void setFlow(int f) {\n        assert (f <= capacity);\n        this.flow = f;\n    }\n\n    public boolean equals(Object other) {\n        if (other instanceof Edge) {\n            Edge that = (Edge) other;\n            return this.capacity == that.capacity\n                    && this.flow == that.flow\n                    && this.from.getId() == that.getFrom().getId()\n                    && this.to.getId() == that.getTo().getId();\n        }\n        return false;\n    }\n}\n\nclass MaxFlow {\n\n    private static List<Edge> findPath(Graph g, Node start, Node end) {\n        Map<Node, Edge> mapPath = new HashMap<Node, Edge>();\n        Queue<Node> sQueue = new LinkedList<Node>();\n        Node currentNode = start;\n        sQueue.add(currentNode);\n        while (!sQueue.isEmpty() && currentNode != end) {\n            currentNode = sQueue.remove();\n            for (Edge e : currentNode.getEdges()) {\n                Node to = e.getTo();\n                if (to != start && mapPath.get(to) == null && e.getResidual() > 0) {\n                    sQueue.add(e.getTo());\n                    mapPath.put(to, e);\n                }\n            }\n        }\n        if (sQueue.isEmpty() && currentNode != end) return null;\n        LinkedList<Edge> path = new LinkedList<Edge>();\n        Node current = end;\n        while (mapPath.get(current) != null) {\n            Edge e = mapPath.get(current);\n            path.addFirst(e);\n            current = e.getFrom();\n        }\n        return path;\n    }\n\n    public static int maximizeFlow(Graph g) {\n        int f = 0;\n        Node sink = g.getSink();\n        Node source = g.getSource();\n        List<Edge> path;\n        while ((path = findPath(g, source, sink)) != null) {\n            int r = Integer.MAX_VALUE;\n            for (Edge e : path) {\n                r = Math.min(r, e.getResidual());\n            }\n            for (Edge e : path) {\n                e.augmentFlow(r);\n            }\n            f += r;\n        }\n        return f;\n    }\n}\n\n\n",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "试题库",
        "query": "# 试题库\n## 题目描述\n假设一个试题库中有 $ n $ 道试题。每道试题都标明了所属类别。同一道题可能有多个类别属性。现要从题库中抽取 $ m $ 道题组成试卷。并要求试卷包含指定类型的试题。试设计一个满足要求的组卷算法。\n## 输入格式\n第 $ 1 $ 行有 $ 2 $ 个正整数 $ k $ 和 $ n $。$ k $ 表示题库中试题类型总数，$ n $ 表示题库中试题总数。第 $ 2 $ 行有 $ k $ 个正整数，第 $ i $ 个正整数表示要选出的类型 $ i $ 的题数。这 $ k $ 个数相加就是要选出的总题数 $ m $。\r\n\r\n接下来的 $ n $ 行给出了题库中每个试题的类型信息。每行的第 $ 1 $ 个正整数 $ p $ 表明该题可以属于 $ p $ 类，接着的 $ p $ 个数是该题所属的类型号。\n## 输出格式\n第 $ i $ 行输出 `i:` 后接类型 $ i $ 的题号。如果有多个满足要求的方案，只要输出一个方案。如果问题无解，则输出 `No Solution!`。\n## 样例\n输入:\n3 15\n3 3 4\n2 1 2\n1 3\n1 3\n1 3\n1 3\n3 1 2 3\n2 2 3\n2 1 3\n1 2\n1 2\n2 1 2\n2 1 3\n2 1 2\n1 1\n3 1 2 3\n输出:\n1: 1 6 8\n2: 7 9 10\n3: 2 3 4 5\n\n\n## 数据范围与提示\n$ 2 \\leq k \\leq 20, k \\leq n \\leq 1000 $",
        "sample": {
            "input": "3 15\n3 3 4\n2 1 2\n1 3\n1 3\n1 3\n1 3\n3 1 2 3\n2 2 3\n2 1 3\n1 2\n1 2\n2 1 2\n2 1 3\n2 1 2\n1 1\n3 1 2 3",
            "output": "1: 1 6 8\n2: 7 9 10\n3: 2 3 4 5"
        }
    },
    {
        "code_id": 16,
        "code": "import java.util.Scanner;\nimport java.util.Random;\n\npublic final class MillerRabin {\n\n    private static final int[] PRIME = {2, 3, 5, 7, 11, 61, 24251};\n    private static final Random RANDOM = new Random();\n\n    public static void main(String[] args) {\n        Scanner scanner = new Scanner(System.in);\n        while (scanner.hasNextLong()) {\n            long n = scanner.nextLong();\n            System.out.println(judge(n) ? \"Y\" : \"N\");\n        }\n        scanner.close();\n    }\n\n    private static boolean judge(long n) {\n        if (n == 1) return false;\n        for (int prime : PRIME) {\n            if (n == prime) return true;\n            if (n % prime == 0) return false;\n            if (!millerRabinTest(prime, n)) return false;\n        }\n        for (int i = 0; i < 10; i++) {\n            if (!millerRabinTest(2 + Math.abs(RANDOM.nextLong()) % (n - 2), n)) return false;\n        }\n        return true;\n    }\n\n    private static boolean millerRabinTest(long a, long p) {\n        long s = p - 1;\n        while ((s & 1) == 0) s >>= 1;\n        long k = modExp(a, s, p);\n        while (s != p - 1 && k != 1 && k != p - 1) {\n            k = modMul(k, k, p);\n            s <<= 1;\n        }\n        return k == p - 1 || (s & 1) == 1;\n    }\n\n    private static long modExp(long base, long exp, long mod) {\n        long result = 1;\n        while (exp > 0) {\n            if ((exp & 1) == 1) result = modMul(result, base, mod);\n            base = modMul(base, base, mod);\n            exp >>= 1;\n        }\n        return result % mod;\n    }\n\n    private static long modMul(long x, long y, long mod) {\n        x %= mod;\n        y %= mod;\n        long result = 0;\n        while (y > 0) {\n            if ((y & 1) == 1) result = (result + x) % mod;\n            x = (x * 2) % mod;\n            y >>= 1;\n        }\n        return result;\n    }\n}",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "质数判定",
        "query": "质数判定\n题目描述\n判定输入的数是不是质数。\n输入格式\n若干行，一行一个数 $x$。\r\n\r\n行数不超过 $10^5$。\n输出格式\n对于输入的每一行，如果 $x$ 是质数输出一行 `Y`，否则输出一行 `N`。\n样例\n输入:\n1\n2\n6\n9\n666623333\n输出:\nN\nY\nN\nN\nY\n\n\n数据范围与提示\n$1 \\leq x \\leq 10^{18}$。\r\n\r\n",
        "sample": {
            "input": "1\n2\n6\n9\n666623333",
            "output": "N\nY\nN\nN\nY"
        }
    },
    {
        "code_id": 0,
        "code": "l, n, m = [int(_) for _ in input().split()]\nrock = []\nfor _ in range(n):\n    rock.append(int(input()))\n# rock.append(l)\n\n\ndef check(dis):\n    tmp, mov = 0, 0\n    for nxt in rock:\n        if tmp + dis > nxt:\n            mov += 1\n        # 隐含条件：玩家可以跳的最大距离不限制\n        else:\n            tmp = nxt\n    # 最短距离跳得到终点\n    # 需要距离再变小一点，check不通过\n    if tmp + dis > l:\n        return False\n        # mov += 10\n    # print(\"check: \",dis,mov<=m)\n    return mov <= m\n\n\ntry:\n    # 答案介于0和(l//(n-m))+1之间\n    left, right = 0, (l//(n-m))+1\n    # 且取不到(l//(n-m))+1\n    while left<right:\n        med = (left+right)//2\n        # print(left, med, right)\n        # 返回正值，拿的偏少，距离可以更大\n        # 倾向于取更大的距离，所以等于的情况我们也向后继续取直到不满足\n        if check(med):\n            left=med+1\n        else:\n            right=med-1\n            \n    # 退出时的left已经被加1了\n    print(left-1)\n\nexcept:\n    print(l)",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "跳石头",
        "query": "# 跳石头\n## 题目描述\n一年一度的“跳石头”比赛又要开始了！\r\n\r\n这项比赛将在一条笔直的河道中进行，河道中分布着一些巨大岩石。组委会已经选择好了两块岩石作为比赛起点和终点。在起点和终点之间，有 $ N $ 块岩石（不含起点和终点的岩石）。在比赛过程中，选手们将从起点出发，每一步跳向相邻的岩石，直至到达终点。\r\n\r\n为了提高比赛难度，组委会计划移走一些岩石，使得选手们在比赛过程中的最短跳跃距离尽可能长。由于预算限制，组委会至多从起点和终点之间移走 $ M $ 块岩石（不能移走起点和终点的岩石）。\n## 输入格式\n输入文件第一行包含三个整数 $ L,N,M $，分别表示起点到终点的距离，起点和终点之间的岩石数，以及组委会至多移走的岩石数。\r\n\r\n接下来 $ N $ 行，每行一个整数，第 $ i $ 行的整数 $ D_i $（$ 0 < D_i < L $）表示第 $ i $ 块岩石与起点的距离。这些岩石按与起点距离从小到大的顺序给出，且不会有两个岩石出现在同 一个位置。\n## 输出格式\n输出文件只包含一个整数，即最短跳跃距离的最大值。\n## 样例\n输入:\n25 5 2\n2\n11\n14\n17\n21\n输出:\n4\n\n\n数据范围与提示\r\n对于 $ 100\\% $ 的数据，$ 0 \\leq M \\leq N \\leq 50,000 $，$ 1 \\leq L \\leq 1,000,000,000 $。",
        "sample": {
            "input": "25 5 2\n2\n11\n14\n17\n21",
            "output": "4"
        }
    },
    {
        "code_id": 4,
        "code": "from fractions import Fraction as Frac\n\nINF = 10_000\n\nn, m = map(int, input().split())\nV = n + m + 1\na, b, cap, z = [0] * n, [0] * n, [0] * n, [Frac(0)] * n\nfor i in range(n):\n    a[i], b[i], cap[i] = map(int, input().split())\n\nto, residue = [], []\ngraph = [[] for _ in range(V)]\n\n\ndef add_edge(a, b, c):\n    graph[a].append(len(residue))\n    to.append(b)\n    residue.append(c)\n    graph[b].append(len(to))\n    to.append(a)\n    residue.append(0)\n\n\ntarget = n + m\nfor i, d in enumerate(map(int, input().split())):\n    add_edge(n + i, target, d)\nfor i in range(n):\n    for j, e in enumerate(map(int, input().split())):\n        if e == 1:\n            add_edge(i, n + j, INF)\n\n\nparent, queue = [0] * V, []\n\n\ndef bfs():\n    for u in range(V):\n        parent[u] = -1\n    head = 0\n    queue.clear()\n    queue.append(target)\n    while head < len(queue):\n        v = queue[head]\n        head += 1\n        for e in graph[v]:\n            u = to[e]\n            if residue[e ^ 1] > 0 and (u != target and parent[u] == -1):\n                parent[u] = e ^ 1\n                queue.append(u)\n\n\ncoef0, coef = [Frac(0)] * n, [Frac(0)] * V\n\n\ndef work():\n    bfs()\n    best, second_best, has_zero = INF, INF, False\n    for i in range(n):\n        if z[i] < cap[i] and parent[i] != -1:\n            intercept = 2 * a[i] * z[i] + b[i]\n            if best > intercept:\n                second_best = best\n                best = intercept\n                has_zero = False\n            elif second_best > intercept > best:\n                second_best = intercept\n            if best == intercept and a[i] == 0:\n                has_zero = True\n    if best == INF:\n        return False\n    for i in range(n):\n        coef0[i] = Frac(0)\n    f = INF\n    if has_zero:\n        for i in range(n):\n            if z[i] < cap[i] and parent[i] != -1 and a[i] == 0 and b[i] == best:\n                coef0[i] = 1\n                f = min(f, cap[i] - z[i])\n    else:\n        f = min(f, second_best - best)\n        for i in range(n):\n            if z[i] < cap[i] and parent[i] != -1 and 2 * a[i] * z[i] + b[i] == best:\n                coef0[i] = Frac(1, 2 * a[i])\n                f = min(f, 2 * a[i] * (cap[i] - z[i]))\n    for i in range(n):\n        coef[i] = coef0[i]\n    for i in range(n, V):\n        coef[i] = 0\n    for u in reversed(queue[1:]):\n        e = parent[u]\n        if coef[u] > 0:\n            f = min(f, residue[e] / coef[u])\n        coef[to[e]] += coef[u]\n    for u in queue[1:]:\n        if coef[u] > 0:\n            e = parent[u]\n            ff = coef[u] * f\n            residue[e] -= ff\n            residue[e ^ 1] += ff\n            if u < n:\n                z[u] += coef0[u] * f\n    return True\n\n\nwhile work():\n    pass\n\nf = sum(z)\nprint(int(f))\nc = Frac(sum(a[i] * z[i] * z[i] + b[i] * z[i] for i in range(n)))\nprint(f\"{c.numerator}/{c.denominator}\")",
        "status": [
            "EXE"
        ],
        "details": "'std'",
        "tcb_id": "醉醺醺的幻想乡",
        "query": "醉醺醺的幻想乡\n题目描述\n傲娇少女幽香是一个很萌很萌的妹子，这些天幻想乡的大家都不知道为何还是拼命喝酒。很快酒就供不应求了，为了满足大家的需求，幽香决定在森林里酿酒。\r\n\r\n经过调查，幽香发现森林里面有一些地方非常适合酿酒，有一些地方则非常适合存酒。  \r\n幽香把这些适合酿酒的地方称为酿酒点，不妨认为有 $n$ 个酿酒点，从 $1$ 到 $n$ 标号。  \r\n同时也有 $m$ 个适合存酒的地方，幽香将它们称为存酒点，从 $1$ 到 $m$ 标号。  \r\n在一些酿酒点和存酒点之间存在通道，如果酿酒点 $i$ 到存酒点 $j$ 之间存在通道，那么 $i$ 生产的酒就可以被运输到 $j$。\r\n\r\n但是在一个地方酿酒是需要消耗幽香的魔力的，由于存在管理上的因素，在酿酒点 $i$，制造 $x$ 升的酒，需要花费 $a_ix^2+b_ix$ 的魔力，注意 $x$ 不一定是一个非负整数，也可以是一个非负实数，同时在这个点最多只能制造 $c_i$ 升的酒。\r\n\r\n每个存酒点 $j$ 有一个容量 $d_j$，表示这个存酒点最多能存多少升的酒。幽香打算存尽量多的酒，那么她需要在一些酿酒点生产一些酒并且通过通道将酒运送到存酒点。\r\n\r\n当然幽香想要节省自己的魔力，所以想让你帮忙算出在满足要求的情况下，最少花费的魔力是多少？\n输入格式\n第一行两个正整数 $n,m$，表示酿酒点和存酒点的数量。  \r\n接下来 $n$ 行，第 $i$ 行三个数 $a_i,b_i,c_i$，表示在酿酒点i制造酒的花费系数，和上限。  \r\n接下来一行 $m$ 个整数，依次为每个存酒点的 $d_i$ 值。  \r\n接下来 $n$ 行，每行 $m$ 个数，其中第 $i$ 行第 $j$ 个表示酿酒点 $i$ 到存酒点 $j$ 有没有通道（$1$ 表示有，$0$ 表示没有）。\n输出格式\n输出第一行表示幽香最多能存多少升酒（注意这肯定是个整数，直接输出即可）。  \r\n输出一行表示最小花费魔力，注意这肯定是一个有理数，化简后按照 ``a/b`` 的形式输出（$0$ 输出 ``0/1``）。\n样例\n输入:\n10 10\n0 2 3\n2 3 2\n3 1 3\n1 2 1\n1 0 1\n1 1 0\n3 3 0\n1 2 2\n3 1 1\n3 1 0\n3 1 2 2 3 1 1 2 2 0\n0 0 0 0 0 0 0 1 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 1 0 0 0 0 0\n0 0 0 1 0 0 0 0 0 0\n1 0 0 0 1 0 0 0 0 0\n1 0 1 0 0 0 0 1 1 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 1 0 0 0 1 0 0 0\n0 0 0 0 0 1 0 0 1 0\n输出:\n8\n42/1\n\n\n数据范围与提示\n对于 $30 \\%$ 的数据：所有 $a_i=0$。  \r\n对于另 $30 \\%$ 的数据：最终答案的分母$\\leq 1000$。  \r\n对于 $100 \\%$ 的数据：$1 \\leq n \\leq 100, \\ 1 \\leq m \\leq 100$。  \r\n对于所有数据，$0 \\leq a_i,b_i,c_i,d_i \\leq 3$且都是整数。同时对于每个 $i$，$a_i+b_i>0$ 通道的数量不超过 $1000$ 条。  \r\n非常神奇的是，对于所有数据存在一个正整数 $X \\leq 10^7$，使得存在一个最优解，使得所有路径上运送的酒的体积都是 $1/X$ 的倍数。",
        "sample": {
            "input": "10 10\n0 2 3\n2 3 2\n3 1 3\n1 2 1\n1 0 1\n1 1 0\n3 3 0\n1 2 2\n3 1 1\n3 1 0\n3 1 2 2 3 1 1 2 2 0\n0 0 0 0 0 0 0 1 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 1 0 0 0 0 0\n0 0 0 1 0 0 0 0 0 0\n1 0 0 0 1 0 0 0 0 0\n1 0 1 0 0 0 0 1 1 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 1 0 0 0 1 0 0 0\n0 0 0 0 0 1 0 0 1 0",
            "output": "8\n42/1"
        }
    }
]