problem_id
stringlengths 32
32
| name
stringclasses 1
value | problem
stringlengths 200
14k
| solutions
stringlengths 12
1.12M
| test_cases
stringlengths 37
74M
| difficulty
stringclasses 3
values | language
stringclasses 1
value | source
stringclasses 7
values | num_solutions
int64 12
1.12M
| starter_code
stringlengths 0
956
|
|---|---|---|---|---|---|---|---|---|---|
c7e7264505e4569a731351461cd80313 | UNKNOWN | This is an easier version of the next problem. In this version, $q = 0$.
A sequence of integers is called nice if its elements are arranged in blocks like in $[3, 3, 3, 4, 1, 1]$. Formally, if two elements are equal, everything in between must also be equal.
Let's define difficulty of a sequence as a minimum possible number of elements to change to get a nice sequence. However, if you change at least one element of value $x$ to value $y$, you must also change all other elements of value $x$ into $y$ as well. For example, for $[3, 3, 1, 3, 2, 1, 2]$ it isn't allowed to change first $1$ to $3$ and second $1$ to $2$. You need to leave $1$'s untouched or change them to the same value.
You are given a sequence of integers $a_1, a_2, \ldots, a_n$ and $q$ updates.
Each update is of form "$i$ $x$" — change $a_i$ to $x$. Updates are not independent (the change stays for the future).
Print the difficulty of the initial sequence and of the sequence after every update.
-----Input-----
The first line contains integers $n$ and $q$ ($1 \le n \le 200\,000$, $q = 0$), the length of the sequence and the number of the updates.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 200\,000$), the initial sequence.
Each of the following $q$ lines contains integers $i_t$ and $x_t$ ($1 \le i_t \le n$, $1 \le x_t \le 200\,000$), the position and the new value for this position.
-----Output-----
Print $q+1$ integers, the answer for the initial sequence and the answer after every update.
-----Examples-----
Input
5 0
3 7 3 7 3
Output
2
Input
10 0
1 2 1 2 3 1 1 1 50 1
Output
4
Input
6 0
6 6 3 3 4 4
Output
0
Input
7 0
3 3 1 3 2 1 2
Output
4 | ["n, _q = map(int, input().split())\nmni = [-1] * 200001\nmxi = [-1] * 200001\ncnt = [0] * 200001\nnd = 0\na = list(map(int, input().split()))\nfor i, v in enumerate(a):\n if mni[v] == -1: mni[v] = i; nd += 1\n mxi[v] = i\n cnt[v] += 1\nr = 0\nz = 0\ncurrmax = 0\nfor i, v in enumerate(a):\n if i == mni[v]: z += 1\n if i == mxi[v]: z -= 1\n currmax = max(currmax, cnt[v])\n if z == 0: r += currmax; currmax = 0\nprint(n - r)", "from sys import stdin\nn, q = tuple(int(x) for x in stdin.readline().split())\n\ntpl = tuple(x for x in stdin.readline().split())\n\ndic = {}\namt = {}\nfor i in range(n):\n dic[tpl[i]] = i\n if tpl[i] not in amt:\n amt[tpl[i]] = 1\n else:\n amt[tpl[i]] += 1\n\nans = 0\ncounter = 0\nwhile counter < n:\n right_bound = dic[tpl[counter]]\n involved = set((tpl[counter],))\n counter += 1\n while counter < right_bound:\n if tpl[counter] not in involved:\n involved.add(tpl[counter])\n right_bound = max(right_bound, dic[tpl[counter]])\n counter += 1\n \n \n temp = tuple(amt[x] for x in involved)\n ans += sum(temp) - max(temp)\nprint(ans)\n", "N, Q = list(map(int, input().split()))\nA = [int(a) for a in input().split()]\nB = sorted(list(set(A)))\nM = len(B)\nIA = {}\nfor i in range(M):\n IA[B[i]] = i\n\nA = [IA[a] for a in A]\nL = [N] * M\nR = [-1] * M\nC = [0] * M\nfor i in range(N):\n L[A[i]] = min(L[A[i]], i)\n R[A[i]] = max(R[A[i]], i)\n C[A[i]] += 1\n\nX = []\nfor i in range(M):\n X.append((L[i], R[i], C[i]))\nX = sorted(X, key = lambda x: x[1])\n\nY = [(-1, 0, 0)]\nfor i in range(M):\n l, r, t = X[i]\n m = t\n while Y[-1][0] > l:\n a, b, c = Y.pop()\n t += b\n m = max(m, c)\n Y.append((r, t, m))\nprint(sum([y[1] - y[2] for y in Y[1:]]))\n\n", "import sys\ninput = sys.stdin.readline\n\nn,q=list(map(int,input().split()))\nA=list(map(int,input().split()))\n\nif max(A)==min(A):\n print(0)\n return\n\n\nL=max(A)\n\nMM=[[200005,-1,i] for i in range(L+1)]\nCOUNT=[0]*(L+1)\n\nfor i in range(n):\n a=A[i]\n MM[a][0]=min(MM[a][0],i)\n MM[a][1]=max(MM[a][1],i)\n COUNT[a]+=1\n\nMM.sort()\n\ni,j,k=MM[0]\n\nMAX=j\nCC=COUNT[k]\nMAXC=COUNT[k]\nANS=0\n\nfor i,j,k in MM[1:]:\n if i==200005:\n ANS+=CC-MAXC\n break\n \n if MAX<i:\n ANS+=CC-MAXC\n \n MAX=j\n CC=COUNT[k]\n MAXC=COUNT[k]\n\n else:\n CC+=COUNT[k]\n MAX=max(MAX,j)\n MAXC=max(MAXC,COUNT[k])\n\nprint(ANS)\n", "n, q = map(int, input().split())\nA = list(map(int, input().split()))\nleft = {}\nright = {}\nfor i in range(n):\n if A[i] not in left:\n left[A[i]] = i\n right[A[i]] = i\nE = []\nfor elem in left:\n E.append([left[elem], -1])\n E.append([right[elem], 1])\nE.sort()\nu = 0\nb = 0\ncntr = {}\nans = 0\nfor i in range(n):\n while u < len(E) and E[u][0] == i:\n b -= E[u][1]\n u += 1\n if A[i] not in cntr:\n cntr[A[i]] = 0\n cntr[A[i]] += 1\n if b == 0:\n s = 0\n m = 0\n for iss in cntr:\n s += cntr[iss]\n m = max(m, cntr[iss])\n ans += s - m\n cntr = {}\nprint(ans)", "#!usr/bin/env python3\nfrom collections import defaultdict,deque\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef I(): return int(sys.stdin.readline())\ndef LS():return [list(x) for x in sys.stdin.readline().split()]\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res\ndef IR(n):\n return [I() for i in range(n)]\ndef LIR(n):\n return [LI() for i in range(n)]\ndef SR(n):\n return [S() for i in range(n)]\ndef LSR(n):\n return [LS() for i in range(n)]\n\nsys.setrecursionlimit(1000000)\nmod = 1000000007\n\n#A\ndef A():\n n = I()\n a = LI()\n a.sort()\n f = [1]*n\n p = 0\n ans = 0\n while p < n:\n while p < n and not f[p]:\n p += 1\n if p == n:\n break\n ans += 1\n for i in range(n):\n if a[i]%a[p] == 0:\n f[i] = 0\n print(ans)\n return\n\n#B\ndef B():\n n = I()\n s = list(map(int, input()))\n g = LIR(n)\n ans = sum(s)\n for t in range(30000):\n for i in range(n):\n ai,bi = g[i]\n if t < bi:\n continue\n if (t-bi)%ai == 0:\n s[i] ^= 1\n su = sum(s)\n if ans < su:\n ans = su\n print(ans)\n return\n\n#C\ndef C():\n t = I()\n for _ in range(t):\n n = I()\n s = list(map(int, input()))\n mi = [s[-1]]\n for i in range(n-1)[::-1]:\n mi.append(min(mi[-1],s[i]))\n mi = mi[::-1]\n ans = [None]*n\n for i in range(n):\n if mi[i] == s[i]:\n ans[i] = 1\n else:\n ans[i] = 2\n q = [s[i] for i in range(n) if ans[i] > 1]\n p = [q[i] for i in range(len(q))]\n p.sort()\n if p == q:\n for i in ans:\n print(i,end = \"\")\n print()\n else:\n print(\"-\")\n return\n\n#D\ndef D():\n def root(x):\n if x == par[x]:\n return x\n par[x] = root(par[x])\n return par[x]\n\n def unite(x,y):\n x = root(x)\n y = root(y)\n if rank[x] < rank[y]:\n par[x] = y\n else:\n par[y] = x\n if rank[x] == rank[y]:\n rank[x] += 1\n\n n,k = LI()\n par = [i for i in range(n)]\n rank = [0]*n\n for i in range(k):\n x,y = LI()\n x -= 1\n y -= 1\n if root(x) != root(y):\n unite(x,y)\n size = [0]*n\n for i in range(n):\n size[root(i)] += 1\n ans = 0\n for i in size:\n if i > 0:\n ans += i-1\n print(k-ans)\n return\n\n#E\ndef E():\n t = I()\n for _ in range(t):\n n,m = LI()\n s = LIR(n)\n s = [[s[i][j] for i in range(n)] for j in range(m)]\n if n <= m:\n ma = [max(s[i]) for i in range(m)]\n ma.sort(reverse = True)\n print(sum(ma[:n]))\n else:\n ans = 0\n k = [[]]\n for _ in range(m):\n k_ = []\n for i in range(n):\n k_ += [x+[i] for x in k]\n k = [x for x in k_]\n for l in k:\n s_ = [[s[i][(j+l[i])%n] for j in range(n)] for i in range(m)]\n print(l)\n p = sum([max([s_[i][j] for i in range(m)]) for j in range(n)])\n print(s_,p)\n if ans < p:\n ans = p\n print(ans)\n return\n\n#F\ndef F():\n\n return\n\n#G\ndef G():\n def root(x):\n if x == par[x]:\n return x\n par[x] = root(par[x])\n return par[x]\n\n def unite(x,y):\n x = root(x)\n y = root(y)\n if rank[x] < rank[y]:\n par[x] = y\n else:\n par[y] = x\n if rank[x] == rank[y]:\n rank[x] += 1\n\n m = 200000\n par = [i for i in range(m)]\n rank = [0]*m\n n,q = LI()\n a = LI()\n for i in range(n):\n a[i] -= 1\n count = defaultdict(lambda : 0)\n l = defaultdict(lambda : 0)\n lis = []\n for i in range(n):\n ai = a[i]\n if count[ai] == 0:\n l[ai] = i\n lis.append(ai)\n count[ai] += 1\n f = defaultdict(lambda : 0)\n r = defaultdict(lambda : 0)\n for i in range(n)[::-1]:\n ai = a[i]\n if not f[ai]:\n r[ai] = i\n f[ai] = 1\n f = [0]*n\n for i in lis:\n li,ri = l[i],r[i]\n f[li] += 1\n f[ri] -= 1\n for i in range(n-1):\n if f[i] > 0:\n x,y = a[i], a[i+1]\n if root(x) != root(y):\n unite(x,y)\n f[i+1] += f[i]\n size = defaultdict(lambda : [])\n for i in l:\n size[root(i)].append(count[i])\n ans = 0\n for i in size.values():\n ans += sum(i)-max(i)\n print(ans)\n return\n\n#H\ndef H():\n\n return\n\n#Solve\ndef __starting_point():\n G()\n\n__starting_point()", "MAXN = 200100\n\nn, q = list(map(int, input().split()))\na = list(map(int, input().split()))\nlpos = [-1]*MAXN\nfor i in range(n):\n\tlpos[a[i]] = i\nneed = 0\ni = 0\nwhile i < n:\n\tstart = i\n\tr = lpos[a[i]]\n\tj = i + 1\n\twhile j < r:\n\t\tr = max(r, lpos[a[j]])\n\t\tj += 1\n\tcnts = {}\n\twhile i <= r:\n\t\tif a[i] in cnts:\n\t\t\tcnts[a[i]] += 1\n\t\telse:\n\t\t\tcnts[a[i]] = 1\n\t\ti += 1\n\tbest = 0\n\tfor k, v in list(cnts.items()):\n\t\tbest = max(best, v)\n\tneed += i - start - best\n\nprint(need)\n", "MAXN = 200100\n\nn, q = list(map(int, input().split()))\na = list(map(int, input().split()))\nlpos = [-1]*MAXN\nfor i in range(n):\n\tlpos[a[i]] = i\nneed = 0\ni = 0\nwhile i < n:\n\tstart = i\n\tr = lpos[a[i]]\n\tcnts = {}\n\twhile i <= r:\n\t\tr = max(r, lpos[a[i]])\n\t\tif a[i] in cnts:\n\t\t\tcnts[a[i]] += 1\n\t\telse:\n\t\t\tcnts[a[i]] = 1\n\t\ti += 1 \n\tneed += i - start - max(cnts.values())\n\nprint(need)\n", "from sys import stdin\nn,m=list(map(int,stdin.readline().strip().split()))\ns=list(map(int,stdin.readline().strip().split()))\nmx=200000\narr=[-1 for i in range(mx+1)]\nvisited=[False for i in range(mx+1)]\ncnt=[0 for i in range(mx+1)]\nfor i in range(n):\n arr[s[i]]=i\nx=0\nans=0\ninf=mx+30\nwhile x<n:\n ind=arr[s[x]]\n v=[]\n l=x\n while x<=ind and x<n:\n ind=max(arr[s[x]],ind)\n v.append(s[x])\n cnt[s[x]]+=1\n x+=1\n aux=0\n for i in v:\n aux=max(aux,cnt[i])\n ans+=(x-l-aux)\n \n \nprint(ans)\n", "n, q = map(int, input().split())\na = list(map(int, input().split()))\nd = {}\n\ndef max_frequent(s, e, a):\n d = {}\n for x in a[s: e+1]:\n if x not in d:\n d[x] = 0\n d[x] += 1\n \n return e - s + 1 - max(list(d.values())) \n \nfor i, x in enumerate(a):\n if x not in d:\n d[x] = []\n d[x].append(i)\n\nsegment = [[v[0], v[-1]] for v in d.values()] \nend = -1\nstart = -1 \nblock = []\n\nfor s, e in segment:\n if s > end:\n if end != -1:\n block.append([start, end])\n start = s \n end = e \n if e > end:\n end = e\n \nblock.append([start, end]) \n\ncnt = 0\nfor s, e in block:\n cnt += max_frequent(s, e, a)\nprint(cnt) ", "n, _q = map(int, input().split())\nmni = [-1] * 200001\nmxi = [-1] * 200001\ncnt = [0] * 200001\nnd = 0\na = list(map(int, input().split()))\nfor i, v in enumerate(a):\n if mni[v] == -1: mni[v] = i; nd += 1\n mxi[v] = i\n cnt[v] += 1\nr = 0\nz = 0\ncurrmax = 0\nfor i, v in enumerate(a):\n if i == mni[v]: z += 1\n if i == mxi[v]: z -= 1\n currmax = max(currmax, cnt[v])\n if z == 0: r += currmax; currmax = 0\nprint(n - r)", "n, q = map(int,input().split())\nA = list(map(int,input().split()))\nsizes = dict()\n\n\nfor j in range(n):\n if A[j] in sizes:\n sizes[A[j]][2] += 1\n sizes[A[j]][1] = j\n else:\n sizes[A[j]] = [j,j,1]\n#print(sizes)\n\nanswer = 0\nend = -1\nmax_size = -1\nfor j in range(n):\n end = max(end, sizes[A[j]][1])\n max_size = max(max_size, sizes[A[j]][2])\n if j == end:\n answer+= max_size\n #print(j, max_size)\n max_size = 0\n\nanswer = -answer\n\nfor j in sizes:\n answer += sizes[j][2]\n\nprint(answer)", "import itertools\nimport sys\n\ndef __starting_point():\n n, q = map(int, input().split())\n blocks = list(map(int, input().split()))\n # create empty dictionary - unordered collection\n dif = dict()\n\n for i in range(n):\n if blocks[i] in dif:\n dif[blocks[i]][1] = i\n dif[blocks[i]][2] = dif[blocks[i]][2] + 1\n elif blocks[i] not in dif:\n dif[blocks[i]] = [i, i, 1]\n\n rez = 0\n end = -1\n maxi = -1\n for i in range(n):\n if dif[blocks[i]][1] >= end:\n end = dif[blocks[i]][1]\n if dif[blocks[i]][2] >= maxi:\n maxi = dif[blocks[i]][2]\n if i == end:\n rez = rez + maxi\n maxi = 0\n rez = (-1) * rez\n for i in dif:\n rez = rez + dif[i][2]\n print(rez)\n__starting_point()"] | {
"inputs": [
"5 0\n3 7 3 7 3\n",
"10 0\n1 2 1 2 3 1 1 1 50 1\n",
"6 0\n6 6 3 3 4 4\n",
"7 0\n3 3 1 3 2 1 2\n",
"5 0\n1 2 1 2 1\n",
"5 0\n2 3 2 3 3\n",
"100 0\n6 7 100 8 5 61 5 75 59 65 51 47 83 37 34 54 87 46 4 26 21 87 12 97 86 68 60 11 62 76 14 83 29 31 91 62 57 80 47 75 85 97 62 77 91 86 14 25 48 77 83 65 39 61 78 77 45 46 90 74 100 91 86 98 55 5 84 42 91 69 100 4 74 98 60 37 75 44 41 12 15 34 36 1 99 16 7 87 36 26 79 42 41 84 17 98 72 16 38 55\n",
"100 0\n91 32 10 38 92 14 100 7 48 72 47 10 76 99 56 53 41 46 68 18 37 47 61 99 16 60 12 51 17 50 69 8 82 78 34 95 3 15 79 4 51 45 83 91 81 68 79 91 16 30 6 86 72 97 63 75 67 14 50 60 1 13 77 37 57 14 65 79 41 62 15 11 74 56 76 62 54 52 9 96 8 27 44 21 59 57 17 53 15 66 49 94 62 58 71 53 88 97 65 37\n",
"100 0\n44 8 97 30 48 96 35 54 42 9 66 27 99 57 74 97 90 24 78 97 98 55 74 56 25 30 34 26 12 87 77 12 7 49 79 2 95 33 72 50 47 28 95 31 99 27 96 43 9 62 6 21 55 22 10 79 71 27 85 37 32 66 54 61 48 48 10 61 57 78 91 41 30 43 29 70 96 4 36 19 50 99 16 68 8 80 55 74 18 35 54 84 70 9 17 77 69 71 67 24\n"
],
"outputs": [
"2\n",
"4\n",
"0\n",
"4\n",
"2\n",
"2\n",
"95\n",
"97\n",
"96\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 12,550 | |
022e1fd3d01884198fbddb2d748d1413 | UNKNOWN | Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.
Consider a set consisting of k (0 ≤ k < n) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.
Now Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (10^9 + 7).
-----Input-----
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of tree vertices.
The second line contains the description of the tree: n - 1 integers p_0, p_1, ..., p_{n} - 2 (0 ≤ p_{i} ≤ i). Where p_{i} means that there is an edge connecting vertex (i + 1) of the tree and vertex p_{i}. Consider tree vertices are numbered from 0 to n - 1.
The third line contains the description of the colors of the vertices: n integers x_0, x_1, ..., x_{n} - 1 (x_{i} is either 0 or 1). If x_{i} is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.
-----Output-----
Output a single integer — the number of ways to split the tree modulo 1000000007 (10^9 + 7).
-----Examples-----
Input
3
0 0
0 1 1
Output
2
Input
6
0 1 1 0 4
1 1 0 0 1 0
Output
1
Input
10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1
Output
27 | ["MOD = 1000000007\n\nn = int(input())\np = [int(x) for x in input().split()]\nx = [int(x) for x in input().split()]\n\nchildren = [[] for x in range(n)]\n\nfor i in range(1,n):\n children[p[i-1]].append(i)\n\n#print(children)\n\ncount = [(0,0) for i in range(n)]\nfor i in reversed(list(range(n))):\n prod = 1\n for ch in children[i]:\n prod *= count[ch][0]+count[ch][1]\n if x[i]:\n count[i] = (0,prod % MOD)\n else:\n tot = 0\n for ch in children[i]:\n cur = count[ch][1]*prod // (count[ch][0]+count[ch][1])\n tot += cur\n count[i] = (prod % MOD, tot % MOD)\n\nprint(count[0][1])\n", "from collections import UserDict\n\n\nclass Tree(UserDict):\n def __init__(self, g):\n super().__init__()\n for name, value in enumerate(g, 1):\n self[value] = name\n\n def __setitem__(self, name, value):\n if name in self:\n if value is not None:\n self[name].add(value)\n self[value] = None\n else:\n if value is None:\n super().__setitem__(name, set())\n else:\n super().__setitem__(name, {value})\n self[value] = None\n\n\ndef __starting_point():\n n = int(input())\n\n tree = Tree(int(i) for i in input().split())\n colors = [int(i) for i in input().split()]\n t = [()] * n\n\n def dfs(v):\n stack = [v]\n visited = set()\n\n while stack:\n v = stack.pop()\n if v not in visited:\n visited.add(v)\n stack.append(v)\n stack.extend(tree[v])\n else:\n t[v] = (1, colors[v])\n for u in tree[v]:\n t[v] = (\n (t[v][0] * t[u][1] + t[v][0] * t[u][0] * (not colors[u])) % (10**9 + 7),\n (t[v][1] * t[u][1] + t[v][0] * t[u][1] * (not colors[v])\n + t[v][1] * t[u][0] * (not colors[u])) % (10**9 + 7)\n )\n\n \n dfs(0)\n\n print(t[0][1])\n\n\n\n \n\n\n\n\n# Made By Mostafa_Khaled\n\n__starting_point()", "MOD = 10**9 + 7\n\n\ndef topo_compute(childrens, colors, parents):\n def f(node, connected_to_black):\n if colors[node] == 1 and connected_to_black:\n return 0\n\n children = childrens[node]\n if colors[node] == 1 or connected_to_black:\n ret = 1\n\n for child in children:\n x = dp_conn[child] + dp_not_conn[child]\n x %= MOD\n\n ret *= x\n ret %= MOD\n\n return ret\n\n s = 1\n prefix_prod = []\n for child in children:\n x = dp_conn[child] + dp_not_conn[child]\n x %= MOD\n s *= x\n s %= MOD\n prefix_prod.append(s)\n\n s = 1\n suffix_prod = []\n for child in reversed(children):\n x = dp_conn[child] + dp_not_conn[child]\n x %= MOD\n s *= x\n s %= MOD\n suffix_prod.append(s)\n\n suffix_prod = list(reversed(suffix_prod))\n\n ret = 0\n\n for i in range(len(children)):\n pre = prefix_prod[i - 1] if i > 0 else 1\n suf = suffix_prod[i + 1] if i + 1 < len(suffix_prod) else 1\n\n x = pre * suf\n x %= MOD\n\n x *= dp_not_conn[children[i]]\n x %= MOD\n\n ret += x\n ret %= MOD\n\n return ret\n\n ########################\n\n num_childrens = [len(x) for x in childrens]\n N = len(childrens)\n dp_conn = [None] * N\n dp_not_conn = [None] * N\n\n stack = [i for i in range(N) if num_childrens[i] == 0]\n\n while True:\n node = stack.pop()\n\n dp_conn[node] = f(node, True)\n dp_not_conn[node] = f(node, False)\n\n parent = parents[node]\n\n if parent is None:\n return dp_not_conn[node]\n\n num_childrens[parent] -= 1\n if num_childrens[parent] == 0:\n stack.append(parent)\n\n\ndef build_tree(d, root):\n childrens = [None] * len(d)\n parents = [None] * len(d)\n\n stack = [(root, None)]\n\n while len(stack) > 0:\n node, parent = stack.pop()\n\n children = [x for x in d[node] if x != parent]\n\n childrens[node] = children\n parents[node] = parent\n\n for child in children:\n stack.append((child, node))\n\n return childrens, parents\n\n\ndef main():\n import sys\n\n n = sys.stdin.readline()\n n = int(n)\n\n p = list(map(int, sys.stdin.readline().split(\" \")))\n\n d = {}\n\n for i in range(n):\n d[i] = []\n\n for i, b in enumerate(p):\n a = i + 1\n d[a].append(b)\n d[b].append(a)\n\n colors = list(map(int, sys.stdin.readline().split(\" \")))\n colors = list(colors)\n\n for i in range(n - 1):\n line = sys.stdin.readline()\n if line == \"\":\n break\n\n a, b = list(map(int, line.split(\" \")))\n\n d[a].append(b)\n d[b].append(a)\n\n childrens, parents = build_tree(d, 0)\n\n ans = topo_compute(childrens, colors, parents)\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()"] | {
"inputs": [
"3\n0 0\n0 1 1\n",
"6\n0 1 1 0 4\n1 1 0 0 1 0\n",
"10\n0 1 2 1 4 4 4 0 8\n0 0 0 1 0 1 1 0 0 1\n",
"5\n0 1 1 3\n0 0 0 1 1\n",
"10\n0 1 1 2 4 3 3 3 2\n1 0 1 1 1 0 0 1 1 0\n",
"100\n0 0 2 2 0 3 5 0 6 2 0 4 0 2 3 7 8 3 15 19 13 8 18 19 3 14 23 9 6 3 6 17 26 24 20 6 4 27 8 5 14 5 35 31 27 3 41 25 20 14 25 31 49 40 0 1 10 5 50 13 29 58 1 6 8 1 40 52 30 15 50 8 66 52 29 71 25 68 36 7 80 60 6 2 11 43 62 27 84 86 71 38 14 50 88 4 8 95 53\n1 0 0 1 0 0 1 0 1 0 0 0 1 0 1 1 0 1 1 1 1 0 0 0 0 1 1 0 1 0 0 0 0 1 1 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 1 1 0 1 1 1 0 1 0 1 0 1 0 0 0 0 1 0 1 0 1 0 1 0 1 1 1 1 1 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 0 0 1\n",
"2\n0\n1 0\n",
"115\n0 0 1 2 0 4 1 3 4 1 4 5 4 5 0 0 3 1 2 3 3 0 5 1 3 4 1 5 2 0 1 3 3 1 3 5 0 4 5 1 3 0 0 1 3 1 1 3 3 3 2 3 1 3 0 2 5 5 1 1 2 2 1 1 3 2 1 2 3 1 5 4 2 1 2 1 1 2 3 4 3 1 5 0 2 4 4 5 2 5 0 2 4 5 5 5 5 0 3 1 1 4 2 2 4 3 3 0 3 3 0 2 0 0\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n"
],
"outputs": [
"2\n",
"1\n",
"27\n",
"1\n",
"3\n",
"9523200\n",
"1\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 5,380 | |
592e2aad66d6182508a7419038cd59cc | UNKNOWN | Jzzhu has picked n apples from his big apple tree. All the apples are numbered from 1 to n. Now he wants to sell them to an apple store.
Jzzhu will pack his apples into groups and then sell them. Each group must contain two apples, and the greatest common divisor of numbers of the apples in each group must be greater than 1. Of course, each apple can be part of at most one group.
Jzzhu wonders how to get the maximum possible number of groups. Can you help him?
-----Input-----
A single integer n (1 ≤ n ≤ 10^5), the number of the apples.
-----Output-----
The first line must contain a single integer m, representing the maximum number of groups he can get. Each of the next m lines must contain two integers — the numbers of apples in the current group.
If there are several optimal answers you can print any of them.
-----Examples-----
Input
6
Output
2
6 3
2 4
Input
9
Output
3
9 3
2 4
6 8
Input
2
Output
0 | ["\"\"\"\nCodeforces Round 257 Div 1 Problem C\n\nAuthor : chaotic_iak\nLanguage: Python 3.3.4\n\"\"\"\n\ndef read(mode=2):\n # 0: String\n # 1: List of strings\n # 2: List of integers\n inputs = input().strip()\n if mode == 0:\n return inputs\n if mode == 1:\n return inputs.split()\n if mode == 2:\n return [int(x) for x in inputs.split()]\n\ndef write(s=\"\\n\"):\n if isinstance(s, list): s = \" \".join(map(str,s))\n s = str(s)\n print(s, end=\"\")\n\n################################################### SOLUTION\n\n# croft algorithm to generate primes\n# from pyprimes library, not built-in, just google it\nfrom itertools import compress\nimport itertools\ndef croft():\n \"\"\"Yield prime integers using the Croft Spiral sieve.\n\n This is a variant of wheel factorisation modulo 30.\n \"\"\"\n # Implementation is based on erat3 from here:\n # http://stackoverflow.com/q/2211990\n # and this website:\n # http://www.primesdemystified.com/\n # Memory usage increases roughly linearly with the number of primes seen.\n # dict ``roots`` stores an entry x:p for every prime p.\n for p in (2, 3, 5):\n yield p\n roots = {9: 3, 25: 5} # Map d**2 -> d.\n primeroots = frozenset((1, 7, 11, 13, 17, 19, 23, 29))\n selectors = (1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0)\n for q in compress(\n # Iterate over prime candidates 7, 9, 11, 13, ...\n itertools.islice(itertools.count(7), 0, None, 2),\n # Mask out those that can't possibly be prime.\n itertools.cycle(selectors)\n ):\n # Using dict membership testing instead of pop gives a\n # 5-10% speedup over the first three million primes.\n if q in roots:\n p = roots[q]\n del roots[q]\n x = q + 2*p\n while x in roots or (x % 30) not in primeroots:\n x += 2*p\n roots[x] = p\n else:\n roots[q*q] = q\n yield q\n\nn, = read()\ncr = croft()\nprimes = []\nfor i in cr:\n if i < n:\n primes.append(i)\n else:\n break\nprimes.reverse()\n\nused = [0] * (n+1)\nres = []\nfor p in primes:\n k = n//p\n tmp = []\n while k:\n if not used[k*p]:\n tmp.append(k*p)\n used[k*p] = 1\n if len(tmp) == 2:\n res.append(tmp)\n tmp = []\n k -= 1\n if tmp == [p] and p > 2 and p*2 <= n and len(res) and res[-1][1] == p*2:\n res[-1][1] = p\n used[p*2] = 0\n used[p] = 1\n\nprint(len(res))\nfor i in res:\n print(\" \".join(map(str, i)))", "apples=int(input())\n\nif apples<=3:\n\n print(0)\n\nelse:\n\n halfpr=int(apples/2)\n\n def primes(n):\n\n isPrime = [True for i in range(n + 1)]\n\n isPrime[0] = isPrime[1] = False\n\n \n\n idx = 2\n\n while idx * idx <= n:\n\n if isPrime[idx]:\n\n for i in range(idx * 2, n, idx):\n\n isPrime[i] = False\n\n idx += 1\n\n \n\n return isPrime\n\n\n\n primeslist=primes(halfpr)\n\n totallist=[False]*(apples+1)\n\n applepairs=[]\n\n for prime in range(len(primeslist)-1, 1, -1):\n\n if primeslist[prime]:\n\n numprimes=int(apples/prime)\n\n primesx=[int(i*prime) for i in range(1, numprimes+1) if not totallist[i*prime]]\n\n if len(primesx)%2==1:\n\n primesx.remove(2*prime)\n\n for pr in primesx:\n\n applepairs.append(pr)\n\n totallist[pr]=True\n\n print(int(len(applepairs)/2))\n\n for t in range(int(len(applepairs)/2)):\n\n print(applepairs[2*t], applepairs[2*t+1])\n\n \n\n\n\n\n\n# Made By Mostafa_Khaled\n"] | {"inputs": ["6\n", "9\n", "2\n", "10\n", "100\n", "1\n", "3\n", "5\n"], "outputs": ["2\n6 3\n2 4\n", "3\n9 3\n2 4\n6 8\n", "0\n", "4\n2 4\n6 8\n10 5\n9 3\n", "44\n33 27\n22 11\n25 5\n64 66\n42 44\n31 62\n58 29\n43 86\n15 21\n6 99\n8 12\n85 65\n7 49\n23 46\n16 14\n20 18\n90 92\n48 50\n40 36\n74 37\n35 55\n10 95\n56 60\n47 94\n45 39\n93 87\n88 84\n72 76\n28 24\n75 81\n78 80\n54 52\n38 19\n3 9\n32 30\n91 77\n70 68\n63 69\n2 4\n57 51\n82 41\n17 34\n13 26\n96 98\n", "0\n", "0\n", "1\n2 4\n"]} | COMPETITION | PYTHON3 | CODEFORCES | 3,832 | |
92896894f49e5268a147b005e021312f | UNKNOWN | Today Sonya learned about long integers and invited all her friends to share the fun. Sonya has an initially empty multiset with integers. Friends give her t queries, each of one of the following type: + a_{i} — add non-negative integer a_{i} to the multiset. Note, that she has a multiset, thus there may be many occurrences of the same integer. - a_{i} — delete a single occurrence of non-negative integer a_{i} from the multiset. It's guaranteed, that there is at least one a_{i} in the multiset. ? s — count the number of integers in the multiset (with repetitions) that match some pattern s consisting of 0 and 1. In the pattern, 0 stands for the even digits, while 1 stands for the odd. Integer x matches the pattern s, if the parity of the i-th from the right digit in decimal notation matches the i-th from the right digit of the pattern. If the pattern is shorter than this integer, it's supplemented with 0-s from the left. Similarly, if the integer is shorter than the pattern its decimal notation is supplemented with the 0-s from the left.
For example, if the pattern is s = 010, than integers 92, 2212, 50 and 414 match the pattern, while integers 3, 110, 25 and 1030 do not.
-----Input-----
The first line of the input contains an integer t (1 ≤ t ≤ 100 000) — the number of operation Sonya has to perform.
Next t lines provide the descriptions of the queries in order they appear in the input file. The i-th row starts with a character c_{i} — the type of the corresponding operation. If c_{i} is equal to '+' or '-' then it's followed by a space and an integer a_{i} (0 ≤ a_{i} < 10^18) given without leading zeroes (unless it's 0). If c_{i} equals '?' then it's followed by a space and a sequence of zeroes and onse, giving the pattern of length no more than 18.
It's guaranteed that there will be at least one query of type '?'.
It's guaranteed that any time some integer is removed from the multiset, there will be at least one occurrence of this integer in it.
-----Output-----
For each query of the third type print the number of integers matching the given pattern. Each integer is counted as many times, as it appears in the multiset at this moment of time.
-----Examples-----
Input
12
+ 1
+ 241
? 1
+ 361
- 241
? 0101
+ 101
? 101
- 101
? 101
+ 4000
? 0
Output
2
1
2
1
1
Input
4
+ 200
+ 200
- 200
? 0
Output
1
-----Note-----
Consider the integers matching the patterns from the queries of the third type. Queries are numbered in the order they appear in the input. 1 and 241. 361. 101 and 361. 361. 4000. | ["from sys import stdin\n\n\ndef main():\n cnt = [0] * 2 ** 18\n t = str.maketrans(\"0123456789\", \"0101010101\")\n _, *l = stdin.read().splitlines()\n for sign, s in map(str.split, l):\n if sign == '?':\n print(cnt[int(s, 2)])\n else:\n cnt[int(s.translate(t), 2)] += 1 if sign == '+' else -1\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nt=str.maketrans('0123456789','0101010101')\nC=(1<<18)*[0]\nfor _ in range(int(input())):\n\tc,a=input().split()\n\tif'?'==c:print(C[int(a,2)])\n\telse:C[int(a.translate(t),2)]+=1 if'-'!=c else-1\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nt=str.maketrans('0123456789','0101010101')\nC=(1<<18)*[0]\nfor _ in range(int(input())):\n\tc,a=input().split()\n\tif'?'==c:print(C[int(a,2)])\n\telse:C[int(a.translate(t),2)]+=1 if'-'!=c else-1", "\n\ndef convert(strVal):\n \n ls = list()\n for c in strVal:\n if (ord(c)&1):\n ls.append('1')\n else:\n ls.append('0')\n \n \n a = ''.join(ls)\n \n \n \n \n \n '''strLength = len(strVal)\n a='0'*strLength\n \n \n i=strLength-1\n \n \n while i>=0:\n \n divByTwo =''\n \n if (ord(strVal[i])&1):\n divByTwo='1'\n else:\n divByTwo='0'\n \n if i==(strLength-1):\n a= a[:i] +divByTwo\n elif i==0:\n a= divByTwo + a[1:]\n else:\n a = a[:i]+divByTwo+a[i+1:]\n \n i-=1'''\n #aLength-=1\n \n return int(a)\n\nfrom collections import defaultdict\ninputList=defaultdict(int)\n\ninputNum = int(input())\n\n#print (inputNum)\n\n#iterate n times and do changes in each iteration\nfor x in range(0,inputNum):\n inputStr=input()\n \n firstValue = inputStr[0]\n secondValue = inputStr[2:]\n \n if firstValue!='?':\n convertedValue = convert(secondValue)\n #print(secondValue)\n #print(convertedValue)\n #print (convertedValue)\n \n # + case\n if firstValue=='+':\n #plusVal = int(convertedValue)\n inputList[convertedValue]+=1\n \n # - case\n elif firstValue=='-':\n #minusVal = int(convertedValue)\n inputList[convertedValue]-=1\n \n # ? case\n elif firstValue=='?':\n patString = int(secondValue)\n count=inputList[patString]\n print(count) \n \n \n#print(inputList) \n \n#print(inputList) \n'''for x in inputList:\n print('{}, {}', x, inputList[x])'''\n \n \n\n\n", "t=int(input())\nT=str.maketrans('0123456789','0101010101')\nl=[0]*300000\nfor _ in ' '*t:\n a,b=input().split()\n if a=='?':print(l[int(b,2)])\n else:l[int(b.translate(T),2)]+=1if a=='+'else -1", "t=int(input())\nT=str.maketrans('0123456789','0101010101')\nd={}\nfor _ in ' '*t:\n a,b=input().split()\n b=int(b.translate(T))\n if a=='?':print(d.get(b,0))\n elif a=='+':d[b]=d.get(b,0)+1\n else:d[b]-=1", "t=int(input())\nT=str.maketrans('0123456789','0101010101')\nd={}\nfor _ in ' '*t:\n a,b=input().split()\n b=int(b.translate(T))\n if a=='?':print(d.get(b,0))\n elif a=='+':d[b]=d.get(b,0)+1\n else:d[b]-=1", "n = int(input())\na = []\nwk1 = \"0\" * 18\nrules = str.maketrans(\"0123456789\", \"0101010101\")\ntrans = lambda x : str.translate(x, rules)\nd = {}\nfor _ in range(n):\n x, y = input().split()\n y = int(trans(y), 2)\n if x == \"+\":\n d[y] = d.get(y, 0) + 1\n elif x == \"-\":\n d[y] -= 1\n elif x == \"?\":\n print(d.get(y, 0))\n\n\n", "cnt = [0]*262200\ntrans = str.maketrans('0123456789', '0101010101')\nt = int(input())\nfor _ in range(t):\n o, a = input().split()\n\n if o == '+':\n cnt[int(a.translate(trans), 2)] += 1\n elif o == '-':\n cnt[int(a.translate(trans), 2)] -= 1\n else:\n print(cnt[int(a, 2)])\n", "n = int(input())\n\nd = {}\n\ndef get_mask(num):\n res = ''\n for el in num:\n if (int(el) & 1):\n res += '1'\n else:\n res += '0'\n\n return '0' * (18 - len(num)) + res\n \n\nfor _ in range(n):\n c, v = input().split(' ')\n if c == '?':\n v = '0' * (18 - len(v)) + v\n if v in d.keys():\n print(d[v])\n else:\n print(0)\n elif c == '+':\n v = get_mask(v)\n if v in d.keys():\n d[v] += 1\n else:\n d[v] = 1\n else:\n v = get_mask(v)\n d[v] -= 1", "n = int(input())\n\nd = {}\n\ndef get_mask(num):\n res = ''\n for el in num:\n if (int(el) & 1):\n res += '1'\n else:\n res += '0'\n\n return '0' * (18 - len(num)) + res\n \n\nfor _ in range(n):\n c, v = input().split(' ')\n if c == '?':\n v = '0' * (18 - len(v)) + v\n \n if d.get(v) != None:\n print(d[v])\n else:\n print(0)\n elif c == '+':\n v = get_mask(v)\n if d.get(v) != None:\n d[v] += 1\n else:\n d[v] = 1\n else:\n v = get_mask(v)\n d[v] -= 1", "from collections import defaultdict\nclass trie:\n def __init__(self):\n self.nodes1,self.nodes2 = None,None\n self.count1,self.count2 = 0,0\n\n def add(self,s,i):\n if i>=len(s):\n return\n md = int(s[i])%2\n if md==0:\n if not self.nodes1:\n self.nodes1 = trie()\n\n self.count1 += 1\n self.nodes1.add(s,i+1)\n else:\n if not self.nodes2:\n self.nodes2 = trie()\n\n self.count2 += 1\n self.nodes2.add(s,i+1)\n \n def remove(self,s,i):\n if i>=len(s):\n return\n md = int(s[i])%2\n if md==0:\n self.count1 -= 1\n self.nodes1.remove(s,i+1)\n if self.count1==0:\n self.nodes1 = None\n else:\n self.count2 -= 1\n self.nodes2.remove(s,i+1)\n if self.count2==0:\n self.nodes2 = None\n \n def search(self,s,i,mn):\n if i>=len(s):\n return mn\n md = int(s[i])%2\n if md==0:\n if self.nodes1:\n return self.nodes1.search(s,i+1,min(mn,self.count1))\n else:\n return 0\n else:\n if self.nodes2:\n return self.nodes2.search(s,i+1,min(mn,self.count2))\n else:\n return 0\n\n\n\nt = int(input())\n# tr = trie()\nst = set('02468')\nmp = defaultdict(int)\nres = []\nwhile t>0:\n t-=1\n c,s = input().split()\n # s = s.zfill(18)\n if c=='+':\n # ss = [str(int(i)%2) for i in s]\n ss = ''\n for i in s:\n if i in st:\n ss += '0'\n else:\n ss += '1'\n\n # ss = ''.join(ss)\n mp[int(ss,2)]+=1\n # print('**',ss,int(ss,2))\n # tr.add(s,0)\n elif c=='-':\n # ss = [str(int(i)%2) for i in s]\n # ss = ''.join(ss)\n ss = ''\n for i in s:\n if i in st:\n ss += '0'\n else:\n ss += '1'\n mp[int(ss,2)]-=1\n # tr.remove(s,0)\n elif c=='?':\n # v = tr.search(s,0,10**6)\n # print(v)\n # print('##',ss,int(ss,2))\n res.append(mp[int(s,2)])\n\nprint(*res,sep='\\n')", "t = int(input())\nrules = str.maketrans(\"0123456789\", \"0101010101\")\ntrans = lambda x : str.translate(x, rules)\ncnt, res = {}, []\nfor _ in range(t):\n op, n = input().split()\n n = int(trans(n), 2)\n if op == '+':\n cnt[n] = cnt.get(n, 0) + 1\n elif op == '-':\n cnt[n] -= 1\n else:\n print(cnt.get(n, 0))\n", "t = int(input())\nrules = str.maketrans(\"0123456789\", \"0101010101\")\ntrans = lambda x : str.translate(x, rules)\ncnt, res = {}, []\nfor _ in range(t):\n op, n = input().split()\n n = int(trans(n), 2)\n if op == '+':\n cnt[n] = cnt.get(n, 0) + 1\n elif op == '-':\n cnt[n] -= 1\n else:\n res.append(str(cnt.get(n, 0)))\nprint('\\n'.join(res))\n", "from sys import stdin\nd,res,elem={},'','0101010101'\nfor _ in range(int(stdin.readline())):\n c,x=map(str,stdin.readline().split())\n if c!='?':\n x=[*x]\n x=[elem[int(y)] for i,y in enumerate(x)]\n x=''.join(x)\n x=x[x.find('1'):]\n if c=='+':\n if d.get(x)==None:d[x]=0\n d[x]+=1\n elif c=='-':d[x]-=1\n else:\n if d.get(x)==None:res+='0'+'\\n'\n else:res+=str(d[x])+'\\n'\nprint(res)", "from sys import stdin\nd,res,elem={},'','0101010101'\na=lambda:stdin.readline().split()\nfor _ in range(int(stdin.readline())):\n c,x=map(str,a())\n if c!='?':\n x=[*x]\n x=[elem[int(y)] for i,y in enumerate(x)]\n x=''.join(x)\n x=x[x.find('1'):]\n if c=='+':\n if d.get(x)==None:d[x]=0\n d[x]+=1\n elif c=='-':d[x]-=1\n else:\n if d.get(x)==None:res+='0'+'\\n'\n else:res+=str(d[x])+'\\n'\nprint(res)", "LVL = 18\nfrom collections import defaultdict\n\n\ndef pattern_repr(x):\n rep = [1 if int(x) % 2 else 0 for x in x]\n return [0] * (LVL - len(rep)) + rep\n\n\nclass Node:\n def __init__(self, key, node_id=0):\n self.key = key\n self.node_id = node_id\n self.left = None\n self.right = None\n\n\nclass CodeforcesTask713ASolution:\n def __init__(self):\n self.result = ''\n self.t = 0\n self.queries = []\n\n def read_input(self):\n self.t = int(input())\n for _ in range(self.t):\n self.queries.append(input().split(\" \"))\n\n def process_task(self):\n res = []\n root = Node(0, 1)\n node_id = 2\n treesol = False\n if treesol:\n for query in self.queries:\n if query[0] in \"+-\":\n pattern = pattern_repr(query[1])\n #print(pattern)\n current = root\n while pattern:\n #print(current.node_id)\n if pattern[0]:\n # going right\n if current.right:\n current = current.right\n else:\n current.right = Node(0, node_id)\n current = current.right\n node_id += 1\n else:\n # going left\n if current.left:\n current = current.left\n else:\n current.left = Node(0, node_id)\n current = current.left\n node_id += 1\n pattern = pattern[1:]\n current.key += 1 if query[0] == \"+\" else -1\n #print(current.key, current.node_id)\n else:\n pattern = [int(x) for x in \"0\" * (LVL - len(query[1])) + query[1]]\n current = root\n #print(pattern)\n while pattern:\n if pattern[0]:\n # going right\n if current.right:\n current = current.right\n else:\n current = Node(0)\n pattern = []\n else:\n # going left\n if current.left:\n current = current.left\n else:\n current = Node(0)\n pattern = []\n pattern = pattern[1:]\n res.append(current.key)\n else:\n counts = defaultdict(int)\n for query in self.queries:\n\n if query[0] in \"+-\":\n pattern = \"0\" * (LVL - len(query[1])) + \"\".join((\"1\" if int(x) % 2 else \"0\" for x in query[1]))\n counts[pattern] += 1 if query[0] == \"+\" else -1\n else:\n pattern = \"0\" * (LVL - len(query[1])) + query[1]\n res.append(counts[pattern])\n\n self.result = \"\\n\".join([str(x) for x in res])\n\n def get_result(self):\n return self.result\n\n\ndef __starting_point():\n Solution = CodeforcesTask713ASolution()\n Solution.read_input()\n Solution.process_task()\n print(Solution.get_result())\n\n__starting_point()", "# -*- coding: utf-8 -*-\n\n# Baqir Khan\n# Software Engineer (Backend)\n\nfrom collections import defaultdict\nfrom sys import stdin\n\ninp = stdin.readline\n\n\ndef convert_num(number):\n number_list = list(map(int, number))\n res = \"\".join(str(d & 1) for d in number_list)\n return \"0\" * (18 - len(res)) + res\n\n\ndef convert_pattern(pattern):\n return \"0\" * (18 - len(pattern)) + pattern\n\n\nt = int(inp())\nmultiset = defaultdict(int)\n\nwhile t:\n t -= 1\n op, item = inp().split()\n if op == \"+\":\n multiset[convert_num(item)] += 1\n elif op == \"-\":\n multiset[convert_num(item)] -= 1\n else:\n print(multiset[convert_pattern(item)])\n"] | {
"inputs": [
"12\n+ 1\n+ 241\n? 1\n+ 361\n- 241\n? 0101\n+ 101\n? 101\n- 101\n? 101\n+ 4000\n? 0\n",
"4\n+ 200\n+ 200\n- 200\n? 0\n",
"20\n+ 61\n+ 99\n+ 51\n+ 70\n+ 7\n+ 34\n+ 71\n+ 86\n+ 68\n+ 39\n+ 78\n+ 81\n+ 89\n? 10\n? 00\n? 10\n? 01\n? 01\n? 00\n? 00\n",
"20\n+ 13\n+ 50\n+ 9\n? 0\n+ 24\n? 0\n- 24\n? 0\n+ 79\n? 11\n- 13\n? 11\n- 50\n? 10\n? 1\n- 9\n? 1\n? 11\n- 79\n? 11\n",
"10\n+ 870566619432760298\n+ 869797178280285214\n+ 609920823721618090\n+ 221159591436767023\n+ 730599542279836538\n? 101001100111001011\n? 001111010101010011\n? 100010100011101110\n? 100110010110001100\n? 110000011101110011\n",
"10\n+ 96135\n? 10111\n+ 63322\n? 10111\n+ 44490\n? 10111\n+ 69312\n? 10111\n? 01100\n+ 59396\n",
"10\n+ 2\n- 2\n+ 778\n+ 3\n+ 4\n- 4\n+ 1\n+ 617\n? 011\n? 011\n",
"20\n+ 8\n+ 39532\n+ 813\n- 39532\n? 00011\n? 00000\n? 00011\n+ 70424\n- 8\n? 00011\n- 70424\n? 00011\n+ 29\n? 00001\n+ 6632\n+ 3319\n? 00001\n+ 3172\n? 01111\n- 29\n"
],
"outputs": [
"2\n1\n2\n1\n1\n",
"1\n",
"3\n2\n3\n4\n4\n2\n2\n",
"0\n1\n0\n2\n1\n0\n1\n0\n1\n0\n",
"0\n0\n0\n0\n0\n",
"1\n1\n1\n1\n1\n",
"1\n1\n",
"1\n1\n1\n1\n1\n1\n1\n1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 13,648 | |
df1e6fffcb43a1ddaeb53045ffdf0289 | UNKNOWN | T is playing a game with his friend, HL.
There are $n$ piles of stones, the $i$-th pile initially has $a_i$ stones.
T and HL will take alternating turns, with T going first. In each turn, a player chooses a non-empty pile and then removes a single stone from it. However, one cannot choose a pile that has been chosen in the previous turn (the pile that was chosen by the other player, or if the current turn is the first turn then the player can choose any non-empty pile). The player who cannot choose a pile in his turn loses, and the game ends.
Assuming both players play optimally, given the starting configuration of $t$ games, determine the winner of each game.
-----Input-----
The first line of the input contains a single integer $t$ $(1 \le t \le 100)$ — the number of games. The description of the games follows. Each description contains two lines:
The first line contains a single integer $n$ $(1 \le n \le 100)$ — the number of piles.
The second line contains $n$ integers $a_1, a_2, \dots, a_n$ $(1 \le a_i \le 100)$.
-----Output-----
For each game, print on a single line the name of the winner, "T" or "HL" (without quotes)
-----Example-----
Input
2
1
2
2
1 1
Output
T
HL
-----Note-----
In the first game, T removes a single stone from the only pile in his first turn. After that, although the pile still contains $1$ stone, HL cannot choose from this pile because it has been chosen by T in the previous turn. Therefore, T is the winner. | ["t = int(input())\n\nfor _ in range(t):\n n = int(input())\n a = list(map(int,input().split()))\n sumA = sum(a)\n TWins = False\n for elem in a:\n if elem > sumA // 2:\n TWins = True\n break\n if TWins or sumA % 2 != 0:\n print(\"T\")\n else:\n print(\"HL\")", "import sys\n\nT = int(sys.stdin.readline().strip())\nfor t in range (0, T):\n n = int(sys.stdin.readline().strip())\n a = list(map(int, sys.stdin.readline().strip().split()))\n if max(a) > sum(a) / 2:\n print('T')\n elif sum(a) % 2 == 1:\n print('T')\n else:\n print('HL')", "import sys\nreadline = sys.stdin.readline\n\n\nT = int(readline())\nAns = [None]*T\n\nfor qu in range(T):\n N = int(readline())\n A = list(map(int, readline().split()))\n A.sort()\n if N == 1:\n Ans[qu] = 'T'\n elif N == 2:\n if A[0] == A[1]:\n Ans[qu] = 'HL'\n else:\n Ans[qu] = 'T'\n elif A[-1] > sum(A[:-1]):\n Ans[qu] = 'T'\n else:\n if sum(A) %2 == 0:\n Ans[qu] = 'HL'\n else:\n Ans[qu] = 'T'\n \n \nprint('\\n'.join(Ans))", "import sys\ninput = sys.stdin.readline\nfor f in range(int(input())):\n n=int(input())\n a=list(map(int,input().split()))\n m=max(a)\n s=sum(a)\n if 2*m>s:\n print(\"T\")\n else:\n if s%2==0:\n print(\"HL\")\n else:\n print(\"T\")", "\nfrom sys import stdin\nimport heapq\n\ntt = int(stdin.readline())\n\nfor loop in range(tt):\n\n n = int(stdin.readline())\n a = list(map(int,stdin.readline().split()))\n\n q = []\n for i in a:\n heapq.heappush(q,-1*i)\n\n f = 0\n g = 0\n\n while True:\n\n if len(q) == 0:\n print (\"HL\")\n break\n\n f = heapq.heappop(q)\n f += 1\n if g != 0:\n heapq.heappush(q,g)\n\n if len(q) == 0:\n print (\"T\")\n break\n g = heapq.heappop(q)\n g += 1\n if f != 0:\n heapq.heappush(q,f)\n \n", "t=int(input())\nfor _ in range(t):\n n=int(input())\n a=list(map(int,input().split()))\n t=sum(a)\n flag=0\n for i in range(n):\n if 2*a[i]>t:\n flag=1\n break\n if t%2==1:\n flag=1\n if flag==1:\n print('T')\n else:\n print('HL')"] | {
"inputs": [
"2\n1\n2\n2\n1 1\n",
"1\n4\n2 3 1 2\n",
"2\n2\n1 4\n3\n3 1 3\n",
"3\n2\n4 3\n4\n2 2 2 3\n3\n1 4 1\n",
"4\n5\n1 3 1 3 4\n1\n4\n1\n5\n2\n3 3\n",
"1\n3\n2 1 1\n",
"1\n4\n3 1 1 1\n",
"1\n7\n10 3 1 1 1 1 1\n"
],
"outputs": [
"T\nHL\n",
"HL\n",
"T\nT\n",
"T\nT\nT\n",
"HL\nT\nT\nHL\n",
"HL\n",
"HL\n",
"T\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 2,388 | |
887b586a0aa4900f68c5742845c18555 | UNKNOWN | There are n psychos standing in a line. Each psycho is assigned a unique integer from 1 to n. At each step every psycho who has an id greater than the psycho to his right (if exists) kills his right neighbor in the line. Note that a psycho might kill and get killed at the same step.
You're given the initial arrangement of the psychos in the line. Calculate how many steps are needed to the moment of time such, that nobody kills his neighbor after that moment. Look notes to understand the statement more precise.
-----Input-----
The first line of input contains integer n denoting the number of psychos, (1 ≤ n ≤ 10^5). In the second line there will be a list of n space separated distinct integers each in range 1 to n, inclusive — ids of the psychos in the line from left to right.
-----Output-----
Print the number of steps, so that the line remains the same afterward.
-----Examples-----
Input
10
10 9 7 8 6 5 3 4 2 1
Output
2
Input
6
1 2 3 4 5 6
Output
0
-----Note-----
In the first sample line of the psychos transforms as follows: [10 9 7 8 6 5 3 4 2 1] → [10 8 4] → [10]. So, there are two steps. | ["n = int(input())\nans = 0\nstk = []\nfor v in map(int, input().split()):\n last = 0\n while len(stk) and stk[-1][0] < v and stk[-1][1]:\n last = max(last, stk[-1][1])\n del stk[-1]\n\n if not len(stk) or stk[-1][0] < v:\n stk.append((v, 0))\n else:\n stk.append((v, last + 1)); ans = max(ans, last + 1)\nprint(ans)\n", "n, t = int(input()), list(map(int, input().split()))\np, s, r = [0] * n, [0] * n, t[0]\nfor i in range(n - 1):\n j = i + 1\n x = t[j]\n if x > r: r = x\n else:\n while t[i] < x: s[j], i = max(s[j], s[i]), p[i]\n p[j] = i\n s[j] += 1\nprint(max(s))", "n = int(input())\nans = 0\nstk = []\nfor v in map(int, input().split()):\n last = 0\n while len(stk) and stk[-1][0] < v and stk[-1][1]:\n last = max(last, stk[-1][1])\n del stk[-1]\n\n if not len(stk) or stk[-1][0] < v:\n stk.append((v, 0))\n else:\n stk.append((v, last + 1));\n ans = max(ans, last + 1)\nprint(ans)", "n, t = int(input()), list(map(int, input().split()))\n\np, s, r = [0] * n, [0] * n, t[0]\n\nfor i in range(n - 1):\n\n j = i + 1\n\n x = t[j]\n\n if x > r: r = x\n\n else:\n\n while t[i] < x: s[j], i = max(s[j], s[i]), p[i]\n\n p[j] = i\n\n s[j] += 1\n\nprint(max(s))\n\n\n\n# Made By Mostafa_Khaled\n", "n = int(input())\nA = [int(i) for i in input().split()]\nans = 0\n\nst = [0]\n\ntdeath = [-1 for i in range(n)]\n\nfor i in range(1, n):\n tdeath[i] = 0\n while len(st) > 0 and A[st[-1]] < A[i]:\n tdeath[i] = max(tdeath[i], tdeath[st[-1]]+1)\n st.pop()\n if len(st)==0:\n tdeath[i] = -1\n st.append(i)\n ans = max(ans, tdeath[i]+1)\n \nprint(ans)\n", "n = int(input())\nA = list(map(int,input().strip().split()))[::-1]\np = 0\np_max = 0\nX = []\nfor i in A:\n # print(X)\n while(len(X)>0 and X[-1][0]<i):\n p = max((p+1,X[-1][1]))\n X.pop()\n X.append((i,p))\n if p>p_max:\n p_max = p\n p=0\nprint(p_max)\n", "N=int(input())\npsychos=list(map(int, input().split(\" \")))\ntime_of_death=[0 for i in range(N)]\n\nstack=[(psychos[0], 0)]\nfor index, p in enumerate(psychos):\n if index==0:\n continue\n if p<stack[-1][0]:\n stack.append((p, 1))\n time_of_death[index]=1\n\n elif p>stack[-1][0]:\n max_time=-1\n while stack!=[] and p>stack[-1][0]:\n max_time=max(max_time, stack[-1][1])\n del stack[-1]\n if stack==[]:\n # will never die, no bigger psychos to left\n stack.append((p, 0)) \n time_of_death[index]=0 \n else:\n # will die, bigger psycho to left\n stack.append((p, max_time+1))\n time_of_death[index]=max_time+1\n\nprint(max(time_of_death))\n \n\n'''\n7\n15 9 5 10 7 11 14\n'''", "def main():\n\n from bisect import bisect_left as bl, bisect_right as br, insort\n import sys,math\n #from heapq import heapify, heappush, heappop\n from collections import defaultdict as dd, deque\n def data(): return sys.stdin.readline().strip()\n def mdata(): return list(map(int, data().split()))\n out = sys.stdout.write\n # sys.setrecursionlimit(100000)\n INF = float(\"INF\")\n mod = int(1e9)+7\n\n n=int(data())\n l=mdata()\n cnt=0\n m=0\n max1=0\n X=[]\n for i in l[::-1]:\n while len(X) and X[-1][0]<i:\n m=max(m+1,X[-1][1])\n X.pop()\n X.append([i, m])\n if m>max1:\n max1=m\n m=0\n print(max1)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from math import sqrt,ceil,gcd\nfrom collections import defaultdict\n\n\n\ndef modInverse(b,m):\n g = gcd(b, m)\n if (g != 1):\n # print(\"Inverse doesn't exist\")\n return -1\n else:\n # If b and m are relatively prime,\n # then modulo inverse is b^(m-2) mode m\n return pow(b, m - 2, m)\n\ndef sol(n,m,rep):\n\n r = 1\n for i in range(2,n+1):\n j = i\n while j%2 == 0 and rep>0:\n\n j//=2\n rep-=1\n\n r*=j\n r%=m\n\n return r\n\n\n\n\n\ndef solve():\n\n n = int(input())\n l = list(map(int,input().split()))\n st = []\n ans = 0\n hash = defaultdict(lambda : -1)\n for i in range(n):\n hash[i] = 0\n\n\n while st!=[] and l[st[-1]]<l[i]:\n z = st.pop()\n hash[i] = max(hash[i],hash[z]+1)\n\n\n if st == []:\n hash[i] = -1\n st.append(i)\n ans = max(ans,hash[i]+1)\n print(ans)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n# t = int(input())\n# for _ in range(t):\nsolve()\n\n\n\n\n\n\n\n\n\n"] | {
"inputs": [
"10\n10 9 7 8 6 5 3 4 2 1\n",
"6\n1 2 3 4 5 6\n",
"6\n6 5 4 3 2 1\n",
"10\n10 7 4 2 5 8 9 6 3 1\n",
"15\n15 9 5 10 7 11 14 6 2 3 12 1 8 13 4\n",
"1\n1\n",
"2\n1 2\n",
"2\n2 1\n"
],
"outputs": [
"2\n",
"0\n",
"1\n",
"4\n",
"4\n",
"0\n",
"0\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 4,723 | |
7935074fc451a9096bde1e1ff9782a6a | UNKNOWN | You are given a sequence a consisting of n integers. Find the maximum possible value of $a_{i} \operatorname{mod} a_{j}$ (integer remainder of a_{i} divided by a_{j}), where 1 ≤ i, j ≤ n and a_{i} ≥ a_{j}.
-----Input-----
The first line contains integer n — the length of the sequence (1 ≤ n ≤ 2·10^5).
The second line contains n space-separated integers a_{i} (1 ≤ a_{i} ≤ 10^6).
-----Output-----
Print the answer to the problem.
-----Examples-----
Input
3
3 4 5
Output
2 | ["def main():\n input()\n aa = sorted(map(int, input().split()))\n maxa = max(aa)\n m = [False] * (maxa + 1)\n x = []\n b = 0\n for a in aa:\n if b != a:\n m[a] = True\n for i in range(b, a):\n x.append(b)\n b = a\n x.append(b)\n ans = 0\n for i in range(maxa - 1, 1, -1):\n if i < ans:\n break\n if m[i]:\n for j in range(1, maxa // i + 1):\n ans = max(ans, x[min(i * (j + 1) - 1, maxa)] % i)\n print(ans)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(map(int, input().split()))\n maxa = aa[-1]\n m = [False] * (maxa + 1)\n x = []\n b = res = 0\n for a in aa:\n if b != a:\n m[a] = True\n for i in range(b, a):\n x.append(b)\n b = a\n x.append(b)\n for a in range(maxa - 1, 1, -1):\n if a < res:\n break\n if m[a]:\n for b in range(2 * a - 1, maxa + 2 * a, a):\n res = max(res, x[min(b, maxa)] % a)\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n if b != a:\n for _ in range(b, a):\n x.append(b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a < res:\n break\n for b in range(2 * a - 1, maxa + 2 * a, a):\n res = max(res, x[min(b, maxa)] % a)\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n #aa = sorted(set(map(int, input().split())))\n aa = sorted(map(int, set(input().split())))\n x = []\n b = res = 0\n for a in aa:\n if b != a:\n for _ in range(b, a):\n x.append(b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a < res:\n break\n for b in range(2 * a - 1, maxa + 2 * a, a):\n res = max(res, x[min(b, maxa)] % a)\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n for _ in range(b, a):\n x.append(b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a < res:\n break\n for b in range(2 * a - 1, maxa + 2 * a, a):\n res = max(res, x[min(b, maxa)] % a)\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n x += [b] * (a - b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a < res:\n break\n for b in range(2 * a - 1, maxa + 2 * a, a):\n res = max(res, x[min(b, maxa)] % a)\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n x += [b] * (a - b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a < res:\n break\n for b in range(2 * a - 1, maxa, a):\n res = max(res, x[b] % a)\n res = max(res, maxa % a)\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n x += [b] * (a - b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a < res:\n break\n res = max(res, maxa % a, *[b % a for b in x[2 * a - 1::a]])\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n x += [b] * (a - b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a <= res:\n break\n res = max(res, maxa % a, *(b % a for b in x[2 * a - 1::a]))\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n x += [b] * (a - b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a <= res:\n break\n res = max(res, maxa % a, *tuple(b % a for b in x[2 * a - 1::a]))\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "def main():\n input()\n aa = sorted(set(map(int, input().split())))\n x = []\n b = res = 0\n for a in aa:\n x += [b] * (a - b)\n b = a\n x.append(b)\n maxa = aa.pop()\n for a in reversed(aa):\n if a <= res:\n break\n res = max(res, maxa % a, *[b % a for b in x[2 * a - 1::a]])\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "input()\naa = sorted(set(map(int, input().split())))\nx = []\nb = res = 0\nfor a in aa:\n x += [b] * (a - b)\n b = a\nx.append(b)\nmaxa = aa.pop()\nfor a in reversed(aa):\n if a < res:\n break\n res = max(res, maxa % a, *[b % a for b in x[2 * a - 1::a]])\nprint(res)\n", "n = int(input())\na = list(set(map(int,input().split())))\nprev = [0] * 2000001\nfor x in a:\n\tprev[x] = x\nlatest = 0\nfor x in range(2000001):\n\tif prev[x] == x:\n\t\tprev[x] = latest\n\t\tlatest = x\n\telse:\n\t\tprev[x] = latest\nans = 0\t\nfor x in a:\n\tfor j in range(2 * x, 2000001, x):\n\t\tans = max(ans, prev[j] % x)\nprint (ans)", "N = 2000001\nn = int(input())\na = list(set(map(int,input().split())))\nprev = [0] * N\nfor x in a:\n\tprev[x] = x\nfor x in range(N):\n\tprev[x] = max(prev[x], prev[x - 1])\nans = 0\t\nfor x in a:\n\tfor j in range(2 * x, N, x):\n\t\tans = max(ans, prev[j - 1] % x)\nprint (ans)", "n = int(input())\na = sorted(list(set(map(int, input().split()))))\nn = len(a)\n\nlb = [0] + [-1] * 2000000\nfor x in a: lb[x] = x\nfor i in range(1,2000001):\n if (lb[i] == -1): lb[i] = lb[i-1]\n\nans = 0\nfor i in range(n):\n for j in range(2,2000000):\n if (a[i]*j > 1000000):\n ans = max(ans, a[-1] % a[i])\n break\n else: ans = max(ans, lb[j*a[i]-1] % a[i])\nprint(ans)\n\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)", "input()\nd = [0] * 2000000\nfor k in map(int, input().split()): d[k] = 1\nfor i in range(len(d)): d[i] = i if d[i] else d[i - 1]\nm = 0\nfor i in range(999999, 0, -1):\n if d[i] == i and i > m + 1: m = max(m, max(j % i for j in d[2 * i - 1::i]))\nprint(m)", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n", "input()\ns = sorted(set(map(int, input().split())))\nc = m = 0\nd = []\nfor b in s:\n d += [c] * (b - c)\n c = b\nfor b in s[-1::-1]:\n if b < m + 2: break\n m = max(m, c % b, *(a % b for a in d[2 * b - 1::b]))\nprint(m)\n"] | {
"inputs": [
"3\n3 4 5\n",
"3\n1 2 4\n",
"1\n1\n",
"1\n1000000\n",
"2\n1000000 999999\n",
"12\n4 4 10 13 28 30 41 43 58 61 70 88\n",
"7\n2 13 22 32 72 91 96\n",
"5\n5 11 12 109 110\n"
],
"outputs": [
"2\n",
"0\n",
"0\n",
"0\n",
"1\n",
"30\n",
"27\n",
"10\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 9,081 | |
9ba9292bd18eeddde8c6995e1221b5f8 | UNKNOWN | There are n beacons located at distinct positions on a number line. The i-th beacon has position a_{i} and power level b_{i}. When the i-th beacon is activated, it destroys all beacons to its left (direction of decreasing coordinates) within distance b_{i} inclusive. The beacon itself is not destroyed however. Saitama will activate the beacons one at a time from right to left. If a beacon is destroyed, it cannot be activated.
Saitama wants Genos to add a beacon strictly to the right of all the existing beacons, with any position and any power level, such that the least possible number of beacons are destroyed. Note that Genos's placement of the beacon means it will be the first beacon activated. Help Genos by finding the minimum number of beacons that could be destroyed.
-----Input-----
The first line of input contains a single integer n (1 ≤ n ≤ 100 000) — the initial number of beacons.
The i-th of next n lines contains two integers a_{i} and b_{i} (0 ≤ a_{i} ≤ 1 000 000, 1 ≤ b_{i} ≤ 1 000 000) — the position and power level of the i-th beacon respectively. No two beacons will have the same position, so a_{i} ≠ a_{j} if i ≠ j.
-----Output-----
Print a single integer — the minimum number of beacons that could be destroyed if exactly one beacon is added.
-----Examples-----
Input
4
1 9
3 1
6 1
7 4
Output
1
Input
7
1 1
2 1
3 1
4 1
5 1
6 1
7 1
Output
3
-----Note-----
For the first sample case, the minimum number of beacons destroyed is 1. One way to achieve this is to place a beacon at position 9 with power level 2.
For the second sample case, the minimum number of beacons destroyed is 3. One way to achieve this is to place a beacon at position 1337 with power level 42. | ["n = int(input())\npos_blast = [list(map(int, input().split())) for _ in range(n)]\nMAX_N = max(pos_blast, key=lambda x: x[0])[0] + 2\npower = [0 for _ in range(MAX_N)]\ntower = [False for _ in range(MAX_N)]\ncan_destroy = [0 for _ in range(MAX_N)]\nfor pos, blast in pos_blast:\n pos += 1\n tower[pos] = True\n power[pos] = blast\nfor i in range(1, MAX_N):\n if not tower[i]:\n can_destroy[i] = can_destroy[i-1]\n else:\n can_destroy[i] = can_destroy[max(0, i - power[i] - 1)] + 1\nprint(n - max(can_destroy))\n", "import sys\nN = 1<<20\nar = [0]*N\n\ndp = [0]*N\nn = int(input())\nfor i in range(0, n):\n inp = input().split()\n ar[int(inp[0])+1]= int(inp[1])\nfor i in range(N):\n dp[i] = (1 if ar[i]>=i else dp[i-ar[i]-1]+1) if ar[i] else dp[i-1]\nprint(n-max(dp))\n", "import sys\nN = 1<<20\nar = [0]*N\nn = int(input())\nfor i in range(0, n):\n inp = input().split()\n ar[int(inp[0])+1]= int(inp[1])\nfor i in range(N):\n ar[i] = (1 if ar[i]>=i else ar[i-ar[i]-1]+1) if ar[i] else ar[i-1]\nprint(n-max(ar))\n", "n = int(input())\nBecone = [list(map(int, input().split())) for i in range(n) ]\nBecone.sort( key = lambda x : x[0])\ndp = [0]*1000001\n#for i in range(1000001) :\n# dp[i] = 0\n\nif Becone[0][0] == 0 :\n dp[0] = 1\n Becone.pop(0)\n\nans = n - dp[0]\nfor i in range(1, 1000001) :\n if not Becone :\n break\n if i != Becone[0][0] :\n dp[i] = dp[i-1]\n continue\n\n a,b = Becone.pop(0)\n if a-b <= 0 :\n dp[i] = 1\n else :\n dp[i] = dp[i-b-1]+1\n\n ans = min( ans, n - dp[i] )\n\nprint( ans )\n", "from array import *\n\nn = int(input())\nBecone = [list(map(int, input().split())) for i in range(n) ]\nBecone.sort( key = lambda x : x[0])\ndp = array('i', [0]*1000001)\n\nif Becone[0][0] == 0 :\n dp[0] = 1\n Becone.pop(0)\n\nans = n - dp[0]\nfor i in range(1, 1000001) :\n if not Becone :\n break\n if i != Becone[0][0] :\n dp[i] = dp[i-1]\n continue\n\n a,b = Becone.pop(0)\n if a-b <= 0 :\n dp[i] = 1\n else :\n dp[i] = dp[i-b-1]+1\n\n ans = min( ans, n - dp[i] )\n\nprint( ans )\n", "from sys import stdin\n\nn = int(stdin.readline())\nBecone = [list(map(int, stdin.readline().split())) for i in range(n) ]\nBecone.sort( key = lambda x : x[0])\ndp = [0]*1000001\n\nif Becone[0][0] == 0 :\n dp[0] = 1\n Becone.pop(0)\n\nans = n - dp[0]\nfor i in range(1, 1000001) :\n if not Becone :\n break\n if i != Becone[0][0] :\n dp[i] = dp[i-1]\n continue\n\n a,b = Becone.pop(0)\n if a-b <= 0 :\n dp[i] = 1\n else :\n dp[i] = dp[i-b-1]+1\n\n ans = min( ans, n - dp[i] )\n\nprint( ans )\n", "def main():\n n = int(input())\n bb = [0] * 1000001\n for _ in range(n):\n a, b = list(map(int, input().split()))\n bb[a] = b\n a = 0\n for i, b in enumerate(bb):\n if b:\n a = (bb[i - b - 1] + 1) if i > b else 1\n bb[i] = a\n print(n - max(bb))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n = int(input())\ndp = [0] * 1000007\nmajak = [0] * 1000007\n\nq = 1000007\np = 0\nfor i in range(n):\n a, b = map(int, input().split())\n q = min(q, a)\n majak[a] = b\n\ndp[q] = 1\nma = 1\nfor i in range(q + 1, 1000003, 1):\n if(majak[i] == 0):\n dp[i] = dp[i - 1]\n else:\n dp[i] = dp[i - majak[i] - 1] + 1\n ma = max(ma, dp[i])\n\nprint(n - ma)", "dp = []\ndef fun(n, a):\n\tdp[0] = 1\n\tfor i in range(1, n):\n\t\tl, r = 0, i - 1\n\t\twhile l <= r:\n\t\t\tm = (l + r)>>1\n\t\t\tif a[i][0] - a[m][0] <= a[i][1]:\n\t\t\t\tr = m - 1\n\t\t\telse:\n\t\t\t\tl = m + 1\n\t\t#print (i, x)\n\t\tdp[i] = dp[r] + 1\n\n\n\n\nn = int(input())\ndp = [0 for i in range(n)]\na=[]\nfor i in range(n):\n\tl = list(map(int, input().split()))\n\ta.append(l)\na.sort()\npower = [0 for i in range(n)]\n\nfun(n, a)\n#print (dp)\nprint(n - max(dp))\t\n", "import bisect\n\ndef __starting_point():\n n = int(input())\n beacon = [tuple(map(int, input().split())) for _ in range(n)]\n beacon.sort()\n \n destroyed = [0]*n\n for i in range(n):\n lo = beacon[i][0] - beacon[i][1]\n pos = bisect.bisect_left(beacon, (lo, -1), hi=i-1)\n if beacon[pos][0] >= lo:\n pos -= 1\n if pos < 0:\n destroyed[i] = i\n else:\n destroyed[i] = max(0, i - pos - 1 + destroyed[pos])\n \n best = n\n for i, v in enumerate(destroyed):\n best = min(best, v + n - i - 1)\n print(best)\n__starting_point()", "import sys\n\nMAX_X = 1000 * 1000 + 10\n\ndef main():\n n = int(sys.stdin.readline())\n\n arr = [0] * MAX_X\n cnt = [0] * MAX_X\n dp = [0] * MAX_X\n for i in range(n):\n x, c = list(map(int, sys.stdin.readline().split()))\n arr[x + 1] = c\n\n for i in range(1, MAX_X):\n cnt[i] += cnt[i - 1] + (arr[i] != 0)\n \n for i in range(1, MAX_X):\n dp[i] = dp[max(0, i - arr[i] - 1)] + cnt[i - 1] - cnt[max(0, i - arr[i] - 1)]\n\n answer = dp[MAX_X - 1]\n add = 0\n\n for i in range(MAX_X - 1, -1, -1):\n answer = min(answer, add + dp[i])\n add += (arr[i] != 0)\n\n sys.stdout.write(str(answer))\n\nmain()\n", "read = lambda: list(map(int, input().split()))\nn = int(input())\np = sorted([tuple(read()) for i in range(n)])\na = [0] * (n + 1)\nb = [0] * (n + 1)\nfor i in range(1, n + 1):\n a[i], b[i] = p[i - 1]\na[0] = int(-1e7)\ndp = [0] * (n + 1)\nfor i in range(1, n + 1):\n L = 0\n R = n + 1\n while R - L > 1:\n M = (L + R) // 2\n if a[i] - b[i] <= a[M]: R = M\n else: L = M\n dp[i] = dp[L] + 1\nans = n - max(dp)\nprint(ans)\n", "import bisect\n\n\ndef min_destroyed(beacons):\n beacons.sort()\n dest = []\n for i, (a, b) in enumerate(beacons):\n pos = bisect.bisect_left(beacons, (a-b, 0), hi=i)\n if pos == 0:\n dest.append(i)\n else:\n dest.append(dest[pos-1] + i-pos)\n\n n = len(beacons)\n return min(d + (n-i-1) for i, d in enumerate(dest))\n\n\ndef __starting_point():\n n = int(input())\n beacons = []\n for _ in range(n):\n a, b = list(map(int, input().split()))\n beacons.append((a, b))\n print(min_destroyed(beacons))\n\n__starting_point()", "n = int(input())\na = [0]*1000001\nb = [0]*1000001\nfor i in range(n):\n l = list(map(int,input().split()))\n a[l[0]] = 1\n b[l[0]] = l[1]\n \nnotdestroyed = [0]*1000001\nif a[0] == 1:\n notdestroyed[0] = 1\nfor i in range(1,1000001):\n if a[i] == 1:\n notdestroyed[i] = notdestroyed[i-b[i]-1]+1\n else:\n notdestroyed[i] = notdestroyed[i-1]\n \nprint(n-max(notdestroyed))", "n = int(input())\nlista = []\nfor i in range(n):\n lista.append([int(x) for x in input().split()])\nlista.sort()\n\ndiccionario = dict()\nnada = True\nlast = 0\nmaximo = 0\nfor x, i in lista:\n if nada == True:\n for c in range(0, x):\n diccionario[c] = 0\n diccionario[x] = 1\n maximo = 1\n nada = False\n last = x\n else:\n for w in range(last, x):\n diccionario[w] = diccionario[last]\n if i >= x:\n diccionario[x] = 1\n else:\n aux = diccionario[x - i - 1] + 1\n if aux > maximo:\n maximo = aux\n diccionario[x] = aux\n last = x\nprint(n - maximo)\n", "N = int(input())\nd = [0 for i in range(1000005)]\nMemo = [0 for i in range(1000005)]\nmax_pos = 0\nfor i in range(N):\n subList = input().split()\n index = int(subList[0])\n d[index] = int(subList[1])\n max_pos = max(index, max_pos)\nif (d[0] != 0):\n Memo[0] = 1\n\nresult = N\nresult = min(result, N-Memo[0])\n\nfor i in range(1, max_pos+1):\n if d[i] == 0:\n Memo[i] = Memo[i-1]\n else:\n if d[i] >= i:\n Memo[i] = 1\n else:\n Memo[i] = Memo[i-d[i]-1]+1\n result = min(result, N-Memo[i])\nprint(result)\n", "N = int(input())\nd = [0 for i in range(1000001)]\nMemo = [0 for i in range(1000001)]\nmax_pos = 0\nfor i in range(N):\n subList = input().split()\n index = int(subList[0])\n d[index] = int(subList[1])\n max_pos = max(index, max_pos)\nif (d[0] != 0):\n Memo[0] = 1\n\nresult = N\nresult = min(result, N-Memo[0])\n\nfor i in range(1, max_pos+1):\n if d[i] == 0:\n Memo[i] = Memo[i-1]\n else:\n if d[i] >= i:\n Memo[i] = 1\n else:\n Memo[i] = Memo[i-d[i]-1]+1\n result = min(result, N-Memo[i])\nprint(result)\n", "from bisect import bisect_left, bisect_right\nfrom collections import Counter\nfrom collections import deque\nfrom itertools import accumulate\n\nimport math\n\nR = lambda: map(int, input().split())\nn = int(input())\na, dp = sorted([tuple(R()) for _ in range(n)]), [0] * n\nfor i, (loc, dis) in enumerate(a):\n dp[i] = dp[bisect_left(a, (loc - dis, -10**10)) - 1] + 1\nprint(n - max(dp))", "n = int(input())\n\ndp = [0] * 1000007\n\nmajak = [0] * 1000007\n\n\n\nq = 1000007\n\np = 0\n\nfor i in range(n):\n\n a, b = list(map(int, input().split()))\n\n q = min(q, a)\n\n majak[a] = b\n\n\n\ndp[q] = 1\n\nma = 1\n\nfor i in range(q + 1, 1000003, 1):\n\n if(majak[i] == 0):\n\n dp[i] = dp[i - 1]\n\n else:\n\n dp[i] = dp[i - majak[i] - 1] + 1\n\n ma = max(ma, dp[i])\n\n\n\nprint(n - ma)\n\n\n\n# Made By Mostafa_Khaled\n", "import sys,bisect\nn=int(input())\na,b=[],[]\nfor _ in range(n):\n\tai,bi=list(map(int,input().split(' ')))\n\ta.append(ai)\n\tb.append(bi)\n\ndptable=[1 for i in range(n+1)]\ndptable[0]=0\na.insert(0,-1*sys.maxsize)\nb.insert(0,0)\nab=list(zip(a,b))\nsorted(ab)\nb=[x for _,x in sorted(zip(a,b))]\na.sort()\n#print(a,\"\\n\",b)\nfor i in range(1,len(dptable)):\n\tdelupto=a[i]-b[i]\n\tdelupto=bisect.bisect_left(a,delupto)\n\t#print(delupto,i)\n\tdptable[i]=dptable[delupto-1]+1\nprint(n-max(dptable))\n", "import bisect\nclass b:\n\tdef __init__(self, loc, val, ls):\n\t\tself.loc = loc\n\t\tself.val = val\n\t\tself.ls = ls\n\t\tself.done = False\n\t\tself.ans = -1\n\n\tdef do(self):\n\t\tif self.done: return self.ans\n\t\tx = bisect.bisect_left(self.ls, self.loc-self.val) - 1\n\t\tif x == -1: self.ans = 0\n\t\telse:\n\t\t\tself.ans = ls[x].do() + 1\n\t\tself.done =True\n\t\treturn self.ans\n\n\tdef __lt__(self, obj):\n\t\tif type(obj) == int: return obj > self.loc\n\t\treturn obj.loc > self.loc\n\nls = []\nfor _ in range(int(input())):\n\tx,y = map(int, input().split(\" \"))\n\tls.append(b(x, y, ls))\nls.sort()\nm = -1\nfor l in ls:\n\tm = max(m, l.do())\nprint(len(ls) - (m+1))", "n = int(input())\nbb = [0] * 1000001\nfor _ in range(n):\n a, b = list(map(int, input().split()))\n bb[a] = b\na = 0\nfor i, b in enumerate(bb):\n if b:\n if i>b :\n a = (bb[i - b - 1] + 1)\n else :\n a=1\n \n \n bb[i] = a\nprint(n - max(bb))\n", "def bin(mas,x):\n l = 0\n r = len(mas)\n while (r > l + 1):\n m = (r + l) // 2;\n if (x < mas[m]):\n r = m;\n else:\n l = m\n return l\n\nn = int(input())\na = [-9999999]\nb = [9999999]\ndp = [0] * (n + 1)\nfor i in range(n):\n x,y=[int(i) for i in input().split()]\n a.append(x)\n b.append(y)\n\na, b = (list(x) for x in zip(*sorted(zip(a, b))))\n\n\n\nfor i in range(1,n+1):\n z = a[i] - b[i] - 1\n x = bin(a, z)\n dp[i] = dp[x] + ( i - x - 1)\nans = 10**30\nfor i in range(1, n + 1):\n ans = min(ans, dp[i] + n - i)\nprint(ans)", "from operator import itemgetter\nn = int(input())\nabi = [[-10**9,0]] + [list(map(int,input().split())) for i in range(n)]\nabi.sort(key = itemgetter(0))\nar = [0] * (n+1)\nar[0] = 0\ndef check(pos,num):\n #print(pos,num)\n if abi[pos][0] < num:\n return True\n else:\n return False\ndef binsearch(num):\n high = n+1\n low = 0\n mid = (high + low) // 2\n while high >= low:\n if check(mid,num):\n low = mid + 1\n else:\n high = mid - 1\n mid = (high + low) // 2\n return mid\nans = n\nfor i in range(1,n+1):\n num = binsearch(abi[i][0] - abi[i][1])\n ar[i] = i - num - 1+ ar[num]\n ans = min(ans, ar[i] + n - i)\nprint(ans)\n", "def bsearch(arr,num,start,end):\n mid=int((start+end)/2)\n if start>end:\n return (start,0)\n if arr[mid]==num:\n return (mid,1)\n elif arr[mid]<num:\n return bsearch(arr,num,mid+1,end)\n else:\n return bsearch(arr,num,start,mid-1)\nt=int(input())\nA=[]\nB=[]\nN=[]#next undestroyed beacon\nNUM=[]#number of destroyed beacon if current veacon activated\n\nabp=[]\nfor i in range(0,t):\n ab=input().split(' ')\n a,b=int(ab[0]),int(ab[1])\n abp.append((a,b))\nabp_S=sorted(abp,key = lambda bk:bk[0])\nfor i in range(0,len(abp_S)):\n a,b=abp_S[i]\n A.append(a)\n B.append(b)\n pos=bsearch(A,a-b,0,len(A)-1) \n if pos[0]==0:\n N.append(pos[0]-1)\n NUM.append(i)\n else:\n N.append(pos[0]-1)\n NUM.append((i-pos[0])+NUM[pos[0]-1])\ndamages=[]\nfor i in range(0,len(A)):\n damages.append((len(A)-(i+1))+NUM[i])\nprint(min(damages))\n\n\n"] | {
"inputs": [
"4\n1 9\n3 1\n6 1\n7 4\n",
"7\n1 1\n2 1\n3 1\n4 1\n5 1\n6 1\n7 1\n",
"1\n0 1\n",
"1\n0 1000000\n",
"1\n1000000 1000000\n",
"7\n1 1\n2 1\n3 1\n4 1\n5 1\n6 6\n7 7\n",
"5\n1 1\n3 1\n5 1\n7 10\n8 10\n",
"11\n110 90\n100 70\n90 10\n80 10\n70 1\n60 1\n50 10\n40 1\n30 1\n10 1\n20 1\n"
],
"outputs": [
"1\n",
"3\n",
"0\n",
"0\n",
"0\n",
"4\n",
"2\n",
"4\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 13,246 | |
f435ef669b822066e342265027a67ad0 | UNKNOWN | John Smith knows that his son, Thomas Smith, is among the best students in his class and even in his school. After the students of the school took the exams in English, German, Math, and History, a table of results was formed.
There are $n$ students, each of them has a unique id (from $1$ to $n$). Thomas's id is $1$. Every student has four scores correspond to his or her English, German, Math, and History scores. The students are given in order of increasing of their ids.
In the table, the students will be sorted by decreasing the sum of their scores. So, a student with the largest sum will get the first place. If two or more students have the same sum, these students will be sorted by increasing their ids.
Please help John find out the rank of his son.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 1000$) — the number of students.
Each of the next $n$ lines contains four integers $a_i$, $b_i$, $c_i$, and $d_i$ ($0\leq a_i, b_i, c_i, d_i\leq 100$) — the grades of the $i$-th student on English, German, Math, and History. The id of the $i$-th student is equal to $i$.
-----Output-----
Print the rank of Thomas Smith. Thomas's id is $1$.
-----Examples-----
Input
5
100 98 100 100
100 100 100 100
100 100 99 99
90 99 90 100
100 98 60 99
Output
2
Input
6
100 80 90 99
60 60 60 60
90 60 100 60
60 100 60 80
100 100 0 100
0 0 0 0
Output
1
-----Note-----
In the first sample, the students got total scores: $398$, $400$, $398$, $379$, and $357$. Among the $5$ students, Thomas and the third student have the second highest score, but Thomas has a smaller id, so his rank is $2$.
In the second sample, the students got total scores: $369$, $240$, $310$, $300$, $300$, and $0$. Among the $6$ students, Thomas got the highest score, so his rank is $1$. | ["def main():\n n = int(input())\n scores = []\n for i in range(n):\n a = list(map(int, input().split()))\n tot = sum(a)\n scores.append((-tot, i))\n\n scores.sort()\n for i in range(n):\n if scores[i][1] == 0:\n print(i + 1)\n\nmain()\n", "n = int(input())\na = [sum(map(int, input().split())) for _ in range(n)]\nprint(sum(v > a[0] for v in a[1:]) + 1)", "n = int(input())\n\narr = [(0, 0)] * n\n\nfor i in range(n):\n\ta = sum(list(map(int, input().split())))\n\tarr[i] = (-a, i)\narr.sort()\n\nfor i in range(n):\n\tif arr[i][1] == 0:\n\t\tprint(i + 1)", "n = int(input())\ns = []\nfor i in range(n):\n a, b, c, d = list(map(int, input().split()))\n s.append((-(a + b + c + d), i))\n if i == 0:\n x = -(a + b + c + d)\ns.sort()\nprint(1 + s.index((x, 0)))\n", "n = int(input())\n\ndata = []\nfor i in range(n):\n a = [int(v) for v in input().split()]\n data.append((-sum(a), i))\ndata.sort()\n\nfor j, (_, i) in enumerate(data):\n if i == 0:\n print(j + 1)\n break\n", "n = int(input())\nx = []\nfor i in range(1,n+1):\n l = list(map(int,input().split()))\n x.append([i,sum(l)])\nx.sort(key=lambda x:x[1],reverse=True)\nc = 0\nfor i in x:\n c+=1\n if(i[0]==1):\n print(c)\n break", "n=int(input())\nl=list(map(int,input().strip().split()))\ncount=1\nr=sum(l)\nfor i in range(n-1):\n\tl=list(map(int,input().strip().split()))\n\tr1=sum(l)\n\tif r1>r:\n\t\tcount=count+1\nprint (count)\n", "n = int(input())\na = []\ns = sum(list(map(int, input().split())))\nans = 1\nfor i in range(n - 1):\n x = sum(list(map(int, input().split())))\n if x > s:\n ans += 1\n\nprint(ans)\n", "n = int(input())\nans = 1\na, b, c, d = map(int, input().split())\ns = a+b+c+d\nfor i in range(n-1):\n a, b, c, d = map(int, input().split())\n t = a+b+c+d\n if s < t: ans += 1\nprint(ans)", "from sys import stdin\nfrom math import *\n\nline = stdin.readline().rstrip().split()\nn = int(line[0])\n\nnumbers = list(map(int, stdin.readline().rstrip().split()))\n\nscoreSon = sum(numbers)\n\nnumBefore = 0\n\nfor i in range(n-1):\n numbers = list(map(int, stdin.readline().rstrip().split()))\n score = sum(numbers)\n if score > scoreSon:\n numBefore+=1\nprint(numBefore+1)\n\n", "n=int(input())\nx=[]\nfor i in range(n):\n a=list(map(int,input().split()))\n a.append(i+1)\n x.append(a)\nx.sort(key=lambda x:[-sum(x[:4]),x[4]])\nfor i in range(n):\n if x[i][4]==1:\n print(i+1)\n return", "n = int(input())\np = sorted([(-sum(map(int, input().split())), i) for i in range(n)])\n\nfor i in range(n):\n if p[i][1] == 0:\n print(i + 1)\n break\n\n", "def ii():\n return int(input())\ndef mi():\n return map(int, input().split())\ndef li():\n return list(mi())\n\nn = ii()\na = [(sum(list(map(int, input().split()))), -i) for i in range(n)]\na.sort(reverse=True)\n\nfor i in range(n):\n if a[i][1] == 0:\n print(i + 1)", "from sys import stdin, stdout\nfrom math import log2\n\nn = int(stdin.readline())\nchallengers = []\n\nfor i in range(n):\n a, b, c, d = map(int, stdin.readline().split())\n challengers.append((-(a + b + c + d), i))\n\nchallengers.sort()\n\nfor i in range(n):\n if not challengers[i][1]:\n stdout.write(str(i + 1))\n break", "n=int(input())\narrx=[]\nfor i in range(n):\n arr=list(map(int,input().split()))\n arrx.append(sum(arr))\nans=1\nfor i in range(1,n):\n if(arrx[i]>arrx[0]):\n ans+=1\nprint(ans)", "n = int(input())\nthomas = sum(map(int, input().split()))\nall = [thomas]\nfor _ in range(n - 1):\n all.append(sum(map(int, input().split())))\nall.sort(reverse=True)\ni = all.index(thomas)\nprint(i + 1)\n", "n = int(input())\nc = 0\nson = sum(list(map(int, input().split()))) / 4\nfor i in range(n-1):\n others = sum(list(map(int, input().split()))) / 4\n if son >= others:\n c += 1\nprint(n-c)", "n = int(input())\nscore = []\nson = 0\nfor i in range(n):\n wk1 = sum([*list(map(int, input().split()))])\n if (i == 0):\n son = wk1\n score.append(wk1)\nscore.sort(reverse = True)\nprint(score.index(son) + 1)\n", "students = []\nfor i in range(int(input())):\n students.append([i, sum(map(int, input().split()))])\n\nstudents.sort(key=lambda x:(-x[1], x[0]))\nfor i, student in enumerate(students):\n if student[0] == 0:\n print(i+1)\n break\n\n", "3\n\nn = int(input())\nl = []\n\nfor i in range(n):\n a, b, c, d = list(map(int, input().split()))\n l.append((a, b, c, d))\n\nans = 1\nfor i in range(1, n):\n if sum(l[i]) > sum(l[0]):\n ans += 1\n\nprint(ans)\n", "n = int(input())\nj = list(map(int, input().split()))\nq = sum(j)\nk = 1\nfor i in range(n - 1):\n x = list(map(int, input().split()))\n y = sum(x)\n if y > q:\n k += 1\n\nprint(k)", "n = int(input())\nu = []\nt = 0\nfor i in range(n):\n u.append(sum(list(map(int, input().split()))))\nt = u[0]\nu.sort(reverse = 1)\nfor i in range(n):\n if u[i] == t:\n print(i + 1)\n break\n", "3\n\ndef main():\n N = int(input())\n A = []\n for i, _ in enumerate(range(N)):\n a, b, c, d = [int(e) for e in input().split(' ')]\n A.append((-(a + b + c + d), i + 1))\n\n A.sort()\n\n for i in range(N):\n if A[i][1] == 1:\n print(i + 1)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "# \nimport collections, atexit, math, sys, bisect \n\nsys.setrecursionlimit(1000000)\ndef getIntList():\n return list(map(int, input().split())) \n\ntry :\n #raise ModuleNotFoundError\n import numpy\n def dprint(*args, **kwargs):\n print(*args, **kwargs, file=sys.stderr)\n dprint('debug mode')\nexcept ModuleNotFoundError:\n def dprint(*args, **kwargs):\n pass\n\n\n\ninId = 0\noutId = 0\nif inId>0:\n dprint('use input', inId)\n sys.stdin = open('input'+ str(inId) + '.txt', 'r') #\u6807\u51c6\u8f93\u51fa\u91cd\u5b9a\u5411\u81f3\u6587\u4ef6\nif outId>0:\n dprint('use output', outId)\n sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #\u6807\u51c6\u8f93\u51fa\u91cd\u5b9a\u5411\u81f3\u6587\u4ef6\n atexit.register(lambda :sys.stdout.close()) #idle \u4e2d\u4e0d\u4f1a\u6267\u884c atexit\n \nN, = getIntList()\nzz = []\nfor i in range(N):\n zx = getIntList()\n zz.append((sum(zx),-i, i+1))\n\nzz.sort(reverse= True)\n\nfor i in range(N):\n if zz[i][2] ==1:\n print(i+1)\n break\n\n\n\n\n\n\n", "USE_STDIO = False\n\nif not USE_STDIO:\n try: import mypc\n except: pass\n\ndef main():\n n, = list(map(int, input().split(' ')))\n scores = []\n for id in range(n):\n scores.append((-sum(map(int, input().split(' '))), id))\n scores.sort()\n for rank in range(n):\n if scores[rank][1] == 0:\n print(rank + 1)\n return\n\ndef __starting_point():\n main()\n\n\n\n\n__starting_point()"] | {
"inputs": [
"5\n100 98 100 100\n100 100 100 100\n100 100 99 99\n90 99 90 100\n100 98 60 99\n",
"6\n100 80 90 99\n60 60 60 60\n90 60 100 60\n60 100 60 80\n100 100 0 100\n0 0 0 0\n",
"1\n0 0 0 0\n",
"1\n15 71 57 86\n",
"5\n4 8 2 6\n8 3 5 2\n7 9 5 10\n7 10 10 7\n7 6 7 3\n",
"9\n1 2 1 1\n2 2 2 2\n3 3 3 3\n4 4 4 4\n5 5 5 5\n6 6 6 6\n7 7 7 7\n8 8 8 8\n9 9 9 9\n",
"8\n19 12 11 0\n10 3 14 5\n9 9 5 12\n4 9 1 4\n19 17 9 0\n20 16 10 13\n8 13 16 3\n10 0 9 19\n",
"18\n68 32 84 6\n44 53 11 21\n61 34 77 82\n19 36 47 58\n47 73 31 96\n17 50 82 16\n57 90 64 8\n14 37 45 69\n48 1 18 58\n42 34 96 14\n56 82 33 77\n40 66 30 53\n33 31 44 95\n0 90 24 8\n7 85 39 1\n76 77 93 35\n98 9 62 13\n24 84 60 51\n"
],
"outputs": [
"2\n",
"1\n",
"1\n",
"1\n",
"4\n",
"9\n",
"3\n",
"8\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 6,978 | |
b5084491e2f69e10852921f33b466ed8 | UNKNOWN | You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.
For instance, if we are given an array $[10, 20, 30, 40]$, we can permute it so that it becomes $[20, 40, 10, 30]$. Then on the first and the second positions the integers became larger ($20>10$, $40>20$) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals $2$. Read the note for the first example, there is one more demonstrative test case.
Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
-----Input-----
The first line contains a single integer $n$ ($1 \leq n \leq 10^5$) — the length of the array.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the elements of the array.
-----Output-----
Print a single integer — the maximal number of the array's elements which after a permutation will stand on the position where a smaller element stood in the initial array.
-----Examples-----
Input
7
10 1 1 1 5 5 3
Output
4
Input
5
1 1 1 1 1
Output
0
-----Note-----
In the first sample, one of the best permutations is $[1, 5, 5, 3, 10, 1, 1]$. On the positions from second to fifth the elements became larger, so the answer for this permutation is 4.
In the second sample, there is no way to increase any element with a permutation, so the answer is 0. | ["from collections import Counter\n\nn = int(input())\na = list(map(int, input().split()))\nc = Counter(a)\n\nres = 0\ncur = 0\nfor i in sorted(c.keys()):\n d = min(c[i], cur)\n cur -= d\n res += d\n cur += c[i]\n\nprint(res)", "3\n\ndef solve(N, A):\n A.sort()\n\n i = 0\n j = 0\n c = 0\n\n while j < N:\n while j < N and A[j] == A[i]:\n j += 1\n\n if j == N:\n break\n\n c += 1\n i += 1\n j += 1\n\n return c\n\n\ndef main():\n N = int(input())\n A = [int(e) for e in input().split(' ')]\n print(solve(N, A))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n = int(input())\narr = [int(t) for t in input().split()]\narr.sort()\n\nnx = 0\ni = 0\nres = 0\nwhile i < n:\n j = i\n while j < n and arr[i] == arr[j]:\n j += 1\n nx = max(nx, j)\n t = min(j - i, n - nx)\n nx += t\n nx = min(nx, n)\n res += t\n i = j\nprint(res)\n", "from collections import *\nprint(int(input()) - max(Counter(map(int,input().split())).values()))", "n = int(input())\narr = list(map(int, input().split()))\narr.sort(reverse=True)\nr = 0\ns = 0\nm = 1\nfor i in range(1, n):\n if arr[i] < arr[i - 1]:\n s += m\n m = 1\n else:\n m += 1\n if s:\n s -= 1\n r += 1\nprint(r)\n", "from collections import Counter\n\n\ndef main():\n input()\n cnt = Counter(list(map(int, input().split())))\n a, *rest = sorted(cnt.keys())\n pool, res = cnt[a], 0\n for a in rest:\n c = cnt[a]\n if pool < c:\n res += pool\n pool = c\n else:\n res += c\n print(res)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "\ndef main():\n\tn=int(input())\n\tli=list(map(int,input().split()))\n\tli.sort()\n\tli.reverse()\n\ti,j,count=0,1,0\n\twhile j<len(li):\n\t\tif li[j]<li[i]:\n\t\t\tj+=1\n\t\t\ti+=1\n\t\t\tcount+=1\n\t\telse:\n\t\t\tj+=1\n\tprint(count)\n\t\n\ndef __starting_point():\n\tmain()\n\n__starting_point()", "def readints():\n return [int(x) for x in input().strip().split()]\n\n\ndef main():\n n = readints()[0]\n a = sorted(readints())\n\n marker = 0\n for i in range(n):\n if a[i] > a[0]:\n break\n marker += 1\n\n ans = 0\n for i in range(n):\n while marker < n:\n if a[i] < a[marker]:\n ans += 1\n marker += 1\n break\n marker += 1\n\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n = int(input())\n\na = list(map(int,input().split(' ')))\n\nz = {}\n\nfor i in range(n):\n if a[i] not in z:\n z[a[i]] = 1\n else:\n z[a[i]] +=1\n\nans = n\n\n\ns = sorted(z.values())\n\nans = ans - max(s)\n\nprint(ans)\n", "n = int(input())\na = [int(i) for i in input().split()]\nd = {}\nfor i in a:\n d[i] = 0\n\nfor i in a:\n d[i] += 1\n\nans = n - max(d.values())\nprint(ans)\n", "def solution(n, num_array):\n\n\t# If there is only one element in the list, return 0.\n\tif (len(num_array) == 1):\n\t\treturn 0\n\t\n\n\t# sort the array first\n\tnum_array.sort()\n\tidx1 = 0\n\tidx2 = 1\n\tres = 0\n\twhile (idx2 < len(num_array)):\n\t\tnum1 = num_array[idx1]\n\t\tnum2 = num_array[idx2]\n\n\t\tif (num1 < num2):\n\t\t\tres += 1\n\t\t\tidx1 += 1\n\n\t\tidx2 += 1\n\n\t\n\treturn res\n\n\n\n\nn = input()\nnum_array = list(map(int, input().split()))\n\nprint(solution(n, num_array))\n\n\n", "def solution(n, num_array):\n\n\t# If there is only one element in the list, return 0.\n\t# import pdb; pdb.set_trace\n\tif (len(num_array) == 1):\n\t\treturn 0\n\t\n\n\t# sort the array first\n\tnum_array.sort()\n\tidx1 = 0\n\tidx2 = 1\n\tres = 0\n\twhile (idx2 < len(num_array)):\n\t\tnum1 = num_array[idx1]\n\t\tnum2 = num_array[idx2]\n\n\t\tif (num1 < num2):\n\t\t\t# swap the numbers\n\t\t\tres += 1\n\t\t\tidx1 += 1\n\t\t\tidx2 += 1\n\n\t\telse:\n\t\t\tidx2 += 1\n\n\t# print(sorted_arr)\n\treturn res\n\n\n\n\nn = input()\nnum_array = list(map(int, input().split()))\n\nprint(solution(n, num_array))\n\n\n", "n = int(input())\narr = sorted([int(a) for a in input().split()])\nj = 0\nfor i in range(0, n):\n if arr[i] > arr[j]:\n j += 1\nprint(j)\n\n", "n = int(input())\na = list(map(int, input().split(' ')))\na.sort()\nd = 0\nj = 0\nm = 1\nfor i in range(1, len(a)):\n if a[i] == a[j]:\n m += 1\n else:\n if m > d:\n d = m\n m = 1\n j = i\n\nif m > d:\n d = m\n\nprint(len(a) - d)\n", "def count_sort(mass, st):\n i = st\n while i < len(mass):\n if mass[i] != mass[st]:\n break\n i += 1\n return i - st\n\n\nn = int(input())\n\na = [int(x) for x in input().split(\" \")]\n\na.sort()\n\ni = a.count(a[0]) \nleft = i\nres = n - left\nwhile i < len(a) :\n count = count_sort(a, i)\n i += count\n left -= count\n if left < 0:\n res += left\n left = 0\n left += count\n \nprint(res)\n", "def go():\n n = int(input())\n a = sorted([int(i) for i in input().split(' ')])\n total = i = j = 0\n while j < n:\n if a[i] == a[j]:\n j += 1\n else:\n break\n while j < n:\n if a[i] < a[j]:\n total += 1\n i += 1\n j += 1\n return total\n\nprint(go())\n", "n = int(input())\na = list(map(int, input().split()))\n\na.sort()\n\ni = 0\nfor j in range(n):\n\tif a[i] < a[j]:\n\t\ti = i + 1\n\nprint(i)", "from collections import Counter\nn = int(input())\narray = list(map(int, input().split()))\nprint(n - Counter(array).most_common(1)[0][1])\n", "from collections import Counter\nn=int(input())\na =map(int, input().split())\nb=Counter(a).values()\nmaxx=max(b)\nprint(n-maxx)", "from collections import Counter as co\nx=int(input())\ny=list(map(int,input().split()))\nprint(x-max(co(y).values()))\n", "from collections import*\nn = int(input())\n\ns = list(map(int, input().split()))\n\nx = max(Counter(s).values())\n\nprint(n - x)\n\n", "from collections import Counter\nlength = int(input())\narray = list(map(int, input().split()))\ndic = Counter(array)\nvalue_list = list(dic.values())\nprint(len(array) - max(value_list))", "from collections import *\n\nprint( int(input()) - max(Counter(map(int, input().split())).values()) )", "from collections import*\nprint(int(input())-max(Counter(map(int,input().split())).values()))"] | {
"inputs": [
"7\n10 1 1 1 5 5 3\n",
"5\n1 1 1 1 1\n",
"6\n300000000 200000000 300000000 200000000 1000000000 300000000\n",
"10\n1 2 3 4 5 6 7 8 9 10\n",
"1\n1\n",
"7\n3 5 2 2 5 2 4\n",
"5\n1 5 4 2 3\n"
],
"outputs": [
"4\n",
"0\n",
"3\n",
"9\n",
"0\n",
"4\n",
"4\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 6,432 | |
3cf34b775c9ec938ce3f3e0461910ef6 | UNKNOWN | You are given a string S of length n with each character being one of the first m lowercase English letters.
Calculate how many different strings T of length n composed from the first m lowercase English letters exist such that the length of LCS (longest common subsequence) between S and T is n - 1.
Recall that LCS of two strings S and T is the longest string C such that C both in S and T as a subsequence.
-----Input-----
The first line contains two numbers n and m denoting the length of string S and number of first English lowercase characters forming the character set for strings (1 ≤ n ≤ 100 000, 2 ≤ m ≤ 26).
The second line contains string S.
-----Output-----
Print the only line containing the answer.
-----Examples-----
Input
3 3
aaa
Output
6
Input
3 3
aab
Output
11
Input
1 2
a
Output
1
Input
10 9
abacadefgh
Output
789
-----Note-----
For the first sample, the 6 possible strings T are: aab, aac, aba, aca, baa, caa.
For the second sample, the 11 possible strings T are: aaa, aac, aba, abb, abc, aca, acb, baa, bab, caa, cab.
For the third sample, the only possible string T is b. | ["n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = map(int, input().split())\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = list(map(int, input().split()))\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)\n", "n, m = map(int, input().split())\ns = input()\np = c = 0\nfor i in range(1, n):\n if s[i] == s[i - 1]:\n c += n * (m - 1)\n p = i\n elif s[i] != s[i - 2]:\n p = i - 1\n c += i - p\nans = n * n * (m - 1) - c\nprint(ans)"] | {
"inputs": [
"3 3\naaa\n",
"3 3\naab\n",
"1 2\na\n",
"10 9\nabacadefgh\n",
"15 3\nabababababababa\n",
"100 26\njysrixyptvsesnapfljeqkytlpeepjopspmkviqdqbdkylvfiawhdjjdvqqvcjmmsgfdmpjwahuwhgsyfcgnefzmqlvtvqqfbfsf\n",
"1 26\nz\n"
],
"outputs": [
"6\n",
"11\n",
"1\n",
"789\n",
"345\n",
"237400\n",
"25\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 2,844 | |
befee0d917057ab5d749349d54948fdf | UNKNOWN | You are given a string A. Find a string B, where B is a palindrome and A is a subsequence of B.
A subsequence of a string is a string that can be derived from it by deleting some (not necessarily consecutive) characters without changing the order of the remaining characters. For example, "cotst" is a subsequence of "contest".
A palindrome is a string that reads the same forward or backward.
The length of string B should be at most 10^4. It is guaranteed that there always exists such string.
You do not need to find the shortest answer, the only restriction is that the length of string B should not exceed 10^4.
-----Input-----
First line contains a string A (1 ≤ |A| ≤ 10^3) consisting of lowercase Latin letters, where |A| is a length of A.
-----Output-----
Output single line containing B consisting of only lowercase Latin letters. You do not need to find the shortest answer, the only restriction is that the length of string B should not exceed 10^4. If there are many possible B, print any of them.
-----Examples-----
Input
aba
Output
aba
Input
ab
Output
aabaa
-----Note-----
In the first example, "aba" is a subsequence of "aba" which is a palindrome.
In the second example, "ab" is a subsequence of "aabaa" which is a palindrome. | ["a = input()\nb = a[::-1]\nprint(a + b)", "a = input()\nprint(a + a[::-1])", "a = input()\nprint(a, a[::-1], sep = '')", "s = input()\nprint( s + s[::-1])\n", "inp = input()\nprint(inp+inp[::-1])", "def main():\n a = input()\n print(a + a[::-1])\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "s = input()\ns = s + s[::-1]\nprint(s)", "s = input()\nprint(s + s[::-1])", "s = input().strip()\nprint(s + s[::-1])", "s = input()\nprint(s, s[::-1], sep='')\n", "s = input()\nprint(s + s[::-1])", "a = input()\nprint(a + a[::-1])", "s = input()\ns2 = s\nprint(s + s2[::-1])\n", "s = input()\nprint(s + s[::-1])", "s = input()\nprint(s + s[::-1])", "a=input()\nprint(a+a[::-1])\n", "a = input()\nprint (a+a[::-1])", "a = input()\nprint(a + a[::-1])\n", "a = input()\nprint(a + a[::-1])\n", "s=str(input())\nprint(s+s[::-1])\n", "a = input()\nprint(a+a[::-1])", "s = input()\nprint(s + s[::-1])", "A = input().strip()\nprint(A + A[::-1])\n"] | {
"inputs": [
"aba\n",
"ab\n",
"abcab\n",
"baaaaaaa\n",
"baaaaaa\n",
"baaaaaaaaa\n",
"baaaaaaaa\n"
],
"outputs": [
"abaaba",
"abba",
"abcabbacba",
"baaaaaaaaaaaaaab",
"baaaaaaaaaaaab",
"baaaaaaaaaaaaaaaaaab",
"baaaaaaaaaaaaaaaab"
]
}
| COMPETITION | PYTHON3 | CODEFORCES | 959 | |
03d4d8a71ed51db2f203ed49ab73dc4d | UNKNOWN | Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$ (a_1 + a_2) \oplus (a_1 + a_3) \oplus \ldots \oplus (a_1 + a_n) \\ \oplus (a_2 + a_3) \oplus \ldots \oplus (a_2 + a_n) \\ \ldots \\ \oplus (a_{n-1} + a_n) \\ $$
Here $x \oplus y$ is a bitwise XOR operation (i.e. $x$ ^ $y$ in many modern programming languages). You can read about it in Wikipedia: https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation.
-----Input-----
The first line contains a single integer $n$ ($2 \leq n \leq 400\,000$) — the number of integers in the array.
The second line contains integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^7$).
-----Output-----
Print a single integer — xor of all pairwise sums of integers in the given array.
-----Examples-----
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
-----Note-----
In the first sample case there is only one sum $1 + 2 = 3$.
In the second sample case there are three sums: $1 + 2 = 3$, $1 + 3 = 4$, $2 + 3 = 5$. In binary they are represented as $011_2 \oplus 100_2 \oplus 101_2 = 010_2$, thus the answer is 2.
$\oplus$ is the bitwise xor operation. To define $x \oplus y$, consider binary representations of integers $x$ and $y$. We put the $i$-th bit of the result to be 1 when exactly one of the $i$-th bits of $x$ and $y$ is 1. Otherwise, the $i$-th bit of the result is put to be 0. For example, $0101_2 \, \oplus \, 0011_2 = 0110_2$. | ["import sys\ninput = sys.stdin.readline \n\n\nn = int(input())\na = list(map(int, input().split()))\nb = a\n\nans = 0\nfor k in range(29):\n a0 = []\n a1 = []\n a0a = a0.append\n a1a = a1.append\n \n b0 = []\n b1 = []\n b0a = b0.append\n b1a = b1.append\n for i in a:\n if i&(1<<k): a1a(i)\n else: a0a(i)\n for i in b:\n if i&(1<<k): b1a(i)\n else: b0a(i)\n \n a = a0+a1\n b = b0+b1\n mask = (1<<(k+1))-1\n \n aa = [i&mask for i in a]\n bb = [i&mask for i in b]\n \n res = 0\n p1 = 1<<k\n p2 = mask+1\n p3 = p1+p2\n\n j1 = j2 = j3 = 0 \n for jj, ai in enumerate(reversed(aa)):\n while j1 < n and ai+bb[j1] < p1:\n j1 += 1\n while j2 < n and ai+bb[j2] < p2:\n j2 += 1\n while j3 < n and ai+bb[j3] < p3:\n j3 += 1\n res += max(n, n - jj) - max(j3, n - jj)\n res += max(j2, n - jj) - max(j1, n - jj)\n ans |= (res & 1) << k\n \nprint(ans) \n"] | {
"inputs": [
"2\n1 2\n",
"3\n1 2 3\n",
"2\n1 1\n",
"100\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100\n",
"50\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n",
"51\n50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100\n",
"3\n2 2 8\n"
],
"outputs": [
"3",
"2",
"2",
"102",
"3",
"148",
"4"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,023 | |
437193bd52a56e6941e7bcc6c01a45b2 | UNKNOWN | You are given a sequence of n integers a_1, a_2, ..., a_{n}.
Determine a real number x such that the weakness of the sequence a_1 - x, a_2 - x, ..., a_{n} - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
-----Input-----
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a_1, a_2, ..., a_{n} (|a_{i}| ≤ 10 000).
-----Output-----
Output a real number denoting the minimum possible weakness of a_1 - x, a_2 - x, ..., a_{n} - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10^{ - 6}.
-----Examples-----
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
-----Note-----
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | ["import sys\nn = int(sys.stdin.readline())\na = [int(x) for x in sys.stdin.readline().split()]\n\neps = 1e-12\n\ndef f(x):\n mx = a[0] - x\n tsmx = 0.0\n mn = a[0] - x\n tsmn = 0.0\n for ai in a:\n tsmx = max(tsmx + ai - x, ai - x)\n mx = max(tsmx, mx)\n tsmn = min(tsmn + ai - x, ai - x)\n mn = min(tsmn, mn)\n\n return abs(mx), abs(mn)\n\nl = min(a)\nr = max(a)\nf1, f2 = f(l)\nfor i in range(0, 90):\n m = (l + r) / 2\n f1, f2 = f(m)\n if f1 > f2:\n l = m\n else:\n r = m\n\nA, B = f(l)\nprint(min(A,B))", "def f(x):\n bi = 0\n ci = 0\n cnt1 = -10 ** 10\n minsum1 = 10 ** 10\n cnt2 = -10 ** 10\n minsum2 = 10 ** 10\n for i in range(len(A)):\n if bi - minsum1 > cnt1:\n cnt1 = bi - minsum1\n if bi <= minsum1:\n minsum1 = bi\n if ci - minsum2 > cnt2:\n cnt2 = ci - minsum2\n if ci <= minsum2:\n minsum2 = ci\n bi += A[i] - x\n ci += x - A[i]\n if bi - minsum1 > cnt1:\n cnt1 = bi - minsum1\n if bi <= minsum1:\n minsum1 = bi\n if ci - minsum2 > cnt2:\n cnt2 = ci - minsum2\n if ci <= minsum2:\n minsum2 = ci\n return max(cnt1, cnt2, 0)\n\n\nn = int(input())\nA = list(map(int, input().split()))\nl = min(A)\nr = max(A)\nfor _ in range(70):\n p = l + (r - l) / 3\n q = r - (r - l) / 3\n x = f(p)\n y = f(q)\n if x > y:\n l = p\n elif y > x:\n r = q\n else:\n l = p\n r = q\nprint(f(l))", "def weakness(a, x):\n a = [elem-x for elem in a]\n acumulado = maximo = 0\n for elem in a:\n if acumulado + elem > 0:\n acumulado += elem\n else:\n acumulado = 0\n if acumulado > maximo:\n maximo = acumulado\n acumulado = minimo = 0\n for elem in a:\n if acumulado + elem < 0:\n acumulado += elem\n else:\n acumulado = 0\n if acumulado < minimo:\n minimo = acumulado\n return max(maximo, -minimo)\n\n\nn, a = input(), list(map(int, input().split()))\n\ninf, sup = min(a), max(a)\nfor _ in range(70):\n c1, c2 = (2*inf+sup)/3, (inf+2*sup)/3\n if weakness(a, c1) < weakness(a, c2):\n sup = c2\n else:\n inf = c1\n\nprint(weakness(a, (inf+sup)/2))\n\n"] | {
"inputs": [
"3\n1 2 3\n",
"4\n1 2 3 4\n",
"10\n1 10 2 9 3 8 4 7 5 6\n",
"1\n-10000\n",
"3\n10000 -10000 10000\n",
"20\n-16 -23 29 44 -40 -50 -41 34 -38 30 -12 28 -44 -49 15 50 -28 38 -2 0\n",
"10\n-405 -230 252 -393 -390 -259 97 163 81 -129\n"
],
"outputs": [
"1.000000000000000\n",
"2.000000000000000\n",
"4.500000000000000\n",
"0.000000000000000\n",
"10000.000000000000000\n",
"113.875000000000000\n",
"702.333333333333370\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 2,361 | |
164a4a23e29b65e58aaf5c5042220dfc | UNKNOWN | An array of integers $p_{1},p_{2}, \ldots,p_{n}$ is called a permutation if it contains each number from $1$ to $n$ exactly once. For example, the following arrays are permutations: $[3,1,2], [1], [1,2,3,4,5]$ and $[4,3,1,2]$. The following arrays are not permutations: $[2], [1,1], [2,3,4]$.
There is a hidden permutation of length $n$.
For each index $i$, you are given $s_{i}$, which equals to the sum of all $p_{j}$ such that $j < i$ and $p_{j} < p_{i}$. In other words, $s_i$ is the sum of elements before the $i$-th element that are smaller than the $i$-th element.
Your task is to restore the permutation.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 2 \cdot 10^{5}$) — the size of the permutation.
The second line contains $n$ integers $s_{1}, s_{2}, \ldots, s_{n}$ ($0 \le s_{i} \le \frac{n(n-1)}{2}$).
It is guaranteed that the array $s$ corresponds to a valid permutation of length $n$.
-----Output-----
Print $n$ integers $p_{1}, p_{2}, \ldots, p_{n}$ — the elements of the restored permutation. We can show that the answer is always unique.
-----Examples-----
Input
3
0 0 0
Output
3 2 1
Input
2
0 1
Output
1 2
Input
5
0 1 1 1 10
Output
1 4 3 2 5
-----Note-----
In the first example for each $i$ there is no index $j$ satisfying both conditions, hence $s_i$ are always $0$.
In the second example for $i = 2$ it happens that $j = 1$ satisfies the conditions, so $s_2 = p_1$.
In the third example for $i = 2, 3, 4$ only $j = 1$ satisfies the conditions, so $s_2 = s_3 = s_4 = 1$. For $i = 5$ all $j = 1, 2, 3, 4$ are possible, so $s_5 = p_1 + p_2 + p_3 + p_4 = 10$. | ["import sys\ninput = sys.stdin.readline\n\nn=int(input())\nA=list(map(int,input().split()))\n\nBIT=[0]*(n+1)\n\ndef update(v,w):\n while v<=n:\n BIT[v]+=w\n v+=(v&(-v))\n\ndef getvalue(v):\n ANS=0\n while v!=0:\n ANS+=BIT[v]\n v-=(v&(-v))\n return ANS\n\nfor i in range(1,n+1):\n update(i,i)\n\nANS=[-1]*n\n\nfor i in range(n-1,-1,-1):\n MIN=0\n MAX=n\n k=A[i]\n\n while True:\n x=(MIN+MAX+1)//2\n\n\n if getvalue(x)>k:\n if getvalue(x-1)==k:\n ANS[i]=x\n break\n else:\n MAX=x\n else:\n MIN=x\n\n update(x,-x)\n\n \nprint(*ANS)\n", "class DualBIT():\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def get(self, i):\n '''i\u756a\u76ee\u306e\u8981\u7d20\u3092\u53d6\u5f97'''\n i = i + 1\n s = 0\n while i <= self.n:\n s += self.bit[i]\n i += i & -i\n return s\n\n def _add(self, i, x):\n while i > 0:\n self.bit[i] += x\n i -= i & -i\n\n def add(self, i, j, x):\n '''[i, j)\u306e\u8981\u7d20\u306bx\u3092\u52a0\u7b97\u3059\u308b'''\n self._add(j, x)\n self._add(i, -x)\n\n\nn = int(input())\na = list(map(int, input().split()))\n \nbit = DualBIT(n+3)\nfor i in range(1, n+1):\n bit.add(i+1, n+1, i)\n\nli = []\nflag = False\nwhile True:\n if not a:\n break\n ok = n + 1\n ng = 0\n num = a[-1]\n if num == 0 and not flag:\n flag = True\n bit.add(1, n + 2, -1)\n li.append(1)\n del a[-1]\n continue\n while abs(ok - ng) > 1:\n mid = (ok + ng) // 2\n if bit.get(mid) > num:\n ok = mid\n else:\n ng = mid\n tmp = ok - 1\n bit.add(ok, n + 2, -tmp)\n li.append(tmp)\n del a[-1]\nprint(*li[::-1])\n \n\n", "NN = 18\nBIT=[0]*(2**NN+1)\n\ndef addbit(i, x):\n while i <= 2**NN:\n BIT[i] += x\n i += i & (-i)\n\ndef getsum(i):\n ret = 0\n while i != 0:\n ret += BIT[i]\n i -= i&(-i)\n return ret\n\ndef searchbit(x):\n l, sl = 0, 0\n d = 2**(NN-1)\n while d:\n m = l + d\n sm = sl + BIT[m]\n if sm <= x:\n l, sl = m, sm\n d //= 2\n return l\n \nN = int(input())\nA = [int(a) for a in input().split()]\nfor i in range(1, N+1):\n addbit(i, i)\n\nANS = []\nfor s in A[::-1]:\n a = searchbit(s) + 1\n addbit(a, -a)\n ANS.append(a)\n \nprint(*ANS[::-1])", "from sys import setrecursionlimit as SRL, stdin\n\nSRL(10 ** 7)\nrd = stdin.readline\nrrd = lambda: map(int, rd().strip().split())\n\nn = int(rd())\n\nbit = [0] * 200005\n\n\ndef add(x, val):\n while x <= n:\n bit[x] += val\n x += (x & -x)\n\n\ndef query(x):\n num = 0\n for i in range(30, -1, -1):\n if num+(1 << i) <= n and bit[num + (1 << i)] <= x:\n \n x -= bit[num + (1 << i)]\n num += (1 << i)\n\n return num + 1\n\n\nfor i in range(1, n + 1):\n add(i, i)\n\ns = list(rrd())\n\nans = []\n\nfor i in range(len(s) - 1, -1, -1):\n q = query(s[i])\n ans.append(q)\n add(q, -q)\n\nans = ans[::-1]\nprint(*ans)", "from sys import setrecursionlimit as SRL, stdin\n\nSRL(10 ** 7)\nrd = stdin.readline\nrrd = lambda: map(int, rd().strip().split())\n\nn = int(rd())\n\nbit = [0] * 200005\n\n\ndef add(x, val):\n while x <= n:\n bit[x] += val\n x += (x & -x)\n\n\ndef query(x):\n num = 0\n for i in range(30, -1, -1):\n if num+(1 << i) <= n and bit[num + (1 << i)] <= x:\n\n x -= bit[num + (1 << i)]\n num += (1 << i)\n\n return num + 1\n\n\nfor i in range(1, n + 1):\n add(i, i)\n\ns = list(rrd())\n\nans = []\n\nfor i in range(len(s) - 1, -1, -1):\n q = query(s[i])\n ans.append(q)\n add(q, -q)\n\nans = ans[::-1]\nprint(*ans)", "import sys\ninput = sys.stdin.readline\n\nnn = 18\nbit=[0]*(2**nn+1)\n \ndef addbit(i, x):\n while i <= 2**nn:\n bit[i] += x\n i += i & (-i)\n \ndef getsum(i):\n ret = 0\n while i != 0:\n ret += bit[i]\n i -= i&(-i)\n return ret\n \ndef searchbit(x):\n l, sl = 0, 0\n d = 2**(nn-1)\n while d:\n m = l + d\n sm = sl + bit[m]\n if sm <= x:\n l, sl = m, sm\n d //= 2\n return l + 1\n\nn = int(input())\nl = list(map(int, input().split()))\nfor i in range(1, n + 1):\n\taddbit(i, i)\nans = [0 for _ in range(n)]\nfor i in range(n - 1, -1, -1):\n\ta = searchbit(l[i])\n\taddbit(a, -a)\n\tans[i] = a\nprint(*ans)\n\n\n\n\n\n", "n=int(input())\nP=[int(i) for i in input().split()]\nimport math\nimport bisect\n\nn_max=2*10**5\nnn=int(math.log2(n_max))+1\nBIT=[0]*(2**nn+1)\n\ndef bitsum(BIT,i):\n s=0\n while i>0:\n s+=BIT[i]\n i-=i&(-i)\n return s\ndef bitadd(BIT,i,x):\n if i<=0:\n return True\n else:\n while i<=2**nn:\n BIT[i]+=x\n i+=i&(-i)\n return BIT\ndef bitlowerbound(BIT,s):\n if s<=0:\n return 0\n else:\n ret=0\n k=2**nn\n while k>0:\n if k+ret<=2**nn and BIT[k+ret]<s:\n s-=BIT[k+ret]\n ret+=k\n k//=2\n return ret+1\nfor i in range(n_max):\n bitadd(BIT,i+1,i+1)\n\nAns=[]\nfor i in reversed(range(n)):\n p=P[i]\n ans=bitlowerbound(BIT,p+1)\n Ans.append(ans)\n bitadd(BIT,ans,-ans)\nAns=Ans[::-1]\nprint(*Ans)", "# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\n# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\n# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\nfrom sys import stdin, stdout\nfrom collections import defaultdict\nfrom collections import deque\nimport math\nimport copy\n \n#T = int(input())\nN = int(input())\n#s1 = input()\n#s2 = input()\n#N,Q = [int(x) for x in stdin.readline().split()]\narr = [int(x) for x in stdin.readline().split()]\n \nbit = [0]*N\n\nseries = [x for x in range(N)]\n\ndef lowbit(x):\n return x&(-x)\n\ndef update(idx,delta):\n while idx<N:\n bit[idx] += delta\n idx += lowbit(idx)\n\ndef query(x):\n s = 0\n while x>0:\n s += bit[x]\n x -= lowbit(x)\n return s\n \n# init\nfor i in range(N):\n bit[i] += series[i]\n y = i + lowbit(i)\n if y<N:\n series[y] += series[i]\n \nvisited = [0]*N\nans = [0]*N\nfor i in range(N-1,-1,-1):\n # find\n left = 0\n right = N-1\n target = arr[i]\n while left<=right:\n mid = (left+right)//2\n q = query(mid)\n if q<target:\n left = mid + 1\n elif q>target:\n right = mid - 1\n else:\n if visited[mid]==1:\n left = mid + 1\n else:\n visited[mid] = 1\n ans[i] = mid + 1\n break\n # update\n if mid+1<N:\n update(mid+1,-mid-1)\n \n \nprint(*ans)\n", "# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\n# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\n# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\nfrom sys import stdin, stdout\nfrom collections import defaultdict\nfrom collections import deque\nimport math\nimport copy\n \n#T = int(input())\nN = int(input())\n#s1 = input()\n#s2 = input()\n#N,Q = [int(x) for x in stdin.readline().split()]\narr = [int(x) for x in stdin.readline().split()]\n \nbit = [0]*(N+1)\n\nseries = [0] + [x for x in range(N)]\n\ndef lowbit(x):\n return x&(-x)\n\ndef update(idx,delta):\n while idx<=N:\n bit[idx] += delta\n idx += lowbit(idx)\n\ndef query(x):\n s = 0\n while x>0:\n s += bit[x]\n x -= lowbit(x)\n return s\n \n# init\nfor i in range(1,N+1):\n bit[i] += series[i]\n y = i + lowbit(i)\n if y<=N:\n series[y] += series[i]\n \nvisited = [0]*(N+1)\nans = [0]*N\nfor i in range(N-1,-1,-1):\n # find\n left = 1\n right = N\n target = arr[i]\n while left<=right:\n mid = (left+right)//2\n q = query(mid)\n #print(mid,q)\n if q<target:\n left = mid + 1\n elif q>target:\n right = mid - 1\n else:\n if visited[mid]==1:\n left = mid + 1\n else:\n visited[mid] = 1\n ans[i] = mid \n break\n # update\n update(mid+1,-mid)\n \n \nprint(*ans)\n", "# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\n# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\n# TAIWAN NUMBER ONE!!!!!!!!!!!!!!!!!!!\nfrom sys import stdin, stdout\nfrom collections import defaultdict\nfrom collections import deque\nimport math\nimport copy\n \n#T = int(input())\nN = int(input())\n#s1 = input()\n#s2 = input()\n#N,Q = [int(x) for x in stdin.readline().split()]\narr = [int(x) for x in stdin.readline().split()]\n \nbit = [0]*(N+1)\n\nseries = [0] + [x for x in range(N)]\n\ndef lowbit(x):\n return x&(-x)\n\ndef update(idx,delta):\n while idx<=N:\n bit[idx] += delta\n idx += lowbit(idx)\n\ndef query(x):\n s = 0\n while x>0:\n s += bit[x]\n x -= lowbit(x)\n return s\n \n# init\nfor i in range(1,N+1):\n bit[i] += series[i]\n y = i + lowbit(i)\n if y<=N:\n series[y] += series[i]\n \nvisited = [0]*(N+1)\nans = [0]*N\n\nfor i in range(N-1,-1,-1):\n # find\n left = 1\n right = N\n target = arr[i]\n \n \n while True:\n L = right - left + 1\n num = left - 1 + 2**int(math.log(L,2))\n \n q = bit[num]\n #print(num,q,target,left,right)\n if q<target:\n target -= q\n left = num + 1\n elif q>target:\n right = num - 1\n else:\n if visited[num]==1:\n target -= q\n left = num + 1\n else:\n visited[num] = 1\n ans[i] = num\n break\n \n # update\n update(num+1,-num)\n \n \nprint(*ans)\n", "from operator import add\n\nclass Stree:\n def __init__(self, f, n, default, init_data):\n self.ln = 2**(n-1).bit_length()\n self.data = [default] * (self.ln * 2)\n self.f = f\n for i, d in init_data.items():\n self.data[self.ln + i] = d\n for j in range(self.ln - 1, 0, -1):\n self.data[j] = f(self.data[j*2], self.data[j*2+1])\n\n def update(self, i, a):\n p = self.ln + i\n self.data[p] = a\n while p > 1:\n p = p // 2\n self.data[p] = self.f(self.data[p*2], self.data[p*2+1])\n\n def get(self, i, j):\n def _get(l, r, p):\n if i <= l and j >= r:\n return self.data[p]\n else:\n m = (l+r)//2\n if j <= m:\n return _get(l, m, p*2)\n elif i >= m:\n return _get(m, r, p*2+1)\n else:\n return self.f(_get(l, m, p*2), _get(m, r, p*2+1))\n return _get(0, self.ln, 1)\n\n def find_value(self, v):\n def _find_value(l, r, p, v):\n if r == l+1:\n return l\n elif self.data[p*2] <= v:\n return _find_value((l+r)//2, r, p*2+1, v - self.data[p*2])\n else:\n return _find_value(l, (l+r)//2, p*2, v)\n return _find_value(0, self.ln, 1, v)\n\n\ndef main():\n n = int(input())\n sums = {i:i for i in range(n+1)}\n stree = Stree(add, n+1, 0, sums)\n ss = list(map(int, input().split()))\n ss.reverse()\n pp = []\n for s in ss:\n sval = stree.find_value(s)\n pp.append(sval)\n stree.update(sval,0)\n print(*(reversed(pp)))\n\ndef __starting_point():\n main()\n__starting_point()", "def update(x,val):\n while x<=n:\n BIT[x]+=val\n x+=(x&-x)\ndef query(x):\n s=0\n while x>0:\n s=(s+BIT[x])\n x-=(x&-x)\n return s\nn=int(input())\nBIT=[0]*(n+1)\nfor i in range(1,n+1):\n update(i,i)\narr=list(map(int,input().split()))\nanswers=[0]*(n)\n#print(BIT)\nfor i in range(n-1,-1,-1):\n lol=arr[i]\n low=0\n fjf=0\n high=n\n # print(lol)\n while True:\n \n mid=(high+low+1)//2\n j=query(mid)\n # print(mid,j)\n # print(answers)\n # break\n if j>lol:\n if query(mid-1)==lol:\n answers[i]=mid\n update(mid,-mid)\n break\n else:\n high=mid\n else:\n low=mid\n \nprint(*answers)\n \n", "# 1208D\nclass segTree():\n def __init__(self, n):\n self.t = [0] * (n << 2)\n\n def update(self, node, l, r, index, value):\n if l == r:\n self.t[node] = value\n return\n mid = (l + r) >> 1\n if index <= mid:\n self.update(node*2, l, mid, index, value)\n else:\n self.update(node*2 + 1, mid + 1, r, index, value)\n self.t[node] = self.t[node*2] + self.t[node*2 + 1]\n\n def query(self, node, l, r, value):\n if l == r:\n return self.t[node]\n mid = (l + r) >> 1\n if self.t[node*2] >= value:\n return self.query(node*2, l, mid, value)\n return self.query(node*2 + 1, mid + 1, r, value - self.t[node*2])\n\ndef do():\n n = int(input())\n nums = [int(i) for i in input().split(\" \")]\n res = [0]*n\n weightTree = segTree(n)\n for i in range(1, n+1):\n weightTree.update(1, 1, n, i, i)\n # print(weightTree.t)\n for i in range(n-1, -1, -1):\n res[i] = weightTree.query(1, 1, n, nums[i] + 1)\n weightTree.update(1, 1, n, res[i], 0)\n return \" \".join([str(c) for c in res])\nprint(do())\n", "class FTree:\n\n def __init__(self, f):\n\n self.n = len(f)\n\n self.ft = [0] * (self.n + 1)\n\n\n\n for i in range(1, self.n + 1):\n\n self.ft[i] += f[i - 1]\n\n if i + self.lsone(i) <= self.n:\n\n self.ft[i + self.lsone(i)] += self.ft[i]\n\n\n\n def lsone(self, s):\n\n return s & (-s)\n\n\n\n def query(self, i, j):\n\n if i > 1:\n\n return self.query(1, j) - self.query(1, i - 1)\n\n\n\n s = 0\n\n while j > 0:\n\n s += self.ft[j]\n\n j -= self.lsone(j)\n\n\n\n return s\n\n\n\n def update(self, i, v):\n\n while i <= self.n:\n\n self.ft[i] += v\n\n i += self.lsone(i)\n\n\n\n def select(self, k):\n\n lo = 1\n\n hi = self.n\n\n\n\n for i in range(19): ######## 30\n\n mid = (lo + hi) // 2\n\n if self.query(1, mid) < k:\n\n lo = mid\n\n else:\n\n hi = mid\n\n\n\n return hi\n\n\nn = int(input())\ndata = [int(i) for i in input().split()]\nft = FTree(list(range(1, n+1)))\nans = [\"\"]*n\n\nfor i in range(n-1, -1, -1):\n val = data[i]\n ind = ft.select(val+1)\n ans[i] = str(ind)\n ft.update(ind, -ind)\n\nprint(\" \".join(ans))", "class FTree:\n def __init__(self, f):\n self.n = len(f)\n self.ft = [0] * (self.n + 1)\n for i in range(1, self.n + 1):\n self.ft[i] += f[i - 1]\n if i + self.lsone(i) <= self.n:\n self.ft[i + self.lsone(i)] += self.ft[i]\n def lsone(self, s):\n return s & (-s)\n def query(self, i, j):\n if i > 1:\n return self.query(1, j) - self.query(1, i - 1)\n s = 0\n while j > 0:\n s += self.ft[j]\n j -= self.lsone(j)\n return s\n def update(self, i, v):\n while i <= self.n:\n self.ft[i] += v\n i += self.lsone(i)\n def select(self, k):\n lo = 1\n hi = self.n\n for i in range(19): ######## 30\n mid = (lo + hi) // 2\n if self.query(1, mid) < k:\n lo = mid\n else:\n hi = mid\n return hi\nn = int(input())\ndata = [int(i) for i in input().split()]\nft = FTree(list(range(1, n+1)))\nans = [\"\"]*n\nfor i in range(n-1, -1, -1):\n val = data[i]\n ind = ft.select(val+1)\n ans[i] = str(ind)\n ft.update(ind, -ind)\nprint(\" \".join(ans))\n\n", "def sumsegtree(l,seg,st,en,x):\n if st==en:\n seg[x]=l[st]\n else:\n mid=(st+en)>>1\n sumsegtree(l,seg,st,mid,2*x)\n sumsegtree(l,seg,mid+1,en,2*x+1)\n seg[x]=seg[2*x]+seg[2*x+1]\n\ndef query(seg,st,en,val,x):\n if st==en:\n return seg[x]\n mid=(st+en)>>1\n if seg[2*x]>=val:\n return query(seg,st,mid,val,2*x)\n return query(seg,mid+1,en,val-seg[2*x],2*x+1)\n\ndef upd(seg,st,en,ind,val,x):\n if st==en:\n seg[x]=val\n return\n mid=(st+en)>>1\n if mid>=ind:\n upd(seg,st,mid,ind,val,2*x)\n else:\n upd(seg,mid+1,en,ind,val,2*x+1)\n seg[x]=seg[2*x]+seg[2*x+1]\n\nn=int(input())\nl=list(map(int,range(1,n+1)))\ns=[0]*n\np=list(map(int,input().split()))\n\n\nseg=[\"#\"]*(n<<2)\nsumsegtree(l,seg,0,len(l)-1,1)\n\nfor i in range(n-1,-1,-1):\n s[i]=query(seg,1,n,p[i]+1,1)\n upd(seg,1,n,s[i],0,1)\n\nprint (*s)", "def sumsegtree(l,seg,st,en,x):\n if st==en:\n seg[x]=l[st]\n else:\n mid=(st+en)>>1\n sumsegtree(l,seg,st,mid,2*x)\n sumsegtree(l,seg,mid+1,en,2*x+1)\n seg[x]=seg[2*x]+seg[2*x+1]\n \ndef query(seg,st,en,val,x):\n if st==en:\n return seg[x]\n mid=(st+en)>>1\n if seg[2*x]>=val:\n return query(seg,st,mid,val,2*x)\n return query(seg,mid+1,en,val-seg[2*x],2*x+1)\n \ndef upd(seg,st,en,ind,val,x):\n if st==en:\n seg[x]=val\n return\n mid=(st+en)>>1\n if mid>=ind:\n upd(seg,st,mid,ind,val,2*x)\n else:\n upd(seg,mid+1,en,ind,val,2*x+1)\n seg[x]=seg[2*x]+seg[2*x+1]\n \nn=int(input())\nl=list(map(int,range(1,n+1)))\ns=[0]*n\np=list(map(int,input().split()))\n \n \nseg=[\"#\"]*(n<<2)\nsumsegtree(l,seg,0,len(l)-1,1)\n \nfor i in range(len(p)-1,-1,-1):\n s[i]=query(seg,1,n,p[i]+1,1)\n upd(seg,1,n,s[i],0,1)\n \nprint (*s)", "_ = input()\nx = [int(i) for i in input().split()]\n\nres = []\n\nfrom math import log\n\n\nclass SegmentTree(object):\n\n def __init__(self, nums):\n self.arr = nums\n self.l = len(nums)\n self.tree = [0] * self.l + nums\n for i in range(self.l - 1, 0, -1):\n self.tree[i] = self.tree[i << 1] + self.tree[i << 1 | 1]\n\n def update(self, i, val):\n n = self.l + i\n self.tree[n] = val\n while n > 1:\n self.tree[n >> 1] = self.tree[n] + self.tree[n ^ 1]\n n >>= 1\n\n def query(self, i, j):\n m = self.l + i\n n = self.l + j\n res = 0\n while m <= n:\n if m & 1:\n res += self.tree[m]\n m += 1\n m >>= 1\n if n & 1 == 0:\n res += self.tree[n]\n n -= 1\n n >>= 1\n return res\n\ntree = SegmentTree(list(range(1, len(x) + 1)))\norg = len(x)\nwhile x:\n q = x.pop()\n\n lo = 0\n hi = org - 1\n\n while lo < hi:\n mid = (lo + hi) // 2\n # print(lo, hi, mid)\n sm = tree.query(0, mid)\n # print(sm, mid)\n if sm > q:\n hi = mid\n else:\n lo = mid + 1\n # print(tree.arr, lo, hi)\n idx = tree.arr[lo]\n # print(idx)\n tree.update(lo, 0)\n res.append(idx)\n\nprint(' '.join(str(i) for i in res[::-1]))", "\n\ndef sum_number(n,j):\n j[0]=0\n j[1]=0\n for i in range(2,n+1):\n j[i]=j[i-1]+(i-1)\n return(j)\npo=int(input())\nl=[0]*(po+1)\nl1=[int(i) for i in input().split()]\ndef getsum(BITTree,i):\n s = 0\n while i > 0:\n s += BITTree[i]\n i -= i & (-i) \n return(s) \ndef updatebit(BITTree , n , i ,v):\n #print('n',n)\n while i <= n:\n #print('i',i)\n BITTree[i] += v\n i += i & (-i)\n #print(BITTree)\nfor i in range(1,po+1):\n updatebit(l,po,i,i)\noutput=[0]*po\nfor i in range(po-1,-1,-1):\n min_=0\n max_=po\n k=l1[i]\n while True:\n x=(min_+max_+1)//2\n if getsum(l,x)>k:\n if getsum(l,x-1)==k:\n output[i]=x\n break\n else:\n #print(x)\n max_=x\n else :\n #print(x)\n min_=x\n updatebit(l,po,x,-x)\nprint(*output)\n\n\n\n \n \n \n\n\n\n", "# https://codeforces.com/contest/1208/problem/D\n\nfrom sys import stdin, stdout\ninput = stdin.readline\nprint = stdout.write\n\n# For every i from N to 1, let's say the value of the si is x. \n# So it means there are k smallest unused numbers whose sum is x.\n# We simply put the (k+1)st number in the output permutation at this i, and continue to move left. \n\n# segment tree and binary search\n\n_ = input()\nx = [int(i) for i in input().split()]\n \nres = []\n \nfrom math import log\n \n \nclass SegmentTree(object):\n \n def __init__(self, nums):\n self.arr = nums\n self.l = len(nums)\n self.tree = [0] * self.l + nums\n for i in range(self.l - 1, 0, -1):\n self.tree[i] = self.tree[i << 1] + self.tree[i << 1 | 1]\n \n def update(self, i, val):\n n = self.l + i\n self.tree[n] = val\n while n > 1:\n self.tree[n >> 1] = self.tree[n] + self.tree[n ^ 1]\n n >>= 1\n \n def query(self, i, j):\n m = self.l + i\n n = self.l + j\n res = 0\n while m <= n:\n if m & 1:\n res += self.tree[m]\n m += 1\n m >>= 1\n if n & 1 == 0:\n res += self.tree[n]\n n -= 1\n n >>= 1\n return res\n \ntree = SegmentTree(list(range(1, len(x) + 1)))\norg = len(x)\nwhile x:\n # from back to forth\n q = x.pop()\n \n lo = 0\n hi = org - 1\n \n while lo < hi:\n mid = (lo + hi) // 2\n # print(lo, hi, mid)\n sm = tree.query(0, mid)\n # print(sm, mid)\n if sm > q:\n hi = mid\n else:\n lo = mid + 1\n # print(tree.arr, lo, hi)\n idx = tree.arr[lo]\n # print(idx)\n tree.update(lo, 0)\n # also from back to forth\n res.append(idx)\n \nprint(' '.join(str(i) for i in res[::-1]))", "# https://codeforces.com/contest/1208/problem/D\n\nfrom sys import stdin, stdout\ninput = stdin.readline\n# print = stdout.write\n\n# si is the sum of elements before the i-th element that are smaller than the i-th element.\n\n# For every i from N to 1, let's say the value of the si is x.\n# So it means there are k smallest unused numbers whose sum is x.\n# We simply put the k+1st number in the output permutation at this i, and continue to move left.\n\n# BIT and binary lifting\n# https://codeforces.com/contest/1208/submission/59526098\n\n\nclass BIT:\n def __init__(self, nums):\n # we store the sum information in bit 1.\n # so the indices should be 1 based.\n # here we assume nums[0] = 0\n self.nums = [0] * (len(nums))\n for i, x in enumerate(nums):\n if i == 0:\n continue\n self.update(i, x)\n\n def low_bit(self, x):\n return x & (-x)\n\n def update(self, i, diff):\n while i < len(self.nums):\n self.nums[i] += diff\n i += self.low_bit(i)\n\n def prefix_sum(self, i):\n ret = 0\n while i != 0:\n ret += self.nums[i]\n i -= self.low_bit(i)\n return ret\n\n def search(self, x):\n # find the index i such that prefix_sum(i) == x\n cur_index, cur_sum = 0, 0\n delta = len(self.nums) - 1\n while delta - self.low_bit(delta):\n delta -= self.low_bit(delta)\n\n while delta: \n m = cur_index + delta\n if m < len(self.nums):\n sm = cur_sum + self.nums[m]\n if sm <= x:\n cur_index, cur_sum = m, sm\n delta //= 2\n return cur_index + 1\n\n\nn = int(input())\nbit = BIT(list(range(n+1)))\n\nans = [0 for _ in range(n)]\nnums = list(map(int, input().split()))\nfor i in range(n - 1, -1, -1):\n index = bit.search(nums[i])\n bit.update(index, -index)\n ans[i] = index\nprint(*ans)\n", "import sys\ninput = sys.stdin.readline\nclass SegTree(object):\n\t\"\"\"docstring for SegTree\"\"\"\n\tdef __init__(self, n, arr):\n\t\tself.n = n\n\t\tself.arr = arr\n\t\tself.tree = [0 for i in range(2*n)]\n\n\tdef construct(self): # Construction\n\t\tfor i in range(self.n):\n\t\t\tself.tree[n+i] = self.arr[i]\n\t\tfor i in range(n-1,0,-1):\n\t\t\tself.tree[i] = self.function(self.tree[2*i],self.tree[2*i+1])\n\n\tdef update(self,index,value):\n\t\tstart = index+self.n\n\t\tself.tree[start] = value\n\t\twhile start>0:\n\t\t\tstart = start//2\n\t\t\tself.tree[start] = self.function(self.tree[2*start],self.tree[2*start+1])\n\n\tdef calc(self,low,high): # 0-indexed\n\t\tlow+=self.n\n\t\thigh+=self.n\n\t\tans = 0 # Needs to initialised\n\t\twhile low<high:\n\t\t\tif low%2:\n\t\t\t\tans = self.function(ans, self.tree[low])\n\t\t\t\tlow += 1\n\t\t\tif high%2:\n\t\t\t\thigh -= 1\n\t\t\t\tans = self.function(ans, self.tree[high])\n\t\t\tlow = low//2\n\t\t\thigh = high//2\n\t\treturn ans\n\t\n\tdef function(self,a,b): # Function used to construct Segment Tree\n\t\treturn a + b\n\n\ndef find(num):\n\tlow = 0\n\thigh = n-1\n\twhile low<high:\n\t\tmid = (low+high)//2\n\t\tif st.calc(0,mid+1)>num:\n\t\t\thigh = mid - 1\n\t\telse:\n\t\t\tlow = mid + 1\n\tif st.calc(0,low+1)>num:\n\t\treturn low\n\telse:\n\t\treturn low + 1\n\n\n\nn = int(input())\na = list(map(int,input().split()))\narr = [i for i in range(1,n+1)]\nst = SegTree(n,arr)\nst.construct()\nans = [-1]*n\nfor i in range(n-1,-1,-1):\n\tind = find(a[i])\n\t# print (a[i],ind,arr)\n\tans[i] = arr[ind]\n\tst.update(ind,0)\nprint(*ans)\n"] | {
"inputs": [
"3\n0 0 0\n",
"2\n0 1\n",
"5\n0 1 1 1 10\n",
"1\n0\n",
"15\n0 0 3 3 13 3 6 34 47 12 20 6 6 21 55\n",
"20\n0 1 7 15 30 15 59 42 1 4 1 36 116 36 16 136 10 36 46 36\n",
"100\n0 0 57 121 57 0 19 251 19 301 19 160 57 578 664 57 19 50 0 621 91 5 263 34 5 96 713 649 22 22 22 5 108 198 1412 1147 84 1326 1777 0 1780 132 2000 479 1314 525 68 690 1689 1431 1288 54 1514 1593 1037 1655 807 465 1674 1747 1982 423 837 139 1249 1997 1635 1309 661 334 3307 2691 21 3 533 1697 250 3920 0 343 96 242 2359 3877 3877 150 1226 96 358 829 228 2618 27 2854 119 1883 710 0 4248 435\n"
],
"outputs": [
"3 2 1\n",
"1 2\n",
"1 4 3 2 5\n",
"1\n",
"2 1 15 10 12 3 6 13 14 8 9 5 4 7 11\n",
"1 6 8 15 17 12 18 16 3 4 2 14 20 13 7 19 5 10 11 9\n",
"94 57 64 90 58 19 53 71 50 67 38 56 45 86 89 42 31 36 5 68 37 10 49 24 7 32 65 59 14 12 11 6 27 34 91 72 21 87 98 3 97 25 100 46 85 48 18 51 88 83 70 13 79 82 62 80 55 43 73 76 81 40 52 22 60 77 69 61 47 35 92 84 9 4 41 66 28 99 2 33 17 26 74 96 95 20 54 15 29 44 23 75 8 78 16 63 39 1 93 30\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 25,996 | |
175af8ab0e4c500325e35385bd79a813 | UNKNOWN | Bob has a permutation of integers from 1 to n. Denote this permutation as p. The i-th element of p will be denoted as p_{i}. For all pairs of distinct integers i, j between 1 and n, he wrote the number a_{i}, j = min(p_{i}, p_{j}). He writes a_{i}, i = 0 for all integer i from 1 to n.
Bob gave you all the values of a_{i}, j that he wrote down. Your job is to reconstruct any permutation that could have generated these values. The input will be formed so that it is guaranteed that there is at least one solution that is consistent with the information given.
-----Input-----
The first line of the input will contain a single integer n (2 ≤ n ≤ 50).
The next n lines will contain the values of a_{i}, j. The j-th number on the i-th line will represent a_{i}, j. The i-th number on the i-th line will be 0. It's guaranteed that a_{i}, j = a_{j}, i and there is at least one solution consistent with the information given.
-----Output-----
Print n space separated integers, which represents a permutation that could have generated these values. If there are multiple possible solutions, print any of them.
-----Examples-----
Input
2
0 1
1 0
Output
2 1
Input
5
0 2 2 1 2
2 0 4 1 3
2 4 0 1 3
1 1 1 0 1
2 3 3 1 0
Output
2 5 4 1 3
-----Note-----
In the first case, the answer can be {1, 2} or {2, 1}.
In the second case, another possible answer is {2, 4, 5, 1, 3}. | ["def main():\n n = int(input())\n a = [[int(i) for i in input().split()] for j in range(n)]\n \n result = [-1] * n\n for i in range(n - 1):\n for j in range(n):\n d = set(a[j][k] for k in range(n) if result[k] == -1 and j != k)\n if len(d) == 1:\n result[j] = d.pop()\n result[result.index(-1)] = n\n \n print(' '.join(str(i) for i in result))\n \nmain()", "n = int(input())\narr = [list(map(int, input().split())) for i in range(n)]\nans = []\nfor i in arr:\n\tanf = max(i)\n\twhile (anf in ans):\n\t\tanf+=1\n\tans.append(anf)\nprint(*ans)", "n = int(input())\nfor i in range(n):\n k = list(map(int, input().split()))\n if len(set(k)) == n:\n k[k.index(0)] = n\n print(*k)\n break", "v = [max(map(int, input().split())) for i in range(int(input()))]\nv[v.index(max(v))] += 1\nprint(' '.join(map(str, v)))", "n = int(input())\nperm = [0 for i in range(n)]\na = [[0 for i in range(n)] for i in range(n)]\nb = [0 for i in range(n)]\nfor i in range(n):\n a[i] = list(map(int, input().split()))\n b[i] = max(a[i])\n\ns = set()\n\nfor i in range(1, n + 1):\n for j in range(n):\n if b[j] <= i and j not in s:\n perm[j] = i\n s.add(j)\n break\nprint(*perm)\n", "3\n\ndef remove(A, i, n):\n for j in range(n):\n A[i][j] = 0\n A[j][i] = 0\n\n\nn = int(input())\nA = [list(map(int, input().split())) for i in range(n)]\n\nans = [0 for i in range(n)]\nfor i in range(n - 1):\n t = -1\n for j in range(n):\n f = True\n g = False\n for k in range(n):\n if not (A[j][k] in (0, i + 1) and A[k][j] in (0, i + 1)):\n f = False\n if A[j][k] != 0:\n g = True\n if f and g:\n t = j\n\n\n ans[t] = i + 1\n remove(A, t, n)\n\n\nfor i in range(n):\n if ans[i] == 0:\n ans[i] = n\n\nprint(\" \".join(map(str, ans)))\n \n", "N = int(input())\nmat = [[int(x) for x in input().split()] for _ in range(N)]\na = list(range(N))\nfor row in mat:\n if sorted(row) == a:\n row[row.index(0)] = N\n print(*row)\n break\nelse:\n assert(0)\n", "n = int(input())\nl = [list(map(int, input().split())) for i in range(n)]\np = [-1 for i in range(n)]\nfor i in range(n):\n for j in range(1, n+1):\n if l[i].count(j) == n-j:\n p[i] = j\n break\nif p.count(n-1) == 2:\n p[p.index(n-1)] = n\nprint(\" \".join(map(str, p)))\n", "#!/usr/bin/env python3\nN = int(input())\n\nmin_arr = [0 for _ in range(N)]\n\nfor i in range(N):\n arr_i = [n-1 for n in map(int, input().split())]\n for j in range(N):\n if i == j:\n continue\n min_arr[i] = max(arr_i[j], min_arr[i])\n min_arr[j] = max(arr_i[j], min_arr[j])\n\nassign = [0 for _ in range(N)]\nblah = [(min_arr[i], i) for i in range(N)]\nblah.sort()\nfor i in range(N):\n assign[blah[i][1]] = i+1\n\nprint(' '.join(map(str, assign)))\n", "n = int(input())\n\ntarget = [x for x in range(n)]\nfor i in range(n):\n v = list(map(int, input().split()))\n\n if sorted(v) == target:\n print(' '.join([str(x) if x != 0 else str(n) for x in v]))\n return\n\n\n", "n = int(input())\na = [list(map(int, input().split())) for x in range(n)]\nresult = [0] * n\nfor x in range(1, n):\n result[max(list(range(n)), key = lambda i: a[i].count(x))] = x\nprint(*[(x if x else n) for x in result])\n", "n = int(input())\npole = []\nfor i in range(n):\n s = list(map(int, input().split()))\n pole.append(s)\n\nans = [0] * n\nfor number in range(1, n + 1):\n for i in range(n):\n s = set()\n for j in range(n):\n if pole[i][j] > number - 1:\n s.add(pole[i][j])\n if len(s) == 1:\n for k in s:\n ans[i] = k\nfor i in range(n):\n if ans[i] == n - 1:\n ans[i] = n\n break\nprint(*ans)\n", "n = int(input())\nM = [[int(x) for x in input().split()] for i in range(n)]\nlast = False\nperm = [0 for i in range(n)]\nfor i in range(n):\n S = set()\n for x in M[i]:\n if x in S:\n perm[i] = x\n break\n else:\n S.add(x)\n else:\n if last:\n perm[i] = n-1\n else:\n perm[i] = n\n last = True\nfor x in perm:\n print(x, end = ' ')\n", "n = int(input())\np = []\nfor i in range(n):\n p.append(list(map(int, input().split())))\n p[i].sort()\n p[i].append(i)\np.sort()\npos = [0] * n\nfor i in range(n):\n pos[p[i][-1]] = i + 1\nprint(*pos)\n\n \n \n \n", "n = int(input())\na = []\nfor i in range(n):\n a.append(list(map(int, input().split())))\n\nans = [0 for i in range(n)]\nfor cur in range(1, n + 1):\n k = -1\n for i, row in enumerate(a):\n if all((x <= cur for x in row)):\n k = i\n break\n #assert(k != -1)\n for i in range(len(row)):\n row[i] = 999\n ans[k] = cur\nprint(' '.join(map(str, ans)))\n", "n = int(input())\ns = [0] * n\ndp = [[0] for i in range(n)]\nfor i in range(n):\n dp[i] = list(map(int, input().split()))\nfor i in range(n):\n for j in range(n):\n s[i] = max(s[i], dp[i][j])\n s[j] = max(s[j], dp[i][j])\nused = [False] * n\nfor i in range(n):\n if used[s[i] - 1]:\n s[i] *= -1\n else:\n used[s[i] - 1] = True\nfor i in range(n):\n if s[i] < 0:\n for j in range(1, n + 1):\n if abs(s[i]) < j and not used[j - 1]:\n s[i] = j\n break\nprint(*s)", "#!/bin/python3\nimport sys\nn = int(input())\nmatrix = []\nfor i in range(n):\n tlist = [int(a) for a in input().split(' ')]\n matrix.append(tlist)\n\nfor i in range(n):\n if set(range(n)) == set(matrix[i]):\n big = i\n break\n\nfor i in range(n):\n if i == big:\n sys.stdout.write(\"{} \".format(n))\n else:\n sys.stdout.write(\"{} \".format(matrix[big][i]))\n\n", "#! /usr/bin/env python\n# -*- coding: utf-8 -*-\n# vim:fenc=utf-8\n#\n# Copyright \u00a9 2016 missingdays <missingdays@missingdays>\n#\n# Distributed under terms of the MIT license.\n\n\"\"\"\n\n\"\"\"\n\nn = int(input())\n\na = []\n\nfor i in range(n):\n a.append([int(i) for i in input().split()])\n\nb = [0 for i in range(n)]\nc = {}\n\nfor i in range(n):\n for j in range(n):\n c[j] = 0\n\n for j in range(n):\n c[a[i][j]] += 1\n\n for j in range(n):\n if j in c and c[j] > 1:\n b[i] = j \n\ni1 = -1\nm = 0\n\nfor i in range(n):\n if b[i] == 0:\n l = max(a[i])\n\n if l > m:\n m = l\n i1 = i\n\nb[i1] = n-1\n\nfor i in range(n):\n if b[i] == 0 and i != i1:\n b[i] = n\n\nfor e in b:\n print(e, end=\" \")\nprint()\n", "# from pprint import pprint\n\nn = int(input())\na = []\nfor i in range(n):\n row = [int(k) for k in input().split()]\n a.append(row)\n\nresult = [0] * n\nfor k in range(1, n):\n # print('k=', k)\n for i in range(n):\n countK = 0\n countNonK = 0\n for j in range(n):\n if a[i][j] == k:\n countK += 1\n elif a[i][j] != 0:\n countNonK += 1\n # print('@', countK, countNonK)\n if countK > 0 and countNonK == 0:\n # print('j', j)\n result[i] = k\n for j in range(n):\n a[i][j] = 0\n a[j][i] = 0\n continue\n\n countK = 0\n countNonK = 0\n for j in range(n):\n if a[j][i] == k:\n countK += 1\n elif a[j][i] != 0:\n countNonK += 1\n if countK > 0 and countNonK == 0:\n # print('j#', j)\n result[i] = k\n for j in range(n):\n a[j][i] = 0\n a[i][j] = 0\n # pprint(a)\nresult[result.index(0)] = n\n\nprint(' '.join(str(i) for i in result))\n\n", "n = int(input())\nnumbers = [0] * n\nused = set()\nfor i in range(n):\n for j in range(max(list(map(int, input().split()))), n + 1):\n if j not in used:\n used.add(j)\n numbers[i] = j\n break\nprint(' '.join(map(str, numbers)))", "\nfrom itertools import chain\nn = int(input())\n\na = [list(map(int, input().split())) for i in range(n)]\n\nfor i in range(n):\n a[i][i] = i\n\nans = []\n\nwhile n > 0:\n done = False\n for i in chain(range(1, n-1), [0, n-1]):\n if done:\n break\n b = True\n for dx in -1, 0, 1:\n for dy in -1, 0, 1:\n if dx != 0 and dy != 0:\n continue\n if dx == 0 and dy == 0:\n continue\n nx, ny = i+dx, i+dy\n if nx < 0 or nx >= n:\n continue\n if ny < 0 or ny >= n:\n continue\n b = b and a[nx][ny] == 1\n if b:\n ans.append(a[i][i])\n# print(ans)\n if i < n - 1:\n a = a[:i] + a[i+1:]\n else:\n a = a[:i]\n for j in range(len(a)):\n if i < n - 1:\n a[j] = a[j][:i] + a[j][i+1:]\n else:\n a[j] = a[j][:i]\n for x in range(len(a)):\n for y in range(len(a)):\n if x == y:\n continue\n a[x][y] -= 1\n n -= 1\n done = True\n if not done:\n return\n# for x in a:\n# for y in x:\n# print(y, end = ' ')\n# print()\n\n\nret = [0] * len(ans)\nfor i in range(len(ans)):\n ret[ans[i]] = i + 1\n\nfor i in ret:\n print(i, end = ' ')\n", "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nimport time\n\n\nn = int(input())\na = []\n\nfor i in range(n):\n a.append(max([int(i) for i in input().split()]))\n\nstart = time.time()\n\nfor i in range(n):\n if a[i] == n-1:\n a[i] += 1\n break\n\nfor i in a:\n print(i, end=' ')\nprint()\n\nfinish = time.time()\n#print(finish - start)\n", "n = int(input())\na = [list(map(int, input().split(' '))) for i in range(n)]\nans = [0]*n\nfor i in range(1, n+1):\n for j in range(n):\n if ans[j] == 0 and a[j].count(i) == n-i:\n ans[j] = str(i)\n break\nprint(' '.join(ans))\n", "n = int(input())\na = []\nfor i in range(n):\n a.append(list(map(int,input().split())))\n\nfor i in range(n):\n is_dif = True\n for j in range(n):\n c = a[i].count(a[i][j])\n if c > 1:\n is_dif = False\n break\n if is_dif:\n for k in range(n):\n if a[i][k] == 0:\n a[i][k] = n\n print(a[i][k],end=' ')\n break", "n = int(input())\n\na = [0]*n\nfor i in range(n):\n\ta[i] = list(map(int, input().split()))\nunused = set(range(1,n+1))\nused = {0}\nbind = [-1]*(n)\nfor cur in range(1, n+1):\n\tfor i in range(n):\n\t\tif (bind[i]==-1) and (max(a[i])<=cur):\n\t\t\tbind[i] = cur\n\t\t\tbreak\nprint(' '.join(map(str, bind)))\n"] | {
"inputs": [
"2\n0 1\n1 0\n",
"5\n0 2 2 1 2\n2 0 4 1 3\n2 4 0 1 3\n1 1 1 0 1\n2 3 3 1 0\n",
"10\n0 1 5 2 5 3 4 5 5 5\n1 0 1 1 1 1 1 1 1 1\n5 1 0 2 6 3 4 6 6 6\n2 1 2 0 2 2 2 2 2 2\n5 1 6 2 0 3 4 8 8 7\n3 1 3 2 3 0 3 3 3 3\n4 1 4 2 4 3 0 4 4 4\n5 1 6 2 8 3 4 0 9 7\n5 1 6 2 8 3 4 9 0 7\n5 1 6 2 7 3 4 7 7 0\n",
"4\n0 1 3 2\n1 0 1 1\n3 1 0 2\n2 1 2 0\n",
"7\n0 3 2 4 1 4 4\n3 0 2 3 1 3 3\n2 2 0 2 1 2 2\n4 3 2 0 1 5 5\n1 1 1 1 0 1 1\n4 3 2 5 1 0 6\n4 3 2 5 1 6 0\n",
"10\n0 4 4 1 4 4 4 2 3 4\n4 0 5 1 6 8 9 2 3 7\n4 5 0 1 5 5 5 2 3 5\n1 1 1 0 1 1 1 1 1 1\n4 6 5 1 0 6 6 2 3 6\n4 8 5 1 6 0 8 2 3 7\n4 9 5 1 6 8 0 2 3 7\n2 2 2 1 2 2 2 0 2 2\n3 3 3 1 3 3 3 2 0 3\n4 7 5 1 6 7 7 2 3 0\n",
"13\n0 5 5 2 5 4 5 5 3 5 5 5 1\n5 0 6 2 6 4 6 6 3 6 6 6 1\n5 6 0 2 10 4 7 10 3 8 10 9 1\n2 2 2 0 2 2 2 2 2 2 2 2 1\n5 6 10 2 0 4 7 12 3 8 11 9 1\n4 4 4 2 4 0 4 4 3 4 4 4 1\n5 6 7 2 7 4 0 7 3 7 7 7 1\n5 6 10 2 12 4 7 0 3 8 11 9 1\n3 3 3 2 3 3 3 3 0 3 3 3 1\n5 6 8 2 8 4 7 8 3 0 8 8 1\n5 6 10 2 11 4 7 11 3 8 0 9 1\n5 6 9 2 9 4 7 9 3 8 9 0 1\n1 1 1 1 1 1 1 1 1 1 1 1 0\n"
],
"outputs": [
"2 1\n",
"2 5 4 1 3\n",
"5 1 6 2 8 3 4 10 9 7\n",
"4 1 3 2\n",
"4 3 2 5 1 7 6\n",
"4 10 5 1 6 8 9 2 3 7\n",
"5 6 10 2 13 4 7 12 3 8 11 9 1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 11,203 | |
a9eb93c239c9de4355c75e22727f182d | UNKNOWN | You are given a directed graph of $n$ vertices and $m$ edges. Vertices are numbered from $1$ to $n$. There is a token in vertex $1$.
The following actions are allowed: Token movement. To move the token from vertex $u$ to vertex $v$ if there is an edge $u \to v$ in the graph. This action takes $1$ second. Graph transposition. To transpose all the edges in the graph: replace each edge $u \to v$ by an edge $v \to u$. This action takes increasingly more time: $k$-th transposition takes $2^{k-1}$ seconds, i.e. the first transposition takes $1$ second, the second one takes $2$ seconds, the third one takes $4$ seconds, and so on.
The goal is to move the token from vertex $1$ to vertex $n$ in the shortest possible time. Print this time modulo $998\,244\,353$.
-----Input-----
The first line of input contains two integers $n, m$ ($1 \le n, m \le 200\,000$).
The next $m$ lines contain two integers each: $u, v$ ($1 \le u, v \le n; u \ne v$), which represent the edges of the graph. It is guaranteed that all ordered pairs $(u, v)$ are distinct.
It is guaranteed that it is possible to move the token from vertex $1$ to vertex $n$ using the actions above.
-----Output-----
Print one integer: the minimum required time modulo $998\,244\,353$.
-----Examples-----
Input
4 4
1 2
2 3
3 4
4 1
Output
2
Input
4 3
2 1
2 3
4 3
Output
10
-----Note-----
The first example can be solved by transposing the graph and moving the token to vertex $4$, taking $2$ seconds.
The best way to solve the second example is the following: transpose the graph, move the token to vertex $2$, transpose the graph again, move the token to vertex $3$, transpose the graph once more and move the token to vertex $4$. | ["import sys\ninput = sys.stdin.readline\nimport heapq\n\nmod=998244353\n\nn,m=list(map(int,input().split()))\n\nE=[[] for i in range(n+1)]\nE2=[[] for i in range(n+1)]\n\nfor i in range(m):\n x,y=list(map(int,input().split()))\n E[x].append(y)\n E2[y].append(x)\n\nTIME=[1<<29]*(n+1)\nTIME[1]=0\n\ndef shuku(x,y):\n return (x<<20)+y\n\nQ=[]\nANS=[]\n\nfor k in range(n+1):\n NQ=[]\n\n if k<=1:\n heapq.heappush(Q,shuku(0,1))\n\n if k%2==0:\n while Q:\n #print(Q)\n x=heapq.heappop(Q)\n time=x>>20\n town=x-(time<<20)\n\n #print(x,time,town)\n\n if TIME[town]<time:\n continue\n\n for to in E[town]:\n if TIME[to]>time+1:\n TIME[to]=time+1\n heapq.heappush(Q,shuku(TIME[to],to))\n heapq.heappush(NQ,shuku(TIME[to],to))\n\n else:\n while Q:\n x=heapq.heappop(Q)\n time=x>>20\n town=x-(time<<20)\n\n #print(x,time,town)\n\n if TIME[town]<time:\n continue\n\n for to in E2[town]:\n if TIME[to]>time+1:\n TIME[to]=time+1\n heapq.heappush(Q,shuku(TIME[to],to))\n heapq.heappush(NQ,shuku(TIME[to],to))\n\n #print(k,TIME)\n\n Q=NQ\n ANS.append(TIME[n])\n\n if k>=100 and TIME[n]!=1<<29:\n break\n\nA=ANS[0]\nfor k in range(1,len(ANS)):\n if ANS[k]==1<<29:\n continue\n\n if ANS[k-1]==1<<29:\n A=(ANS[k]+pow(2,k,mod)-1)%mod\n\n if k<60 and ANS[k-1]-ANS[k]>pow(2,k-1):\n A=(ANS[k]+pow(2,k,mod)-1)%mod\n\nprint(A)\n \n\n\n \n \n \n \n \n\n \n"] | {
"inputs": [
"4 4\n1 2\n2 3\n3 4\n4 1\n",
"4 3\n2 1\n2 3\n4 3\n",
"10 20\n2 1\n7 9\n10 2\n4 9\n3 1\n6 4\n3 6\n2 9\n5 2\n3 9\n6 8\n8 7\n10 4\n7 4\n8 5\n3 4\n6 7\n2 6\n10 6\n3 8\n",
"10 9\n8 5\n3 5\n3 7\n10 6\n4 6\n8 1\n9 2\n4 2\n9 7\n",
"50 49\n1 3\n6 46\n47 25\n11 49\n47 10\n26 10\n12 38\n45 38\n24 39\n34 22\n36 3\n21 16\n43 44\n45 23\n2 31\n26 13\n28 42\n43 30\n12 27\n32 44\n24 25\n28 20\n15 19\n6 48\n41 7\n15 17\n8 9\n2 48\n33 5\n33 23\n4 19\n40 31\n11 9\n40 39\n35 27\n14 37\n32 50\n41 20\n21 13\n14 42\n18 30\n35 22\n36 5\n18 7\n4 49\n29 16\n29 17\n8 37\n34 46\n",
"13 13\n2 1\n2 3\n1 4\n4 5\n5 6\n6 7\n7 3\n8 3\n8 9\n10 9\n10 11\n12 11\n12 13\n",
"2 1\n2 1\n"
],
"outputs": [
"2\n",
"10\n",
"3\n",
"520\n",
"16495294\n",
"74\n",
"2\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,802 | |
87964e5f55e8314bef0bab9350e5758f | UNKNOWN | Recently, Dima met with Sasha in a philatelic store, and since then they are collecting coins together. Their favorite occupation is to sort collections of coins. Sasha likes having things in order, that is why he wants his coins to be arranged in a row in such a way that firstly come coins out of circulation, and then come coins still in circulation.
For arranging coins Dima uses the following algorithm. One step of his algorithm looks like the following:
He looks through all the coins from left to right; If he sees that the i-th coin is still in circulation, and (i + 1)-th coin is already out of circulation, he exchanges these two coins and continues watching coins from (i + 1)-th.
Dima repeats the procedure above until it happens that no two coins were exchanged during this procedure. Dima calls hardness of ordering the number of steps required for him according to the algorithm above to sort the sequence, e.g. the number of times he looks through the coins from the very beginning. For example, for the ordered sequence hardness of ordering equals one.
Today Sasha invited Dima and proposed him a game. First he puts n coins in a row, all of them are out of circulation. Then Sasha chooses one of the coins out of circulation and replaces it with a coin in circulation for n times. During this process Sasha constantly asks Dima what is the hardness of ordering of the sequence.
The task is more complicated because Dima should not touch the coins and he should determine hardness of ordering in his mind. Help Dima with this task.
-----Input-----
The first line contains single integer n (1 ≤ n ≤ 300 000) — number of coins that Sasha puts behind Dima.
Second line contains n distinct integers p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n) — positions that Sasha puts coins in circulation to. At first Sasha replaces coin located at position p_1, then coin located at position p_2 and so on. Coins are numbered from left to right.
-----Output-----
Print n + 1 numbers a_0, a_1, ..., a_{n}, where a_0 is a hardness of ordering at the beginning, a_1 is a hardness of ordering after the first replacement and so on.
-----Examples-----
Input
4
1 3 4 2
Output
1 2 3 2 1
Input
8
6 8 3 4 7 2 1 5
Output
1 2 2 3 4 3 4 5 1
-----Note-----
Let's denote as O coin out of circulation, and as X — coin is circulation.
At the first sample, initially in row there are coins that are not in circulation, so Dima will look through them from left to right and won't make any exchanges.
After replacement of the first coin with a coin in circulation, Dima will exchange this coin with next three times and after that he will finally look through the coins and finish the process.
XOOO → OOOX
After replacement of the third coin, Dima's actions look this way:
XOXO → OXOX → OOXX
After replacement of the fourth coin, Dima's actions look this way:
XOXX → OXXX
Finally, after replacement of the second coin, row becomes consisting of coins that are in circulation and Dima will look through coins from left to right without any exchanges. | ["n = int(input())\na = list(map(int, input().split()))\np = [0] * (n + 1)\nans = [1] * (n + 1)\nind = n\nfor i in range(n):\n p[a[i] - 1] = 1\n while ind > 0 and p[ind - 1] == 1:\n ind -= 1\n ans[i + 1] = 1 + (i + 1) - (n - ind)\nprint(' '.join(map(str, ans)))", "n = int(input())\np = list(map(int, input().split()))\n\nlp = n+1\nans = [1]\nvis = [0 for i in range(n)]\nans = [1]\ntop = n\nhardness = 1\nfor i in range(len(p)):\n vis[p[i]-1] = 1\n hardness += 1\n while vis[top-1] == 1 and top > 0:\n top -= 1\n hardness -=1\n ans.append(hardness)\n \nprint(' '.join([str(i) for i in ans]))", "n = int(input())\na = list(map(int, input().split()))\np = [0] * (n + 1)\nans = [1] * (n + 1)\nind = n\nfor i in range(n):\n p[a[i] - 1] = 1\n while ind > 0 and p[ind - 1] == 1:\n ind -= 1\n ans[i + 1] = 1 + (i + 1) - (n - ind)\nprint(' '.join(map(str, ans)))", "n = int(input())\nP = list(map(int,input().split()))\n\nP[:] = [x - 1 for x in P]\n\nlst = [0]*n\n\ni = 0\nS = n-1\nans = [1]*(n+1)\n\nwhile i<n:\n lst[P[i]] = 1\n if P[i] == S:\n k=0\n while k==0:\n S+=-1\n if lst[S]==0 or S == -1:\n k=1\n i += 1\n ans[i] = i - n + S + 2\n \nprint(' '.join(map(str, ans)))", "n = int(input())\ninput_ = list(map(int, input().split()))\npos = n\na = [0 for i in range(n+1)]\nres = 1\nans = [1]\nfor x in input_:\n a[x] = 1\n res += 1\n while a[pos]==1:\n pos -= 1\n res -= 1\n ans.append(res)\nprint(' '.join(map(str, ans)))\n\n", "n = int(input())\ninput_ = list(map(int, input().split()))\npos = n\na = [0 for i in range(n+1)]\nres = 1\nans = [1]\nfor x in input_:\n a[x] = 1\n res += 1\n while a[pos]==1:\n pos -= 1\n res -= 1\n ans.append(res)\nprint(' '.join(map(str, ans)))", "n = int(input())\npositions = [int(x) for x in input().split(\" \")]\n\noutput = '1 '\n\npointer_to_right_wall = n - 1\n\ncoins = [False for i in range(len(positions))]\nfilled = 1\n\nfor i in range(len(positions)):\n\tcoins[positions[i] - 1] = True\n\tif positions[i]-1 == pointer_to_right_wall:\n\t\tcount = 0\n\t\twhile coins[pointer_to_right_wall] == True:\n\t\t\tif pointer_to_right_wall == 0 and coins[0] == True:\n\t\t\t\tcount += 1\n\t\t\t\tbreak\n\t\t\tpointer_to_right_wall -= 1\n\t\t\tcount += 1\n\t\tfilled = filled - count + 1\n\telse:\n\t\tfilled += 1\n\toutput += str(filled) + ' '\n\nprint(output[:-1])", "n = int(input())\ninput_ = list(map(int, input().split(' ')))\npos = n\na = [0 for i in range(n+1)]\nres = 1\nans = [1]\nfor x in input_:\n a[x] = 1\n res += 1\n while a[pos]==1:\n pos -= 1\n res -= 1\n ans.append(res)\nprint (' '.join(map(str, ans)))", "n = int(input())\nx = [0]*n\na = 0\np = list(map(int, input().split()))\nz = n-1\nans = ['1']\nfor i in range(n):\n x[p[i]-1] = 1\n a += 1\n while z> -1 and x[z] == 1:\n z-=1\n a-=1\n ans.append(str(a+1))\nprint(' '.join(ans))", "n = int(input())\n\np = [int(x) for x in input().split()]\n\nmx = n\n\na = [0]*(n+1)\n\nans = [1]\n\nfor i in range(0, n):\n\n t = p[i]\n\n a[t] = 1\n\n while a[mx]==1 and mx>=1: mx-=1\n\n ans.append(i+1-(n-mx)+1)\n\nprint(' '.join(map(str, ans)))\n\n\n\n\n\n# Made By Mostafa_Khaled\n", "n=int(input())\nl=list(map(int,input().split()))\np=n\niss=set()\nans=[1]\nout=1\nfor i in range(n) :\n if l[i]==p :\n p-=1\n while p in iss :\n p-=1\n out-=1\n ans.append(out)\n else :\n iss.add(l[i])\n out+=1\n ans.append(out)\nprint(*ans)\n \n \n \n \n \n \n \n", "import sys\ninput = sys.stdin.readline\nfrom collections import defaultdict\n\nn = int(input())\nans = [0 for _ in range(n + 1)]\nans[0] = 1\nans[-1] = 1\nsample = [0 for _ in range(n)]\nlast = n - 1\nq = list(map(int, input().split()))\nfor i in range(n - 1):\n\tx = q[i]\n\tsample[x-1] = 1\n\tif x - 1 == last:\n\t\twhile sample[x-1] != 0:\n\t\t\tx -= 1\n\t\tlast = x - 1\n\ttarget = n - i - 2\n\t#print(last, target)\n\tans[i + 1] = last - target + 1\nprint(*ans)\n\n", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\np = list(map(int, input().split()))\nflag = [1]*n\nr = n-1\ncnt = 0\n\nprint(1, end=' ')\n\nfor i in range(n-1):\n flag[p[i]-1] = 0\n \n while flag[r]==0:\n r -= 1\n cnt += 1\n \n print(i+2-cnt, end=' ')\n\nprint(1)", "n = int(input())\nx = [0]*n\na = 0\np = list(map(int, input().split()))\nz = n-1\nans = ['1']\nfor i in range(n):\n x[p[i]-1] = 1\n a += 1\n while z> -1 and x[z] == 1:\n z-=1\n a-=1\n ans.append(str(a+1))\nprint(' '.join(ans))\n", "n = int(input())\np=[0]*n\np=input().split()\nfor i in range (n):\n p[i]=int(p[i])\nmx = n\na = [0]*(n+1)\nans = [1]\nfor i in range(0, n):\n t = p[i]\n a[t] = 1\n while a[mx]==1 and mx>=1:\n mx-=1\n ans.append(i+1-(n-mx)+1)\nprint(' '.join(map(str, ans)))", "n = int(input())\nl = list(map(int,input().split()))\nprint(1,end = \" \")\nptr = n-1\nv = [0]*n\nfor i in range(n):\n v[l[i]-1] = 1\n while(ptr>=0 and v[ptr]==1):ptr-=1\n print(i+1-(n-1-ptr)+1,end = \" \")", "n = int(input())\nl = list(map(int,input().split()))\nprint(1,end = \" \")\nptr = n-1\nv = [0]*n\nfor i in range(n):\n v[l[i]-1] = 1\n while(ptr>=0 and v[ptr]==1):ptr-=1\n print(i+1-(n-1-ptr)+1,end = \" \")"] | {
"inputs": [
"4\n1 3 4 2\n",
"8\n6 8 3 4 7 2 1 5\n",
"1\n1\n",
"11\n10 8 9 4 6 3 5 1 11 7 2\n",
"11\n10 8 9 4 3 5 1 11 7 2 6\n",
"100\n1 72 43 50 58 87 10 94 29 51 99 86 92 80 36 31 9 100 85 59 66 30 3 78 17 73 93 37 57 71 45 15 24 2 64 44 65 22 38 79 23 8 16 52 98 97 96 95 91 90 89 88 84 83 82 81 77 76 75 74 70 69 68 67 63 62 61 60 56 55 54 53 49 48 47 46 42 41 40 39 35 34 33 32 28 27 26 25 21 20 19 18 14 13 12 11 7 6 5 4\n",
"100\n98 52 63 2 18 96 31 58 84 40 41 45 66 100 46 71 26 48 81 20 73 91 68 76 13 93 17 29 64 95 79 21 55 75 19 85 54 51 89 78 15 87 43 59 36 1 90 35 65 56 62 28 86 5 82 49 3 99 33 9 92 32 74 69 27 22 77 16 44 94 34 6 57 70 23 12 61 25 8 11 67 47 83 88 10 14 30 7 97 60 42 37 24 38 53 50 4 80 72 39\n"
],
"outputs": [
"1 2 3 2 1\n",
"1 2 2 3 4 3 4 5 1\n",
"1 1\n",
"1 2 3 4 5 6 7 8 9 6 2 1\n",
"1 2 3 4 5 6 7 8 5 5 6 1\n",
"1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 43 43 43 40 40 40 40 37 37 37 37 34 34 34 34 31 31 31 31 28 28 28 28 25 25 25 25 22 22 22 22 19 19 19 19 16 16 16 16 13 13 13 13 10 10 10 10 7 7 7 7 4 4 4 4 1\n",
"1 2 3 4 5 6 7 8 9 10 11 12 13 14 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 70 71 72 73 74 75 76 77 78 71 39 1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 5,476 | |
f94c83acd7d1699a1a0a5acb23988133 | UNKNOWN | Polycarpus is a system administrator. There are two servers under his strict guidance — a and b. To stay informed about the servers' performance, Polycarpus executes commands "ping a" and "ping b". Each ping command sends exactly ten packets to the server specified in the argument of the command. Executing a program results in two integers x and y (x + y = 10; x, y ≥ 0). These numbers mean that x packets successfully reached the corresponding server through the network and y packets were lost.
Today Polycarpus has performed overall n ping commands during his workday. Now for each server Polycarpus wants to know whether the server is "alive" or not. Polycarpus thinks that the server is "alive", if at least half of the packets that we send to this server reached it successfully along the network.
Help Polycarpus, determine for each server, whether it is "alive" or not by the given commands and their results.
-----Input-----
The first line contains a single integer n (2 ≤ n ≤ 1000) — the number of commands Polycarpus has fulfilled. Each of the following n lines contains three integers — the description of the commands. The i-th of these lines contains three space-separated integers t_{i}, x_{i}, y_{i} (1 ≤ t_{i} ≤ 2; x_{i}, y_{i} ≥ 0; x_{i} + y_{i} = 10). If t_{i} = 1, then the i-th command is "ping a", otherwise the i-th command is "ping b". Numbers x_{i}, y_{i} represent the result of executing this command, that is, x_{i} packets reached the corresponding server successfully and y_{i} packets were lost.
It is guaranteed that the input has at least one "ping a" command and at least one "ping b" command.
-----Output-----
In the first line print string "LIVE" (without the quotes) if server a is "alive", otherwise print "DEAD" (without the quotes).
In the second line print the state of server b in the similar format.
-----Examples-----
Input
2
1 5 5
2 6 4
Output
LIVE
LIVE
Input
3
1 0 10
2 0 10
1 10 0
Output
LIVE
DEAD
-----Note-----
Consider the first test case. There 10 packets were sent to server a, 5 of them reached it. Therefore, at least half of all packets sent to this server successfully reached it through the network. Overall there were 10 packets sent to server b, 6 of them reached it. Therefore, at least half of all packets sent to this server successfully reached it through the network.
Consider the second test case. There were overall 20 packages sent to server a, 10 of them reached it. Therefore, at least half of all packets sent to this server successfully reached it through the network. Overall 10 packets were sent to server b, 0 of them reached it. Therefore, less than half of all packets sent to this server successfully reached it through the network. | ["n=int(input())\nta,tb,da,db=[0]*4\nfor i in range (n):\n t,x,y=list(map(int,input().split()))\n if t==1:\n ta+=(x+y)\n da+=y\n if (t==2):\n tb+=(x+y)\n db+=y \nif (ta-da>=0.5*ta):\n print ('LIVE')\nelse :\n print ('DEAD')\nif (tb-db>=0.5*tb):\n print ('LIVE')\nelse :\n print ('DEAD') \n \n", "n=int(input())\nlive1, dead1, live2, dead2 = 0, 0, 0, 0\nfor i in range(n):\n I=[int(j) for j in input().split()]\n if I[0]==1:\n live1+=I[1]\n dead1+=I[2]\n else:\n live2+=I[1]\n dead2+=I[2]\nif live1>=(live1+dead1)/2: print('LIVE')\nelse: print('DEAD')\nif live2>=(live2+dead2)/2: print('LIVE')\nelse: print('DEAD')", "import sys\n#f = sys.stdin\n# f = open(\"input.txt\", \"r\")\nn = int(input())\na, b = [[],[]], [[],[]]\nfor i in range(n):\n t, xi, yi = map(int, input().split())\n if t == 1:\n a[0].append(xi)\n a[1].append(yi)\n else:\n b[0].append(xi)\n b[1].append(yi)\nif sum(a[0]) >= sum(a[1]):\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\nif sum(b[0]) >= sum(b[1]):\n print(\"LIVE\")\nelse:\n print(\"DEAD\")", "3\n\nn = int(input())\nsend = [[], []]\nfor _ in range(n):\n t, x, y = tuple(map(int, input().split()))\n send[t - 1].append(x)\nfor _ in range(2):\n print('LIVE' if 2 * sum(send[_]) >= 10 * len(send[_]) else 'DEAD')\n", "while(1):\n try:\n n=int(input())\n a,b,c=[0 for j in range(n)],[0 for j in range(n)],[0 for j in range(n)]\n sum1,sum2=0,0\n for i in range(0,n):\n a[i],b[i],c[i]=list(map(int,input().split()))\n if a[i]==1:\n sum1+=b[i]\n else:\n sum2+=b[i]\n count1,count2=a.count(1),a.count(2)\n t1,t2=10*count1,10*count2\n if sum1/t1>=0.5:\n print(\"LIVE\")\n else:\n print(\"DEAD\")\n if sum2/t2>=0.5:\n print(\"LIVE\")\n else:\n print(\"DEAD\")\n except EOFError:\n break\n \n \n \n \n \n", "n = int(input())\nu, v = [0, 0], [0, 0]\nfor i in range(n):\n t, x, y = list(map(int, input().split()))\n k = int(t == 1)\n u[k] += x\n v[k] += y\nprint('LDIEVAED'[u[1] < v[1] :: 2])\nprint('LDIEVAED'[u[0] < v[0] :: 2]) \n", "n=int(input())\nAns=\"\"\nA=[0,0]\nB=[0,0]\nfor i in range(n):\n l,x,y=list(map(int,input().split()))\n if(l==1):\n A[0]+=x\n A[1]+=10\n else:\n B[0]+=x\n B[1]+=10\nif(A[0]/A[1]>=1/2):\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n\nif(B[0]/B[1]>=1/2):\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n", "n=int(input())\na,ar,b,br=0,0,0,0\nfor i in range(n):\n x=list(map(int,input().split()))\n if(x[0]==1):\n a+=10\n ar+=x[1]\n else:\n b+=10\n br+=x[1]\nprint('DLEIAVDE'[ar>=a//2::2])\nprint('DLEIAVDE'[br>=b//2::2])\n", "n = int(input())\nr = [[0,0,0],[0,0,0]]\nfor i in range(n):\n t,x,y = map(int, input().split())\n if t == 1:\n r[0][0] += 1\n r[0][1] += x\n r[0][2] += y\n else:\n r[1][0] += 1\n r[1][1] += x\n r[1][2] += y\nfor i in r:\n if i[1] < i[2]:\n print('DEAD')\n else:\n print('LIVE')", "n=int(input())\na=0\na1=0\nb=0\nb1=0\nfor i in range(n):\n t,x,y=list(map(int,input().split()))\n if t==1:\n a+=x\n a1+=y\n else:\n b+=x\n b1+=y\nif a>=a1:\n print('LIVE')\nelse:\n print('DEAD')\nif b>=b1:\n print('LIVE')\nelse:\n print('DEAD')\n", "c = [[0, 0], [0, 0]]\nfor i in range(int(input())):\n l = [int(x) for x in input().split()]\n c[l[0] - 1][0] += l[1]\n c[l[0] - 1][1] += l[2]\nfor i in range(2):\n print('LIVE' if c[i][0] >= c[i][1] else 'DEAD')", "n = int(input())\nax = ay = bx = by = 0\nfor i in range(n):\n\tx, y, z = [int(t) for t in input().split()]\n\tif x == 1:\n\t\tax += y\n\t\tay += z\n\telse:\n\t\tbx += y\n\t\tby += z\nprint('LIVE' if ax >= ay else 'DEAD')\nprint('LIVE' if bx >= by else 'DEAD')\n", "def main():\n n = int(input())\n LIVE, DEAD = [0, 0, 0], [0, 0, 0]\n for _ in range(n):\n t, x, y = map(int, input().split())\n LIVE[t] += x\n DEAD[t] += y\n for _ in 1, 2:\n print(('LIVE', 'DEAD')[LIVE[_] < DEAD[_]])\n\n\ndef __starting_point():\n main()\n__starting_point()", "n = int(input())\naSended = 0\nbSended = 0\naPing = 0\nbPing = 0\n\nwhile n > 0:\n t, x, y = map(int, input().split())\n if t == 1:\n aSended = aSended + 10\n aPing = aPing + x\n elif t == 2:\n bSended = bSended + 10\n bPing = bPing + x\n n = n - 1\n\nif(int(aSended / 2) <= aPing):\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n\nif(int(bSended / 2) <= bPing):\n print(\"LIVE\")\nelse:\n print(\"DEAD\")", "s = [[0, 0], [0, 0]]\nfor i in range(int(input())):\n server, pass_, down = map(int, input().split())\n s[server - 1][0] += pass_\n s[server - 1][1] += down\nprint('LIVE' if s[0][0] >= s[0][1] else 'DEAD', 'LIVE' if s[1][0] >= s[1][1] else 'DEAD', sep='\\n')", "from functools import reduce\nfrom operator import *\nfrom math import *\nfrom sys import *\nfrom string import *\nfrom collections import *\nsetrecursionlimit(10**7)\ndX= [-1, 1, 0, 0,-1, 1,-1, 1]\ndY= [ 0, 0,-1, 1, 1,-1,-1, 1]\nRI=lambda: list(map(int,input().split()))\nRS=lambda: input().rstrip().split()\n#################################################\nn=RI()[0]\nti=[0]*3\ntot=[0]*3\nfor i in range(n):\n t,x,y=RI()\n tot[t]+=x\n ti[t]+=1\nfor i in (1,2):\n print([\"LIVE\",\"DEAD\"][ti[i]*5>tot[i]])\n\n\n\n\n", "n = int(input())\nres1success = 0\nres1fail = 0\nres2success = 0\nres2fail = 0\nfor i in range(n):\n s, x, y = list(map(int, input().split()))\n if s == 1:\n res1success += x\n res1fail += y\n else:\n res2success += x\n res2fail += y\n\nif res1success >= res1fail:\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n\nif res2success >= res2fail:\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n", "n = int(input())\nres1success = 0\nres1fail = 0\nres2success = 0\nres2fail = 0\nfor i in range(n):\n s, x, y = list(map(int, input().split()))\n if s == 1:\n res1success += x\n res1fail += y\n else:\n res2success += x\n res2fail += y\n\nif res1success >= res1fail:\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n\nif res2success >= res2fail:\n print(\"LIVE\")\nelse:\n print(\"DEAD\")\n", "n = int(input())\n\na = b = 0\na_success = b_success = 0\n\nfor i in range(0, n):\n description = [int(x) for x in input().split()]\n if description[0] == 1:\n a += 1\n a_success += description[1]\n else:\n b += 1\n b_success += description[1]\n\nprint([\"DEAD\", \"LIVE\"][a_success >= a*5])\nprint([\"DEAD\", \"LIVE\"][b_success >= b*5])\n\n", "n = int(input())\nq = 0\ne = 0\nw = 0\nr = 0\nfor i in range(n):\n t, x, y = map(int, input().split())\n if(t == 1):\n q+=x\n w+=10\n else:\n e+=x\n r+=10\nif(q < w//2):\n print(\"DEAD\")\nelse:\n print(\"LIVE\")\nif(e < r//2):\n print(\"DEAD\")\nelse:\n print(\"LIVE\")", "n=int(input())\nna,nb,ca,cb=0,0,0,0 \nwhile n>0:\n\tx,y,z=map(int,input().split())\n\tif x==1:\n\t\tna+=10\n\t\tca+=y\n\telse:\n\t\tnb+=10\n\t\tcb+=y\n\tn=n-1\nif ca*2>=na:\n\tprint('LIVE')\nelse:\n\tprint('DEAD')\n\nif cb*2>=nb:\n\tprint('LIVE')\nelse:\n\tprint('DEAD')", "def myprint(ca,na):\n\tif ca*2>=na:\n\t\tprint('LIVE')\n\telse:\n\t\tprint('DEAD')\n\nn=int(input())\nna,nb,ca,cb=0,0,0,0 \nwhile n>0:\n\tx,y,z=map(int,input().split())\n\tif x==1:\n\t\tna+=10\n\t\tca+=y\n\telse:\n\t\tnb+=10\n\t\tcb+=y\n\tn=n-1\nmyprint(ca,na)\nmyprint(cb,nb)", "n = int(input())\nsuccess = [0, 0]\ntotal = [0, 0]\nfor _ in range(n):\n\ti, x, y = map(int, input().split())\n\ttotal[i-1] += 10\n\tsuccess[i-1] += x\nfor i in range(2):\n\tprint(\"LIVE\" if success[i] * 2 >= total[i] else \"DEAD\")", "n = int(input())\na = [[0,0],[0,0]]\nfor i in range(n):\n t,x,y = map(int, input().split())\n a[t-1][0] += x\n a[t-1][1] += 5\nif a[0][0] >= a[0][1]:\n print('LIVE')\nelse:\n print('DEAD')\nif a[1][0] >= a[1][1]:\n print('LIVE')\nelse:\n print('DEAD')", "# from dust i have come dust i will be\n\nn=int(input())\n\nax=0;bx=0\nay=0;by=0\n\nfor i in range(n):\n t,x,y=list(map(int,input().split()))\n\n if t==1:\n ax+=x\n ay+=y\n else:\n bx+=x\n by+=y\n\nif ax>=(ax+ay)//2:\n print('LIVE')\nelse:\n print('DEAD')\n\nif bx>=(bx+by)//2:\n print('LIVE')\nelse:\n print('DEAD')\n"] | {
"inputs": [
"2\n1 5 5\n2 6 4\n",
"3\n1 0 10\n2 0 10\n1 10 0\n",
"10\n1 3 7\n2 4 6\n1 2 8\n2 5 5\n2 10 0\n2 10 0\n1 8 2\n2 2 8\n2 10 0\n1 1 9\n",
"11\n1 8 2\n1 6 4\n1 9 1\n1 7 3\n2 0 10\n2 0 10\n1 8 2\n2 2 8\n2 6 4\n2 7 3\n2 9 1\n",
"12\n1 5 5\n1 0 10\n1 4 6\n1 2 8\n1 2 8\n1 5 5\n1 9 1\n2 9 1\n1 5 5\n1 1 9\n2 9 1\n2 7 3\n",
"13\n1 8 2\n1 4 6\n1 5 5\n1 5 5\n2 10 0\n2 9 1\n1 3 7\n2 6 4\n2 6 4\n2 5 5\n1 7 3\n2 3 7\n2 9 1\n",
"14\n1 7 3\n1 0 10\n1 7 3\n1 1 9\n2 2 8\n2 0 10\n1 1 9\n2 8 2\n2 6 4\n1 3 7\n1 3 7\n2 6 4\n2 1 9\n2 7 3\n"
],
"outputs": [
"LIVE\nLIVE\n",
"LIVE\nDEAD\n",
"DEAD\nLIVE\n",
"LIVE\nDEAD\n",
"DEAD\nLIVE\n",
"LIVE\nLIVE\n",
"DEAD\nDEAD\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 8,689 | |
926958a201a07bcb54133f7a06cc6dbd | UNKNOWN | The legendary Farmer John is throwing a huge party, and animals from all over the world are hanging out at his house. His guests are hungry, so he instructs his cow Bessie to bring out the snacks! Moo!
There are $n$ snacks flavors, numbered with integers $1, 2, \ldots, n$. Bessie has $n$ snacks, one snack of each flavor. Every guest has exactly two favorite flavors. The procedure for eating snacks will go as follows: First, Bessie will line up the guests in some way. Then in this order, guests will approach the snacks one by one. Each guest in their turn will eat all remaining snacks of their favorite flavor. In case no favorite flavors are present when a guest goes up, they become very sad.
Help Bessie to minimize the number of sad guests by lining the guests in an optimal way.
-----Input-----
The first line contains integers $n$ and $k$ ($2 \le n \le 10^5$, $1 \le k \le 10^5$), the number of snacks and the number of guests.
The $i$-th of the following $k$ lines contains two integers $x_i$ and $y_i$ ($1 \le x_i, y_i \le n$, $x_i \ne y_i$), favorite snack flavors of the $i$-th guest.
-----Output-----
Output one integer, the smallest possible number of sad guests.
-----Examples-----
Input
5 4
1 2
4 3
1 4
3 4
Output
1
Input
6 5
2 3
2 1
3 4
6 5
4 5
Output
0
-----Note-----
In the first example, Bessie can order the guests like this: $3, 1, 2, 4$. Guest $3$ goes first and eats snacks $1$ and $4$. Then the guest $1$ goes and eats the snack $2$ only, because the snack $1$ has already been eaten. Similarly, the guest $2$ goes up and eats the snack $3$ only. All the snacks are gone, so the guest $4$ will be sad.
In the second example, one optimal ordering is $2, 1, 3, 5, 4$. All the guests will be satisfied. | ["#!usr/bin/env python3\nfrom collections import defaultdict,deque\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef I(): return int(sys.stdin.readline())\ndef LS():return [list(x) for x in sys.stdin.readline().split()]\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res\ndef IR(n):\n return [I() for i in range(n)]\ndef LIR(n):\n return [LI() for i in range(n)]\ndef SR(n):\n return [S() for i in range(n)]\ndef LSR(n):\n return [LS() for i in range(n)]\n\nsys.setrecursionlimit(1000000)\nmod = 1000000007\n\n#A\ndef A():\n n = I()\n a = LI()\n a.sort()\n f = [1]*n\n p = 0\n ans = 0\n while p < n:\n while p < n and not f[p]:\n p += 1\n if p == n:\n break\n ans += 1\n for i in range(n):\n if a[i]%a[p] == 0:\n f[i] = 0\n print(ans)\n return\n\n#B\ndef B():\n n = I()\n s = list(map(int, input()))\n g = LIR(n)\n ans = sum(s)\n for t in range(30000):\n for i in range(n):\n ai,bi = g[i]\n if t < bi:\n continue\n if (t-bi)%ai == 0:\n s[i] ^= 1\n su = sum(s)\n if ans < su:\n ans = su\n print(ans)\n return\n\n#C\ndef C():\n t = I()\n for _ in range(t):\n n = I()\n s = list(map(int, input()))\n mi = [s[-1]]\n for i in s[:-1][::-1]:\n mi.append(min(mi[-1],i))\n mi = mi[::-1]\n ans = [None]*n\n for i in range(n):\n if mi[i] == s[i]:\n ans[i] = 1\n else:\n ans[i] = 2\n q = [s[i] for i in range(n) if ans[i] > 1]\n p = [q[i] for i in range(len(q))]\n p.sort()\n if p == q:\n print(*ans,sep = \"\")\n else:\n print(\"-\")\n return\n\n#D\ndef D():\n def root(x):\n if x == par[x]:\n return x\n par[x] = root(par[x])\n return par[x]\n\n def unite(x,y):\n x = root(x)\n y = root(y)\n if rank[x] < rank[y]:\n par[x] = y\n else:\n par[y] = x\n if rank[x] == rank[y]:\n rank[x] += 1\n\n n,k = LI()\n par = [i for i in range(n)]\n rank = [0]*n\n for i in range(k):\n x,y = LI()\n x -= 1\n y -= 1\n if root(x) != root(y):\n unite(x,y)\n size = [0]*n\n for i in range(n):\n size[root(i)] += 1\n ans = 0\n for i in size:\n if i > 0:\n ans += i-1\n print(k-ans)\n return\n\n#E\ndef E():\n\n return\n\n#F\ndef F():\n\n return\n\n#G\ndef G():\n\n return\n\n#H\ndef H():\n\n return\n\n#Solve\ndef __starting_point():\n D()\n\n__starting_point()", "import sys\ninput = sys.stdin.readline\n\nfrom collections import deque\nN, K = list(map(int, input().split()))\nX = [[] for i in range(N)]\nfor i in range(K):\n x, y = list(map(int, input().split()))\n X[x-1].append(y-1)\n X[y-1].append(x-1)\n\nmi = 10**6\nmii = 0\nfor i in range(N):\n if len(X) and (len(X) < mi):\n mi = len(X)\n mii = i\n\nY = [(len(X[i]), i) for i in range(N) if len(X[i])]\nY = sorted(Y)\nQ = [y[1] for y in Y]\n\nP = [-1] * N\nD = [0] * N\nans = 0\nwhile Q:\n i = Q.pop()\n for a in X[i]:\n if D[a] == 0 or D[i] == 0:\n ans += 1\n D[a] = 1\n D[i] = 1\n if a != P[i]:\n P[a] = i\n X[a].remove(i)\n Q.append(a)\nprint(K - ans)\n\n\n", "n, ne = map(int, input().split())\ntr = [[] for __ in range(n)]\nfor __ in range(ne):\n u, v = map(int, input().split())\n u -= 1; v -= 1\n tr[u].append(v)\n tr[v].append(u)\n\nvisited = [0] * n\nr = 0\nfor i in range(n):\n if visited[i]: continue \n q = [i]; visited[i] = 1\n for u in q:\n for v in tr[u]:\n if not visited[v]:\n visited[v] = 1\n q.append(v); r += 1\nprint(ne - r)", "import sys\ninput = sys.stdin.readline\n\nn,k=list(map(int,input().split()))\nsnack=[tuple(sorted(map(int,input().split()))) for i in range(k)]\nsnack.sort()\n\nGroup=[i for i in range(n+1)]\n\ndef find(x):\n while Group[x] != x:\n x=Group[x]\n return x\n\ndef Union(x,y):\n if find(x) != find(y):\n MIN,MAX=sorted((find(y),find(x)))\n W[MIN]=W[find(x)]+W[find(y)]\n W[MAX]=1\n Group[find(y)]=Group[find(x)]=MIN\n\nW=[1]*(n+1)\n\na,b=snack[0]\nUnion(a,b)\n\n#print(Group,W)\n\nfor i in range(1,k):\n if snack[i]==snack[i-1]:\n continue\n\n a,b=snack[i]\n\n if find(a)!=find(b):\n Union(a,b)\n\n #print(Group,W)\n\nSUM=sum([w-1 for w in W])\n\nprint(k-SUM)\n", "import sys\ninput = sys.stdin.readline\nn, k = list(map(int, input().split()))\n\nclass Union_Find():\n def __init__(self, num):\n self.par = [-1]*(num+1)\n self.siz = [1]*(num+1)\n\n def same_checker(self, x, y):\n return self.find(x) == self.find(y)\n\n def find(self, x):\n if self.par[x] < 0:\n return x\n else:\n x = self.par[x]\n return self.find(x)\n\n def union(self, x, y):\n rx = self.find(x)\n ry = self.find(y)\n if rx != ry:\n if self.par[rx] < self.par[ry]:\n self.par[ry] = rx\n self.siz[rx] += self.siz[ry]\n elif self.par[rx] > self.par[ry]:\n self.par[rx] = ry\n self.siz[ry] += self.siz[rx]\n else:\n self.par[rx] -= 1\n self.par[ry] = rx\n self.siz[rx] += self.siz[ry]\n return\n\n def size(self, x):\n return self.siz[self.find(x)]\n\nans = 0\nguest = Union_Find(n)\nfor i in range(k):\n a, b = list(map(int, input().split()))\n if guest.same_checker(a, b):\n ans += 1\n else:\n guest.union(a, b)\n\nprint(ans)\n", "n, k = list(map(int, input().split()))\ngraph = {i: set() for i in range(1, n + 1)}\nfor _ in range(k):\n u, v = list(map(int, input().split()))\n graph[u].add(v)\n graph[v].add(u)\nans = 0\nused = [0] * (n + 1)\nfor v in range(1, n + 1):\n if used[v] == 0:\n ans += 1\n S = [v]\n while S:\n ver = S.pop()\n for u in graph[ver]:\n if used[u] == 0:\n S.append(u)\n used[u] = 1\nprint(k - n + ans)\n", "class UnionFind:\n def __init__(self,n):\n self.par=[i for i in range(n)]\n self.rank=[0]*n\n self.size=[1]*n\n def find(self,x):\n if self.par[x]==x:\n return x\n else:\n self.par[x]=self.find(self.par[x])\n return self.par[x]\n def union(self,x,y):\n px=self.find(x)\n py=self.find(y)\n if px!=py:\n if self.rank[px]==self.rank[py]:\n self.rank[px]+=1\n elif self.rank[px]<self.rank[py]:\n px,py=py,px\n self.par[py]=px\n self.size[px]+=self.size[py]\n def same_check(self,x,y):\n return self.find(x)==self.find(y)\n\nimport sys\ninput=sys.stdin.readline\nsys.setrecursionlimit(10**9)\nn,k=map(int,input().split())\nuf=UnionFind(n)\nEdges=set()\nfor _ in range(k):\n a,b=map(int,input().split())\n a-=1; b-=1\n if a>b:\n a,b=b,a\n Edges.add((a,b))\nfor a,b in Edges:\n uf.union(a,b)\nP=set()\nfor i in range(n):\n P.add(uf.find(i))\nnum=0\nfor p in P:\n num+=uf.size[p]-1\nprint(k-num)", "def find(x):\n x1 = x\n while p[x] != x:\n x = p[x]\n while p[x1] != x1:\n x2 = p[x1]\n p[x1] = x\n x1 = x2\n return x\n\ninp = lambda : list(map(int, input().split()))\nn, k = inp()\nedges = []\nfor i in range(k):\n x, y = inp()\n edges.append([x - 1, y - 1])\n\np = [i for i in range(n)]\nans = 0\nfor i in edges:\n p1 = find(i[0])\n p2 = find(i[1])\n if p1 == p2:\n ans += 1\n else:\n p[p1] = p2\nprint(ans)\n", "class UnionFind:\n def __init__(self, n):\n self.par = [i for i in range(n)]\n self.size = [1] * n\n self.edge = [0] * n\n self.rank = [0] * n\n\n def find(self, x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n\n def same_check(self, x, y):\n return self.find(x) == self.find(y)\n\n def get_size(self, x):\n return self.size[self.find(x)]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n self.edge[x] += 1\n return\n\n if self.rank[x] < self.rank[y]:\n self.par[x] = y\n self.size[y] += self.size[x]\n self.edge[y] += self.edge[x] + 1\n else:\n self.par[y] = x\n self.size[x] += self.size[y]\n self.edge[x] += self.edge[y] + 1\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n \nn, k = [int(item) for item in input().split()]\nUF = UnionFind(2 * 10**5)\nfor i in range(k):\n a, b = [int(item) for item in input().split()]\n a -= 1; b -= 1\n UF.union(a, b)\nseen = [False] * (2 * 10**5)\nans = 0\nfor i in range(2 * 10**5):\n par = UF.find(i)\n if seen[par]:\n continue\n if UF.edge[par] == 0:\n continue\n else:\n ans += UF.edge[par] - (UF.size[par] - 1)\n seen[par] = True \nprint(ans)", "import sys\nn, k = [int(i) for i in sys.stdin.readline().split()]\ngwl = []\nfor i in range(n+1):\n gwl.append([])\ndata = []\nfor kk in range(k):\n d = [int(i) for i in sys.stdin.readline().split()]\n gwl[d[0]].append(kk)\n gwl[d[1]].append(kk)\n data.append(d)\n\none = set()\ntwo = set(range(k))\nsn = [1] * (n+1)\ndoub = [1] * k\nans = 0\n\n\nwhile True:\n # print(one, two)\n if one:\n ans += 1\n q = one.pop()\n d = data[q]\n # print(q, d)\n if sn[d[0]]:\n sn[d[0]] = 0\n for oth in gwl[d[0]]:\n if doub[oth]:\n two.remove(oth)\n one.add(oth)\n doub[oth] = 0\n else:\n one.discard(oth)\n else:\n sn[d[1]] = 0\n for oth in gwl[d[1]]:\n if doub[oth]:\n two.remove(oth)\n one.add(oth)\n doub[oth] = 0\n else:\n one.discard(oth)\n elif two:\n ans += 1\n q = two.pop()\n doub[q] = 0\n d = data[q]\n # print(q, d)\n for w in range(2):\n sn[d[w]] = 0\n for oth in gwl[d[w]]:\n if doub[oth]:\n two.remove(oth)\n one.add(oth)\n doub[oth] = 0\n else:\n one.discard(oth)\n else:\n break\nprint(k - ans)\n", "from sys import stdin\nn, k = tuple(int(x) for x in stdin.readline().split())\ndic = {}\nans = 0\nfor i in range(k):\n a, b = tuple(int(x) for x in stdin.readline().split())\n a -= 1\n b -= 1\n if a not in dic:\n dic[a] = set((b,))\n else:\n dic[a].add(b)\n\n if b not in dic:\n dic[b] = set((a,))\n else:\n dic[b].add(a)\n\nfor i in range(n):\n if i in dic:\n lst = [i]\n s = set((i,))\n for src in lst:\n if src in dic:\n for dest in dic[src]:\n if dest in dic and dest not in s:\n lst.append(dest)\n s.add(dest)\n ans += 1\n del dic[src]\nprint(k-ans)\n \n \n", "n,m=list(map(int,input().split()))\ngr=[set() for i in range(n)]\nfor i in range(m):\n\ta,b=list(map(int,input().split()))\n\tgr[a-1].add(b-1)\n\tgr[b-1].add(a-1)\n\nv=[False for i in range(n)]\nan=0\nfor i in range(n):\n\tif v[i]:continue\n\ts=[i]\n\td=0\n\tv[i]=True\n\twhile s:\n\t\tx=s.pop()\n\t\td+=1\n\t\tfor j in gr[x]:\n\t\t\tif v[j]:continue\n\t\t\tv[j]=True\n\t\t\ts.append(j)\n\n\tan+=d-1\n\nprint(m-an)\n", "from queue import Queue\n\nn, k = map(int, input().split())\na = [tuple(sorted(list(map(lambda x: int(x)-1, input().split())))) for i in range(k)]\na = list(set(a))\na.sort()\nedges = [[] for i in range(n)]\nfor i in a:\n edges[i[0]].append(i[1])\n edges[i[1]].append(i[0])\n\nans = 0\nvisited = [False for i in range(n)]\nqueue = Queue(maxsize=n)\nfor j in range(len(a)):\n if not visited[a[j][0]] and visited[a[j][1]]:\n visited[a[j][0]] = True\n s = a[j][0]\n ans += 1\n\n queue.put(s)\n while not queue.empty():\n s = queue.get()\n for i in edges[s]:\n if visited[i] == False:\n queue.put(i)\n visited[i] = True\n ans += 1\n\n elif visited[a[j][0]] and not visited[a[j][1]]:\n visited[a[j][1]] = True\n s = a[j][1]\n ans += 1\n\n queue.put(s)\n while not queue.empty():\n s = queue.get()\n for i in edges[s]:\n if visited[i] == False:\n queue.put(i)\n visited[i] = True\n ans += 1\n elif not visited[a[j][0]] and not visited[a[j][1]]:\n visited[a[j][0]] = True\n visited[a[j][1]] = True\n ans += 1\n\n s = a[j][0]\n queue.put(s)\n while not queue.empty():\n s = queue.get()\n for i in edges[s]:\n if visited[i] == False:\n queue.put(i)\n visited[i] = True\n ans += 1\n\n s = a[j][1]\n queue.put(s)\n while not queue.empty():\n s = queue.get()\n for i in edges[s]:\n if visited[i] == False:\n queue.put(i)\n visited[i] = True\n ans += 1\nprint(abs(k-ans))", "from collections import deque\n\ndef dfs(s,vis,items):\n ans=0\n q=deque()\n q.append(s)\n vis[s]=True\n while len(q)>0:\n u=q.popleft()\n for v in items[u]:\n if not vis[v]:\n vis[v]=True\n q.append(v)\n ans+=1\n return ans\n\nn,k=map(int,input().split())\narr=[map(int,input().split()) for _ in range(k)]\nitems=[[] for _ in range(n+1)]\nfor x,y in arr:\n items[x].append(y)\n items[y].append(x)\nvis=[False for _ in range(n+1)]\nans=k\nfor i,a in enumerate(items[1:]):\n if not vis[i]: ans-=dfs(i,vis,items)\nprint(ans)", "def find(people,N):\n dic={}\n gr=[[] for _ in range(N+1)]\n count=0\n for (a,b) in people:\n a,b=sorted([a,b])\n if (a,b) in dic:\n count+=1\n else:\n dic[(a,b)]=1\n gr[a]+=[b]\n gr[b]+=[a]\n \n checked=[0]*(N+1)\n parent=[-1]*(N+1)\n for i in range(1,N+1):\n if checked[i]==0:\n stack=[i]\n while stack:\n node=stack.pop()\n checked[node]=2\n for v in gr[node]:\n if parent[node]==v:\n continue\n if checked[v]==2:\n continue\n if checked[v]==1:\n count+=1\n else:\n stack+=[v]\n parent[v]=node\n checked[v]=1\n return count\n\n\n \npeople=[]\nn,k=list(map(int,input().strip().split(\" \")))\nfor _ in range(k):\n a,b=list(map(int,input().strip().split(\" \")))\n people+=[(a,b)]\nprint(find(people,n))\n \n \n \n", "n,k=list(map(int,input().split()))\nparent=[i for i in range(n)]\nrank=[1 for i in range(n)]\ndef find_parent(u):\n if parent[u]!=u:\n parent[u]=find_parent(parent[u])\n return parent[u]\nfor i in range(k):\n u,v=list(map(int,input().split()))\n u=find_parent(u-1)\n v=find_parent(v-1)\n if u!=v:\n parent[u]=v;\n rank[v]+=rank[u];\nsat=0;\nfor i in range(n):\n if parent[i]==i:\n sat+=(rank[i]-1)\nprint(k-sat)\n", "def find_set(v):\n if v==parent[v]:\n return v\n parent[v] = find_set(parent[v])\n return parent[v]\n\ndef union_sets(x,y):\n x = find_set(x)\n y = find_set(y)\n if x!=y:\n if rank[x] < rank[y]:\n x,y = y,x\n parent[y] = x\n if rank[x] == rank[y]:\n rank[x]+=1\n\nn,k = list(map(int,input().split()))\nparent = [0]*n\nrank = [0]*n\nvis = [0]*n\nfor i in range(n):\n parent[i] = i\nfor _ in range(k):\n x,y = list(map(int,input().split()))\n union_sets(x-1,y-1)\n #print(parent)\n\nc = 0\nfor i in range(n):\n if parent[i] == i:\n c+=1\nprint(k-n+c)\n", "\ndef find_parent(u):\n if par[u]!=u:\n par[u]=find_parent(par[u])\n return par[u]\n\nn,k = list(map(int,input().split()))\n\nl = []\n\npar = [0]+[i+1 for i in range(n)]\n\ng = []\nrank = [1]*(n+1)\n\nans = 0\nfor i in range(k):\n a,b = list(map(int,input().split()))\n z1,z2 = find_parent(a),find_parent(b)\n if z1!=z2:\n par[z1] = z2\n rank[z2]+=rank[z1]\n ans+=1\n\nprint(k-ans)\n\n\n\n\n\n\n\n\n\n", "from queue import Queue\n\"\"\"\ndef dfs(graphs, visited, here):\n if visited[here] == False:\n visited[here] = True\n for next in graphs[here]:\n if visited[next] == False:\n dfs(graphs, visited, next)\n\ndef dfsAll(graphs, visited, N):\n ret = 0\n for here in range(1, N+1):\n if visited[here] == False:\n ret += 1\n dfs(graphs, visited, here)\n return ret\n\"\"\"\n\"\"\"\ndef bfs(graphs, visited, here):\n if visited[here] == False:\n q = Queue()\n q.put(here)\n while q.qsize() > 0:\n here = q.get()\n for next in graphs[here]:\n if visited[next] == False:\n visited[next] = True\n q.put(next)\n\ndef bfsAll(graphs, visited, N):\n ret = 0\n for here in range(1, N+1):\n if visited[here] == False:\n ret += 1\n bfs(graphs, visited, here)\n return ret\n\"\"\"\nN, K = list(map(int,input().strip().split(' ')))\nsnacks = [[] for i in range(N+1)]\nvisited = [False for i in range(N+1)]\nfor k in range(K):\n a, b = list(map(int,input().strip().split(' ')))\n snacks[a].append(b)\n snacks[b].append(a)\nq = Queue()\ncomponents = 0\nfor here in range(1, N+1):\n if visited[here] == False:\n visited[here] = True\n for there in snacks[here]:\n if visited[there] == False:\n visited[there] = True\n q.put(there)\n while q.qsize() > 0:\n here = q.get()\n for there in snacks[here]:\n if visited[there] == False:\n visited[there] = True\n q.put(there)\n components += 1\nret = K - (N - components)\nprint(ret)\n", "import sys\n\ndef main():\n def input():\n return sys.stdin.readline()[:-1]\n\n N, k = list(map(int,input().split()))\n\n # union-find\n parent = [k for k in range(N)]\n def find(x):\n if parent[x] == x:\n return x\n else:\n parent[x] = find(parent[x])\n return find(parent[x])\n def unite(x,y):\n parent[find(x)] = find(y)\n ans = 0\n for q in range(k):\n x, y = list(map(int,input().split()))\n if find(x-1) == find(y-1):\n ans += 1\n else:\n unite(x-1,y-1)\n print(ans)\ndef __starting_point():\n main()\n\n__starting_point()", "#!python3\n\"\"\"\n11\n 22\n 33\n 66\n 11\n 22\n 33\n 44\n 55\n12\n23\n34\n\"\"\"\n\nfrom collections import deque, Counter\nimport array\nfrom itertools import combinations, permutations\nfrom math import sqrt\nimport unittest\n\n\ndef read_int():\n return int(input().strip())\n\n\ndef read_int_array():\n return [int(i) for i in input().strip().split(' ')]\n\n######################################################\n\nn, k = read_int_array()\nadj = [[] for _ in range(n)]\nedges = set()\nfor _ in range(k):\n x, y = read_int_array()\n x, y = (y, x) if y < x else (x, y)\n if (x,y) not in edges:\n edges.add((x, y))\n adj[x-1] += [y-1]\n adj[y-1] += [x-1]\n\nmarked = set()\n\ndef bfs(s):\n tree = []\n queue = [s]\n count = 0\n while queue:\n v = queue.pop()\n if v in marked:\n continue\n tree += [v]\n count += 1\n marked.add(v)\n for w in adj[v]:\n if w not in marked:\n queue += [w]\n # if len(tree) > 1:\n # print(' '.join(str(i) for i in tree))\n return count\n\ncount = 0\nfor v in range(n):\n if v not in marked:\n m = bfs(v)\n count += m - 1\n\nprint(k - count)\n\n\"\"\"\n0 1\n3 2\n0 3\n2 3\n\"\"\"\n\n", "def flood_fill(adj_lists, colors, i, color):\n q = set()\n q.add(i)\n while len(q) > 0:\n j = q.pop()\n if colors[j] is None:\n colors[j] = color\n for k in adj_lists[j]:\n q.add(k)\n\n\ndef main():\n n, k = list(map(int, input().split()))\n adj_lists = [[] for _ in range(n)]\n for _ in range(k):\n a, b = list(map(int, input().split()))\n a -= 1\n b -= 1\n adj_lists[a].append(b)\n adj_lists[b].append(a)\n colors = [None for _ in range(n)]\n num_colors = 0\n for i in range(n):\n if colors[i] is None:\n flood_fill(adj_lists, colors, i, num_colors)\n num_colors += 1\n print(k - n + num_colors)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import deque\n\n\ndef flood_fill(adj_lists, colors, i, color):\n q = deque()\n q.append(i)\n while len(q) > 0:\n j = q.pop()\n if colors[j] is None:\n colors[j] = color\n q.extend(adj_lists[j])\n\n\ndef main():\n n, k = list(map(int, input().split()))\n adj_lists = [[] for _ in range(n)]\n for _ in range(k):\n a, b = list(map(int, input().split()))\n a -= 1\n b -= 1\n adj_lists[a].append(b)\n adj_lists[b].append(a)\n colors = [None for _ in range(n)]\n num_colors = 0\n for i in range(n):\n if colors[i] is None:\n flood_fill(adj_lists, colors, i, num_colors)\n num_colors += 1\n print(k - n + num_colors)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import sys\n\ndef find(u,a):\n if a[u]!=-1:\n a[u]=find(a[u],a)\n return a[u]\n else:\n return u\ndef union(a,u,v,ct):\n x=find(u,a)\n y=find(v,a)\n #print(x,y)\n if x==y:\n ct+=1\n else:\n a[x]=y\n ct=ct\n return ct \n \nn,k=map(int,input().split())\na=[-1 for i in range(n+1)]\ncount=0\nfor i in range(k):\n u,v=map(int,input().split())\n count=union(a,u,v,count)\n #print(a)\n \nprint(count)", "\"\"\"\nNTC here\n\"\"\"\nfrom sys import stdin, setrecursionlimit\nsetrecursionlimit(10**7)\n\nimport threading\nthreading.stack_size(2 ** 27)\n\ndef iin(): return int(stdin.readline())\n \n \ndef lin(): return list(map(int, stdin.readline().split()))\n\n# range = xrange\n# input = raw_input\n\n\nclass Disjoint_set:\n \n def __init__(sf, n):\n sf.parent = {i:i for i in range(1,n+1)}\n\n def union(sf, x, y):\n sf.link(sf.find_set(x), sf.find_set(y))\n\n def link(sf, val1, val2):\n sf.parent[val1]=val2\n\n def find_set(sf, val):\n if sf.parent[val] != val:\n sf.parent[val] = sf.find_set(sf.parent[val])\n return sf.parent[val]\n else:\n return val\n\nfrom collections import defaultdict\ndef main():\n n,k=lin()\n \n a=[lin() for i in range(k)]\n da=Disjoint_set(n)\n for i,j in a:\n da.union(i,j)\n ch=defaultdict(int)\n for i in range(1,n+1):\n #print(\"CNN\",i,da.find_set(da.data[i]).value)\n ch[da.find_set(i)]+=1\n ans=0\n for i in ch:\n if ch[i]:\n ans+=ch[i]-1 \n print(k-ans)\ntry: \n def __starting_point():\n threading.Thread(target=main).start()\nexcept Exception as e: print(e)\n\n__starting_point()"] | {
"inputs": [
"5 4\n1 2\n4 3\n1 4\n3 4\n",
"6 5\n2 3\n2 1\n3 4\n6 5\n4 5\n",
"2 1\n1 2\n",
"100000 12\n8 7\n1 9\n5 4\n11 12\n7 8\n3 4\n3 5\n12 15\n15 13\n13 14\n7 8\n11 14\n",
"10 15\n1 2\n2 3\n3 4\n4 5\n5 1\n1 6\n2 7\n3 8\n4 9\n5 10\n6 8\n7 9\n8 10\n9 6\n10 7\n",
"4 2\n1 2\n2 3\n",
"4 2\n1 3\n2 4\n"
],
"outputs": [
"1\n",
"0\n",
"0\n",
"4\n",
"6\n",
"0\n",
"0\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 24,711 | |
0335d225fe07561d0749f86bc45b9e26 | UNKNOWN | You are given a sequence a = \{a_1, ..., a_N\} with all zeros, and a sequence b = \{b_1, ..., b_N\} consisting of 0 and 1. The length of both is N.
You can perform Q kinds of operations. The i-th operation is as follows:
- Replace each of a_{l_i}, a_{l_i + 1}, ..., a_{r_i} with 1.
Minimize the hamming distance between a and b, that is, the number of i such that a_i \neq b_i, by performing some of the Q operations.
-----Constraints-----
- 1 \leq N \leq 200,000
- b consists of 0 and 1.
- 1 \leq Q \leq 200,000
- 1 \leq l_i \leq r_i \leq N
- If i \neq j, either l_i \neq l_j or r_i \neq r_j.
-----Input-----
Input is given from Standard Input in the following format:
N
b_1 b_2 ... b_N
Q
l_1 r_1
l_2 r_2
:
l_Q r_Q
-----Output-----
Print the minimum possible hamming distance.
-----Sample Input-----
3
1 0 1
1
1 3
-----Sample Output-----
1
If you choose to perform the operation, a will become \{1, 1, 1\}, for a hamming distance of 1. | ["import sys\n\ninput=sys.stdin.readline\n\nn=int(input())\nb=list(map(int,input().split()))\nope=[[] for i in range(n)]\nQ=int(input())\nfor i in range(Q):\n l,r=list(map(int,input().split()))\n ope[r-1].append(l-1)\n\nres=b.count(0)\n\nData=[(-1)**((b[i]==1)+1) for i in range(n)]\nfor i in range(1,n):\n Data[i]+=Data[i-1]\nData=[0]+Data\n\nfor i in range(n):\n ope[i].sort(reverse=True)\n\n# N: \u51e6\u7406\u3059\u308b\u533a\u9593\u306e\u9577\u3055\nN=n+1\nN0 = 2**(N-1).bit_length()\ndata = [None]*(2*N0)\nINF = (-2**31, -2**31)\n# \u533a\u9593[l, r+1)\u306e\u5024\u3092v\u306b\u66f8\u304d\u63db\u3048\u308b\n# v\u306f(t, value)\u3068\u3044\u3046\u5024\u306b\u3059\u308b (\u65b0\u3057\u3044\u5024\u307b\u3069t\u306f\u5927\u304d\u304f\u306a\u308b)\ndef update(l, r, v):\n L = l + N0; R = r + N0\n while L < R:\n if R & 1:\n R -= 1\n if data[R-1]:\n data[R-1] = max(v,data[R-1])\n else:\n data[R-1]=v\n\n if L & 1:\n if data[L-1]:\n data[L-1] = max(v,data[L-1])\n else:\n data[L-1]=v\n L += 1\n L >>= 1; R >>= 1\n# a_i\u306e\u73fe\u5728\u306e\u5024\u3092\u53d6\u5f97\ndef _query(k):\n k += N0-1\n s = INF\n while k >= 0:\n if data[k]:\n s = max(s, data[k])\n k = (k - 1) // 2\n return s\n# \u3053\u308c\u3092\u547c\u3073\u51fa\u3059\ndef query(k):\n return _query(k)[1]\n\nfor i in range(n+1):\n update(i,i+1,(-Data[i],-Data[i]))\nif ope[0]:\n update(1,2,(0,0))\n\nfor i in range(1,n):\n val=query(i)\n update(i+1,i+2,(val+Data[i]-Data[i+1],val+Data[i]-Data[i+1]))\n for l in ope[i]:\n val=query(l)\n update(l+1,i+2,(val,val))\n\n\n\nprint((n-(res+query(n)+Data[n])))\n", "n=int(input())\nb=list(map(int,input().split()))\nope=[[] for i in range(n)]\nQ=int(input())\nfor i in range(Q):\n l,r=map(int,input().split())\n ope[r-1].append(l-1)\n\nres=b.count(0)\n\nData=[(-1)**((b[i]==1)+1) for i in range(n)]\nfor i in range(1,n):\n Data[i]+=Data[i-1]\nData=[0]+Data\n\nfor i in range(n):\n ope[i].sort(reverse=True)\n\n# N: \u51e6\u7406\u3059\u308b\u533a\u9593\u306e\u9577\u3055\nN=n+1\nN0 = 2**(N-1).bit_length()\ndata = [None]*(2*N0)\nINF = (-2**31, -2**31)\n# \u533a\u9593[l, r+1)\u306e\u5024\u3092v\u306b\u66f8\u304d\u63db\u3048\u308b\n# v\u306f(t, value)\u3068\u3044\u3046\u5024\u306b\u3059\u308b (\u65b0\u3057\u3044\u5024\u307b\u3069t\u306f\u5927\u304d\u304f\u306a\u308b)\ndef update(l, r, v):\n L = l + N0; R = r + N0\n while L < R:\n if R & 1:\n R -= 1\n if data[R-1]:\n data[R-1] = max(v,data[R-1])\n else:\n data[R-1]=v\n\n if L & 1:\n if data[L-1]:\n data[L-1] = max(v,data[L-1])\n else:\n data[L-1]=v\n L += 1\n L >>= 1; R >>= 1\n# a_i\u306e\u73fe\u5728\u306e\u5024\u3092\u53d6\u5f97\ndef _query(k):\n k += N0-1\n s = INF\n while k >= 0:\n if data[k]:\n s = max(s, data[k])\n k = (k - 1) // 2\n return s\n# \u3053\u308c\u3092\u547c\u3073\u51fa\u3059\ndef query(k):\n return _query(k)[1]\n\nfor i in range(n+1):\n update(i,i+1,(-Data[i],-Data[i]))\nif ope[0]:\n update(1,2,(0,0))\n\nfor i in range(1,n):\n val=query(i)\n update(i+1,i+2,(val+Data[i]-Data[i+1],val+Data[i]-Data[i+1]))\n for l in ope[i]:\n val=query(l)\n update(l+1,i+2,(val,val))\n\n\n\nprint(n-(res+query(n)+Data[n]))"] | {"inputs": ["3\n1 0 1\n1\n1 3\n", "3\n1 0 1\n2\n1 1\n3 3\n", "3\n1 0 1\n2\n1 1\n2 3\n", "5\n0 1 0 1 0\n1\n1 5\n", "9\n0 1 0 1 1 1 0 1 0\n3\n1 4\n5 8\n6 7\n", "15\n1 1 0 0 0 0 0 0 1 0 1 1 1 0 0\n9\n4 10\n13 14\n1 7\n4 14\n9 11\n2 6\n7 8\n3 12\n7 13\n", "10\n0 0 0 1 0 0 1 1 1 0\n7\n1 4\n2 5\n1 3\n6 7\n9 9\n1 5\n7 9\n"], "outputs": ["1\n", "0\n", "1\n", "2\n", "3\n", "5\n", "1\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 3,566 | |
c615fc427f1b50b77f3ce4cf3eb052db | UNKNOWN | Bessie has way too many friends because she is everyone's favorite cow! Her new friend Rabbit is trying to hop over so they can play!
More specifically, he wants to get from $(0,0)$ to $(x,0)$ by making multiple hops. He is only willing to hop from one point to another point on the 2D plane if the Euclidean distance between the endpoints of a hop is one of its $n$ favorite numbers: $a_1, a_2, \ldots, a_n$. What is the minimum number of hops Rabbit needs to get from $(0,0)$ to $(x,0)$? Rabbit may land on points with non-integer coordinates. It can be proved that Rabbit can always reach his destination.
Recall that the Euclidean distance between points $(x_i, y_i)$ and $(x_j, y_j)$ is $\sqrt{(x_i-x_j)^2+(y_i-y_j)^2}$.
For example, if Rabbit has favorite numbers $1$ and $3$ he could hop from $(0,0)$ to $(4,0)$ in two hops as shown below. Note that there also exists other valid ways to hop to $(4,0)$ in $2$ hops (e.g. $(0,0)$ $\rightarrow$ $(2,-\sqrt{5})$ $\rightarrow$ $(4,0)$).
$1$ Here is a graphic for the first example. Both hops have distance $3$, one of Rabbit's favorite numbers.
In other words, each time Rabbit chooses some number $a_i$ and hops with distance equal to $a_i$ in any direction he wants. The same number can be used multiple times.
-----Input-----
The input consists of multiple test cases. The first line contains an integer $t$ ($1 \le t \le 1000$) — the number of test cases. Next $2t$ lines contain test cases — two lines per test case.
The first line of each test case contains two integers $n$ and $x$ ($1 \le n \le 10^5$, $1 \le x \le 10^9$) — the number of favorite numbers and the distance Rabbit wants to travel, respectively.
The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 10^9$) — Rabbit's favorite numbers. It is guaranteed that the favorite numbers are distinct.
It is guaranteed that the sum of $n$ over all the test cases will not exceed $10^5$.
-----Output-----
For each test case, print a single integer — the minimum number of hops needed.
-----Example-----
Input
4
2 4
1 3
3 12
3 4 5
1 5
5
2 10
15 4
Output
2
3
1
2
-----Note-----
The first test case of the sample is shown in the picture above. Rabbit can hop to $(2,\sqrt{5})$, then to $(4,0)$ for a total of two hops. Each hop has a distance of $3$, which is one of his favorite numbers.
In the second test case of the sample, one way for Rabbit to hop $3$ times is: $(0,0)$ $\rightarrow$ $(4,0)$ $\rightarrow$ $(8,0)$ $\rightarrow$ $(12,0)$.
In the third test case of the sample, Rabbit can hop from $(0,0)$ to $(5,0)$.
In the fourth test case of the sample, Rabbit can hop: $(0,0)$ $\rightarrow$ $(5,10\sqrt{2})$ $\rightarrow$ $(10,0)$. | ["\nimport sys\n#sys.stdin=open(\"data.txt\")\ninput=sys.stdin.readline\nmii=lambda:list(map(int,input().split()))\n\nfor _ in range(int(input())):\n n,x=mii()\n has=0\n a=0\n for i in mii():\n if x==i: has=1\n a=max(a,i)\n if has:\n print(1)\n else:\n print(max(2,(x-1)//a+1))\n", "nc=int(input())\nfor cas in range(nc):\n n,x=list(map(int,input().split()))\n l=[int(i) for i in input().split()]\n l.sort()\n if l[-1]>x:\n if l.count(x)==0:\n print(2)\n else:\n print(1)\n else:\n if x%l[-1]==0:\n print(x//l[-1])\n else:\n print(x//l[-1]+1)\n", "for _ in range(int(input())):\n n, x = list(map(int, input().split()))\n ar = list(map(int, input().split()))\n num = (x + max(ar) - 1) // max(ar)\n if num == 1 and x not in ar:\n num = 2\n print(num)", "def solve():\n n,d=list(map(int,input().split()))\n a=list(map(int,input().split()))\n a.sort()\n for i in range(n):\n if a[i]==d:\n print(\"1\")\n return\n for i in range(n):\n if a[i]>=d:\n print(\"2\")\n return\n print(int((d-1)/(a[n-1])+1))\nfor _ in range(int(input())):\n solve()\n", "t = int(input())\nfor _t in range(t):\n n,x = map(int, input().split())\n nums = list(map(int, input().split()))\n\n print(min((x + m-1) // m if m <= x else 2 for m in nums))", "def go():\n n,x = list(map(int,input().split()))\n a = set(map(int,input().split()))\n ma = max(a)\n cand = ((x+ma-1)//ma)\n if cand==1 and x not in a:\n cand =2\n print (cand)\n\nt = int(input())\n\nfor _ in range(t):\n go()\n\n", "def main():\n from sys import stdin, stdout\n for _ in range(int(stdin.readline())):\n n, x = list(map(int, stdin.readline().split()))\n a = set(map(int, stdin.readline().split()))\n max_a = max(a)\n ans = (x - 1) // max_a + 1\n if ans == 1 and x not in a:\n ans = 2\n print(ans)\n\n\nmain()\n", "a = int(input())\nfor i in range(a):\n n, d = map(int, input().split())\n m = list(map(int, input().split()))\n ui = 1e10\n for l in m:\n ans = 0\n if d % l != 0:\n ans += 1\n ans += d//l\n if d//l == 0 and d %l != 0:\n ans += 1\n ui = min(ui, ans)\n print(int(ui))"] | {
"inputs": [
"4\n2 4\n1 3\n3 12\n3 4 5\n1 5\n5\n2 10\n15 4\n",
"1\n10 999999733\n25 68 91 55 36 29 96 4 63 3\n",
"1\n19 1000000000\n15 8 22 12 10 16 2 17 14 7 20 23 9 18 3 19 21 11 1\n",
"1\n1 11\n5\n",
"1\n1 5\n2\n",
"1\n2 9\n2 4\n"
],
"outputs": [
"2\n3\n1\n2\n",
"10416664\n",
"43478261\n",
"3\n",
"3\n",
"3\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 2,420 | |
a5f355e04d7c9bc50362f333f993982d | UNKNOWN | Cengiz recently learned Fibonacci numbers and now he is studying different algorithms to find them. After getting bored of reading them, he came with his own new type of numbers that he named XORinacci numbers. He defined them as follows: $f(0) = a$; $f(1) = b$; $f(n) = f(n-1) \oplus f(n-2)$ when $n > 1$, where $\oplus$ denotes the bitwise XOR operation.
You are given three integers $a$, $b$, and $n$, calculate $f(n)$.
You have to answer for $T$ independent test cases.
-----Input-----
The input contains one or more independent test cases.
The first line of input contains a single integer $T$ ($1 \le T \le 10^3$), the number of test cases.
Each of the $T$ following lines contains three space-separated integers $a$, $b$, and $n$ ($0 \le a, b, n \le 10^9$) respectively.
-----Output-----
For each test case, output $f(n)$.
-----Example-----
Input
3
3 4 2
4 5 0
325 265 1231232
Output
7
4
76
-----Note-----
In the first example, $f(2) = f(0) \oplus f(1) = 3 \oplus 4 = 7$. | ["T = int(input())\nfor t in range(T):\n a, b, n = [int(i) for i in input().split()]\n if n%3 == 2:\n print(a^b)\n elif n%3 == 1:\n print(b)\n else:\n print(a)\n", "t = int(input())\nfor i in range(t):\n a, b, n = map(int, input().split())\n if n % 3 == 0:\n print(a)\n elif n % 3 == 1:\n print(b)\n else:\n print(b ^ a)", "def main():\n import sys\n input = sys.stdin.readline\n \n for _ in range(int(input())):\n a, b, n = map(int, input().split())\n n %= 3\n if n == 0:\n print(a)\n elif n == 1:\n print(b)\n else:\n print(a^b)\n \n return 0\n\nmain()", "for _ in range(int(input())):\n a, b, n = map(int, input().split())\n l = [a, b, a ^ b]\n print(l[(n) % 3])", "t = int( input() )\nfor _ in range(t):\n a, b, n = list(map( int, input().split() ))\n l = [ a, b, a ^ b ]\n print( l[ n % 3 ] )\n", "for _ in range(int(input())):\n a,b,n=map(int,input().split())\n if n%3==0:\n print(a)\n elif n%3==1:\n print(b)\n else :\n print(a^b)", "def iA():\n n=[int(x) for x in input().split()]\n return n\ndef iI():\n n=int(input())\n return n\ndef iS():\n n=input()\n return n\ndef iAA(numArrs):\n n=[]\n for i in range(numArrs):\n m=iA()\n n.append(m)\n return n\ndef pA(arr):\n for i in range(len(arr)):\n print(arr[i],end=\" \")\n print()\n\nfor i in range(iI()):\n r=iA()\n t=r[0]^r[1]\n if r[2]%3==0:\n print(r[0])\n elif r[2]%3==1:\n print(r[1])\n else:\n print(r[0]^r[1])", "#\n# Yet I'm feeling like\n# \tThere is no better place than right by your side\n# \t\tI had a little taste\n# \t\t\tAnd I'll only spoil the party anyway\n# \t\t\t\t'Cause all the girls are looking fine\n# \t\t\t\t\tBut you're the only one on my mind\n\n\nimport sys\n# import re\n# inf = float(\"inf\")\n# sys.setrecursionlimit(1000000)\n\n# abc='abcdefghijklmnopqrstuvwxyz'\n# abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}\nmod,MOD=1000000007,998244353\n# vow=['a','e','i','o','u']\n# dx,dy=[-1,1,0,0],[0,0,1,-1]\n\n# from collections import deque, Counter, OrderedDict,defaultdict\n# from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace\n# from math import ceil,floor,log,sqrt,factorial,pow,pi,gcd,log10,atan,tan\n# from bisect import bisect_left,bisect_right\n# import numpy as np\n\n\ndef get_array(): return list(map(int , sys.stdin.readline().strip().split()))\ndef get_ints(): return list(map(int, sys.stdin.readline().strip().split()))\ndef input(): return sys.stdin.readline().strip()\n\nT=int(input())\nwhile T>0:\n a,b,n=get_ints()\n n=n%3\n if n==0:\n print(a)\n elif n==1:\n print(b)\n else:\n print(a^b)\n T-=1\n", "from math import gcd, ceil, log, log2\nfrom collections import deque\nfrom bisect import bisect_right, bisect_left\nfor _ in range(int(input())):\n a, b, n = map(int, input().split())\n if n % 3 == 0:\n print(a)\n elif n % 3 == 1:\n print(b)\n else:\n print(a ^ b)", "for _ in range(int(input())):\n\ta,b,n = [int(i) for i in input().split()]\n\tprint([a,b,a^b][n%3])", "t = int(input())\nfor qury in range(t):\n A = [0] * 3\n A[0], A[1], n = list(map(int, input().split()))\n A[2] = A[0] ^ A[1]\n print(A[n % 3])\n", "for _ in range(int(input())):\n a,b,n =(int(s) for s in input().split())\n l= [a,b,a^b]\n print(l[n%3])", "import sys\ninput = lambda: sys.stdin.readline().strip()\n\nT = int(input())\nfor i in range(T):\n a, b, n = list(map(int, input().split()))\n if n%3==0: print(a)\n elif n%3==1: print(b)\n else: print(a^b)\n", "t=int(input())\nfor _ in range(t):\n a,b,n=map(int,input().split())\n if n%3==0:\n print(a)\n elif n%3==1:\n print(b)\n else:\n print(a^b)", "for _ in range(int(input())):\n a,b,n=[int(i) for i in input().split()]\n n%=3\n arr=[a,b,a^b]\n print(arr[n])", "t=int(input())\nfor nt in range(t):\n\ta,b,n=map(int,input().split())\n\tc=a^b\n\tif n%3==0:\n\t\tprint (a)\n\telif n%3==1:\n\t\tprint (b)\n\telse:\n\t\tprint (c)", "t=int(input())\nfor I in range(t):\n a,b,n=[int(i) for i in input().split()]\n if(n%3==0):\n print(a)\n elif(n%3==1):\n print(b)\n else:\n print(a^b)\n", "for t in range(int(input())):\n a,b,n = list(map(int,input().split()))\n c = a^b\n ans = [a,b,c]\n print(ans[n%3])", "from sys import stdin\nt=int(stdin.readline().strip())\nfor i in range(t):\n a,b,n=list(map(int,stdin.readline().strip().split()))\n x=a^b\n arr=[a,b,x]\n n=n%3\n print(arr[n])\n \n \n", "for T in range(int(input())):\n a, b, n = [int(x) for x in input().split()]\n\n if n % 3 == 0:\n print(a)\n elif n % 3 == 1:\n print(b)\n else:\n print(a ^ b)\n", "# ========= /\\ /| |====/|\n# | / \\ | | / |\n# | /____\\ | | / |\n# | / \\ | | / |\n# ========= / \\ ===== |/====| \n# code\n\ndef main():\n t = int(input())\n for _ in range(t):\n a,b,n= map(int,input().split())\n f = [a , b , a^b]\n print(f[n%3])\n return\n\ndef __starting_point():\n main()\n__starting_point()", "for cas in range(int(input())):\n x, y, z = map(int, input().split())\n print([x, y, x ^ y][z % 3])"] | {
"inputs": [
"3\n3 4 2\n4 5 0\n325 265 1231232\n",
"10\n0 0 1000000000\n1002 2003 36523\n233 5656 898989\n0 2352 0\n21132 23256 2323256\n12313 454878 11000\n1213 0 21\n11 1 1\n1 1 98532\n1000000000 1000000000 1000000000\n",
"1\n25369 85223 58963241\n",
"2\n168342 440469 517112\n841620 806560 140538\n",
"10\n669924290 408119795 804030560\n663737793 250734602 29671646\n431160679 146708815 289491233\n189259304 606497663 379372476\n707829111 49504411 81710658\n54555019 65618101 626948607\n578351356 288589794 974275296\n400531973 205638174 323247740\n219131617 178762989 799964854\n825160173 502080627 608216046\n",
"1\n1 2 3\n"
],
"outputs": [
"7\n4\n76\n",
"0\n2003\n233\n0\n2132\n442567\n1213\n1\n1\n1000000000\n",
"77822\n",
"272643\n841620\n",
"1069371953\n696139211\n286024744\n189259304\n707829111\n54555019\n578351356\n463366171\n178762989\n825160173\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 5,689 | |
e76091954f1b39e0206f5c3eaa3bcd0d | UNKNOWN | The country has n cities and n - 1 bidirectional roads, it is possible to get from every city to any other one if you move only along the roads. The cities are numbered with integers from 1 to n inclusive.
All the roads are initially bad, but the government wants to improve the state of some roads. We will assume that the citizens are happy about road improvement if the path from the capital located in city x to any other city contains at most one bad road.
Your task is — for every possible x determine the number of ways of improving the quality of some roads in order to meet the citizens' condition. As those values can be rather large, you need to print each value modulo 1 000 000 007 (10^9 + 7).
-----Input-----
The first line of the input contains a single integer n (2 ≤ n ≤ 2·10^5) — the number of cities in the country. Next line contains n - 1 positive integers p_2, p_3, p_4, ..., p_{n} (1 ≤ p_{i} ≤ i - 1) — the description of the roads in the country. Number p_{i} means that the country has a road connecting city p_{i} and city i.
-----Output-----
Print n integers a_1, a_2, ..., a_{n}, where a_{i} is the sought number of ways to improve the quality of the roads modulo 1 000 000 007 (10^9 + 7), if the capital of the country is at city number i.
-----Examples-----
Input
3
1 1
Output
4 3 3
Input
5
1 2 3 4
Output
5 8 9 8 5 | ["\n\nclass Graph:\n def __init__(self, n_vertices, edges, directed=True, weighted=False):\n self.n_vertices = n_vertices\n self.edges = edges\n self.directed = directed\n self.weighted = weighted\n\n @property\n def adj(self):\n try:\n return self._adj\n except AttributeError:\n adj = [[] for _ in range(self.n_vertices)]\n def d_w(e):\n adj[e[0]].append((e[1],e[2]))\n def ud_w(e):\n adj[e[0]].append((e[1],e[2]))\n adj[e[1]].append((e[0],e[2]))\n def d_uw(e):\n adj[e[0]].append(e[1])\n def ud_uw(e):\n adj[e[0]].append(e[1])\n adj[e[1]].append(e[0])\n helper = (ud_uw, d_uw, ud_w, d_w)[self.directed+self.weighted*2]\n for e in self.edges:\n helper(e)\n self._adj = adj\n return adj\n\nclass RootedTree(Graph):\n def __init__(self, n_vertices, edges, root_vertex):\n self.root = root_vertex\n super().__init__(n_vertices, edges, False, False)\n\n @property\n def parent(self):\n try:\n return self._parent\n except AttributeError:\n adj = self.adj\n parent = [None]*self.n_vertices\n parent[self.root] = -1\n stack = [self.root]\n for i in range(self.n_vertices):\n v = stack.pop()\n for u in adj[v]:\n if parent[u] is None:\n parent[u] = v\n stack.append(u)\n self._parent = parent\n return parent\n\n @property\n def children(self):\n try:\n return self._children\n except AttributeError:\n children = [None]*self.n_vertices\n for v,(l,p) in enumerate(zip(self.adj,self.parent)):\n children[v] = [u for u in l if u != p]\n self._children = children\n return children\n\n @property\n def dfs_order(self):\n try:\n return self._dfs_order\n except AttributeError:\n order = [None]*self.n_vertices\n children = self.children\n stack = [self.root]\n for i in range(self.n_vertices):\n v = stack.pop()\n order[i] = v\n for u in children[v]:\n stack.append(u)\n self._dfs_order = order\n return order\n\nfrom functools import reduce\nfrom itertools import accumulate,chain\ndef rerooting(rooted_tree, merge, identity, finalize):\n N = rooted_tree.n_vertices\n parent = rooted_tree.parent\n children = rooted_tree.children\n order = rooted_tree.dfs_order\n\n # from leaf to parent\n dp_down = [None]*N\n for v in reversed(order[1:]):\n dp_down[v] = finalize(reduce(merge,\n (dp_down[c] for c in children[v]),\n identity))\n\n # from parent to leaf\n dp_up = [None]*N\n dp_up[0] = identity\n for v in order:\n if len(children[v]) == 0:\n continue\n temp = (dp_up[v],)+tuple(dp_down[u] for u in children[v])+(identity,)\n left = tuple(accumulate(temp,merge))\n right = tuple(accumulate(reversed(temp[2:]),merge))\n for u,l,r in zip(children[v],left,reversed(right)):\n dp_up[u] = finalize(merge(l,r))\n\n res = [None]*N\n for v,l in enumerate(children):\n res[v] = reduce(merge,\n (dp_down[u] for u in children[v]),\n identity)\n res[v] = finalize(merge(res[v], dp_up[v]))\n\n return res\n\ndef solve(T):\n MOD = 10**9 + 7\n def merge(x,y):\n return (x*y)%MOD\n def finalize(x):\n return x+1\n\n return [v-1 for v in rerooting(T,merge,1,finalize)]\n\n\ndef __starting_point():\n N = int(input())\n edges = [(i+1,p-1) for i,p in enumerate(map(int,input().split()))]\n T = RootedTree(N, edges, 0)\n print(*solve(T))\n\n__starting_point()", "\n\nclass Graph:\n def __init__(self, n_vertices, edges, directed=True, weighted=False):\n self.n_vertices = n_vertices\n self.edges = edges\n self.directed = directed\n self.weighted = weighted\n\n @property\n def adj(self):\n try:\n return self._adj\n except AttributeError:\n adj = [[] for _ in range(self.n_vertices)]\n def d_w(e):\n adj[e[0]].append((e[1],e[2]))\n def ud_w(e):\n adj[e[0]].append((e[1],e[2]))\n adj[e[1]].append((e[0],e[2]))\n def d_uw(e):\n adj[e[0]].append(e[1])\n def ud_uw(e):\n adj[e[0]].append(e[1])\n adj[e[1]].append(e[0])\n helper = (ud_uw, d_uw, ud_w, d_w)[self.directed+self.weighted*2]\n for e in self.edges:\n helper(e)\n self._adj = adj\n return adj\n\nclass RootedTree(Graph):\n def __init__(self, n_vertices, edges, root_vertex):\n self.root = root_vertex\n super().__init__(n_vertices, edges, False, False)\n\n @property\n def parent(self):\n try:\n return self._parent\n except AttributeError:\n adj = self.adj\n parent = [None]*self.n_vertices\n parent[self.root] = -1\n stack = [self.root]\n for i in range(self.n_vertices):\n v = stack.pop()\n for u in adj[v]:\n if parent[u] is None:\n parent[u] = v\n stack.append(u)\n self._parent = parent\n return parent\n\n @property\n def children(self):\n try:\n return self._children\n except AttributeError:\n children = [None]*self.n_vertices\n for v,(l,p) in enumerate(zip(self.adj,self.parent)):\n children[v] = [u for u in l if u != p]\n self._children = children\n return children\n\n @property\n def dfs_order(self):\n try:\n return self._dfs_order\n except AttributeError:\n order = [None]*self.n_vertices\n children = self.children\n stack = [self.root]\n for i in range(self.n_vertices):\n v = stack.pop()\n order[i] = v\n for u in children[v]:\n stack.append(u)\n self._dfs_order = order\n return order\n\nfrom functools import reduce\nfrom itertools import accumulate,chain\ndef rerooting(rooted_tree, merge, identity, finalize):\n N = rooted_tree.n_vertices\n parent = rooted_tree.parent\n children = rooted_tree.children\n order = rooted_tree.dfs_order\n\n # from leaf to parent\n dp_down = [None]*N\n for v in reversed(order[1:]):\n dp_down[v] = finalize(reduce(merge,\n (dp_down[c] for c in children[v]),\n identity))\n\n # from parent to leaf\n dp_up = [None]*N\n dp_up[0] = identity\n for v in order:\n if len(children[v]) == 0:\n continue\n temp = (dp_up[v],)+tuple(dp_down[u] for u in children[v])+(identity,)\n left = accumulate(temp[:-2],merge)\n right = tuple(accumulate(reversed(temp[2:]),merge))\n for u,l,r in zip(children[v],left,reversed(right)):\n dp_up[u] = finalize(merge(l,r))\n\n res = [None]*N\n for v,l in enumerate(children):\n res[v] = reduce(merge,\n (dp_down[u] for u in children[v]),\n identity)\n res[v] = finalize(merge(res[v], dp_up[v]))\n\n return res\n\ndef solve(T):\n MOD = 10**9 + 7\n def merge(x,y):\n return (x*y)%MOD\n def finalize(x):\n return x+1\n\n return [v-1 for v in rerooting(T,merge,1,finalize)]\n\n\ndef __starting_point():\n N = int(input())\n edges = [(i+1,p-1) for i,p in enumerate(map(int,input().split()))]\n T = RootedTree(N, edges, 0)\n print(*solve(T))\n\n__starting_point()"] | {"inputs": ["3\n1 1\n", "5\n1 2 3 4\n", "31\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", "29\n1 2 2 4 4 6 6 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28\n", "2\n1\n", "3\n1 2\n"], "outputs": ["4 3 3", "5 8 9 8 5", "73741817 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913 536870913", "191 380 191 470 236 506 254 506 504 500 494 486 476 464 450 434 416 396 374 350 324 296 266 234 200 164 126 86 44", "2 2", "3 4 3"]} | COMPETITION | PYTHON3 | CODEFORCES | 8,176 | |
1999441568b6e2f2e3142077418e8a9e | UNKNOWN | Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city u_{i} to v_{i} (and vise versa) using the i-th road, the length of this road is x_{i}. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city s_{i} (and vise versa), the length of this route is y_{i}.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
-----Input-----
The first line contains three integers n, m, k (2 ≤ n ≤ 10^5; 1 ≤ m ≤ 3·10^5; 1 ≤ k ≤ 10^5).
Each of the next m lines contains three integers u_{i}, v_{i}, x_{i} (1 ≤ u_{i}, v_{i} ≤ n; u_{i} ≠ v_{i}; 1 ≤ x_{i} ≤ 10^9).
Each of the next k lines contains two integers s_{i} and y_{i} (2 ≤ s_{i} ≤ n; 1 ≤ y_{i} ≤ 10^9).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
-----Output-----
Output a single integer representing the maximum number of the train routes which can be closed.
-----Examples-----
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2 | ["\n\n#===============================================================================================\n#importing some useful libraries.\n\n\n\nfrom fractions import Fraction\nimport sys\nimport os\nfrom io import BytesIO, IOBase\nfrom functools import cmp_to_key\n\n# from itertools import *\nfrom heapq import *\nfrom math import gcd, factorial,floor,ceil,sqrt\n\nfrom copy import deepcopy\nfrom collections import deque\n\n\nfrom bisect import bisect_left as bl\nfrom bisect import bisect_right as br\nfrom bisect import bisect\n\n#==============================================================================================\n#fast I/O region\nBUFSIZE = 8192\n\n\nclass FastIO(IOBase):\n newlines = 0\n\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n\n\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n\n\ndef print(*args, **kwargs):\n \"\"\"Prints the values to a stream, or to sys.stdout by default.\"\"\"\n sep, file = kwargs.pop(\"sep\", \" \"), kwargs.pop(\"file\", sys.stdout)\n at_start = True\n for x in args:\n if not at_start:\n file.write(sep)\n file.write(str(x))\n at_start = False\n file.write(kwargs.pop(\"end\", \"\\n\"))\n if kwargs.pop(\"flush\", False):\n file.flush()\n\n\nif sys.version_info[0] < 3:\n sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)\nelse:\n sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\n\n# inp = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\n#===============================================================================================\n### START ITERATE RECURSION ###\nfrom types import GeneratorType\ndef iterative(f, stack=[]):\n def wrapped_func(*args, **kwargs):\n if stack: return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n continue\n stack.pop()\n if not stack: break\n to = stack[-1].send(to)\n return to\n return wrapped_func\n#### END ITERATE RECURSION ####\n\n#===============================================================================================\n#some shortcuts\n\ndef inp(): return sys.stdin.readline().rstrip(\"\\r\\n\") #for fast input\ndef out(var): sys.stdout.write(str(var)) #for fast output, always take string\ndef lis(): return list(map(int, inp().split()))\ndef stringlis(): return list(map(str, inp().split()))\ndef sep(): return list(map(int, inp().split()))\ndef strsep(): return list(map(str, inp().split()))\n# def graph(vertex): return [[] for i in range(0,vertex+1)]\ndef zerolist(n): return [0]*n\ndef nextline(): out(\"\\n\") #as stdout.write always print sring.\ndef testcase(t):\n for pp in range(t):\n solve(pp)\ndef printlist(a) :\n for p in range(0,len(a)):\n out(str(a[p]) + ' ')\ndef google(p):\n print('Case #'+str(p)+': ',end='')\ndef lcm(a,b): return (a*b)//gcd(a,b)\ndef power(x, y, p) :\n y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.\n res = 1 # Initialize result\n x = x % p # Update x if it is more , than or equal to p\n if (x == 0) :\n return 0\n while (y > 0) :\n if ((y & 1) == 1) : # If y is odd, multiply, x with result\n res = (res * x) % p\n\n y = y >> 1 # y = y/2\n x = (x * x) % p\n return res\ndef ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))\ndef isPrime(n) :\n if (n <= 1) : return False\n if (n <= 3) : return True\n if (n % 2 == 0 or n % 3 == 0) : return False\n i = 5\n while(i * i <= n) :\n if (n % i == 0 or n % (i + 2) == 0) :\n return False\n i = i + 6\n return True\ninf = pow(10,20)\nmod = 10**9+7\n#===============================================================================================\n# code here ;))\ndef djkistra(g,st,dist,lol,vis): #g contains b,dist(a to b) and dist is initiaalised by 10**9 initiallly\n pq = []\n dist[st] = 0\n heappush(pq,(0,st))\n while(len(pq) != 0):\n curr = heappop(pq)[1]\n for i in range(0,len(g[curr])):\n b = g[curr][i][0]\n w = g[curr][i][1]\n if(dist[b] > dist[curr] + w):\n dist[b] = dist[curr]+w\n heappush(pq,(dist[b],b))\n\n\ndef modif_djkistra(g,dist,usedtrains):\n h = []\n for i in range(len(g)):\n if(dist[i] != inf):\n heappush(h,(dist[i],i))\n while(len(h) != 0):\n d,curr = heappop(h)\n if(d != dist[curr]): #dublicate train with larger length\n continue\n for to,newd in g[curr]:\n if(newd+d<=dist[to]):\n usedtrains[to] = False\n if(dist[to] > newd+d):\n heappush(h,(newd+d,to))\n dist[to] = newd+d\n\ndef solve(case):\n n,m,k = sep()\n dist = [inf]*n;dist[0] = 0\n g = [[] for i in range(n)]\n for i in range(m):\n a,b,c = sep()\n a-=1\n b-=1\n g[a].append((b,c))\n g[b].append((a,c))\n have = []\n usedtrain = [False]*n\n for i in range(k):\n a,b = sep()\n a-=1\n dist[a] = min(dist[a],b)\n # g[0].append((a,b))\n # g[a].append((0,b))\n have.append(a)\n usedtrain[a] = True\n modif_djkistra(g,dist,usedtrain)\n cnt = 0\n have = list(set(have))\n for i in range(n):\n if(usedtrain[i]):\n cnt+=1\n # print(cnt)\n print(k - cnt)\n\n\n\n\n\n\ntestcase(1)\n# testcase(int(inp()))\n\n\n\n\n\n\n\n\n\n"] | {
"inputs": [
"5 5 3\n1 2 1\n2 3 2\n1 3 3\n3 4 4\n1 5 5\n3 5\n4 5\n5 5\n",
"2 2 3\n1 2 2\n2 1 3\n2 1\n2 2\n2 3\n",
"5 4 3\n1 2 999999999\n2 3 1000000000\n3 4 529529529\n5 1 524524524\n5 524444444\n5 529999999\n2 1000000000\n",
"3 2 5\n1 2 2\n2 3 4\n3 5\n3 5\n3 5\n3 6\n3 7\n",
"5 5 3\n1 2 999999999\n2 3 1000000000\n3 4 529529529\n5 1 524524524\n5 3 1000000000\n5 524444444\n5 529999999\n2 1000000000\n",
"2 1 5\n1 2 4\n2 3\n2 5\n2 4\n2 4\n2 5\n",
"3 3 6\n1 2 499999999\n2 3 500000000\n1 3 999999999\n2 499999999\n2 500000000\n2 499999999\n3 999999999\n3 1000000000\n3 1000000000\n",
"2 1 1\n1 2 1\n2 1000000000\n",
"3 2 2\n1 2 4\n2 3 4\n2 2\n3 6\n",
"5 5 2\n1 2 100\n2 3 100\n3 4 100\n4 5 20\n2 5 5\n5 50\n4 1\n",
"3 2 2\n1 2 100\n2 3 1\n2 1\n3 3\n"
],
"outputs": [
"2\n",
"2\n",
"2\n",
"4\n",
"2\n",
"4\n",
"6\n",
"1\n",
"1\n",
"1\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 7,009 | |
e551cebd8e2b2ac96fa1f7998fc7a109 | UNKNOWN | Sereja loves all sorts of algorithms. He has recently come up with a new algorithm, which receives a string as an input. Let's represent the input string of the algorithm as q = q_1q_2... q_{k}. The algorithm consists of two steps:
Find any continuous subsequence (substring) of three characters of string q, which doesn't equal to either string "zyx", "xzy", "yxz". If q doesn't contain any such subsequence, terminate the algorithm, otherwise go to step 2. Rearrange the letters of the found subsequence randomly and go to step 1.
Sereja thinks that the algorithm works correctly on string q if there is a non-zero probability that the algorithm will be terminated. But if the algorithm anyway will work for infinitely long on a string, then we consider the algorithm to work incorrectly on this string.
Sereja wants to test his algorithm. For that, he has string s = s_1s_2... s_{n}, consisting of n characters. The boy conducts a series of m tests. As the i-th test, he sends substring s_{l}_{i}s_{l}_{i} + 1... s_{r}_{i} (1 ≤ l_{i} ≤ r_{i} ≤ n) to the algorithm input. Unfortunately, the implementation of his algorithm works too long, so Sereja asked you to help. For each test (l_{i}, r_{i}) determine if the algorithm works correctly on this test or not.
-----Input-----
The first line contains non-empty string s, its length (n) doesn't exceed 10^5. It is guaranteed that string s only contains characters: 'x', 'y', 'z'.
The second line contains integer m (1 ≤ m ≤ 10^5) — the number of tests. Next m lines contain the tests. The i-th line contains a pair of integers l_{i}, r_{i} (1 ≤ l_{i} ≤ r_{i} ≤ n).
-----Output-----
For each test, print "YES" (without the quotes) if the algorithm works correctly on the corresponding test and "NO" (without the quotes) otherwise.
-----Examples-----
Input
zyxxxxxxyyz
5
5 5
1 3
1 11
1 4
3 6
Output
YES
YES
NO
YES
NO
-----Note-----
In the first example, in test one and two the algorithm will always be terminated in one step. In the fourth test you can get string "xzyx" on which the algorithm will terminate. In all other tests the algorithm doesn't work correctly. | ["import sys\ns=sys.stdin.readline().split()[0]\n\nm=int(sys.stdin.readline())\n\nNumx=[]\nNumy=[]\nNumz=[]\nx=0\ny=0\nz=0\nfor i in range(len(s)):\n if(s[i]=='x'):\n x+=1\n if(s[i]=='y'):\n y+=1\n if(s[i]=='z'):\n z+=1\n Numx.append(x)\n Numy.append(y)\n Numz.append(z)\n \n\nAns=\"\"\nfor M in range(m):\n s,e=list(map(int,sys.stdin.readline().split()))\n if(e-s+1<=2):\n Ans+=\"YES\\n\"\n continue\n s-=1\n e-=1\n x=Numx[e]\n y=Numy[e]\n z=Numz[e]\n if(s!=0):\n x-=Numx[s-1]\n y-=Numy[s-1]\n z-=Numz[s-1]\n if(x==y==z):\n Ans+=\"YES\\n\"\n continue\n L=[x,y,z]\n L.sort()\n if(L[0]==L[1] and L[2]==L[1]+1):\n Ans+=\"YES\\n\"\n continue\n if(L[1]==L[2] and L[0]==L[1]-1):\n Ans+=\"YES\\n\"\n else:\n Ans+=\"NO\\n\"\nsys.stdout.write(Ans)\n \n \n\n \n", "def f(x, y, z): return abs(y - x) > 1 or abs(z - x) > 1 or abs(y - z) > 1\nt = input()\nn, p = len(t), {'x': 0, 'y': 1, 'z': 2}\ns = [[0] * (n + 1) for i in range(3)]\nfor i, c in enumerate(t, 1): s[p[c]][i] = 1\nfor i in range(3):\n for j in range(1, n): s[i][j + 1] += s[i][j]\na, b, c = s\nq = [map(int, input().split()) for i in range(int(input()))]\nd = ['YES'] * len(q)\nfor i, (l, r) in enumerate(q):\n if r - l > 1 and f(a[r] - a[l - 1], b[r] - b[l - 1], c[r] - c[l - 1]): d[i] = 'NO'\nprint('\\n'.join(d))", "def f(x, y, z): return max(x, y, z) - min(x, y, z) > 1\nt = input()\nn, m, p = len(t), int(input()), {'x': 0, 'y': 1, 'z': 2}\ns = [[0] * (n + 1) for i in range(3)]\nfor i, c in enumerate(t, 1): s[p[c]][i] = 1\nfor i in range(3):\n r = s[i]\n for j in range(1, n): r[j + 1] += r[j]\na, b, c = s\nq, d = [map(int, input().split()) for i in range(m)], ['YES'] * m\nfor i, (l, r) in enumerate(q):\n if r - l > 1 and f(a[r] - a[l - 1], b[r] - b[l - 1], c[r] - c[l - 1]): d[i] = 'NO'\nprint('\\n'.join(d))", "def f(t): return t[2] - t[0] > 1\nt = input()\nn, m, p = len(t), int(input()), {'x': 0, 'y': 1, 'z': 2}\ns = [[0] * (n + 1) for i in range(3)]\nfor i, c in enumerate(t, 1): s[p[c]][i] = 1\nfor i in range(3):\n for j in range(1, n): s[i][j + 1] += s[i][j]\na, b, c = s\nq, d = [map(int, input().split()) for i in range(m)], ['YES'] * m\nfor i, (l, r) in enumerate(q):\n if r - l > 1 and f(sorted([a[r] - a[l - 1], b[r] - b[l - 1], c[r] - c[l - 1]])): d[i] = 'NO'\nprint('\\n'.join(d))", "import sys\nimport math\n \ns = input()\n\nk = [[0, 0, 0]]\nv = [0] * 3\n\nfor i in range(len(s)): \n v[ord(s[i]) - ord('x')] += 1\n k.append(list(v))\n\nm = int(input())\nfor i in range(m):\n l, r = [int(x) for x in (sys.stdin.readline()).split()]\n vmin = min([k[r][0] - k[l - 1][0], k[r][1] - k[l - 1][1], k[r][2] - k[l - 1][2]])\n vmax = max([k[r][0] - k[l - 1][0], k[r][1] - k[l - 1][1], k[r][2] - k[l - 1][2]])\n if(r - l + 1 <= 2 or vmax - vmin < 2):\n print(\"YES\")\n else:\n print(\"NO\")", "import sys\nimport math\n \ns = input()\n\nk = [[0, 0, 0]]\nv = [0] * 3\n\nfor i in range(len(s)): \n v[ord(s[i]) - ord('x')] += 1\n k.append(list(v))\n\nm = int(input())\nfor i in range(m):\n l, r = map(int, (sys.stdin.readline()).split())\n vmin = min([k[r][0] - k[l - 1][0], k[r][1] - k[l - 1][1], k[r][2] - k[l - 1][2]])\n vmax = max([k[r][0] - k[l - 1][0], k[r][1] - k[l - 1][1], k[r][2] - k[l - 1][2]])\n if(r - l + 1 <= 2 or vmax - vmin < 2):\n print(\"YES\")\n else:\n print(\"NO\")", "def main():\n l, xyz, res = [(0, 0, 0)], [0, 0, 0], []\n for c in input():\n xyz[ord(c) - 120] += 1\n l.append(tuple(xyz))\n for _ in range(int(input())):\n a, b = list(map(int, input().split()))\n if b - a > 1:\n xyz = [i - j for i, j in zip(l[b], l[a - 1])]\n res.append((\"NO\", \"YES\")[max(xyz) - min(xyz) < 2])\n else:\n res.append(\"YES\")\n print('\\n'.join(res))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from sys import stdin, stdout\n\ndef readIn():\n return tuple( map(int,input().split()) )\n\ns = input()\nsz = len(s)+1\ncnt = [ [0]*3 for _ in range(sz) ]\nfor i in range(sz-1):\n for j in range(3):\n cnt[i+1][j] = cnt[i][j]\n if s[i] == 'x':\n cnt[i+1][0] += 1\n elif s[i] == 'y':\n cnt[i+1][1] += 1\n else :\n cnt[i+1][2] += 1\n\nn = int(input())\nres = []\nfor _ in range(n):\n l,r = readIn()\n tmp = [ cnt[r][i]-cnt[l-1][i] for i in range(3) ]\n res.append( 'YES' if r-l<2 or max(tmp)-min(tmp)<2 else 'NO' )\nprint('\\n'.join(res))", "from sys import stdin, stdout\n\ndef readIn():\n return ( map(int,input().split()) )\n\ns = input()\nsz = len(s)+1\ncnt = [ [0]*3 for _ in range(sz) ]\nfor i in range(sz-1):\n for j in range(3):\n cnt[i+1][j] = cnt[i][j]\n if s[i] == 'x':\n cnt[i+1][0] += 1\n elif s[i] == 'y':\n cnt[i+1][1] += 1\n else :\n cnt[i+1][2] += 1\n\nn = int(input())\nres = []\nfor _ in range(n):\n l,r = readIn()\n tmp = [ cnt[r][i]-cnt[l-1][i] for i in range(3) ]\n res.append( 'YES' if r-l<2 or max(tmp)-min(tmp)<2 else 'NO' )\nprint('\\n'.join(res))", "def f(t): return t[2] - t[0] > 1\n\nt = input()\n\nn, m, p = len(t), int(input()), {'x': 0, 'y': 1, 'z': 2}\n\ns = [[0] * (n + 1) for i in range(3)]\n\nfor i, c in enumerate(t, 1): s[p[c]][i] = 1\n\nfor i in range(3):\n\n for j in range(1, n): s[i][j + 1] += s[i][j]\n\na, b, c = s\n\nq, d = [list(map(int, input().split())) for i in range(m)], ['YES'] * m\n\nfor i, (l, r) in enumerate(q):\n\n if r - l > 1 and f(sorted([a[r] - a[l - 1], b[r] - b[l - 1], c[r] - c[l - 1]])): d[i] = 'NO'\n\nprint('\\n'.join(d))\n\n# Made By Mostafa_Khaled\n", "s = input()\ncnt = list([0] * 3 for _ in range(len(s) + 1))\nfor i in range(len(s)):\n for j in range(3):\n cnt[i+1][j] = cnt[i][j]\n if s[i] == 'x': cnt[i+1][0] += 1\n elif s[i] == 'y': cnt[i+1][1] += 1\n else: cnt[i+1][2] += 1\nn = int(input())\nres = []\nfor _ in range(n):\n l, r = list(map(int, input().split()))\n t = [cnt[r][i] - cnt[l-1][i] for i in range(3)]\n res.append('YES' if r - l < 2 or max(t) - min(t) < 2 else 'NO')\nprint('\\n'.join(res))\n", "s=input()\nhs=[[0]*3 for i in range(len(s)+1)]\nfor i in range(len(s)):\n for j in range(3):\n hs[i+1][j]=hs[i][j]\n if s[i]=='x':\n hs[i+1][0]+=1\n if s[i]=='y':\n hs[i+1][1]+=1\n if s[i]=='z':\n hs[i+1][2]+=1\nn=int(input())\nres=[]\nfor i in range(n):\n l,r=list(map(int,input().split(\" \")))\n t = [hs[r][i] - hs[l-1][i] for i in range(3)]\n res.append('YES' if r - l < 2 or max(t) - min(t) < 2 else 'NO')\nprint('\\n'.join(res))\n"] | {
"inputs": [
"zyxxxxxxyyz\n5\n5 5\n1 3\n1 11\n1 4\n3 6\n",
"yxzyzxzzxyyzzxxxzyyzzyzxxzxyzyyzxyzxyxxyzxyxzyzxyzxyyxzzzyzxyyxyzxxy\n10\n17 67\n6 35\n12 45\n56 56\n14 30\n25 54\n1 1\n46 54\n3 33\n19 40\n",
"xxxxyyxyyzzyxyxzxyzyxzyyyzyzzxxxxzyyzzzzyxxxxzzyzzyzx\n5\n4 4\n3 3\n1 24\n3 28\n18 39\n",
"yzxyzxyzxzxzyzxyzyzzzyxzyz\n9\n4 6\n2 7\n3 5\n14 24\n3 13\n2 24\n2 5\n2 14\n3 15\n",
"zxyzxyzyyzxzzxyzxyzx\n15\n7 10\n17 17\n6 7\n8 14\n4 7\n11 18\n12 13\n1 1\n3 8\n1 1\n9 17\n4 4\n5 11\n3 15\n1 1\n",
"x\n1\n1 1\n"
],
"outputs": [
"YES\nYES\nNO\nYES\nNO\n",
"NO\nNO\nNO\nYES\nYES\nNO\nYES\nNO\nNO\nYES\n",
"YES\nYES\nNO\nNO\nNO\n",
"YES\nYES\nYES\nNO\nYES\nNO\nYES\nNO\nNO\n",
"NO\nYES\nYES\nYES\nYES\nYES\nYES\nYES\nNO\nYES\nNO\nYES\nYES\nNO\nYES\n",
"YES\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 6,756 | |
7f05d1feeb814b976c406058b6cbe03a | UNKNOWN | Leha plays a computer game, where is on each level is given a connected graph with n vertices and m edges. Graph can contain multiple edges, but can not contain self loops. Each vertex has an integer d_{i}, which can be equal to 0, 1 or - 1. To pass the level, he needs to find a «good» subset of edges of the graph or say, that it doesn't exist. Subset is called «good», if by by leaving only edges from this subset in the original graph, we obtain the following: for every vertex i, d_{i} = - 1 or it's degree modulo 2 is equal to d_{i}. Leha wants to pass the game as soon as possible and ask you to help him. In case of multiple correct answers, print any of them.
-----Input-----
The first line contains two integers n, m (1 ≤ n ≤ 3·10^5, n - 1 ≤ m ≤ 3·10^5) — number of vertices and edges.
The second line contains n integers d_1, d_2, ..., d_{n} ( - 1 ≤ d_{i} ≤ 1) — numbers on the vertices.
Each of the next m lines contains two integers u and v (1 ≤ u, v ≤ n) — edges. It's guaranteed, that graph in the input is connected.
-----Output-----
Print - 1 in a single line, if solution doesn't exist. Otherwise in the first line k — number of edges in a subset. In the next k lines indexes of edges. Edges are numerated in order as they are given in the input, starting from 1.
-----Examples-----
Input
1 0
1
Output
-1
Input
4 5
0 0 0 -1
1 2
2 3
3 4
1 4
2 4
Output
0
Input
2 1
1 1
1 2
Output
1
1
Input
3 3
0 -1 1
1 2
2 3
1 3
Output
1
2
-----Note-----
In the first sample we have single vertex without edges. It's degree is 0 and we can not get 1. | ["import sys\n\nn, m = list(map(int, sys.stdin.readline().split()))\nd = list(map(int, sys.stdin.readline().split()))\ngph = [[] for _ in range(n)]\n\nfor _ in range(m):\n u, v = list(map(int, sys.stdin.readline().split()))\n u -= 1\n v -= 1\n gph[u].append((v, _))\n gph[v].append((u, _))\n \nt = -1\nif d.count(1) % 2 == 1:\n if -1 not in d:\n print(-1)\n return\n t = d.index(-1)\n\nans = [False] * m\nvis = [False] * n\ned = [(-1, -1)] * n\nrets = [(d[u] == 1) or (u == t) for u in range(n)]\n\nstk = [[0, iter(gph[0])]]\nwhile len(stk) > 0:\n u = stk[-1][0]\n vis[u] = True\n try:\n while True:\n v, i = next(stk[-1][1])\n if not vis[v]:\n ed[v] = (u, i)\n stk.append([v, iter(gph[v])])\n break\n except StopIteration:\n p, e = ed[u]\n if p >= 0 and rets[u]:\n rets[p] = not rets[p]\n ans[e] = True\n stk.pop()\n pass\n \nprint(ans.count(True))\nprint(\"\\n\".join([str(i+1) for i in range(m) if ans[i]]))\n#1231\n"] | {
"inputs": [
"1 0\n1\n",
"4 5\n0 0 0 -1\n1 2\n2 3\n3 4\n1 4\n2 4\n",
"2 1\n1 1\n1 2\n",
"3 3\n0 -1 1\n1 2\n2 3\n1 3\n",
"10 10\n-1 -1 -1 -1 -1 -1 -1 -1 -1 -1\n6 7\n8 3\n6 4\n4 2\n9 2\n5 10\n9 8\n10 7\n5 1\n6 2\n",
"3 2\n1 0 1\n1 2\n2 3\n"
],
"outputs": [
"-1\n",
"0\n",
"1\n1\n",
"1\n2\n",
"0\n",
"2\n2\n1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,098 | |
c6f6ff2385d2bf28106147fa6e1ce3ca | UNKNOWN | There is a country with $n$ citizens. The $i$-th of them initially has $a_{i}$ money. The government strictly controls the wealth of its citizens. Whenever a citizen makes a purchase or earns some money, they must send a receipt to the social services mentioning the amount of money they currently have.
Sometimes the government makes payouts to the poor: all citizens who have strictly less money than $x$ are paid accordingly so that after the payout they have exactly $x$ money. In this case the citizens don't send a receipt.
You know the initial wealth of every citizen and the log of all events: receipts and payouts. Restore the amount of money each citizen has after all events.
-----Input-----
The first line contains a single integer $n$ ($1 \le n \le 2 \cdot 10^{5}$) — the numer of citizens.
The next line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($0 \le a_{i} \le 10^{9}$) — the initial balances of citizens.
The next line contains a single integer $q$ ($1 \le q \le 2 \cdot 10^{5}$) — the number of events.
Each of the next $q$ lines contains a single event. The events are given in chronological order.
Each event is described as either 1 p x ($1 \le p \le n$, $0 \le x \le 10^{9}$), or 2 x ($0 \le x \le 10^{9}$). In the first case we have a receipt that the balance of the $p$-th person becomes equal to $x$. In the second case we have a payoff with parameter $x$.
-----Output-----
Print $n$ integers — the balances of all citizens after all events.
-----Examples-----
Input
4
1 2 3 4
3
2 3
1 2 2
2 1
Output
3 2 3 4
Input
5
3 50 2 1 10
3
1 2 0
2 8
1 3 20
Output
8 8 20 8 10
-----Note-----
In the first example the balances change as follows: 1 2 3 4 $\rightarrow$ 3 3 3 4 $\rightarrow$ 3 2 3 4 $\rightarrow$ 3 2 3 4
In the second example the balances change as follows: 3 50 2 1 10 $\rightarrow$ 3 0 2 1 10 $\rightarrow$ 8 8 8 8 10 $\rightarrow$ 8 8 20 8 10 | ["n=int(input())\na=list(map(int,input().split()))\nq=int(input())\nchanges=[0]*q\nfor i in range(q):\n changes[-i-1]=tuple(map(int,input().split()))\nfinal=[-1]*n\ncurr=0\nfor guy in changes:\n if guy[0]==1:\n if final[guy[1]-1]==-1:\n final[guy[1]-1]=max(guy[2],curr)\n else:\n curr=max(curr,guy[1])\nfor i in range(n):\n if final[i]==-1:\n final[i]=max(curr,a[i])\nfinal=[str(guy) for guy in final]\nprint(\" \".join(final))", "import sys\ninput = sys.stdin.readline\n\nfrom bisect import bisect_left as bl\n\nN = int(input())\nA = [int(a) for a in input().split()]\nQ = int(input())\nL = [-1] * N\n\nX = []\nY = []\n\nfor i in range(Q):\n t = [int(a) for a in input().split()]\n if t[0] == 1:\n p, x = t[1]-1, t[2]\n A[p] = x\n L[p] = i\n else:\n x = t[1]\n while len(Y) and Y[-1] <= x:\n X.pop()\n Y.pop()\n X.append(i)\n Y.append(x)\n \nfor i in range(N):\n j = bl(X, L[i])\n if j < len(X):\n A[i] = max(A[i], Y[j])\n\nprint(*A)\n\n", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\nl = list(map(int,input().split()))\nlUpd = [0]*n\nq = int(input())\n\npayoff = [-1]*q\nfor query in range(q):\n qnext = list(map(int,input().split()))\n if qnext[0] == 1:\n p = qnext[1] - 1\n x = qnext[2]\n l[p] = x\n lUpd[p] = query\n else:\n x = qnext[1]\n payoff[query] = x\n\nmaxPayoff = [-1]*q\nbest = -1\nfor i in range(q-1,-1,-1):\n best = max(best,payoff[i])\n maxPayoff[i] = best\n\nout = [max(l[p], maxPayoff[lUpd[p]]) for p in range(n)]\nprint(' '.join(map(str,out)))\n \n", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\nl = list(map(int,input().split()))\nlUpd = [0]*n\nq = int(input())\n\npayoff = [-1]*q\nfor query in range(q):\n qnext = list(map(int,input().split()))\n if qnext[0] == 1:\n p = qnext[1] - 1\n x = qnext[2]\n l[p] = x\n lUpd[p] = query\n else:\n x = qnext[1]\n payoff[query] = x\n\nmaxPayoff = [-1]*q\nbest = -1\nfor i in range(q-1,-1,-1):\n best = max(best,payoff[i])\n maxPayoff[i] = best\n\nout = [max(l[p], maxPayoff[lUpd[p]]) for p in range(n)]\nprint(' '.join(map(str,out)))\n \n", "n = int(input())\na = list(map(int, input().split()))\nq = int(input())\n\nlast_set = [0] * n\nalles = [0]\n\nfor i in range(q):\n r = list(map(int, input().split()))\n if len(r) == 2:\n alles.append(r[1])\n else:\n last_set[r[1]-1] = len(alles)\n a[r[1]-1] = r[2]\n \nmaxis = alles\ni = len(maxis) -1 \nprev_max = 0\nwhile i >= 0:\n prev_max = max(prev_max, alles[i])\n maxis[i] = prev_max\n i -= 1\n \nfor i in range(n):\n if last_set[i] < len(maxis):\n a[i] = max(a[i], maxis[last_set[i]])\n \nprint(\" \".join(map(str, a)))\n", "n=int(input())\na=list(map(int,input().split()))\nq=int(input())\nr1=[-1]*q\nr2=[-1]*q\nfor i in range(q):\n ne=list(map(int,input().split()))\n if ne[0]==1:\n p=ne[1]-1\n t=ne[2]\n r1[i]=[p,t]\n else:\n r2[i]=ne[1]\n\nb=-1\nfor i in range(q-1,-1,-1):\n b=max(b,r2[i])\n r2[i]=b\n\nm=r2[0]\nfor i in range(n):\n a[i]=max(a[i],m)\n \nfor i in range(q):\n if r1[i]==-1:\n pass\n else:\n a[r1[i][0]]=max(r1[i][1],r2[i])\n \nprint(*a)", "n = int(input())\narray = list(map(int, input().split()))\nq = int(input())\nd = {i:0 for i in range(n)}\nstack = []\nfor i in range(q):\n req = list(map(int, input().split()))\n if req[0] == 2:\n stack.append((req[1], i))\n else:\n p = req[1]-1\n d[p] = i\n array[p] = req[2]\nans_i = [-1]*q\nj = len(stack)-1\nmax_of_stack = -1\nfor i in range(q-1, -1, -1):\n if j > -1 and stack[j][1] >= i:\n max_of_stack = max(max_of_stack, stack[j][0])\n j -= 1\n ans_i[i] = max_of_stack\nfor p in range(n):\n if array[p] < ans_i[d[p]]:\n array[p] = ans_i[d[p]]\nprint(*array)", "\n# -*- coding: utf-8 -*-\n# @Date : 2019-08-01 06:48:30\n# @Author : raj lath ([email protected])\n# @Link : link\n# @Version : 1.0.0\n\nimport sys\nsys.setrecursionlimit(10**5+1)\n\ninf = int(10 ** 20)\nmax_val = inf\nmin_val = -inf\n\nRW = lambda : sys.stdin.readline().strip()\nRI = lambda : int(RW())\nRMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]\nRWI = lambda : [x for x in sys.stdin.readline().strip().split()]\n\n\nnb = RI()\nhave = RMI()\nnb_ops = RI()\n\ncurr = [-1] * nb\nmaxs = 0\n\nops = [RMI() for _ in range(nb_ops)][::-1]\nfor i in ops:\n if i[0] == 2:\n maxs = max(maxs, i[1])\n else: \n if curr[i[1] - 1] == -1:\n curr[i[1] - 1] = max(maxs, i[2])\nfor i in range(nb) :\n if curr[i] == -1:\n curr[i] = max(maxs, have[i])\n\n\nprint(*curr)", "n=int(input())\na=[int(x) for x in input().split()]\nt=q=int(input())\nmaxarr=[-1]*n\nmaxGlob=-1\nquer=[]\nwhile t>0:\n quer.append(tuple(map(int, input().split())))\n t-=1\nfor i in range(q-1,-1,-1):\n k=quer[i]\n if k[0]==2:\n maxGlob=max(maxGlob,k[1])\n else:\n if maxarr[k[1]-1]==-1:\n maxarr[k[1]-1]=max(k[2],maxGlob)\n\nfor i in range(n):\n if maxarr[i]==-1:\n maxarr[i]=(max(maxGlob,a[i]))\n \nprint(*maxarr)\n \n\n", "n=int(input())\na=[int(x) for x in input().split()]\nt=q=int(input())\nmaxarr=[-1]*n\nmaxGlob=-1\nquer=[]\nwhile t>0:\n quer.append([int(x) for x in input().split()])\n t-=1\nfor i in range(q-1,-1,-1):\n k=quer[i]\n if k[0]==2:\n maxGlob=max(maxGlob,k[1])\n else:\n if maxarr[k[1]-1]==-1:\n maxarr[k[1]-1]=max(k[2],maxGlob)\n \nfor i in range(n):\n if maxarr[i]==-1:\n maxarr[i]=(max(maxGlob,a[i]))\n \nprint(*maxarr)", "n=int(input())\na=list(map(int,input().split()))\nq=int(input())\narr=[]\nfor _ in range(q):\n arr.append(list(map(int, input().split())))\narr.reverse()\nans=[-1]*n\ncur=0\nfor i in arr:\n if i[0]==2:\n cur=max(cur,i[1])\n else:\n if ans[i[1]-1]==-1:\n ans[i[1]-1]=max(cur,i[2])\nfor i in range(n):\n if ans[i]==-1:\n ans[i]=max(a[i],cur)\nprint(*ans)\n", "R=lambda:map(int,input().split())\nn = int(input ())\na=list(R())\nq =int(input())\np=[]\nax= [-1]*n\nfor _ in range (q):p.append(list (R()))\ntemp=0\nfor i in range(q-1,-1,-1):\n if p[i][0]==2:temp = max(temp,p[i][1])\n elif ax[p[i][1]-1]==-1:ax[p[i][1]-1] = max(temp,p[i][2])\nfor i in range (0,n):\n if ax[i]==-1:print(max(temp,a[i]),end=\" \")\n else:print(ax[i],end=\" \")\n", "import sys\n\ninput = sys.stdin.readline\nn = int(input())\nli = list(map(int, input().split()))\ncheck = [-1] * n\nmaxx = 0\nfor i in [input().split() for i in range(int(input()))][::-1]:\n if i[0] == '2':\n maxx = max(maxx, int(i[1]))\n else:\n if check[int(i[1]) - 1] == -1:\n check[int(i[1]) - 1] = max(int(i[2]), maxx)\nfor i in range(n):\n if check[i] == -1:\n check[i] = max(maxx, li[i])\nprint(*check)\n", "import sys\nread = sys.stdin.readline\n\n\nn = int(read())\nbalance = list(map(int, read().split(\" \")))\nn_operations = int(read())\n\nminis = []\nnext_mini = 0\nchanged_before = [0] * (len(balance)+1)\n\nfor n_op in range(n_operations):\n operation = list(map(int, read().split(\" \")))\n if operation[0] == 1:\n x = operation[1] - 1\n balance[x] = operation[2]\n changed_before[x] = next_mini\n elif operation[0] == 2:\n minis.append(operation[1])\n next_mini += 1\n\nif len(minis) > 0:\n max_mini = minis[-1]\n for m in range(1, len(minis) + 1):\n max_mini = max(max_mini, minis[m * -1])\n minis[m * -1] = max_mini\n\n for x in range(len(balance)):\n cb = changed_before[x]\n if cb < next_mini:\n balance[x] = max(minis[cb], balance[x])\n balance[x] = str(balance[x])\nelse:\n for x in range(len(balance)):\n balance[x] = str(balance[x])\n\nprint(\" \".join(balance))", "import sys\ninput = sys.stdin.readline\nn = int(input())\na = list(map(int,input().split()))\nq = int(input())\na2 = [-1]*len(a)\narr = [None]*q\npay = [-1]*q\nfor i in range(q):\n b = input().split()\n if len(b) == 2:\n pay[i] = int(b[1])\n else:\n arr[i] = int(b[1])\n a2[arr[i]-1] = int(b[2])\n \npay_max = max(pay)\npay_maxi = q - pay[::-1].index(pay_max) - 1\na = [pay_max if x<pay_max else x for x in a]\nm = [0]*q\nma = -1\nfor i in range(q-1,-1,-1):\n if pay[i] != -1:\n ma = max(ma,pay[i])\n m[i] = ma\nfor i in range(q):\n if arr[i]:\n if i > pay_maxi:\n a[arr[i]-1] = max(a2[arr[i]-1], m[i])\n else:\n a[arr[i]-1] = max(a2[arr[i]-1], pay_max)\nprint(*a) \n#print(' '.join([str(x) for x in a]))\n", "R=lambda:map(int,input().split())\nn=int(input())\nr=[-1]*n\na=*zip(r,range(1,n+1),R()),*([*R()]for _ in[0]*int(input()))\nm=0\nfor t,p,*x in a[::-1]:\n if t>1:m=max(m,p)\n elif r[p-1]<0:r[p-1]=max(x[0],m)\nprint(*r)", "R=lambda:map(int,input().split())\nn=int(input())\na=*zip([1]*n,range(1,n+1),R()),*([*R()]for _ in[0]*int(input()))\nr=[-1]*n\nm=0\nfor t,p,*x in a[::-1]:\n if t>1:m=max(m,p)\n elif r[p-1]<0:r[p-1]=max(x[0],m)\nprint(*r)", "n = int(input())\nbalance = list(map(int, input().split()))\nq = int(input())\nlog = [list(map(int, input().split())) for i in range(q)]\n\nind_of_last_operation = [None] * n\nmax_pay = 0\nind_of_max_payment = None\npayments = []\npayments_id = []\n\nfor i in range(q):\n if log[i][0] == 1:\n ind_of_last_operation[log[i][1] - 1] = i\n\nfor i in range(q):\n if log[i][0] == 2:\n ind_of_last_payment = i\n last_payment = log[i][1]\n if log[i][1] > max_pay:\n max_pay = log[i][1]\n\nmax_pay_for_moment = [0] * (q + 1)\nfor j in range(q - 1, -1, -1):\n if log[j][0] == 2:\n max_pay_for_moment[j] = max(log[j][1], max_pay_for_moment[j + 1])\n else:\n max_pay_for_moment[j] = max_pay_for_moment[j + 1]\n\nfor i in range(n):\n if ind_of_last_operation[i] == None:\n if balance[i] < max_pay:\n balance[i] = max_pay\n else:\n if max_pay_for_moment[ind_of_last_operation[i] + 1] > log[ind_of_last_operation[i]][2]:\n balance[i] = max_pay_for_moment[ind_of_last_operation[i] + 1]\n else:\n balance[i] = log[ind_of_last_operation[i]][2]\n\nprint(*balance)", "n, a, q = int(input()), [*list(map(int, input().split()))], int(input())\nops = []\n\nfor i in range(q):\n t, *b = list(map(int, input().split()))\n ops.append((t, b))\n\nb = [-1] * n\nm = -1\nfor op, ar in reversed(ops):\n if op == 2:\n m = max(m, ar[0])\n else:\n p, x = ar\n p -= 1\n if b[p] == -1:\n b[p] = max(x, m)\n\nprint(' '.join(str(bi if bi != -1 else max(m, ai))for ai,bi in zip(a,b)))\n", "from bisect import bisect_right\nn = int(input())\nA = list(map(int, input().split()))\nB = [0] * n\nC = []\nfor i in range(int(input())):\n w = list(map(int, input().split()))\n if w[0] == 1:\n A[w[1] - 1] = w[2]\n B[w[1] - 1] = i\n else:\n C.append((i, w[1]))\nsC = [0]\nfor i in range(len(C) - 1, -1, -1):\n sC.append(max(sC[-1], C[i][1]))\nsC = sC[::-1]\nfor i in range(n):\n A[i] = max(A[i], sC[bisect_right(C, (B[i], 0))])\nprint(*A)", "n = int(input().strip())\na = list(map(int, input().split()))\nq = int(input().strip())\nqueries = []\nlast_balance = [-1]*n\nlast_balance_id = [-1]*n\n\nfor i in range(q):\n query = list(map(int, input().split()))\n queries.append(query)\n if query[0]==1:\n p = query[1]-1\n last_balance[p] = query[2]\n last_balance_id[p] = i\n\n\n#print(last_balance)\n#print(last_balance_id)\n\nmax_pay = [0]*(q+1)\nfor i in range(q-1,-1,-1):\n query = queries[i]\n if query[0]==2:\n max_pay[i]=max(query[1], max_pay[i+1])\n else:\n max_pay[i]=max_pay[i+1]\n\n#print(max_pay)\n\nfor p in range(n):\n #print(\"person: \",p)\n if last_balance_id[p]>=0:\n id = last_balance_id[p]\n pay = max_pay[id]\n #print(id, pay)\n a[p] = max(pay, last_balance[p])\n else:\n a[p] = max(a[p], max_pay[0])\n\nprint(\" \".join([str(x) for x in a]))", "n = int(input())\na = list(map(int, input().split()))\nq = int(input())\ns = [0 for i in range(len(a))]\nf = [0 for i in range(q)]\n\nfor i in range(q):\n r = list(map(int, input().split()))\n if(r[0] == 1):\n s[r[1]-1] = i\n a[r[1]-1] = r[2]\n else:\n f[i] = r[1]\n\nfor i in reversed(range(0,q-1)):\n f[i] = max(f[i], f[i+1])\n\nfor i in range(n):\n a[i] = max(a[i], f[s[i]])\n\nprint(*a)", "n = int(input())\nsp = list(map(int, input().split()))\n\nm = int(input())\npos = [-1] * (n + 1)\nm1 = 0\nmem = []\nfor i in range(m):\n sp1 = list(map(int, input().split()))\n mem.append(sp1)\n if sp1[0] == 1:\n sp[sp1[1] - 1] = sp1[2]\n pos[sp1[1] - 1] = i\n else:\n m1 = max(m1, sp1[1])\n \nmaxs = [-1] * (m + 1)\n\nfor i in range(m - 1, -1, -1):\n sp1 = mem[i]\n \n if (sp1[0] == 2):\n if (i == m - 1 or sp1[1] > maxs[i + 1]):\n maxs[i] = sp1[1]\n else:\n maxs[i] = maxs[i + 1]\n else:\n maxs[i] = maxs[i + 1]\nfor i in range(n):\n if pos[i] != -1 and sp[i] < maxs[pos[i]]:\n sp[i] = maxs[pos[i]]\n elif pos[i] == -1:\n sp[i] = max(sp[i], maxs[0])\nprint(*sp)\n", "n=int(input())\na=list(map(int,input().split()))\nq=int(input())\narr=[]\nfor _ in range(q):\n arr.append(list(map(int, input().split())))\narr.reverse()\nans=[-1]*n\ncur=0\nfor i in arr:\n if i[0]==2:\n cur=max(cur,i[1])\n else:\n if ans[i[1]-1]==-1:\n ans[i[1]-1]=max(cur,i[2])\nfor i in range(n):\n if ans[i]==-1:\n ans[i]=max(a[i],cur)\nprint(*ans)\n", "from sys import stdin\ninput = stdin.readline\n\nn = int(input())\narr = list(map(int, input().split()))\nq = int(input())\nqueries = [tuple(map(int, input().split())) for _ in range(q)][::-1]\nres, curr = [-1] * n, 0\nfor q in queries:\n if q[0] == 1:\n if res[q[1]-1] == -1:\n res[q[1]-1] = max(q[2], curr)\n else:\n curr = max(curr, q[1])\nfor i in range(n):\n if res[i] == -1:\n res[i] = max(curr, arr[i])\nres = [str(q) for q in res]\nprint(' '.join(res))\n\n"] | {
"inputs": [
"4\n1 2 3 4\n3\n2 3\n1 2 2\n2 1\n",
"5\n3 50 2 1 10\n3\n1 2 0\n2 8\n1 3 20\n",
"10\n1 2 3 4 5 6 7 8 9 10\n10\n2 1\n2 2\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n2 10\n",
"5\n1 2 3 4 5\n10\n1 1 0\n2 1\n1 2 0\n2 2\n1 3 0\n2 3\n1 4 0\n2 4\n1 5 0\n2 5\n",
"10\n7 9 4 4 7 6 3 7 9 8\n10\n1 3 2\n1 10 5\n1 5 3\n1 5 2\n1 2 9\n1 2 9\n1 2 10\n1 5 7\n1 6 10\n1 10 9\n",
"1\n1\n3\n2 4\n1 1 2\n2 10\n"
],
"outputs": [
"3 2 3 4 \n",
"8 8 20 8 10 \n",
"10 10 10 10 10 10 10 10 10 10 \n",
"5 5 5 5 5 \n",
"7 10 2 4 7 10 3 7 9 9 \n",
"10 \n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 14,468 | |
f07f6b925bf0b51cb2fd1a427e700716 | UNKNOWN | During the archaeological research in the Middle East you found the traces of three ancient religions: First religion, Second religion and Third religion. You compiled the information on the evolution of each of these beliefs, and you now wonder if the followers of each religion could coexist in peace.
The Word of Universe is a long word containing the lowercase English characters only. At each moment of time, each of the religion beliefs could be described by a word consisting of lowercase English characters.
The three religions can coexist in peace if their descriptions form disjoint subsequences of the Word of Universe. More formally, one can paint some of the characters of the Word of Universe in three colors: $1$, $2$, $3$, so that each character is painted in at most one color, and the description of the $i$-th religion can be constructed from the Word of Universe by removing all characters that aren't painted in color $i$.
The religions however evolve. In the beginning, each religion description is empty. Every once in a while, either a character is appended to the end of the description of a single religion, or the last character is dropped from the description. After each change, determine if the religions could coexist in peace.
-----Input-----
The first line of the input contains two integers $n, q$ ($1 \leq n \leq 100\,000$, $1 \leq q \leq 1000$) — the length of the Word of Universe and the number of religion evolutions, respectively. The following line contains the Word of Universe — a string of length $n$ consisting of lowercase English characters.
Each of the following line describes a single evolution and is in one of the following formats: + $i$ $c$ ($i \in \{1, 2, 3\}$, $c \in \{\mathtt{a}, \mathtt{b}, \dots, \mathtt{z}\}$: append the character $c$ to the end of $i$-th religion description. - $i$ ($i \in \{1, 2, 3\}$) – remove the last character from the $i$-th religion description. You can assume that the pattern is non-empty.
You can assume that no religion will have description longer than $250$ characters.
-----Output-----
Write $q$ lines. The $i$-th of them should be YES if the religions could coexist in peace after the $i$-th evolution, or NO otherwise.
You can print each character in any case (either upper or lower).
-----Examples-----
Input
6 8
abdabc
+ 1 a
+ 1 d
+ 2 b
+ 2 c
+ 3 a
+ 3 b
+ 1 c
- 2
Output
YES
YES
YES
YES
YES
YES
NO
YES
Input
6 8
abbaab
+ 1 a
+ 2 a
+ 3 a
+ 1 b
+ 2 b
+ 3 b
- 1
+ 2 z
Output
YES
YES
YES
YES
YES
NO
YES
NO
-----Note-----
In the first example, after the 6th evolution the religion descriptions are: ad, bc, and ab. The following figure shows how these descriptions form three disjoint subsequences of the Word of Universe: $\left. \begin{array}{|c|c|c|c|c|c|c|} \hline \text{Word} & {a} & {b} & {d} & {a} & {b} & {c} \\ \hline ad & {a} & {} & {d} & {} & {} & {} \\ \hline bc & {} & {b} & {} & {} & {} & {c} \\ \hline ab & {} & {} & {} & {a} & {b} & {} \\ \hline \end{array} \right.$ | ["n, q = map(int, input().split())\ns = '!' + input()\n\nnxt = [[n + 1] * (n + 2) for _ in range(26)]\nfor i in range(n - 1, -1, -1):\n c = ord(s[i + 1]) - 97\n for j in range(26):\n nxt[j][i] = nxt[j][i + 1]\n nxt[c][i] = i + 1\n\nw = [[-1], [-1], [-1]]\nidx = lambda i, j, k: i * 65536 + j * 256 + k\ndp = [0] * (256 * 256 * 256)\ndef calc(fix=None):\n r = list(map(range, (len(w[0]), len(w[1]), len(w[2]))))\n if fix is not None: r[fix] = range(len(w[fix]) - 1, len(w[fix]))\n for i in r[0]:\n for j in r[1]:\n for k in r[2]:\n dp[idx(i, j, k)] = min(nxt[w[0][i]][dp[idx(i - 1, j, k)]] if i else n + 1,\n nxt[w[1][j]][dp[idx(i, j - 1, k)]] if j else n + 1,\n nxt[w[2][k]][dp[idx(i, j, k - 1)]] if k else n + 1)\n if i == j == k == 0: dp[idx(i, j, k)] = 0\n\nout = []\nfor _ in range(q):\n t, *r = input().split()\n if t == '+':\n i, c = int(r[0]) - 1, ord(r[1]) - 97\n w[i].append(c)\n calc(i)\n else:\n i = int(r[0]) - 1\n w[i].pop()\n req = dp[idx(len(w[0]) - 1, len(w[1]) - 1, len(w[2]) - 1)]\n out.append('YES' if req <= n else 'NO')\n\nprint(*out, sep='\\n')"] | {
"inputs": [
"6 8\nabdabc\n+ 1 a\n+ 1 d\n+ 2 b\n+ 2 c\n+ 3 a\n+ 3 b\n+ 1 c\n- 2\n",
"6 8\nabbaab\n+ 1 a\n+ 2 a\n+ 3 a\n+ 1 b\n+ 2 b\n+ 3 b\n- 1\n+ 2 z\n",
"1 1\nz\n+ 3 z\n",
"1 1\nt\n+ 2 p\n",
"2 12\naa\n+ 1 a\n+ 2 a\n+ 3 a\n- 1\n+ 1 a\n- 2\n+ 2 a\n- 3\n+ 3 a\n+ 2 a\n- 1\n- 3\n",
"2 10\nuh\n+ 1 h\n+ 2 u\n+ 3 h\n- 1\n- 2\n+ 2 h\n+ 3 u\n- 2\n+ 1 u\n- 3\n"
],
"outputs": [
"YES\nYES\nYES\nYES\nYES\nYES\nNO\nYES\n",
"YES\nYES\nYES\nYES\nYES\nNO\nYES\nNO\n",
"YES\n",
"NO\n",
"YES\nYES\nNO\nYES\nNO\nYES\nNO\nYES\nNO\nNO\nNO\nYES\n",
"YES\nYES\nNO\nYES\nYES\nNO\nNO\nNO\nNO\nYES\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,267 | |
d82c011675f796272fa6441489febecc | UNKNOWN | Serge came to the school dining room and discovered that there is a big queue here. There are $m$ pupils in the queue. He's not sure now if he wants to wait until the queue will clear, so he wants to know which dish he will receive if he does. As Serge is very tired, he asks you to compute it instead of him.
Initially there are $n$ dishes with costs $a_1, a_2, \ldots, a_n$. As you already know, there are the queue of $m$ pupils who have $b_1, \ldots, b_m$ togrogs respectively (pupils are enumerated by queue order, i.e the first pupil in the queue has $b_1$ togrogs and the last one has $b_m$ togrogs)
Pupils think that the most expensive dish is the most delicious one, so every pupil just buys the most expensive dish for which he has money (every dish has a single copy, so when a pupil has bought it nobody can buy it later), and if a pupil doesn't have money for any dish, he just leaves the queue (so brutal capitalism...)
But money isn't a problem at all for Serge, so Serge is buying the most expensive dish if there is at least one remaining.
Moreover, Serge's school has a very unstable economic situation and the costs of some dishes or number of togrogs of some pupils can change. More formally, you must process $q$ queries:
change $a_i$ to $x$. It means that the price of the $i$-th dish becomes $x$ togrogs. change $b_i$ to $x$. It means that the $i$-th pupil in the queue has $x$ togrogs now.
Nobody leaves the queue during those queries because a saleswoman is late.
After every query, you must tell Serge price of the dish which he will buy if he has waited until the queue is clear, or $-1$ if there are no dishes at this point, according to rules described above.
-----Input-----
The first line contains integers $n$ and $m$ ($1 \leq n, m \leq 300\ 000$) — number of dishes and pupils respectively. The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^{6}$) — elements of array $a$. The third line contains $m$ integers $b_1, b_2, \ldots, b_{m}$ ($1 \leq b_i \leq 10^{6}$) — elements of array $b$. The fourth line conatins integer $q$ ($1 \leq q \leq 300\ 000$) — number of queries.
Each of the following $q$ lines contains as follows: if a query changes price of some dish, it contains $1$, and two integers $i$ and $x$ ($1 \leq i \leq n$, $1 \leq x \leq 10^{6}$), what means $a_i$ becomes $x$. if a query changes number of togrogs of some pupil, it contains $2$, and two integers $i$ and $x$ ($1 \leq i \leq m$, $1 \leq x \leq 10^{6}$), what means $b_i$ becomes $x$.
-----Output-----
For each of $q$ queries prints the answer as the statement describes, the answer of the $i$-th query in the $i$-th line (the price of the dish which Serge will buy or $-1$ if nothing remains)
-----Examples-----
Input
1 1
1
1
1
1 1 100
Output
100
Input
1 1
1
1
1
2 1 100
Output
-1
Input
4 6
1 8 2 4
3 3 6 1 5 2
3
1 1 1
2 5 10
1 1 6
Output
8
-1
4
-----Note-----
In the first sample after the first query, there is one dish with price $100$ togrogs and one pupil with one togrog, so Serge will buy the dish with price $100$ togrogs.
In the second sample after the first query, there is one dish with price one togrog and one pupil with $100$ togrogs, so Serge will get nothing.
In the third sample after the first query, nobody can buy the dish with price $8$, so Serge will take it. After the second query, all dishes will be bought, after the third one the third and fifth pupils will by the first and the second dishes respectively and nobody will by the fourth one. | ["import sys\nfrom itertools import accumulate \nclass Lazysegtree:\n #RAQ\n def __init__(self, A, intv, initialize = True, segf = min):\n #\u533a\u9593\u306f 1-indexed \u3067\u7ba1\u7406\n self.N = len(A)\n self.N0 = 2**(self.N-1).bit_length()\n self.intv = intv\n self.segf = segf\n self.lazy = [0]*(2*self.N0)\n if initialize:\n self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)\n for i in range(self.N0-1, 0, -1):\n self.data[i] = self.segf(self.data[2*i], self.data[2*i+1]) \n else:\n self.data = [intv]*(2*self.N0)\n\n def _ascend(self, k):\n k = k >> 1\n c = k.bit_length()\n for j in range(c):\n idx = k >> j\n self.data[idx] = self.segf(self.data[2*idx], self.data[2*idx+1]) \\\n + self.lazy[idx]\n \n def _descend(self, k):\n k = k >> 1\n idx = 1\n c = k.bit_length()\n for j in range(1, c+1):\n idx = k >> (c - j)\n ax = self.lazy[idx]\n if not ax:\n continue\n self.lazy[idx] = 0\n self.data[2*idx] += ax\n self.data[2*idx+1] += ax\n self.lazy[2*idx] += ax\n self.lazy[2*idx+1] += ax\n \n def query(self, l, r):\n L = l+self.N0\n R = r+self.N0\n Li = L//(L & -L)\n Ri = R//(R & -R)\n self._descend(Li)\n self._descend(Ri - 1)\n \n s = self.intv \n while L < R:\n if R & 1:\n R -= 1\n s = self.segf(s, self.data[R])\n if L & 1:\n s = self.segf(s, self.data[L])\n L += 1\n L >>= 1\n R >>= 1\n return s\n \n def add(self, l, r, x):\n L = l+self.N0\n R = r+self.N0\n\n Li = L//(L & -L)\n Ri = R//(R & -R)\n \n while L < R :\n if R & 1:\n R -= 1\n self.data[R] += x\n self.lazy[R] += x\n if L & 1:\n self.data[L] += x\n self.lazy[L] += x\n L += 1\n L >>= 1\n R >>= 1\n \n self._ascend(Li)\n self._ascend(Ri-1)\n \n def binsearch(self, l, r, check, reverse = False):\n L = l+self.N0\n R = r+self.N0\n Li = L//(L & -L)\n Ri = R//(R & -R)\n self._descend(Li)\n self._descend(Ri-1)\n SL, SR = [], []\n while L < R:\n if R & 1:\n R -= 1\n SR.append(R)\n if L & 1:\n SL.append(L)\n L += 1\n L >>= 1\n R >>= 1\n \n if reverse:\n for idx in (SR + SL[::-1]):\n if check(self.data[idx]):\n break\n else:\n return -1\n while idx < self.N0:\n ax = self.lazy[idx]\n self.lazy[idx] = 0\n self.data[2*idx] += ax\n self.data[2*idx+1] += ax\n self.lazy[2*idx] += ax\n self.lazy[2*idx+1] += ax\n idx = idx << 1\n if check(self.data[idx+1]):\n idx += 1\n return idx - self.N0\n else:\n for idx in (SL + SR[::-1]):\n if check(self.data[idx]):\n break\n else:\n return -1\n while idx < self.N0:\n ax = self.lazy[idx]\n self.lazy[idx] = 0\n self.data[2*idx] += ax\n self.data[2*idx+1] += ax\n self.lazy[2*idx] += ax\n self.lazy[2*idx+1] += ax\n idx = idx << 1\n if not check(self.data[idx]):\n idx += 1\n return idx - self.N0\n def provfunc(self):\n idx = 1\n if self.data[1] >= 0:\n return -1\n while idx < self.N0:\n ax = self.lazy[idx]\n self.lazy[idx] = 0\n self.data[2*idx] += ax\n self.data[2*idx+1] += ax\n self.lazy[2*idx] += ax\n self.lazy[2*idx+1] += ax\n idx = idx << 1\n if self.data[idx+1] < 0:\n idx += 1\n return idx - self.N0\n\nN, M = list(map(int, input().split()))\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\ntable = [0]*(10**6+1)\nfor a in A:\n table[a] -= 1\nfor b in B:\n table[b] += 1\ntable = list(accumulate(table[::-1]))[::-1]\nT = Lazysegtree(table, 0, True, min)\nQ = int(input())\nAns = [None]*Q\nfor q in range(Q):\n t, i, x = list(map(int, sys.stdin.readline().split()))\n i -= 1\n if t == 1:\n T.add(0, x+1, -1)\n T.add(0, A[i]+1, 1)\n A[i] = x\n else:\n T.add(0, x+1, 1)\n T.add(0, B[i]+1, -1)\n B[i] = x\n Ans[q] = T.provfunc()\n\nprint('\\n'.join(map(str, Ans))) \n"] | {
"inputs": [
"1 1\n1\n1\n1\n1 1 100\n",
"1 1\n1\n1\n1\n2 1 100\n",
"4 6\n1 8 2 4\n3 3 6 1 5 2\n3\n1 1 1\n2 5 10\n1 1 6\n",
"3 5\n3 2 8\n1 2 8 1 1\n4\n1 3 3\n1 2 2\n2 2 10\n1 1 5\n",
"4 1\n7 6 1 1\n3\n3\n2 1 9\n2 1 10\n2 1 6\n",
"5 1\n8 4 8 7 3\n9\n5\n2 1 3\n1 5 1\n2 1 8\n2 1 7\n2 1 3\n"
],
"outputs": [
"100\n",
"-1\n",
"8\n-1\n4\n",
"3\n3\n2\n2\n",
"6\n6\n7\n",
"8\n8\n8\n8\n8\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 5,150 | |
b066b7f9cd4ecc50e490c40f37a15bf0 | UNKNOWN | Sereja loves number sequences very much. That's why he decided to make himself a new one following a certain algorithm.
Sereja takes a blank piece of paper. Then he starts writing out the sequence in m stages. Each time he either adds a new number to the end of the sequence or takes l first elements of the current sequence and adds them c times to the end. More formally, if we represent the current sequence as a_1, a_2, ..., a_{n}, then after we apply the described operation, the sequence transforms into a_1, a_2, ..., a_{n}[, a_1, a_2, ..., a_{l}] (the block in the square brackets must be repeated c times).
A day has passed and Sereja has completed the sequence. He wonders what are the values of some of its elements. Help Sereja.
-----Input-----
The first line contains integer m (1 ≤ m ≤ 10^5) — the number of stages to build a sequence.
Next m lines contain the description of the stages in the order they follow. The first number in the line is a type of stage (1 or 2). Type 1 means adding one number to the end of the sequence, in this case the line contains integer x_{i} (1 ≤ x_{i} ≤ 10^5) — the number to add. Type 2 means copying a prefix of length l_{i} to the end c_{i} times, in this case the line further contains two integers l_{i}, c_{i} (1 ≤ l_{i} ≤ 10^5, 1 ≤ c_{i} ≤ 10^4), l_{i} is the length of the prefix, c_{i} is the number of copyings. It is guaranteed that the length of prefix l_{i} is never larger than the current length of the sequence.
The next line contains integer n (1 ≤ n ≤ 10^5) — the number of elements Sereja is interested in. The next line contains the numbers of elements of the final sequence Sereja is interested in. The numbers are given in the strictly increasing order. It is guaranteed that all numbers are strictly larger than zero and do not exceed the length of the resulting sequence. Consider the elements of the final sequence numbered starting from 1 from the beginning to the end of the sequence.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
-----Output-----
Print the elements that Sereja is interested in, in the order in which their numbers occur in the input.
-----Examples-----
Input
6
1 1
1 2
2 2 1
1 3
2 5 2
1 4
16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Output
1 2 1 2 3 1 2 1 2 3 1 2 1 2 3 4 | ["n=int(input())\na=[]\nfor i in range(n):\n a.append(list(map(int,input().split())))\nm=int(input())\nb=list(map(lambda x:int(x)-1,input().split()))\nc=[]\nnow=0\nk=0\nans=[]\nfor i in range(n):\n t=a[i]\n last=now\n if t[0]==1:\n now+=1\n if len(c)<100000: c.append(t[1])\n if k<m and b[k]==now-1: \n ans.append(t[1])\n k+=1\n else:\n now+=t[1]*t[2]\n while t[2]:\n if len(c)<100000: c.extend(c[:t[1]])\n else: break\n t[2]-=1\n while k<m and last<=b[k]<now:\n ans.append(c[(b[k]-last)%t[1]])\n k+=1 \nfor i in range(m):\n print(ans[i],end=' ')\n", "n=int(input())\na=[]\nfor i in range(n):\n\ta.append(list(map(int,input().split())))\nm=int(input())\nb=list([int(x)-1 for x in input().split()])\nc=[]\nnow=0\nk=0\nans=[]\nfor i in range(n):\n\tt=a[i]\n\tif t[0]==1:\n\t\tnow+=1\n\t\tif len(c)<100000: c.append(t[1])\n\t\tif k<m and b[k]==now-1: \n\t\t\tans.append(t[1])\n\t\t\tk+=1\n\telse:\n\t\tlast=now\n\t\tnow+=t[1]*t[2]\n\t\twhile t[2]:\n\t\t\tif len(c)<100000: c.extend(c[:t[1]])\n\t\t\telse: break\n\t\t\tt[2]-=1\n\t\twhile k<m and last<=b[k]<now:\n\t\t\tans.append(c[(b[k]-last)%t[1]])\n\t\t\tk+=1\t\nprint(' '.join(map(str,ans)))\n", "n=int(input())\na=[list(map(int,input().split())) for i in range(n)]\nm=int(input())\nb=list([int(x)-1 for x in input().split()])\nc=[]\nnow=0\nk=0\nans=[]\nfor i in range(n):\n\tt=a[i]\n\tif t[0]==1:\n\t\tnow+=1\n\t\tif len(c)<100000: c.append(t[1])\n\t\tif k<m and b[k]==now-1: \n\t\t\tans.append(t[1])\n\t\t\tk+=1\n\telse:\n\t\tlast=now\n\t\tnow+=t[1]*t[2]\n\t\twhile t[2]:\n\t\t\tif len(c)<100000: c.extend(c[:t[1]])\n\t\t\telse: break\n\t\t\tt[2]-=1\n\t\twhile k<m and last<=b[k]<now:\n\t\t\tans.append(c[(b[k]-last)%t[1]])\n\t\t\tk+=1\t\nprint(' '.join(map(str,ans)))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))", "# -*- coding: utf-8 -*-\nfrom bisect import bisect_left\n\nm = int(input())\nlines = []\nfor i in range(m):\n lines.append(list(map(int, input().split())))\nn = int(input())\nlengths = list(map(int, input().split()))\n\n#size[i]\u8868\u793ai\u6307\u4ee4\u6267\u884c\u524d\u5df2\u7ecf\u79ef\u7d2f\u4e86\u591a\u957f\u7684\u4e32\nsizes = [0]\nfor l in lines:\n sizes.append(sizes[-1] + (1 if l[0] == 1 else l[1]*l[2]))\n\nresult = {}\ndef find_number(l):\n if l in result:\n return result[l]\n i = bisect_left(sizes, l) - 1\n if lines[i][0] == 1:\n #\u6b64\u65f6\u5fc5\u6709sizes[i+1] == l\n result[l] = lines[i][1]\n return result[l]\n new_l = (l - sizes[i] - 1) % lines[i][1] + 1\n result[new_l] = find_number(new_l)\n return result[new_l]\n\nprint(' '.join([str(find_number(l)) for l in lengths]))\n", "# -*- coding: utf-8 -*-\nfrom bisect import bisect_left\n\nm = int(input())\nlines = []\nfor i in range(m):\n lines.append(list(map(int, input().split())))\nn = int(input())\nlengths = list(map(int, input().split()))\n\n#size[i]\u8868\u793ai\u6307\u4ee4\u6267\u884c\u524d\u5df2\u7ecf\u79ef\u7d2f\u4e86\u591a\u957f\u7684\u4e32\nsizes = [0]\nfor l in lines:\n sizes.append(sizes[-1] + (1 if l[0] == 1 else l[1]*l[2]))\n\nresult = {}\ndef find_number(l):\n if l not in result:\n i = bisect_left(sizes, l) - 1\n result[l] = lines[i][1] if lines[i][0] == 1 else find_number((l - sizes[i] - 1) % lines[i][1] + 1)\n return result[l]\n\nprint(' '.join([str(find_number(l)) for l in lengths]))\n", "# -*- coding: utf-8 -*-\nfrom bisect import bisect_left\n\nm = int(input())\nlines = []\nfor i in range(m):\n lines.append(list(map(int, input().split())))\nn = int(input())\nlengths = list(map(int, input().split()))\n\n#acc_lengths[i]\u8868\u793ai\u6307\u4ee4\u6267\u884c\u4e4b\u524d\u5df2\u7ecf\u79ef\u7d2f\u4e86\u591a\u957f\u7684\u4e32\nacc_lengths = [0]\nfor l in lines:\n acc_lengths.append(acc_lengths[-1] + (1 if l[0] == 1 else l[1]*l[2]))\n\nseq = []\nfor l in lines:\n if l[0] == 1:\n seq.append(l[1])\n else:\n for i in range(l[2]):\n seq.extend(seq[:l[1]])\n if len(seq) >= 10**5:\n break\n if len(seq) >= 10**5:\n break\n \ndef find_number(l):\n if l <= len(seq):\n return seq[l-1]\n #seq[l-1]\u7531\u6307\u4ee4i\u751f\u6210\n i = bisect_left(acc_lengths, l) - 1\n return seq[(l - acc_lengths[i] - 1) % lines[i][1]]\n\nprint(' '.join([str(find_number(l)) for l in lengths]))\n", "# -*- coding: utf-8 -*-\nfrom bisect import bisect_left\n\nm = int(input())\nlines = []\nfor i in range(m):\n lines.append(list(map(int, input().split())))\nn = int(input())\nlengths = list(map(int, input().split()))\n\n#acc_lengths[i]\u8868\u793ai\u6307\u4ee4\u6267\u884c\u4e4b\u524d\u5df2\u7ecf\u79ef\u7d2f\u4e86\u591a\u957f\u7684\u4e32\nacc_lengths = [0]\nfor l in lines:\n acc_lengths.append(acc_lengths[-1] + (1 if l[0] == 1 else l[1]*l[2]))\n\nresult = {}\ndef find_number(l):\n if l not in result:\n i = bisect_left(acc_lengths, l) - 1\n result[l] = lines[i][1] if lines[i][0] == 1 else find_number((l - acc_lengths[i] - 1) % lines[i][1] + 1)\n return result[l]\n\nprint(' '.join([str(find_number(l)) for l in lengths]))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "from bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n", "# Made By Mostafa_Khaled \nbot = True \nfrom bisect import bisect_left\nm = int(input())\nt, s = [input().split() for i in range(m)], [0] * m\nl, n = 0, int(input())\nfor j, i in enumerate(t):\n l += 1 if i[0] == '1' else int(i[1]) * int(i[2])\n t[j], s[j] = l, i[1] if i[0] == '1' else int(i[1])\nF = {}\ndef f(i):\n if not i in F:\n k = bisect_left(t, i)\n F[i] = s[k] if type(s[k]) == str else f((i - t[k] - 1) % s[k] + 1)\n return F[i]\nprint(' '.join(f(i) for i in map(int, input().split())))\n\n\n# Made By Mostafa_Khaled\n", "from bisect import bisect_left\ndef fun(ind,alr,ll,sll):\n if ind in alr:\n return alr[ind]\n k = bisect_left(sll,ind)\n md = ll[k]\n return fun((ind-sll[k])%md,alr,ll,sll)\npos = {}\nm = int(input())\nl = 0\ncp = []\ncpl = []\nknown = []\nfor _ in range(0,m):\n q = [int(i) for i in input().split()]\n if q[0] == 1:\n pos[l] = q[1]\n l += 1\n else:\n cp.append(q[1])\n l += q[1]*q[2]\n cpl.append(l)\nn = int(input())\nqq = [int(i)-1 for i in input().split()]\nans = [fun(i,pos,cp,cpl) for i in qq]\nprint(*ans)\n\n\n\n\n", "from bisect import bisect_left\ndef fun(ind,alr,ll,sll):\n if ind in alr:\n return alr[ind]\n k = bisect_left(sll,ind)\n md = ll[k]\n return fun((ind-sll[k])%md,alr,ll,sll)\npos = {}\nm = int(input())\nl = 0\ncp = []\ncpl = []\nfor _ in range(0,m):\n q = [int(i) for i in input().split()]\n if q[0] == 1:\n pos[l] = q[1]\n l += 1\n else:\n cp.append(q[1])\n l += q[1]*q[2]\n cpl.append(l)\nn = int(input())\nqq = [int(i)-1 for i in input().split()]\nans = [fun(i,pos,cp,cpl) for i in qq]\nprint(*ans)\n\n\n\n\n", "m = int(input())\na, b, start, end = [], [], 0, 0\n\nidx = 0\n\nfor _ in range(m):\n line = list(map(int, input().split()))\n if line[0] == 1:\n x = line[1]\n start = end + 1\n end = end + 1\n if len(a) <= 100000:\n a.append(x)\n b.append((start, end, x))\n else:\n l, c = line[1], line[2]\n start = end + 1\n end = end + l * c\n if len(a) <= 100000:\n for _ in range(c):\n a += a[:l]\n if len(a) > 100000:\n break\n b.append((start, end, l, c))\n\n\ninput() # n\n\n\ndef answer(n):\n nonlocal m, a, b, idx\n\n if (n - 1) < len(a):\n return a[n - 1]\n\n while True:\n bi = b[idx]\n if bi[0] <= n <= bi[1]:\n break\n idx += 1\n\n if len(bi) == 3:\n return bi[2]\n\n n_bak = n\n n = (n - bi[0]) % bi[2] + 1\n\n return a[n - 1]\n\n\nresult = []\nfor n in map(int, input().split()):\n result.append(\"%s\" % answer(n))\n\nprint(\" \".join(result))\n"] | {
"inputs": [
"6\n1 1\n1 2\n2 2 1\n1 3\n2 5 2\n1 4\n16\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16\n",
"2\n1 33085\n1 44638\n2\n1 2\n",
"10\n1 57757\n1 45234\n1 80807\n1 38496\n1 27469\n1 42645\n1 72643\n1 33235\n1 10843\n1 80598\n10\n1 2 3 4 5 6 7 8 9 10\n",
"3\n1 97601\n1 32580\n1 70519\n3\n1 2 3\n",
"7\n1 53989\n1 47249\n1 71935\n2 1 3\n1 84520\n1 84185\n2 6 1\n14\n1 2 3 4 5 6 7 8 9 10 11 12 13 14\n",
"1\n1 1\n1\n1\n"
],
"outputs": [
"1 2 1 2 3 1 2 1 2 3 1 2 1 2 3 4\n",
"33085 44638\n",
"57757 45234 80807 38496 27469 42645 72643 33235 10843 80598\n",
"97601 32580 70519\n",
"53989 47249 71935 53989 53989 53989 84520 84185 53989 47249 71935 53989 53989 53989\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 12,866 | |
a35e027541720ad30493a44ba1073dd2 | UNKNOWN | You've got a list of program warning logs. Each record of a log stream is a string in this format: "2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
-----Input-----
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·10^6 (in particular, this means that the length of some line does not exceed 5·10^6 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
-----Output-----
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
-----Examples-----
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00 | ["# import atexit\n# import io\n# import sys\n#\n# _INPUT_LINES = sys.stdin.read().splitlines()\n# input = iter(_INPUT_LINES).__next__\n# _OUTPUT_BUFFER = io.StringIO()\n# sys.stdout = _OUTPUT_BUFFER\n#\n#\n# @atexit.register\n# def write():\n# sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())\n\nimport bisect\nfrom datetime import datetime\n\n\ndef main():\n n, m = list(map(int, input().split()))\n n -= 1\n\n timestamps = []\n raw = []\n while True:\n s = \"\"\n try:\n s = input()\n except:\n print(-1)\n return\n\n d = datetime.strptime(s[0:19], \"%Y-%m-%d %H:%M:%S\")\n timestamps.append(int(d.timestamp()))\n raw.append(s[0:19])\n idx = bisect.bisect_left(timestamps, timestamps[-1] - n)\n if len(timestamps) - idx == m:\n print(raw[-1])\n return\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n, m = list(map(int, input().split(\" \")))\n\nmessages = []\n\nmonths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n\nwhile True:\n try:\n s = input()\n messages.append(s)\n\n except:\n break\n\n# print(messages)\n\nlength = len(messages)\n\npref = [0]\n\nfor i in range(1, 13):\n pref.append(pref[i - 1] + months[i])\n\n# print(pref)\n\ngot = False\nnow = 0\nprev = 0\nstore = []\n\nfor message in messages:\n date = int(message[8:10]) + pref[int(message[5:7]) - 1]\n time = date * 24 * 60 * 60 + int(message[11:13]) * 60 * 60 + int(message[14:16]) * 60 + int(message[17:19])\n store.append(time)\n\n if now < m - 1:\n now += 1\n continue\n\n else:\n prev = now - (m - 1)\n\n if (store[now] - store[prev]) < n:\n print(message[:19])\n got = True\n break\n\n now += 1\n\nif not got:\n print(-1)\n"] | {
"inputs": [
"60 3\n2012-03-16 16:15:25: Disk size is\n2012-03-16 16:15:25: Network failute\n2012-03-16 16:16:29: Cant write varlog\n2012-03-16 16:16:42: Unable to start process\n2012-03-16 16:16:43: Disk size is too small\n2012-03-16 16:16:53: Timeout detected\n",
"1 2\n2012-03-16 23:59:59:Disk size\n2012-03-17 00:00:00: Network\n2012-03-17 00:00:01:Cant write varlog\n",
"2 2\n2012-03-16 23:59:59:Disk size is too sm\n2012-03-17 00:00:00:Network failute dete\n2012-03-17 00:00:01:Cant write varlogmysq\n",
"10 30\n2012-02-03 10:01:10: qQsNeHR.BLmZVMsESEKKDvqcQHHzBeddbKiIb,aDQnBKNtdcvitwtpUDGVFSh.Lx,FPBZXdSrsSDZtIJDgx!mSovndGiqHlCwCFAHy\n",
"2 3\n2012-02-20 16:15:00: Dis\n2012-03-16 16:15:01: Net\n2012-03-16 16:15:02: Cant write varlog\n2012-03-16 16:15:02: Unable to start process\n2012-03-16 16:16:43: Dis\n2012-03-16 16:16:53: Timeout detected\n",
"2 4\n2012-02-20 16:15:00: Dis\n2012-03-16 16:15:01: Net\n2012-03-16 16:15:02: Cant write varlog\n2012-03-16 16:15:02: Unable to start process\n2012-03-16 16:16:43: Dis\n2012-03-16 16:16:53: Timeout detected\n"
],
"outputs": [
"2012-03-16 16:16:43\n",
"-1\n",
"2012-03-17 00:00:00\n",
"-1\n",
"2012-03-16 16:15:02\n",
"-1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,854 | |
9e2c5f41d9fb6738f5bf5f522d2b2a93 | UNKNOWN | Rudolf is on his way to the castle. Before getting into the castle, the security staff asked him a question:
Given two binary numbers $a$ and $b$ of length $n$. How many different ways of swapping two digits in $a$ (only in $a$, not $b$) so that bitwise OR of these two numbers will be changed? In other words, let $c$ be the bitwise OR of $a$ and $b$, you need to find the number of ways of swapping two bits in $a$ so that bitwise OR will not be equal to $c$.
Note that binary numbers can contain leading zeros so that length of each number is exactly $n$.
Bitwise OR is a binary operation. A result is a binary number which contains a one in each digit if there is a one in at least one of the two numbers. For example, $01010_2$ OR $10011_2$ = $11011_2$.
Well, to your surprise, you are not Rudolf, and you don't need to help him$\ldots$ You are the security staff! Please find the number of ways of swapping two bits in $a$ so that bitwise OR will be changed.
-----Input-----
The first line contains one integer $n$ ($2\leq n\leq 10^5$) — the number of bits in each number.
The second line contains a binary number $a$ of length $n$.
The third line contains a binary number $b$ of length $n$.
-----Output-----
Print the number of ways to swap two bits in $a$ so that bitwise OR will be changed.
-----Examples-----
Input
5
01011
11001
Output
4
Input
6
011000
010011
Output
6
-----Note-----
In the first sample, you can swap bits that have indexes $(1, 4)$, $(2, 3)$, $(3, 4)$, and $(3, 5)$.
In the second example, you can swap bits that have indexes $(1, 2)$, $(1, 3)$, $(2, 4)$, $(3, 4)$, $(3, 5)$, and $(3, 6)$. | ["n = int(input())\na = [int(x) for x in input().strip()]\nb = [int(x) for x in input().strip()]\np, q, r, s = 0, 0, 0, 0\nfor i in range(n):\n if a[i] * 2 + b[i] == 0:\n p += 1\n if a[i] * 2 + b[i] == 1:\n q += 1\n if a[i] * 2 + b[i] == 2:\n r += 1\n if a[i] * 2 + b[i] == 3:\n s += 1\nprint(p*r + p*s + q*r)\n", "n = int(input())\na = input()\nb = input()\n\nao = a.count('1')\naz = n - ao\n\nu, v = 0, 0\n\nfor i in range(n):\n if b[i] == '0':\n if a[i] == '1':\n u += 1\n else:\n v += 1\n\nprint(u * az + v * ao - u * v)\n", "n = int(input())\na = input()\nb = input()\nzo = {(0, 0): 0, (0, 1): 0, (1, 0): 0, (1, 1): 0}\nfor c, d in zip(a, b):\n zo[int(c), int(d)] += 1\n\nprint(zo[0, 0] * (zo[1, 0] + zo[1, 1]) + zo[1, 0] * zo[0, 1])\n", "n = int(input())\na = input()\nb = input()\ncnt0, cnt1 = 0, 0\nfor i in range(n):\n if a[i] == '0':\n cnt0 += 1\n else:\n cnt1 += 1\nans = 0\nt0, t1 = 0, 0\nfor i in range(n):\n if b[i] == '0':\n if a[i] == '0':\n ans += cnt1\n t0 += 1\n else:\n ans += cnt0\n t1 += 1\nprint(ans-t0*t1)", "def ii():\n return int(input())\ndef mi():\n return list(map(int, input().split()))\ndef li():\n return list(mi())\n\nn = ii()\na = list(map(int, list(input().strip())))\nb = list(map(int, list(input().strip())))\n\no = [0, 0]\nz = [0, 0]\nfor i in range(n):\n if a[i]:\n o[b[i]] += 1\n else:\n z[b[i]] += 1\n\nans = z[0] * o[1] + z[1] * o[0] + z[0] * o[0]\n\nprint(ans)\n", "n=int(input())\nr=input()\nr1=input()\nans1=0\nans0=0\nc1=0\nc0=0\nfor i in range(n):\n\tif (r1[i]==\"0\"):\n\t\tif (r[i]==\"0\"):\n\t\t\tc0=c0+1\n\t\telse:\n\t\t\tc1=c1+1\n\telse:\n\t\tif (r[i]==\"0\"):\n\t\t\tans0=ans0+1\n\t\telse:\n\t\t\tans1=ans1+1\nfans=c0*ans1+c1*ans0+(c0*c1)\nprint (fans)", "n = int(input())\na = [*map(int, list(input()))]\nb = [*map(int, list(input()))]\none = sum(a)\nzero = len(a) - one\nans = 0\nwk1 = 0\nwk2 = 0\nfor i in range(n):\n if b[i] == 0:\n if a[i] == 0:\n ans += one\n wk1 += 1\n else:\n ans += zero\n wk2 += 1\nprint(ans - wk1 * wk2)", "def read():\n return int(input())\n\n\ndef readlist():\n return list(map(int, input().split()))\n\n\ndef readmap():\n return map(int, input().split())\n\n\nn = read()\na = input()\nb = input()\n\na_1 = []\nfor i in range(n):\n if b[i] == \"1\":\n a_1.append(a[i])\n\nnum0 = a.count(\"0\")\nnum1 = a.count(\"1\")\nnum0_1 = a_1.count(\"0\")\nnum1_1 = a_1.count(\"1\")\n\nprint(num0 * num1 - num0_1 * num1_1)", "n=int(input())\na,b=[*map(int,list(input()))],[*map(int,list(input()))]\nchanged=[False]*n\n\nfor i in range(n):\n if b[i]==0: changed[i]=True\n\nstateCnt=[0]*4\nfor i in range(n):\n if a[i]==1 and changed[i]==True:\n stateCnt[0]+=1\n elif a[i]==1 and changed[i]==False:\n stateCnt[1]+=1\n elif a[i]==0 and changed[i]==True:\n stateCnt[2]+=1\n else:\n stateCnt[3]+=1\n\nprint(stateCnt[0]*stateCnt[2]+stateCnt[0]*stateCnt[3]+stateCnt[2]*stateCnt[1])", "n = int(input())\na = list(input())\nb = list(input())\n\nother_0 = other_1 = imp_0 = imp_1 = 0\n\nfor i in range(n):\n if b[i] == '1':\n if a[i] == '0':\n other_0 += 1\n else:\n other_1 += 1\n else:\n if a[i] == '0':\n imp_0 += 1\n else:\n imp_1 += 1\n\nprint((imp_0 * other_1) + (imp_1 * other_0) + (imp_0 * imp_1))\n", "n=int(input())\ns1=str(input())\ns2=str(input())\nans1=0\nans2=0\nans3=0\nans4=0\nfor i in range(n):\n if(s2[i]=='0' and s1[i]=='1'):\n ans1+=1\n elif(s2[i]=='0' and s1[i]=='0'):\n ans2+=1\n if(s1[i]=='1'):\n ans3+=1\n if(s1[i]=='0'):\n ans4+=1\nansx=0\nansy=0\nfor i in range(n):\n if(s2[i]=='0' and s1[i]=='0'):\n ansx+=(ans3-ans1)\n ansy+=ans1\n elif(s2[i]=='0' and s1[i]=='1'):\n ansx+=(ans4-ans2)\n ansy+=ans2\nans=ansx\nans+=(ansy)//2\nprint(ans)", "3\n\ndef main():\n N = int(input())\n A = input()\n B = input()\n\n d = {(0, 0): 0, (0, 1): 0, (1, 0): 0, (1, 1): 0}\n c = 0\n for i in range(N):\n a = int(A[i])\n b = int(B[i])\n\n c += d[(a, b)]\n\n if (a, b) == (0, 0):\n d[(1, 0)] += 1\n d[(1, 1)] += 1\n elif (a, b) == (0, 1):\n d[(1, 0)] += 1\n elif (a, b) == (1, 0):\n d[(0, 0)] += 1\n d[(0, 1)] += 1\n else:\n d[(0, 0)] += 1\n\n print(c)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "a=0\nb=0\nc=0\nd=0\nn=int(input())\ns=input()\nt=input()\nfor i in range(n):\n if s[i]=='0' and t[i]=='0':\n a+=1\n elif s[i]=='0' and t[i]=='1':\n b+=1\n elif s[i]=='1' and t[i]=='0':\n c+=1\n elif s[i]=='1' and t[i]=='1':\n d+=1\nprint(a*(c+d)+b*c)", "n = int(input())\na = input()\nb = input()\n\nif len(set(a)) == 1:\n print(0)\nelse:\n ed = 0\n zer = 0\n for i in a:\n if i == '0':\n zer += 1\n else:\n ed += 1\n \n sed = szer = 0\n for i in range(n):\n if b[i] == '0':\n if a[i] == '0':\n szer += 1\n else:\n sed += 1\n print(sed * zer + szer * ed - szer * sed)", "n = int(input())\na = input()\nb = input()\nx = 0\ny = 0\nz = 0\nfor i in range(n):\n\tif(b[i] == '0'):\n\t\tif(a[i] == '1'):\n\t\t\tx+=1\n\t\telse:\n\t\t\ty+=1\n\telse:\n\t\tif(a[i] == '1'):\n\t\t\tz+=1\nprint(y * z + x * a.count('0'))\n", "a,b,c,d=0,0,0,0\nn=int(input())\ns1,s2=input(),input()\n\nfor i in range(n):\n a+=s1[i]=='0' and s2[i]=='1'\n b+=s1[i]=='0' and s2[i]=='0'\n c+=s1[i]=='1' and s2[i]=='1'\n d+=s1[i]=='1' and s2[i]=='0'\n\nprint(a*d+b*c+b*d)\n", "n=int(input())\na=input()\nb=input()\nx,y,z,w=0,0,0,0\n\"\"\" w 00\n x 01\n y 10\n z 11 \"\"\"\nfor i in range(n):\n if a[i]=='0':\n if b[i]=='0':\n w+=1\n else:\n x+=1\n else:\n if b[i]=='0':\n y+=1\n else:\n z+=1\nprint(w*(y+z) + y*x)", "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nimport time\n\n\nn = int(input())\na = input()\nb = input()\n\nstart = time.time()\n\np00 = 0\np11 = 0\np10 = 0\np01 = 0\n\nfor i in range(n):\n if a[i] == '0':\n if b[i] == '0':\n p00 += 1\n else:\n p01 += 1\n else:\n if b[i] == '0':\n p10 += 1\n else:\n p11 += 1\n\nans = p00*p11+p10*p01+p00*p10\nprint(ans)\nfinish = time.time()\n#print(finish - start)\n", "n = int(input())\na = list(map(int, list(input())))\nb = list(map(int, list(input())))\na0 = 0\na1 = 0\nans = 0\nb0 = 0\nb1 = 0\nfor i in a:\n if i == 0:\n a0 += 1\n else:\n a1 += 1\nfor i in range(n):\n if b[i] == 0:\n if a[i] == 0:\n ans += a1\n b0 += 1\n else:\n ans += a0\n b1 += 1\nans -= b0 * b1\nprint(ans)\n", "n=int(input())\na=input()\nb=input()\nzer=0\none=0\nta=a.count('1')\ntz=a.count('0')\nfor i in range(n):\n if a[i]=='0' and b[i]=='0':\n zer+=1\n elif a[i]=='1' and b[i]=='0':\n one+=1\nans=zer*ta+one*tz-zer*one\nprint(ans)", "n = int(input())\ns1 = input()\ns2 = input()\nsmth = dict()\nsmth['01'] = 0\nsmth['00'] = 0\nsmth['10'] = 0\nsmth['11'] = 0\nans = 0\nfor i in range(n):\n smth[s1[i] + s2[i]] += 1\nfor i in range(n):\n if s1[i] == '0':\n if s2[i] == '0':\n ans += smth['10']\n ans += smth['11']\n else:\n ans += smth['10']\nprint(ans)", "n = int(input())\nx = input()\ny = input()\nxl = [int(i) for i in x]\nyl = [int(i) for i in y]\nc1 = 0\nc2 = 0\ncnt1 = xl.count(1)\ncnt0 = xl.count(0)\n#print(cnt1)\nfor i in range(n):\n if(x[i]=='0' and y[i]=='0'):\n c1+=1\n elif(x[i]=='1' and y[i]=='0'):\n c2+=1\ncnt1-=c2\n#print(c1,c2)\nprint(c1*cnt1+c2*cnt0)", "#list_int \u4e26\u3079\u3066\u51fa\u529b print (' '.join(map(str,ans_li)))\n#list_str \u4e26\u3079\u3066\u51fa\u529b print (' '.join(list))\n\nfrom collections import defaultdict\nimport sys,heapq,bisect,math,itertools,string,queue,datetime\nsys.setrecursionlimit(10**8)\nINF = float('inf')\nmod = 10**9+7\neps = 10**-7\nAtoZ = [chr(i) for i in range(65,65+26)]\natoz = [chr(i) for i in range(97,97+26)]\n\ndef inpl(): return list(map(int, input().split()))\ndef inpl_s(): return list(input().split())\n\nN = int(input())\naa = list(map(int,list(input())))\nbb = list(map(int,list(input())))\nx00 = x01 = x10 = x11 = 0\n\nfor i in range(N):\n\tif aa[i] and bb[i]:\n\t\tx11 += 1\n\telif not aa[i] and bb[i]:\n\t\tx01 += 1\n\telif aa[i] and not bb[i]:\n\t\tx10 += 1\n\telse:\n\t\tx00 += 1\n\nprint(x00*(x10+x11)+x10*x01)\n", "USE_STDIO = False\n\nif not USE_STDIO:\n try: import mypc\n except: pass\n\ndef main():\n n, = list(map(int, input().split(' ')))\n a = [x for x in map(int, input())]\n b = [x for x in map(int, input())]\n cnts = [0, 0, 0, 0]\n for x, y in zip(a, b):\n cnts[x*2+y] += 1\n ans = cnts[0] * cnts[3] + cnts[1] * cnts[2] + (cnts[0] * cnts[2])\n print(ans)\n\n\ndef __starting_point():\n main()\n\n\n\n\n__starting_point()", "from sys import stdin\nfrom math import *\n\nline = stdin.readline().rstrip().split()\nn = int(line[0])\n\n\nnumbers = stdin.readline().rstrip().split()[0]\nnumbers2 = stdin.readline().rstrip().split()[0]\n\ncant00 = 0\ncant01 = 0\ncant11 = 0\ncant10 = 0\nfor i in range(len(numbers)):\n if numbers[i] == '0' and numbers2[i] == '0':\n cant00+=1\n if numbers[i] == '1' and numbers2[i] == '0':\n cant01+=1\n if numbers[i] == '0' and numbers2[i] == '1':\n cant10+=1\n if numbers[i] == '1' and numbers2[i] == '1':\n cant11+=1\nprint(cant00*cant01 + cant00 * cant11 + cant01 * cant10)\n\n"] | {
"inputs": [
"5\n01011\n11001\n",
"6\n011000\n010011\n",
"10\n0110101101\n1010000101\n",
"30\n011110110100010000011001000100\n110111101001011001100001101101\n",
"2\n00\n00\n",
"2\n00\n11\n"
],
"outputs": [
"4\n",
"6\n",
"21\n",
"146\n",
"0\n",
"0\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 9,986 | |
7f68a93a0f51f67c21a06c5767f1d1fc | UNKNOWN | For strings s and t, we will say that s and t are prefix-free when neither is a prefix of the other.
Let L be a positive integer. A set of strings S is a good string set when the following conditions hold true:
- Each string in S has a length between 1 and L (inclusive) and consists of the characters 0 and 1.
- Any two distinct strings in S are prefix-free.
We have a good string set S = \{ s_1, s_2, ..., s_N \}. Alice and Bob will play a game against each other. They will alternately perform the following operation, starting from Alice:
- Add a new string to S. After addition, S must still be a good string set.
The first player who becomes unable to perform the operation loses the game. Determine the winner of the game when both players play optimally.
-----Constraints-----
- 1 \leq N \leq 10^5
- 1 \leq L \leq 10^{18}
- s_1, s_2, ..., s_N are all distinct.
- { s_1, s_2, ..., s_N } is a good string set.
- |s_1| + |s_2| + ... + |s_N| \leq 10^5
-----Input-----
Input is given from Standard Input in the following format:
N L
s_1
s_2
:
s_N
-----Output-----
If Alice will win, print Alice; if Bob will win, print Bob.
-----Sample Input-----
2 2
00
01
-----Sample Output-----
Alice
If Alice adds 1, Bob will be unable to add a new string. | ["import sys\ninput=sys.stdin.readline\nsys.setrecursionlimit(10**9)\nfrom collections import deque\n\nclass Node:\n def __init__(self,depth):\n self.depth=depth\n self.left=None\n self.right=None\n\ndef insert(node,s):\n n=node\n for i in range(len(s)):\n t=s[i]\n if t=='0':\n if n.left is None:\n n.left=Node(i+1)\n n=n.left\n else:\n if n.right is None:\n n.right=Node(i+1)\n n=n.right\n\nclass Trie:\n def __init__(self):\n self.root=Node(0)\n def insert(self,s:str):\n insert(self.root,s)\n\nn,l=map(int,input().split())\nS=[input().strip() for _ in range(n)]\ntrie=Trie()\nfor s in S:\n trie.insert(s)\nData=[]\nq=deque([trie.root])\n\ndef dfs(node):\n if node.right is None and node.left is None:\n return\n if node.right is None or node.left is None:\n Data.append(l-node.depth)\n if node.right:\n q.append(node.right)\n if node.left:\n q.append(node.left)\n\nwhile q:\n dfs(q.popleft())\nxor=0\n\ndef Grundy(n):\n ret=1\n while n%2==0:\n n//=2\n ret*=2\n return ret\n\nfor i in Data:\n xor^=Grundy(i)\nprint('Alice' if xor else 'Bob')", "import sys\n#from collections import defaultdict\nsys.setrecursionlimit(10**6)\n\ndef input():\n\treturn sys.stdin.readline()[:-1]\nn, l = list(map(int, input().split()))\nss = [list(input())[::-1] for _ in range(n)]\n\ndef addTree(tree, sentence):\n\tif not sentence:\n\t\treturn None \n\n\tif sentence[-1] not in tree:\n\t\ttree[sentence[-1]] = {}\n\n\tp = sentence.pop()\n\ttree[p] = addTree(tree[p], sentence)\n\n\treturn tree\n\ndef createTree(sentences): \n\ttree = {}\n\tfor sentence in sentences:\n\t\ttree = addTree(tree, sentence)\n\n\treturn tree\n\ntree = createTree(ss)\n#print(tree)\n\ngrundy = 0\ndef dfs(cur, level):\n\tnonlocal grundy\n\tif cur is None:\n\t\treturn\n\telif len(cur) == 1:\n\t\tgrundy ^= (l-level) & (-l+level)\n\tfor k in list(cur.keys()):\n\t\tdfs(cur[k], level+1)\n\treturn\n\t\ndfs(tree, 0)\n\nif grundy == 0:\n\tprint(\"Bob\")\nelse:\n\tprint(\"Alice\")\n", "import sys\nsys.setrecursionlimit(2 * 10 ** 5)\n\n\nclass TrieNode:\n def __init__(self, char):\n self.char = char\n self.nextnode = dict()\n self.is_indict = False\n\n\nclass Trie:\n def __init__(self, charset):\n self.charset = charset\n self.root = TrieNode('')\n\n def add(self, a_str):\n node = self.root\n for i, char in enumerate(a_str):\n if char not in node.nextnode:\n node.nextnode[char] = TrieNode(char)\n node = node.nextnode[char]\n if i == len(a_str) - 1:\n node.is_indict = True\n\n def dfs(self, node, dep):\n ret, cnt = 0, 0\n if node.is_indict:\n return 0\n for s in '01':\n if s not in node.nextnode:\n cnt += 1\n else:\n ret ^= self.dfs(node.nextnode[s], dep + 1)\n height = L - dep\n if cnt % 2:\n power2 = 0\n while height > 0 and height % 2 == 0:\n power2 += 1\n height //= 2\n ret ^= 2 ** power2\n return ret\n\n def debug_output(self, node, now):\n print((node.char, list(node.nextnode.items()), node.is_indict, now))\n if node.is_indict:\n print(now)\n for n in list(node.nextnode.values()):\n self.debug_output(n, now + n.char)\n\nN, L = list(map(int, input().split()))\nT = Trie('01')\nfor _ in range(N):\n T.add(input())\n# T.debug_output(T.root, '')\nprint((\"Alice\" if T.dfs(T.root, 0) else \"Bob\"))\n", "n,l = map(int,input().split())\nls = [input() for i in range(n)]\nsm = sum([len(s) for s in ls])\nls.sort()\nnum = [0]*(sm+1)\nfor i in range(n):\n if i == 0:\n for j in range(len(ls[i])):\n num[j+1] = 1\n else:\n x = ls[i]\n p = ls[i-1]\n cnt = 0\n while cnt < min(len(x),len(p)):\n if x[cnt] == p[cnt]:\n cnt += 1\n else:\n break\n num[cnt+1] -= 1\n for j in range(cnt+2,len(x)+1):\n num[j] += 1\nans = 0\ndef d2(x):\n if x == 0:\n return 0\n cnt = 0\n while x%2 == 0:\n cnt += 1\n x //= 2\n return 2**cnt\nfor i in range(sm+1):\n ans ^= d2(l+1-i)*(num[i]%2)\nif ans:\n print(\"Alice\")\nelse:\n print(\"Bob\")", "def getGrundyNumber(x):\n ans = 1\n while x % (ans * 2) == 0:\n ans *= 2\n return ans\n\n\nN, L = list(map(int, input().split()))\nSs = [input() for i in range(N)]\n\n# \u30c8\u30e9\u30a4\u6728\u3092\u4f5c\u6210\u3059\u308b\nTrie = [[-1, -1]]\nfor S in Ss:\n iT = 0\n for c in map(int, S):\n if Trie[iT][c] == -1:\n Trie += [[-1, -1]]\n Trie[iT][c] = len(Trie) - 1\n iT = Trie[iT][c]\n\n# \u5b50\u304c\uff11\u3064\u306e\u9802\u70b9\u3092\u63a2\u3059\nHgts = {}\nstack = [(0, L + 1)]\nwhile stack:\n iT, Hgt = stack.pop()\n num = 0\n for c in Trie[iT]:\n if c != -1:\n stack.append((c, Hgt - 1))\n num += 1\n\n if num == 1:\n Hgts[Hgt - 1] = Hgts.get(Hgt - 1, 0) + 1\n\n# Grundy\u6570\u306eXOR\u3092\u6c42\u3081\u308b\nans = 0\nfor Hgt, num in list(Hgts.items()):\n if num % 2:\n ans ^= getGrundyNumber(Hgt)\n\nif ans:\n print('Alice')\nelse:\n print('Bob')\n", "from collections import defaultdict\n\n\ndef solve(n, l, nums):\n xor = 0\n\n if n == 1:\n for i in range(min(nums), l + 1):\n xor ^= i & -i\n return xor\n\n for i in range(min(nums), l + 1):\n ni = nums[i]\n for k in ni:\n if k ^ 1 not in ni:\n xor ^= i & -i\n nums[i + 1].add(k // 2)\n del nums[i]\n return xor\n\n\nn, l = list(map(int, input().split()))\nnums = defaultdict(set)\nfor s in (input() for _ in range(n)):\n nums[l - len(s) + 1].add(int(s, 2) + (1 << len(s)))\n\nprint(('Alice' if solve(n, l, nums) else 'Bob'))\n", "from collections import deque\n# \u7bc0\u306e\u5b9a\u7fa9\nclass Node:\n def __init__(self, x):\n self.data = int(x)\n self.left = None\n self.right = None\n# \u633f\u5165\ndef insert(node, x):\n ima = node\n for i in range(len(x)):\n y = x[i]\n if y == \"1\":\n if ima.right is None:\n ima.right = Node(i+1)\n ima = ima.right\n else:\n if ima.left is None:\n ima.left = Node(i+1)\n ima = ima.left\n\n\n\nclass Trie:\n def __init__(self):\n self.root = Node(0)\n\n # \u633f\u5165\n def insert(self, x):\n insert(self.root, x)\n\nn,l = map(int,input().split())\ns = [input() for i in range(n)]\n\ntrie = Trie()\nfor i in s:\n trie.insert(i)\ndata = []\nque = deque([trie.root])\ndef dfs(node):\n if node.right is None and node.left is None:\n return 0\n if node.right is None or node.left is None:\n if l-node.data:\n data.append(l-node.data)\n if node.right:\n que.append(node.right)\n if node.left:\n que.append(node.left)\n \nwhile que:\n dfs(que.popleft())\nxor = 0\ndef nimber(n):\n x = 1\n while n%2 == 0: n//= 2; x*= 2\n return x\nfor i in data:\n xor ^= nimber(i)\nprint(\"Alice\" if xor else \"Bob\")", "# nimber: 0, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1, 16, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1, 32, ...\n\nclass Node:\n def __init__(self, size, avail):\n self.end = False\n self.nxt = [None] * size\n self.avail = avail\n def __setitem__(self, i, x): self.nxt[i] = x\n def __getitem__(self, i): return self.nxt[i]\n\ndef makeTrie(strs, size):\n root = Node(size, l)\n for s in strs:\n n = root\n for c in s:\n i = int(c) # Change this to adapt. ex: ord(c)-ord(\"A\")\n if not n[i]: n[i] = Node(size, n.avail-1)\n n = n[i]\n n.end = True\n return root\n\ndef nimber(n):\n x = 1\n while n%2 == 0: n//= 2; x*= 2\n return x\n\ninput = __import__('sys').stdin.readline\nn, l = map(int,input().split())\nstrs = [input().rstrip() for i in range(n)]\nT = makeTrie(strs, 2)\n\nans = 0\nstack = [T]\nwhile stack:\n n = stack.pop()\n for i in 0, 1:\n if not n[i]: ans^= nimber(n.avail)\n elif not n[i].end: stack.append(n[i])\nprint(\"Alice\" if ans else \"Bob\")", "class Node():\n def __init__(self):\n self.lt = None\n self.rt = None\n self.dep = None\n\nclass Trie():\n def __init__(self):\n self.root = Node()\n self.root.dep = 0\n\n def add(self, string):\n node = self.root\n for s in string:\n if s == '0':\n if node.lt is None:\n node.lt = Node()\n node.lt.dep = node.dep + 1\n node = node.lt\n else:\n if node.rt is None:\n node.rt = Node()\n node.rt.dep = node.dep + 1\n node = node.rt\n\nN, L = map(int, input().split())\n\ntrie = Trie()\n\nfor _ in range(N):\n s = input()\n trie.add(s)\n\nsubgame = []\nstack = [trie.root]\n\nwhile stack:\n node = stack.pop()\n if node.lt is None and node.rt is None:\n continue\n elif node.rt is None:\n stack.append(node.lt)\n subgame.append(L - node.dep)\n elif node.lt is None:\n stack.append(node.rt)\n subgame.append(L - node.dep)\n else:\n stack.append(node.lt)\n stack.append(node.rt)\n\ndef grundy(n):\n if n == 0: return 0\n if n % 2 == 1: return 1\n if n == 2**(n.bit_length() - 1):\n return n\n return grundy(n - 2**(n.bit_length() - 1))\n\ng = 0\n\nfor l in subgame:\n g ^= grundy(l)\n\nprint('Alice' if g != 0 else 'Bob')", "import sys\nN, L = list(map(int, input().split()))\nsys.setrecursionlimit(200000)\n\nclass Node:\n def __init__(self, depth=0):\n self.parent = None\n self.children = {}\n self.depth = depth\n def add(self, n):\n self.children[n] = Node(self.depth+1)\n def has(self, n):\n return n in self.children\nt = Node()\nfor i in range(N):\n s = input()\n nt = t\n for c in s:\n if not nt.has(c):\n nt.add(c)\n nt = nt.children[c]\n\ndef solve(node):\n nonlocal N, L\n ans = 0\n f = lambda d: (L - d) & -(L - d)\n if node.has('0'):\n ans ^= solve(node.children['0'])\n else:\n ans ^= f(node.depth)\n if node.has('1'):\n ans ^= solve(node.children['1'])\n else:\n ans ^= f(node.depth)\n return ans\n\nans = solve(t)\nif ans == 0:\n print('Bob')\nelse:\n print('Alice')\n", "\n\"\"\"\nWriter: SPD_9X2\nhttps://atcoder.jp/contests/arc087/tasks/arc087_c\n\n\u521d\u671f\u72b6\u614b\u3067\u51fa\u3066\u3044\u308b\u6570\u5b57\u3092\u6728\u3068\u3057\u3066\u3042\u3089\u308f\u3059\n\u6570\u5b57\u3067\u3075\u3055\u304c\u3063\u3066\u3044\u308b\u6240\u306f\u3082\u3046\u8ffd\u52a0\u3067\u304d\u306a\u3044\n\u307e\u3060\u304a\u3051\u308b\u306e\u306f\u3001\u7a7a\u3044\u3066\u3044\u308b\u90e8\u5206\u3060\u3051\n\nL\u304c\u3067\u304b\u3044\u306e\u3067\u3001\u6df1\u3055\u3092\u8003\u3048\u3066\u3044\u3066\u306f\u6b7b\u306c\n\n\u305d\u306e\u307e\u307e\u3075\u3055\u3050\u3068\u3001\u7f6e\u3051\u308b\u5834\u6240\u306f1\u6e1b\u308b\n\u4f38\u3070\u3057\u3066\u304a\u3051\u3070\u3001L\u307e\u3067\u5897\u3084\u3057\u3066\u7f6e\u3051\u308b\n\n\u7f6e\u3051\u308b\u5834\u6240\u306e\u5076\u5947\u304b\uff1f\n\u7f6e\u3051\u308b\u5834\u6240\u304c0\u3067\u6765\u305f\u3089\u8ca0\u3051\u2192\u521d\u624b\u304c\u5947\u6570\u306a\u3089\u5148\u624b\u52dd\u3061\u30fb\u305d\u3046\u3067\u306a\u3044\u306a\u3089\u5f8c\u624b\u52dd\u3061\uff1f\n\u4f38\u3070\u305b\u308b\u5974\u306f\u5076\u5947\u53cd\u8ee2\u306b\u4f7f\u3048\u308b\n\n\u90e8\u5206\u3067\u8003\u3048\u3066\u307f\u308b\u304b\u2192\n\nGrundy\u6570\u8a08\u7b97\n\u6df1\u30551\u306e\u90e8\u5206\u6728\u306eGrundy \u2192 1\n\u6df1\u30552\u306e\u90e8\u5206\u6728\u306eGrundy \u2192 2\n\u6df1\u30553\u3000\u3000\u3000\u3000\u3000\u3000\u3000\u3000 \u2192 1 ?\n\u6df1\u30554\n\nGrundy\u3067\u884c\u3051\u308b = xor\u304c\u5168\u4f53\u306eGrundy\u306b\u306a\u308b\u3068\u3044\u3046\u4eee\u5b9a\n\u306a\u306e\u3067\u3001\u6df1\u3055x\u3092\u8a66\u3059\u3068\u304d\u306f\u3001\u6df1\u3055x\u30671\u56de\u3067\u884c\u3051\u308b\u72b6\u614b\u306exor\u306emex\u304cGrundy\u3068\u306a\u308b\n\n\u6df1\u30551\u306a\u3089\u3001\u554f\u7b54\u7121\u7528\u30671\n\u6df1\u30552\u306a\u3089\u30010 or 1 \u306b\u306a\u308b\u306e\u3067 2\n\u6df1\u30553\u306a\u3089, 0 or 2 \u306b\u306a\u308b\u306e\u3067 1\n\u6df1\u30554\u306a\u3089, 0 or 1 or 3 or 2 \u306a\u306e\u3067 4\n\u6df1\u30555\u306a\u3089, 0 or 4 or 5 or 7 or 6 \u3067 1\n\u6df1\u30556\u306a\u3089, 0 or 1 or 5 or 4 or 6 or 7 \u3067 2\n\u6df1\u30557\u306a\u3089, 0 or 2 or 3 or 7 or 6 or 4 or 5 \u3067 1\n\u6df1\u30558\u306a\u3089, 0 or 1 or 3 or 2 or 6 or 7 or 5 or 4 \u3067 8\n\n\u2192\u3069\u3046\u3084\u3089\u3001\u305d\u306e\u6570\u5b57\u3092\u5272\u308a\u5207\u308c\u308b\u6700\u5927\u306e2\u306e\u968e\u4e57\u6570\u304cGrundy\u6570\u306b\u306a\u308b\u307f\u305f\u3044\u3060\n\u3064\u307e\u308a\u3001\u7a7a\u304d\u30dd\u30a4\u30f3\u30c8\u3092\u63a2\u7d22\u3057\u3066\u3001\u5bfe\u5fdc\u3059\u308b\u6df1\u3055\u306eGrundy\u6570\u3092\u8a08\u7b97 & xor\u3092\u3068\u308c\u3070\u3088\u3044\n\n\u3042\u3068\u306f\u5b9f\u88c5\u3060\nprefix tree\u3092\u4f5c\u308a\u305f\u3044\u306a\uff1f\n\u9069\u5f53\u306b\u30ce\u30fc\u30c9\u3092\u8ffd\u52a0\u3057\u3066\u4f5c\u3063\u3066\u3042\u3052\u308c\u3070\u3044\u3044\u304b\n\u4fdd\u6301\u3059\u308b\u30c7\u30fc\u30bf\u306f\u30010\u306e\u5b50index,1\u306e\u5b50index,\u6df1\u3055\u304c\u3042\u308c\u3070\u5341\u5206\u304b\u306a\n\u8a08\u7b97\u91cf\u304c\u3061\u3087\u3063\u3068\u6c17\u306b\u306a\u308b\u3068\u3053\u308d(\u518d\u5e30\u306f\u306a\u308b\u3079\u304f\u907f\u3051\u305f\u3044\u3068\u3053\u308d)\n\n\"\"\"\n\ndef tp_z(now , nd):\n\n if z_child[now] == None:\n ret = len(z_child)\n z_child[now] = ret\n z_child.append(None)\n o_child.append(None)\n dep.append(nd + 1)\n else:\n ret = z_child[now]\n\n return ret\n\ndef tp_o(now , nd):\n\n if o_child[now] == None:\n ret = len(z_child)\n o_child[now] = ret\n z_child.append(None)\n o_child.append(None)\n dep.append(nd + 1)\n else:\n ret = o_child[now]\n\n return ret\n\ndef grundy(nd):\n\n if nd == 0:\n return 0\n\n for i in range(64):\n if nd % (2**i) != 0:\n return 2**(i-1)\n \n\nN,L = map(int,input().split())\n\nz_child = [None]\no_child = [None]\ndep = [0]\n\nfor loop in range(N):\n\n now = 0\n s = input()\n\n for i in s:\n if i == \"0\":\n now = tp_z(now , dep[now])\n else:\n now = tp_o(now , dep[now])\n\n#print (z_child)\n#print (o_child)\n#print (dep)\n\nans = 0\nfor i in range(len(z_child)):\n\n if z_child[i] == None:\n ans ^= grundy(L - dep[i])\n if o_child[i] == None:\n ans ^= grundy(L - dep[i])\n\nif ans == 0:\n print (\"Bob\")\nelse:\n print (\"Alice\")", "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10**6)\nfrom collections import deque\n\nN,M = map(int,input().split())\nwords = [deque(input().rstrip()) for _ in range(N)]\n\n# \u6df1\u3055L\u306efull tree\u306e\u5c0f\u3055\u3044\u65b9\u3092\u8a08\u7b97\u3057\u3066\u307f\u308b\ndef G_small():\n G = [0] * 100\n G_cum = [0] * 100\n G[0] = 1\n G_cum[0] = 1\n for n in range(1,100):\n can_make = set(G_cum[n-1]^G_cum[x] for x in range(n)) | set([G_cum[n-1]])\n rest = set(range(n+10)) - can_make\n G[n] = min(rest)\n G_cum[n] = G_cum[n-1] ^ G[n]\n return G\n\n# print([(n,G[n]) for n in range(100)])\n# G[n] = 2**ord_2(n+1)\n# \u5024\u304c\u308f\u304b\u308c\u3070\u8a3c\u660e\u306f\u6613\u3057\u3044\n\ndef G(n):\n n += 1\n x = 1\n while not n & 1:\n n >>= 1\n x <<= 1\n return x\n\ndef calc_grandy(words,L):\n if not words:\n return G(L)\n if len(words) == 1 and words[0] == deque():\n return 0\n words_0 = []\n words_1 = []\n for word in words:\n first = word.popleft()\n if first == '0':\n words_0.append(word)\n else:\n words_1.append(word)\n return calc_grandy(words_0,L-1) ^ calc_grandy(words_1,L-1)\n\ng = calc_grandy(words,M)\n\nanswer = 'Alice' if g != 0 else 'Bob'\nprint(answer)", "import sys\nsys.setrecursionlimit(1000000)\n\ndef getGrundyNumber(x):\n ans = 1\n while x % (ans * 2) == 0:\n ans *= 2\n return ans\n\n\ndef dfs(iT, Hgt):\n num = 0\n for c in Trie[iT]:\n if c != -1:\n dfs(c, Hgt - 1)\n num += 1\n\n if num == 1:\n Hgts[Hgt - 1] = Hgts.get(Hgt - 1, 0) + 1\n\n\nN, L = list(map(int, input().split()))\nSs = [input() for i in range(N)]\n\n# \u30c8\u30e9\u30a4\u6728\u3092\u4f5c\u6210\u3059\u308b\nTrie = [[-1, -1]]\nfor S in Ss:\n iT = 0\n for c in map(int, S):\n if Trie[iT][c] == -1:\n Trie += [[-1, -1]]\n Trie[iT][c] = len(Trie) - 1\n iT = Trie[iT][c]\n\n# \u5b50\u304c\uff11\u3064\u306e\u9802\u70b9\u3092\u63a2\u3059\nHgts = {}\ndfs(0, L + 1)\n\n# Grundy\u6570\u306eXOR\u3092\u6c42\u3081\u308b\nans = 0\nfor Hgt, num in list(Hgts.items()):\n if num % 2:\n ans ^= getGrundyNumber(Hgt)\n\nif ans:\n print('Alice')\nelse:\n print('Bob')\n", "def main():\n import sys\n from collections import defaultdict\n input = sys.stdin.readline\n\n mod = 10**10+7\n mod2 = 10**10+9\n mod3 = 998244353\n N, L = list(map(int, input().split()))\n dic = defaultdict(int)\n dic2 = defaultdict(int)\n dic3 = defaultdict(int)\n h_list = []\n h2_list = []\n h3_list = []\n pair = {}\n pair2 = {}\n pair3 = {}\n M = 0\n for _ in range(N):\n s = input().rstrip('\\n')\n h = 0\n h2 = 0\n h3 = 0\n for i in range(len(s)):\n M += 1\n h = (h*1007 + int(s[i]) + 1) % mod\n pair[h] = (h + 1)%mod if s[i] == '0' else (h-1)%mod\n h2 = (h2 * 2009 + int(s[i]) + 1) % mod2\n pair2[h2] = (h2 + 1)%mod2 if s[i] == '0' else (h2-1)%mod2\n h3 = (h3 * 3001 + int(s[i]) + 1) % mod3\n pair3[h3] = (h3 + 1) % mod3 if s[i] == '0' else (h3 - 1) % mod3\n dic[h] = i+1\n dic2[h2] = i+1\n dic[h3] = i+1\n h_list.append(h)\n h2_list.append(h2)\n h3_list.append(h3)\n\n g = 0\n seen = defaultdict(int)\n seen2 = defaultdict(int)\n seen3 = defaultdict(int)\n for i in range(M):\n s, s2, s3 = h_list[i], h2_list[i], h3_list[i]\n if seen[s] and seen2[s2] and seen3[s3]:\n continue\n t = pair[s]\n t2 = pair2[s2]\n t3 = pair3[s3]\n if dic[t] == 0 or dic2[t2] == 0 or dic3[t3] == 0:\n p = [dic[s], dic2[s2], dic3[s3]]\n p.sort()\n tmp = L - p[1] + 1\n '''\n if not seen[s]:\n tmp = L - dic[s] + 1\n elif not seen[s2]:\n tmp = L - dic2[s2] + 1\n else:\n tmp = L - dic3[s3] + 1\n '''\n cnt = 0\n while tmp % 2 == 0:\n tmp //= 2\n cnt += 1\n g ^= (2**cnt)\n #print(g, s, s2, t, t2, dic[t], dic2[t2])\n seen[s] = 1\n seen2[s2] = 1\n seen3[s3] = 1\n\n if g:\n print('Alice')\n else:\n print('Bob')\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import defaultdict\n\n\ndef solve(l, ss):\n xor = 0\n for d in range(min(ss), l + 1):\n sl = ss[d]\n sl.sort()\n while sl:\n s = sl.pop()\n ps = s[:-1]\n ss[d + 1].append(ps)\n if s[-1] == '1' and sl and sl[-1][:-1] == ps:\n sl.pop()\n else:\n xor ^= d & -d\n del ss[d]\n return xor\n\n\nn, l = list(map(int, input().split()))\nss = defaultdict(list)\nfor s in (input() for _ in range(n)):\n ss[l - len(s) + 1].append(s)\n\nprint(('Alice' if solve(l, ss) else 'Bob'))\n", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\n_,L = list(map(int,readline().split()))\ns = read().split()\n\ndef grundy(x):\n if x==0: return 0\n r = 1\n while x%2==0:\n x //= 2\n r *= 2\n return r\n\ng = 0\nst = [(s,0)]\nwhile st:\n a,idx = st.pop()\n a0 = []\n a1 = []\n for i in a:\n if len(i) <= idx:\n continue\n if i[idx] == \"0\":\n a0.append(i)\n else:\n a1.append(i)\n \n if (a0 and not a1) or (a1 and not a0):\n g ^= grundy(L-idx)\n\n if a0: st.append((a0,idx+1))\n if a1: st.append((a1,idx+1))\n\nif g: print(\"Alice\")\nelse: print(\"Bob\")\n\n", "import sys\nreadline = sys.stdin.readline\n\nclass Node:\n def __init__(self, sigma, depth):\n self.end = False\n self.child = [None] * sigma\n self.depth = depth\n def __setitem__(self, i, x):\n self.child[i] = x\n def __getitem__(self, i):\n return self.child[i]\n\nclass Trie():\n def __init__(self, sigma):\n self.sigma = sigma\n self.root = Node(sigma, 0)\n \n def add(self, S):\n vn = self.root\n for cs in S:\n if vn[cs] is None:\n vn[cs] = Node(self.sigma, vn.depth + 1)\n vn = vn[cs]\n vn.end = True\n\nans = 0\n\nN, L = list(map(int, readline().split()))\n\nTr = Trie(2)\n\nfor _ in range(N):\n S = list(map(int, readline().strip()))\n Tr.add(S)\n\ncnt = 0\nstack = [Tr.root]\nwhile stack:\n vn = stack.pop()\n for i in range(2):\n if vn[i] is None:\n r = L - vn.depth\n cnt ^= -r&r\n else:\n stack.append(vn[i])\n\nprint(('Alice' if cnt else 'Bob'))\n", "N, L = map(int, input().split())\n\nmake = lambda:[None, None, 0]\nroot = make()\ndef construct(s):\n n = root\n for i in s:\n if n[i] is None:\n n[i] = n = make()\n else:\n n = n[i]\n n[2] = 1\n\nfor i in range(N):\n s = map(int, input())\n construct(s)\n\ncaps = {}\nst = [(root, 0, 0)]\nwhile st:\n n, i, l = st.pop()\n if i:\n if n[1] is None:\n caps[L - l] = caps.get(L - l, 0) + 1\n else:\n if not n[1][2]:\n st.append((n[1], 0, l+1))\n else:\n st.append((n, 1, l))\n if n[0] is None:\n caps[L - l] = caps.get(L - l, 0) + 1\n else:\n if not n[0][2]:\n st.append((n[0], 0, l+1))\nans = 0\nfor v in caps:\n k = caps[v]\n if k % 2 == 0:\n continue\n v -= 1\n r = 1\n while v % 4 == 3:\n v //= 4\n r *= 4\n if v % 4 == 1:\n ans ^= r * 2\n else:\n ans ^= r\nprint('Alice' if ans else 'Bob')", "import sys\n#from collections import defaultdict\nsys.setrecursionlimit(10**6)\n\ndef input():\n\treturn sys.stdin.readline()[:-1]\nn, l = list(map(int, input().split()))\nss = [list(input())[::-1] for _ in range(n)]\n\ndef addTree(tree, sentence):\n\tif not sentence:\n\t\treturn None \n\n\tif sentence[-1] not in tree:\n\t\ttree[sentence[-1]] = {}\n\n\tp = sentence.pop()\n\ttree[p] = addTree(tree[p], sentence)\n\n\treturn tree\n\ndef createTree(sentences): \n\ttree = {}\n\tfor sentence in sentences:\n\t\ttree = addTree(tree, sentence)\n\n\treturn tree\n\ntree = createTree(ss)\n#print(tree)\n\ngrundy = 0\ndef dfs(cur, level):\n\tnonlocal grundy\n\tif cur is None:\n\t\treturn\n\telif len(cur) == 1:\n\t\tgrundy ^= (l-level) & (-l+level)\n\tfor k in list(cur.keys()):\n\t\tdfs(cur[k], level+1)\n\treturn\n\t\ndfs(tree, 0)\n\nif grundy == 0:\n\tprint(\"Bob\")\nelse:\n\tprint(\"Alice\")\n", "import random\nN, L = list(map(int,input().split()))\nM = 2*10**5+1\nsets = [set() for _ in range(M+1)]\n\nMOD = 282525872416376072492401\nr_max = 10**6\ninv_t = [0,1]\nfor i in range(2,r_max+1):\n #print(MOD % i)\n inv_t.append(inv_t[MOD % i] * (MOD - MOD // i) % MOD)\nr = random.randint(10**5, r_max)\nrinv = inv_t[r]\n#print(r, rinv)\n\ndef has(s):\n ans = 0\n i = 0\n for x in s:\n ans *= r\n ans += int(x) + (i+1)**2\n ans %= MOD\n i += 1\n return ans % MOD\ndef tract(x, s, l):\n return ((x - int(s) - l**2) * rinv ) %MOD\n \nstrs = []\ndic = {}\nct = 0\nfor i in range(N):\n s = input()\n strs.append(s)\n sets[len(s)].add(has(s))\n if has(s) in dic:\n print((\"warning!!\", s))\n ct += 1\n dic[has(s)] = i\n#print(ct)\n#print(sets[0:3])\n#print(dic)\nfree_num = [0 for _ in range(M+1)]\nfor l in range(M,0,-1):\n while len(sets[l]) > 0:\n x = sets[l].pop()\n #print(x, dic[x], strs[dic[x]], l)\n #if l-1 > len(strs[dic[x]]):\n #print(l-1, x, dic[x], strs[dic[x]], sets[l])\n last = strs[dic[x]][l-1]\n x_p = tract(x, last, l)\n sets[l-1].add(x_p) \n dic[x_p] = dic[x]\n x_anti = (x_p*r + 1-int(last) + l**2) % MOD\n if x_anti in sets[l]:\n sets[l].remove(x_anti)\n else:\n free_num[l] += 1\n #print(l, x, free_num[0:2],sets[0:3], x_p, x_anti, last)\n#print(free_num[0:100])\nGrandy = 0\nfor i in range(M+1):\n G_base = L - i + 1\n if free_num[i] % 2 == 1:\n #print(i, G_base)\n Grandy ^= (G_base & -G_base)\n#print(Grandy) \nprint((\"Alice\" if Grandy > 0 else \"Bob\"))\n \n#print(2**54 & -2**54, 2**54) \n \n", "import sys\n\nsys.setrecursionlimit(100000)\n\n\ndef dfs(cur, dep=0):\n if cur == -1:\n x = l - dep\n return x & -x\n return dfs(trie[cur][0], dep + 1) ^ dfs(trie[cur][1], dep + 1)\n\n\nn, l = list(map(int, input().split()))\ntrie = [[-1, -1] for _ in range(100001)]\nidx = 1\nfor s in (input() for _ in range(n)):\n cur = 0\n for c in map(int, s):\n if trie[cur][c] == -1:\n trie[cur][c] = idx\n idx += 1\n cur = trie[cur][c]\n\nxor = dfs(trie[0][0]) ^ dfs(trie[0][1])\nprint(('Alice' if xor else 'Bob'))\n", "import sys\nreadline = sys.stdin.readline\n\nclass Node:\n def __init__(self, sigma, depth):\n self.end = False\n self.child = [None] * sigma\n self.depth = depth\n def __setitem__(self, i, x):\n self.child[i] = x\n def __getitem__(self, i):\n return self.child[i]\n\nsigma = 2\nroot = Node(sigma, 0)\ndef add_trie(S):\n vn = root\n for cs in S:\n if vn[cs] is None:\n vn[cs] = Node(sigma, vn.depth + 1)\n vn = vn[cs]\n vn.end = True\n\nans = 0\n\nN, L = map(int, readline().split())\n\nfor _ in range(N):\n S = list(map(int, readline().strip()))\n add_trie(S)\n\ncnt = 0\nstack = [root]\nwhile stack:\n vn = stack.pop()\n for i in range(2):\n if vn[i] is None:\n r = L - vn.depth\n cnt ^= -r&r\n else:\n stack.append(vn[i])\n\nprint('Alice' if cnt else 'Bob')", "def getGrundyNumber(x):\n ans = 1\n while x % (ans * 2) == 0:\n ans *= 2\n return ans\n\n\nN, L = list(map(int, input().split()))\nSs = [input() for i in range(N)]\n\nSs.sort()\n\nHgts = {L: 2}\nprev = '_'\nfor S in Ss:\n for iS, (a, b) in enumerate(zip(prev, S)):\n if a != b:\n Hgts[L - iS] -= 1\n for h in range(L - len(S) + 1, L - iS):\n Hgts[h] = Hgts.get(h, 0) + 1\n break\n prev = S\n\nans = 0\nfor Hgt, num in list(Hgts.items()):\n if num % 2:\n ans ^= getGrundyNumber(Hgt)\n\nif ans:\n print('Alice')\nelse:\n print('Bob')\n", "def main():\n N,L = map(int,input().split())\n keys = []\n grundy_num=0\n if N==1:\n print(\"Alice\")\n return\n for i in range(N):\n s = input()\n #merge node:\n while len(s)>0:\n if s[-1]=='1' and s[:-1]+'0' in keys:\n keys.remove(s[:-1]+'0')\n s = s[:-1]\n elif s[-1]=='0' and s[:-1]+'1' in keys:\n keys.remove(s[:-1]+'1')\n s = s[:-1]\n else:\n if s!=\"\":\n keys.append(s)\n break\n if len(keys):\n keys = sorted(keys,key=len,reverse=True)\n grundy_list = []\n while len(keys):\n j = keys[0]\n keys.remove(j)\n temp_s = list(reversed(bin(L-len(j)+1)))\n grundy_list.append(1 << temp_s.index('1'))\n if j[:-1]!=\"\":\n keys.append(j[:-1])\n j = j[:-1]\n #merge node\n while len(j)>0:\n if j[-1]=='1' and j[:-1]+'0' in keys:\n keys.remove(j[:-1]+'0')\n keys.remove(j)\n j = j[:-1]\n if j!=\"\":\n keys.append(j)\n elif j[-1]=='0' and j[:-1]+'1' in keys:\n keys.remove(j[:-1]+'1')\n keys.remove(j)\n j = j[:-1]\n if j!=\"\":\n keys.append(j)\n else:\n break\n keys = sorted(keys,key=len,reverse=True)\n grundy_num = grundy_list[0]\n for i in range(1,len(grundy_list)):\n grundy_num = grundy_num^grundy_list[i]\n print(\"Bob\" if grundy_num==0 else \"Alice\")\n\n\ndef __starting_point():\n main()\n__starting_point()", "from collections import defaultdict\nimport sys\n\nsys.setrecursionlimit(10 ** 6)\ninput = sys.stdin.readline\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\n\ndef main():\n n, l = map(int, input().split())\n ss = [input()[:-1] for _ in range(n)] + [\"$\"]\n ss.sort()\n # print(ss)\n\n # \u96a3\u540c\u58eb\u306es\u3092\u5148\u982d\u304b\u3089\u6bd4\u3079\u3066\u3001\u7570\u306a\u308b\u3068\u3053\u308d\u3067\u305d\u306elevel\u306e\u6728\u3092\u6d88\u3057\u3066\u3001\u305d\u308c\u4ee5\u964d\u306e\u6728\u3092\u8ffd\u52a0\u3059\u308b\n cnt_tree = defaultdict(int)\n cnt_tree[l] = 2\n for s0, s1 in zip(ss, ss[1:]):\n for depth, (c0, c1) in enumerate(zip(s0, s1)):\n if c0 == c1: continue\n cnt_tree[l - depth] -= 1\n for lv in range(l - depth - 1, l - len(s1), -1):\n cnt_tree[lv] += 1\n # print(cnt_tree)\n break\n\n # Grundy\u6570\u3092lv & -lv\u3067\u6c42\u3081\u3001xor\u3092\u3068\u308b\n sum_xor = 0\n for lv, cnt in cnt_tree.items():\n if cnt % 2 == 0: continue\n sum_xor ^= lv & -lv\n\n if sum_xor:\n print(\"Alice\")\n else:\n print(\"Bob\")\n\nmain()\n", "from functools import cmp_to_key\n\n\ndef f(s, t):\n m = min(len(s), len(t))\n if s[:m] > t[:m]:\n return 1\n elif s[:m] < t[:m]:\n return -1\n else:\n if len(s) > len(t):\n return -1\n else:\n return 1\n\n\ndef ms(s, t):\n i = 0\n for c1, c2 in zip(s, t):\n if c1 != c2:\n return i\n i += 1\n return i\n\n\ndef xxor(x):\n if x & 3 == 0:\n return x\n if x & 3 == 1:\n return 1\n if x & 3 == 2:\n return x + 1\n if x & 3 == 3:\n return 0\n\n\ndef gray(x):\n return x ^ (x // 2)\n\n\nn, l = list(map(int, input().split()))\ns = [input() for _ in range(n)]\ns.sort(key=cmp_to_key(f))\ng = gray(l) ^ gray(l - len(s[0]))\nfor i in range(n - 1):\n b = ms(s[i], s[i + 1]) + 1\n g ^= gray(l - b + 1) ^ gray(l - b)\n t = len(s[i + 1]) - b\n g ^= gray(l - b) ^ gray(l - b - t)\nif g == 0:\n print('Bob')\nelse:\n print('Alice')\n", "def main():\n import sys\n input = sys.stdin.readline\n\n class TreiNode:\n def __init__(self, char_num, depth):\n self.end = False\n self.child = [None] * char_num\n self.depth = depth\n\n def __setitem__(self, i, x):\n self.child[i] = x\n\n def __getitem__(self, i):\n return self.child[i]\n\n class Trei:\n def __init__(self, char_num):\n self.root = TreiNode(char_num, 0)\n self.char_num = char_num\n\n def add(self, S):\n v = self.root\n for s in S:\n if v[s] is None:\n v[s] = TreiNode(self.char_num, v.depth + 1)\n v = v[s]\n v.end = True\n\n def exist(self, S):\n v = self.root\n for s in S:\n if v[s] is None:\n return False\n v = v[s]\n if v.end:\n return True\n else:\n return False\n\n N, L = list(map(int, input().split()))\n T = Trei(2)\n for _ in range(N):\n S = input().rstrip('\\n')\n S = [int(s) for s in S]\n T.add(S)\n\n g = 0\n st = [T.root]\n while st:\n v = st.pop()\n for i in range(2):\n if v[i] is None:\n d = L - v.depth\n g ^= d & -d\n else:\n st.append(v[i])\n if g:\n print('Alice')\n else:\n print('Bob')\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import sys\ninput=sys.stdin.readline\nsys.setrecursionlimit(10**9)\nfrom collections import deque\n\nclass Node:\n def __init__(self,depth):\n self.depth=depth\n self.left=None\n self.right=None\n\ndef insert(node,s):\n n=node\n for i in range(len(s)):\n t=s[i]\n if t=='0':\n if n.left is None:\n n.left=Node(i+1)\n n=n.left\n else:\n if n.right is None:\n n.right=Node(i+1)\n n=n.right\n\nclass Trie:\n def __init__(self):\n self.root=Node(0)\n def insert(self,s:str):\n insert(self.root,s)\n\nn,l=map(int,input().split())\nS=[input().strip() for _ in range(n)]\ntrie=Trie()\nfor s in S:\n trie.insert(s)\nData=[]\nq=deque([trie.root])\n\ndef dfs(node):\n if node.right is None and node.left is None:\n return\n if node.right is None or node.left is None:\n Data.append(l-node.depth)\n if node.right:\n q.append(node.right)\n if node.left:\n q.append(node.left)\n\nwhile q:\n dfs(q.popleft())\nxor=0\n\ndef Grundy(n):\n ret=1\n while n%2==0:\n n//=2\n ret*=2\n return ret\n\nfor i in Data:\n xor^=Grundy(i)\nprint('Alice' if xor else 'Bob')", "import sys\nfrom collections import deque\n\nsys.setrecursionlimit(10000)\nINF = float('inf')\n\nN, L = list(map(int, input().split()))\nS = set()\nfor _ in range(N):\n S.add(input())\n\n\n# \u8ffd\u52a0\u3067\u304d\u308b\u306e\u304c 01... \u3060\u3051\u3067\n# L \u304c 4 \u3068\u3059\u308b\u3068\n# 01: \u6b21\u306f\u306a\u3044\n# 010: 011 \u304c\u3042\u308b\n# 011: 010 \u304c\u3042\u308b\n# 0100: 011, 0101 \u304c\u3042\u308b\n# 0101: 011, 0100\n# 0110: 010, 0111\n# 0111: 010, 0110\n# \u5019\u88dc\u306e\u9577\u3055\u3068 L \u3060\u3051\u306b\u3088\u3063\u3066\u6b21\u306e\u5019\u88dc\u306e\u9577\u3055\u3068\u6570\u304c\u6c7a\u307e\u308b\ndef grundy(size):\n \"\"\"\n :param int size: \u5019\u88dc\u306e\u9577\u3055\n :return:\n \"\"\"\n # gs = {0}\n # g = 0\n # for sz in range(size + 1, L + 1):\n # g ^= grundy(sz)\n # gs.add(g)\n #\n # i = 0\n # while i in gs:\n # i += 1\n # return i\n i = 1\n while (L - size + 1) % i == 0:\n i *= 2\n return i // 2\n\n\n# S \u306e\u5404\u8981\u7d20\u304b\u3089\u30c8\u30e9\u30a4\u6728\u3064\u304f\u308b\ntrie = {}\nfor s in S:\n t = trie\n for c in s:\n if c not in t:\n t[c] = {}\n t = t[c]\n\n# \u5019\u88dc\u6587\u5b57\u5217\u306e\u9577\u3055\u306e\u30ea\u30b9\u30c8\nok_size_list = []\nchildren = deque()\nchildren.append((trie, 0))\nwhile len(children) > 0:\n node, size = children.popleft()\n # 0 \u304b 1 \u304b\u7247\u65b9\u3057\u304b\u884c\u3051\u306a\u304b\u3063\u305f\u3089\u3001\u884c\u3051\u306a\u3044\u65b9\u306f S \u306e prefix \u306b\u306a\u3089\u306a\u3044\n # \u4e21\u65b9\u884c\u3051\u306a\u3044\u5834\u5408\u306f\u3069\u3046\u8ffd\u52a0\u3057\u3066\u3082 S \u306e\u3044\u305a\u308c\u304b\u304c prefix \u306b\u306a\u3063\u3066\u3057\u307e\u3046\u304b\u3089\u30c0\u30e1\n if len(node) == 1:\n ok_size_list.append(size + 1)\n for c, child in node.items():\n children.append((child, size + 1))\n\ng = 0\nfor size in ok_size_list:\n g ^= grundy(size)\nif g != 0:\n print('Alice')\nelse:\n print('Bob')"] | {"inputs": ["2 2\n00\n01\n", "2 2\n00\n11\n", "3 3\n0\n10\n110\n", "2 1\n0\n1\n", "1 2\n11\n", "2 3\n101\n11\n"], "outputs": ["Alice\n", "Bob\n", "Alice\n", "Bob\n", "Alice\n", "Bob\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 36,890 | |
79f02cca5656f367ddb95d9fe5615b76 | UNKNOWN | Zookeeper is buying a carton of fruit to feed his pet wabbit. The fruits are a sequence of apples and oranges, which is represented by a binary string $s_1s_2\ldots s_n$ of length $n$. $1$ represents an apple and $0$ represents an orange.
Since wabbit is allergic to eating oranges, Zookeeper would like to find the longest contiguous sequence of apples. Let $f(l,r)$ be the longest contiguous sequence of apples in the substring $s_{l}s_{l+1}\ldots s_{r}$.
Help Zookeeper find $\sum_{l=1}^{n} \sum_{r=l}^{n} f(l,r)$, or the sum of $f$ across all substrings.
-----Input-----
The first line contains a single integer $n$ $(1 \leq n \leq 5 \cdot 10^5)$.
The next line contains a binary string $s$ of length $n$ $(s_i \in \{0,1\})$
-----Output-----
Print a single integer: $\sum_{l=1}^{n} \sum_{r=l}^{n} f(l,r)$.
-----Examples-----
Input
4
0110
Output
12
Input
7
1101001
Output
30
Input
12
011100011100
Output
156
-----Note-----
In the first test, there are ten substrings. The list of them (we let $[l,r]$ be the substring $s_l s_{l+1} \ldots s_r$): $[1,1]$: 0 $[1,2]$: 01 $[1,3]$: 011 $[1,4]$: 0110 $[2,2]$: 1 $[2,3]$: 11 $[2,4]$: 110 $[3,3]$: 1 $[3,4]$: 10 $[4,4]$: 0
The lengths of the longest contiguous sequence of ones in each of these ten substrings are $0,1,2,2,1,2,2,1,1,0$ respectively. Hence, the answer is $0+1+2+2+1+2+2+1+1+0 = 12$. | ["class SegmentTree:\n def __init__(self, data, default=0, func=max):\n \"\"\"initialize the segment tree with data\"\"\"\n self._default = default\n self._func = func\n self._len = len(data)\n self._size = _size = 1 << (self._len - 1).bit_length()\n\n self.data = [default] * (2 * _size)\n self.data[_size:_size + self._len] = data\n for i in reversed(list(range(_size))):\n self.data[i] = func(self.data[i + i], self.data[i + i + 1])\n\n def __delitem__(self, idx):\n self[idx] = self._default\n\n def __getitem__(self, idx):\n return self.data[idx + self._size]\n\n def __setitem__(self, idx, value):\n idx += self._size\n self.data[idx] = value\n idx >>= 1\n while idx:\n self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])\n idx >>= 1\n\n def __len__(self):\n return self._len\n\n def query(self, start, stop):\n \"\"\"func of data[start, stop)\"\"\"\n start += self._size\n stop += self._size\n\n res_left = res_right = self._default\n while start < stop:\n if start & 1:\n res_left = self._func(res_left, self.data[start])\n start += 1\n if stop & 1:\n stop -= 1\n res_right = self._func(self.data[stop], res_right)\n start >>= 1\n stop >>= 1\n\n return self._func(res_left, res_right)\n\n def __repr__(self):\n return \"SegmentTree({0})\".format(self.data)\n\n\nn = int(input())\ns = input()\n\npref = []\ncurr = 0\nfor c in s:\n if c == '1':\n curr += 1\n else:\n curr = 0\n pref.append(curr)\n\nsuff = []\ncurr = 0\nfor c in s[::-1]:\n if c == '1':\n curr += 1\n else:\n curr = 0\n suff.append(curr)\nsuff.reverse()\n \n\nst = SegmentTree(suff)\n\nout = 0\nadd = 0\nfor i in range(n):\n if s[i] == '1':\n lo = -1\n hi = i - pref[i] + 1\n while hi - lo > 1:\n t = (lo + hi) // 2\n if st.query(t, i - pref[i] + 1) >= pref[i]:\n lo = t\n else:\n hi = t\n add += (i - lo)\n #print(add)\n out += add\nprint(out)\n \n", "n = int(input())\na = list(map(int, input()))\n\nacc = 0\nback = 0\ntop = 0\ncur = 0\ns = []\n\nfor i,x in enumerate(a):\n\tif x == 0:\n\t\tcur = 0\n\telse:\n\t\tif cur > 0:\n\t\t\ts.pop()\n\t\tcur += 1\n\t\tif cur >= top:\n\t\t\ttop = cur\n\t\t\tback = (cur + 1) * (cur) // 2 + (i - cur + 1) * cur\n\t\t\ts = [(cur, i)]\n\t\telse:\n\t\t\tback += i - (s[-1][1] - cur + 1)\n\t\t\tif cur >= s[-1][0]:\n\t\t\t\ts.pop()\n\t\t\ts += [(cur, i)]\n\tacc += back\n\t#print(i,x,acc, back, top, cur)\n\t#print(s)\n\n\nprint(acc)\n", "import math,sys\nn=int(input())\ns=input()\ndp=[0]*(n+1)\ncurrlength=0\nd=[-1]*(n+1)\nfor i in range(n):\n if s[i]=='0':\n dp[i+1]=dp[i]\n if currlength>0:\n for j in range(currlength):\n d[j+1]=i-j-1\n currlength=0\n else:\n currlength+=1\n numsegs=i-d[currlength]-1\n dp[i+1]=dp[i]+numsegs+1\nprint(sum(dp))", "\nfrom sys import stdin\nimport sys\nimport heapq\n\ndef bitadd(a,w,bit):\n \n x = a+1\n while x <= (len(bit)-1):\n bit[x] += w\n x += x & (-1 * x)\n \ndef bitsum(a,bit):\n \n ret = 0\n x = a+1\n while x > 0:\n ret += bit[x]\n x -= x & (-1 * x)\n return ret\n\nn = int(stdin.readline())\ns = stdin.readline()[:-1]\n\nbit = [0] * (n+10)\ndp = [0] * (n+10)\n\ny = 0\nans = 0\nfor i in range(n):\n\n if s[i] == \"0\":\n while y > 0:\n dp[y] += 1\n bitadd(y,y,bit)\n y -= 1\n dp[0] += 1\n else:\n bitadd(y,-1*dp[y]*y,bit)\n bitadd(y+1,-1*dp[y+1]*(y+1),bit)\n dp[y+1] += dp[y]\n dp[y] = 0\n y += 1\n bitadd(y,dp[y]*y,bit)\n \n now = bitsum(i,bit) + (1+y)*y//2\n #print (bitsum(i,bit),(1+y)*y//2,dp)\n ans += now\n \nprint (ans)", "import sys\nreadline = sys.stdin.readline\n\nN = int(readline())\nA = list(map(int, readline().strip()))\ndef calc(l, r):\n m = (l+r)//2\n if l+1 == r:\n return A[l]\n if l+2 == r:\n return 2*(A[l]+A[l+1])\n X = A[l:m][::-1]\n Y = A[m:r]\n LX = len(X)\n LY = len(Y)\n a1 = [0]*LX\n a2 = [0]*LY\n pre = 1\n cnt = 0\n b1 = 0\n b2 = 0\n for i in range(LX):\n if X[i]:\n cnt += 1\n if pre:\n a1[i] = cnt\n b1 = cnt\n else:\n a1[i] = max(a1[i-1], cnt)\n else:\n pre = 0\n cnt = 0\n a1[i] = a1[i-1]\n pre = 1\n cnt = 0\n for i in range(LY):\n if Y[i]:\n cnt += 1\n if pre:\n a2[i] = cnt\n b2 = cnt\n else:\n a2[i] = max(a2[i-1], cnt)\n else:\n pre = 0\n cnt = 0\n a2[i] = a2[i-1]\n \n \n ra = LX-1\n rb = LY-1\n i = ra\n j = rb\n res = 0\n for _ in range(LX+LY):\n if a1[i] >= a2[j]:\n a = a1[i]\n if b1+b2 <= a:\n res += a*(j+1)\n elif a == b1:\n res += b1*b2 + b2*(b2+1)//2 + (b1+b2)*(j+1-b2)\n else:\n res += a*b2 + (b1+b2-a)*(b1+b2-a+1)//2+(b1+b2)*(j+1-b2)\n i -= 1\n b1 = min(b1, i+1)\n else:\n a = a2[j]\n if b1+b2 <= a:\n res += a*(i+1)\n elif a == b2:\n res += b1*b2 + b1*(b1+1)//2 + (b1+b2)*(i+1-b1)\n else:\n res += a*b1 + (b1+b2-a)*(b1+b2-a+1)//2+(b1+b2)*(i+1-b1)\n j -= 1\n b2 = min(b2, j+1)\n if i == -1 or j == -1:\n break\n return res + calc(l, m) + calc(m, r)\n\nprint(calc(0, N))\n\n \n \n"] | {
"inputs": [
"4\n0110\n",
"7\n1101001\n",
"12\n011100011100\n",
"100\n0110110011011111001110000110010010000111111001100001011101101000001011001101100111011111100111101110\n",
"1\n0\n"
],
"outputs": [
"12\n",
"30\n",
"156\n",
"23254\n",
"0\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 6,030 | |
75372005c0cf002ff1c16ab4973ec262 | UNKNOWN | A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.
Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.
You are given a regular bracket sequence $s$ and an integer number $k$. Your task is to find a regular bracket sequence of length exactly $k$ such that it is also a subsequence of $s$.
It is guaranteed that such sequence always exists.
-----Input-----
The first line contains two integers $n$ and $k$ ($2 \le k \le n \le 2 \cdot 10^5$, both $n$ and $k$ are even) — the length of $s$ and the length of the sequence you are asked to find.
The second line is a string $s$ — regular bracket sequence of length $n$.
-----Output-----
Print a single string — a regular bracket sequence of length exactly $k$ such that it is also a subsequence of $s$.
It is guaranteed that such sequence always exists.
-----Examples-----
Input
6 4
()(())
Output
()()
Input
8 8
(()(()))
Output
(()(())) | ["n, k = map(int, input().split())\na = [0] * n\nb = ['0'] * n\nc = []\ns = input()\nfor i in range(n):\n if k != 0:\n if s[i] == '(':\n c.append(i)\n else:\n d = c.pop()\n a[i] = 1\n a[d] = 1\n k -= 2\nfor i in range(n):\n if a[i] == 1:\n print(s[i], end = '')\n"] | {
"inputs": [
"6 4\n()(())\n",
"8 8\n(()(()))\n",
"20 10\n((()))()((()()(())))\n",
"40 30\n((((((((()()()))))))))((())((()())))(())\n",
"2 2\n()\n"
],
"outputs": [
"()()\n",
"(()(()))\n",
"((()))()()\n",
"((((((((()()()))))))))(())()()\n",
"()\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 347 | |
ce8914d9f9ad0bb74359523b4c5d2498 | UNKNOWN | There are $n$ persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of $m$ days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold: Either this person does not go on the trip, Or at least $k$ of his friends also go on the trip.
Note that the friendship is not transitive. That is, if $a$ and $b$ are friends and $b$ and $c$ are friends, it does not necessarily imply that $a$ and $c$ are friends.
For each day, find the maximum number of people that can go on the trip on that day.
-----Input-----
The first line contains three integers $n$, $m$, and $k$ ($2 \leq n \leq 2 \cdot 10^5, 1 \leq m \leq 2 \cdot 10^5$, $1 \le k < n$) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The $i$-th ($1 \leq i \leq m$) of the next $m$ lines contains two integers $x$ and $y$ ($1\leq x, y\leq n$, $x\ne y$), meaning that persons $x$ and $y$ become friends on the morning of day $i$. It is guaranteed that $x$ and $y$ were not friends before.
-----Output-----
Print exactly $m$ lines, where the $i$-th of them ($1\leq i\leq m$) contains the maximum number of people that can go on the trip on the evening of the day $i$.
-----Examples-----
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
-----Note-----
In the first example, $1,2,3$ can go on day $3$ and $4$.
In the second example, $2,4,5$ can go on day $4$ and $5$. $1,2,4,5$ can go on day $6$ and $7$. $1,2,3,4,5$ can go on day $8$.
In the third example, $1,2,5$ can go on day $5$. $1,2,3,5$ can go on day $6$ and $7$. | ["from collections import deque\n\ndef solve(adj, m, k, uv):\n n = len(adj)\n nn = [len(a) for a in adj]\n q = deque()\n for i in range(n):\n if nn[i] < k:\n q.append(i)\n while q:\n v = q.popleft()\n for u in adj[v]:\n nn[u] -= 1\n if nn[u] == k-1:\n q.append(u)\n res = [0]*m\n nk = len([1 for i in nn if i >= k])\n res[-1] = nk\n for i in range(m-1, 0, -1):\n u1, v1 = uv[i]\n\n if nn[u1] < k or nn[v1] < k:\n res[i - 1] = nk\n continue\n if nn[u1] == k:\n q.append(u1)\n nn[u1] -= 1\n if not q and nn[v1] == k:\n q.append(v1)\n nn[v1] -= 1\n\n if not q:\n nn[u1] -= 1\n nn[v1] -= 1\n adj[u1].remove(v1)\n adj[v1].remove(u1)\n\n while q:\n v = q.popleft()\n nk -= 1\n for u in adj[v]:\n nn[u] -= 1\n if nn[u] == k - 1:\n q.append(u)\n res[i - 1] = nk\n return res\n\nn, m, k = map(int, input().split())\na = [set() for i in range(n)]\nuv = []\nfor i in range(m):\n u, v = map(int, input().split())\n a[u - 1].add(v - 1)\n a[v - 1].add(u - 1)\n uv.append((u-1, v-1))\n\nres = solve(a, m, k, uv)\nprint(str(res)[1:-1].replace(' ', '').replace(',', '\\n'))"] | {
"inputs": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n",
"2 1 1\n2 1\n",
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n"
],
"outputs": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n",
"2\n",
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,410 | |
ec9e7af4e6febf10ef3a517312af422a | UNKNOWN | Little Nastya has a hobby, she likes to remove some letters from word, to obtain another word. But it turns out to be pretty hard for her, because she is too young. Therefore, her brother Sergey always helps her.
Sergey gives Nastya the word t and wants to get the word p out of it. Nastya removes letters in a certain order (one after another, in this order strictly), which is specified by permutation of letters' indices of the word t: a_1... a_{|}t|. We denote the length of word x as |x|. Note that after removing one letter, the indices of other letters don't change. For example, if t = "nastya" and a = [4, 1, 5, 3, 2, 6] then removals make the following sequence of words "nastya" $\rightarrow$ "nastya" $\rightarrow$ "nastya" $\rightarrow$ "nastya" $\rightarrow$ "nastya" $\rightarrow$ "nastya" $\rightarrow$ "nastya".
Sergey knows this permutation. His goal is to stop his sister at some point and continue removing by himself to get the word p. Since Nastya likes this activity, Sergey wants to stop her as late as possible. Your task is to determine, how many letters Nastya can remove before she will be stopped by Sergey.
It is guaranteed that the word p can be obtained by removing the letters from word t.
-----Input-----
The first and second lines of the input contain the words t and p, respectively. Words are composed of lowercase letters of the Latin alphabet (1 ≤ |p| < |t| ≤ 200 000). It is guaranteed that the word p can be obtained by removing the letters from word t.
Next line contains a permutation a_1, a_2, ..., a_{|}t| of letter indices that specifies the order in which Nastya removes letters of t (1 ≤ a_{i} ≤ |t|, all a_{i} are distinct).
-----Output-----
Print a single integer number, the maximum number of letters that Nastya can remove.
-----Examples-----
Input
ababcba
abb
5 3 4 1 7 6 2
Output
3
Input
bbbabb
bb
1 6 3 4 2 5
Output
4
-----Note-----
In the first sample test sequence of removing made by Nastya looks like this:
"ababcba" $\rightarrow$ "ababcba" $\rightarrow$ "ababcba" $\rightarrow$ "ababcba"
Nastya can not continue, because it is impossible to get word "abb" from word "ababcba".
So, Nastya will remove only three letters. | ["def sub(a, s):\n pa = 0\n ps = 0\n while pa < len(a) and ps < len(s):\n if a[pa] == s[ps]:\n ps += 1\n pa += 1\n else:\n pa += 1\n\n return ps == len(s)\n\ndef subword(t, ord_ar, n):\n t_copy = []\n for i in range(len(ord_ar)):\n if ord_ar[i] >= n:\n t_copy.append(t[i])\n return t_copy\n\ndef check(t, p, ord_ar, n):\n s = subword(t, ord_ar, n)\n return sub(s, p)\n\ndef bin_s(l, r, f):\n while r > l + 1:\n m = (r + l) // 2\n if f(m):\n l = m\n else:\n r = m\n return l\n\n\n\ndef main():\n t = input().strip()\n p = input().strip()\n ord_ar = [0]*len(t)\n \n seq = list(map(int, input().strip().split()))\n for i,x in enumerate(seq):\n ord_ar[x-1] = i\n\n ans = bin_s(0, len(t), lambda n: check(t, p, ord_ar, n))\n print(ans)\n\nmain()\n", "def possible(t,p,a,n):\n s = ''\n check = [True]*len(t)\n for i in range(n):\n check[a[i]] = False\n for i in range(len(check)):\n if check[i]:\n s += t[i]\n \n m = len(s)\n lp = len(p)\n c = 0\n for i in range(m):\n if s[i] == p[c]:\n c += 1\n if c == lp:\n return True\n return False \n \nt = input()\np = input()\na = list(map(int,input().split()))\nfor i in range(len(a)):\n a[i] -= 1\n\nlow = 0\nhigh = len(a)\nans = 0\nwhile low <= high:\n mid = (low+high)//2\n if possible(t,p,a,mid):\n ans = mid\n low = mid+1\n else:\n high = mid-1\nprint(ans) ", " \nt = input()\np = input()\na = [i-1 for i in list(map(int,input().split()))]\nmin1 = 0\nmax1 = len(t)\nwhile(max1-min1)>1:\n med = min1+(max1-min1)//2\n j=0\n d=list(t)\n for i in range(med):\n d[a[i]]=''\n for i in range(len(t)):\n if d[i]==p[j]:\n j+=1\n if j==len(p):\n min1=med\n break\n if j!=len(p):\n max1=med\nprint(min1)\n", "\ndef main():\n a_string = input()\n b_string = input()\n moves = [int(x) for x in input().split()]\n index_of_move = {}\n lenb = len(b_string)\n\n for index, elem in enumerate(moves):\n index_of_move[elem] = index + 1\n\n l = 0\n r = len(moves) - 1\n while l < r:\n middle = int((l + r + 1) / 2)\n bi = 0\n i = 0\n\n for index, elem in enumerate(a_string):\n #if (index + 1) in moves[:(middle + 1)]:\n # continue\n if index_of_move[index + 1] <= middle + 1:\n continue\n if elem is b_string[bi]:\n bi += 1\n if bi >= lenb:\n break\n\n if bi >= lenb:\n l = middle\n else:\n r = middle - 1\n\n if l is 0 and r is 0:\n bi = 0\n for index, elem in enumerate(a_string):\n if index_of_move[index + 1] <= 1:\n continue\n if elem is b_string[bi]:\n bi += 1\n if bi >= lenb:\n break\n if bi >= lenb:\n print(1)\n else:\n print(0)\n else:\n print(l + 1)\n\ndef __starting_point():\n main()\n\n__starting_point()", "#!/usr/bin/env python3\n# -*- coding = 'utf-8' -*-\n\nt = input()\np = input()\na = list(map(int, input().split()))\n\ndef can(s, p):\n i = 0\n for ch in s:\n if ch == p[i]:\n i += 1\n if i == len(p):\n return True\n\n return False\n\ndef binary_search(l, r):\n \n while(l < r - 1):\n s = list(t)\n mid = (l + r)//2\n\n for index in range(mid):\n s[a[index] - 1] = ' '\n \n ok = False\n i = 0\n for ch in s:\n if ch == p[i]:\n i += 1\n if i == len(p):\n ok = True\n break\n if ok:\n l = mid\n else:\n r = mid\n\n return l\n\nprint(binary_search(0, len(a) + 1))\n", "a=input()\nb=input()\nc=[i-1 for i in list(map(int,input().split()))]\nl=0\nr=len(a)\nwhile r-l>1:\n m=l+(r-l)//2\n t=list(a)\n j=0\n for i in range(m):t[c[i]]=''\n for i in range(len(a)):\n if t[i]==b[j]:\n j+=1\n if j==len(b):\n l=m;break\n if j!=len(b):r=m\nprint(l)\n", "s = list(input().strip())\nt = input().strip()\nsq = [int(a) for a in input().strip().split()]\nl = len(s)\nlt = len(t)\ndef check(x):\n tmp = s.copy()\n for i in range(x):\n tmp[sq[i]-1] = '_'\n idx = 0\n for i in range(l):\n if tmp[i]==t[idx]:\n idx+=1\n if idx==lt:\n return True\n return False\n\nlow = res = 0\nhigh = l\nwhile(low<=high):\n mid = (low + high) >> 1\n if check(mid):\n low = mid + 1\n res = mid\n else:\n high = mid - 1\nprint(res)", "s = list(input().strip())\nt = input().strip()\nsq = [int(a) for a in input().strip().split()]\nl = len(s)\nlt = len(t)\ndef check(x):\n tmp = s.copy()\n for i in range(x):\n tmp[sq[i]-1] = '_'\n idx = 0\n for i in range(l):\n if tmp[i]==t[idx]:\n idx+=1\n if idx==lt:\n return True\n return False\n\nlow = 0\nhigh = l\nwhile(low<=high):\n mid = (low + high) >> 1\n if check(mid):\n low = mid + 1\n else:\n high = mid - 1\nprint(high)", "def is_subsequence(a, b, idx, top):\n i = 0\n for j, c in enumerate(a):\n if c == b[i] and idx[j+1] > top:\n i += 1\n if i == len(b):\n return True\n return False\n\n\na = input()\nb = input()\nr = list(map(int, input().split()))\nidx = [0 for _ in range(len(r)+1)]\nfor i in range(len(r)):\n idx[r[i]] = i\n\nlo = -1\nhi = len(a)\nwhile hi - lo > 1:\n mi = (lo + hi) // 2\n if is_subsequence(a, b, idx, mi):\n lo = mi\n else:\n hi = mi\n\nprint(lo+1)\n\n#~ for i in range(-1, len(r)+1):\n #~ print(is_subsequence(a, b, idx, i))\n\n", "import sys\n\n# listindexes is sorted\ndef removeat(string, indexes):\n\n return [c for i, c in enumerate(string) if i not in indexes]\n\ndef contains(string, what):\n\n if not len(what):\n return True\n if not len(string):\n return False\n\n checked = 0\n for c in string:\n if what[checked] == c:\n checked += 1\n if checked == len(what):\n break\n\n return checked == len(what)\n\nstring = list(input())\nwhat = list(input())\nindexes = [i-1 for i in map(int, input().split())]\n\nfirst = 0\nlast = len(indexes)-1\n\nwhile first<last:\n\n midpoint = first + (last - first)//2 + (last - first)%2\n \n if contains(removeat(string, set(indexes[:midpoint])), what):\n first = midpoint\n else:\n last = midpoint-1\n\nprint(first)\n\n", "import heapq\nfrom bisect import bisect_left, bisect_right\nfrom itertools import accumulate\n\ndef is_substr(fw, tw, seq):\n i, j = 0, 0\n while i < len(fw) and j < len(tw):\n if i in seq:\n i += 1\n elif fw[i] == tw[j]:\n i, j = i + 1, j + 1\n else:\n i += 1\n return j == len(tw)\n\nR = lambda: map(int, input().split())\nfw, tw = input(), input()\nseq = [i - 1 for i in list(R())]\nl, r = 0, len(seq) - 1\nm, res = 0, 0\nwhile l <= r:\n m = (l + r) // 2\n if is_substr(fw, tw, set(seq[:m])):\n res = max(res, m)\n l = m + 1\n else:\n r = m - 1\nprint(res)", "def subseq (s,b):\n h = iter(b)\n return all(any(l == ch for l in h) for ch in s)\n\nt = input()\np = input()\nnum = [int(x) for x in input().split()]\nst = []\nl = 0\nr = len(num)\nans = r+1\nwhile (l <= r):\n mid = (l+r)//2\n st = list(t)\n c = num[:mid]\n for i in c:\n st[i-1] = ''\n if subseq(p,''.join(st)):\n ans = mid\n l = mid + 1\n else:\n r = mid - 1\nprint(ans)", "def main():\n s, w = ['', *input()], input()\n l = list(map(int, input().split()))\n lo, hi = 0, len(s) - len(w)\n while lo < hi:\n mid, t = (lo + hi) // 2, s[:]\n for i in l[:mid]:\n t[i] = ''\n try:\n i = 1\n for c in w:\n while c != t[i]:\n i += 1\n i += 1\n except IndexError:\n hi = mid\n else:\n lo = mid + 1\n print(lo - 1)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "a=input()\nb=input()\nc=[i-1 for i in list(map(int,input().split()))]\nl=0\nr=len(a)\nwhile r-l>1:\n m=l+(r-l)//2\n t=list(a)\n j=0\n for i in range(m):t[c[i]]=''\n for i in range(len(a)):\n if t[i]==b[j]:\n j+=1\n if j==len(b):\n l=m;break\n if j!=len(b):r=m\nprint(l)\n\n\n\n\n# Made By Mostafa_Khaled\n", "t = input()\np = input()\n\na = list(map(int, input().strip().split()))\na = [ x - 1 for x in a]\nn = len(t)\nm = len(p)\n\n\nlo = 0\nhi = n - 1\n\nwhile lo < hi:\n mid = (lo + hi) >> 1\n \n temp = list(t)\n for x in a[ :mid+1]:\n temp[x] = '_'\n \n ptr, curr = 0, 0\n while ptr < n and curr < m:\n while ptr < n and temp[ptr] != p[curr]:\n ptr += 1\n if ptr < n:\n ptr += 1\n curr += 1\n \n if curr == m:\n lo = mid + 1\n else:\n hi = mid\n\nprint(lo)\n", "t = list(input())\np = list(input())\n\n\ndef has_sub(temp):\n idx = 0\n for c in temp:\n if c == p[idx]:\n idx += 1\n if idx == len(p):\n return True\n\n return False\n\n\narr = list(map(int, input().split()))\n\nleft = 0\nright = len(arr) - 1\n\nwhile left < right:\n mid = (left + right + 1) // 2\n temp = t[:]\n\n for idx in range(mid):\n temp[arr[idx] - 1] = '0'\n\n if has_sub(temp):\n left = mid\n else:\n right = mid - 1\n\nprint(right)\n", "t = input()\np = input()\nai = list(map(int,input().split()))\nn = len(ai)\nti = [[t[i],1] for i in range(n)]\nfor i in range(n):\n ai[i] -= 1\n\nnum2 = 1\n\ndef check(num):\n nonlocal num2\n num2 -= 1\n for i in range(num):\n ti[ai[i]][1] = num2\n num3 = 0\n for i in ti:\n if i[1] == num2:\n continue\n if i[0] == p[num3]:\n num3 += 1\n if num3 == len(p):\n return True\n return False\n\nhigh = n\nlow = 0\nmid = (high + low) // 2\nwhile high >= low:\n if check(mid):\n low = mid + 1\n else:\n high = mid - 1\n mid = (high + low) // 2\n\nprint(mid)\n", "#print('HARE KRISHNA')\nt=input()\np=input()\nblock=[int(i)-1 for i in input().split()]\nind={}\nfor i in range(len(block)):\n ind[block[i]]=i \ndef is_part_and_parcel(s1,s2,mid):\n n=len(s2)\n m=len(s1)\n i=0 \n c=0 \n j=0 \n while i<n and j<m:\n if ind[j]<mid:\n j+=1 \n continue \n if s2[i]==s1[j]:\n i+=1\n j+=1 \n c+=1 \n else:\n j+=1 \n return c==n \nn=len(t)\nm=len(p)\nlo= 0 \nhi=len(block)-1 \nwhile lo<=hi:\n mi=(lo+hi)>>1 \n if is_part_and_parcel(t,p,mi):\n ans=mi \n lo=mi+1 \n else:\n hi=mi-1 \nprint(ans)", "def is_obtained(p, t, K):\n i = 0\n for ch in p:\n i = t.find(ch, i) + 1\n if i == 0:\n return False\n while i in K:\n i = t.find(ch, i) + 1\n if i == 0:\n return False\n return True\n\nI = input\n\nt, p, A = I(), I(), list(map(int, I().split()))\nL, R = 0, len(A) - 1\n\nwhile L < R:\n x = (L + R + 1) // 2\n if is_obtained(p, t, set(A[:x])):\n L = x\n else:\n R = x - 1\n\nprint(L)", "s1 = input()\ns2 = input()\nrs = list(map(int, input().split()))\n\ndef is_in(big, little):\n i, j = 0, 0\n matched = 0\n while i < len(big) and j < len(little):\n if big[i] == little[j]:\n matched += 1\n i +=1\n j += 1\n else:\n i += 1\n if matched < len(little):\n return False\n return True\n\ndef gen_st(mid):\n nonlocal s1, s2, rs\n cs = set(rs[:mid])\n n = []\n for i in range(len(s1)):\n if i+1 in cs:\n continue\n n.append(s1[i])\n #print(''.join(n), s2)\n return is_in(''.join(n), s2)\n\nstart = 0\nend = len(rs)\nweird = False\n#print(gen_st(4))\nwhile start < end:\n #print(start, end)\n mid = (start+end)//2\n if gen_st(mid):\n start = mid\n if start == end-1:\n weird = True\n if gen_st(end):\n print(end)\n break\n else:\n print(start)\n break\n else:\n end = mid - 1\n if not weird and start == end:\n print(start)\n\n", "def check(x):\n temp=[]\n for i in t:\n temp.append(i)\n for i in range(x):\n temp[a[i]-1]=''\n #print(''.join(temp))\n l=0;r=0;c=0\n while r<len(s) and l<len(t):\n if s[r]==temp[l]:\n r+=1;c+=1\n l+=1\n #print(c)\n return c==len(s)\nt=input()\ns=input()\na=list(map(int,input().split()))\nlo=0;hi=len(a)\nwhile lo<hi-1:\n mid=lo+(hi-lo)//2\n #print(lo,hi,mid)\n if check(mid):\n lo=mid\n else:\n hi=mid\n \nprint(lo)\n", "s = input()\nt = input()\na = list(map(int, input().split()))\n\n\ndef exist(m):\n vis = [0] * len(s)\n for i in range(m):\n vis[a[i] - 1] = 1\n j = 0\n for i in range(len(s)):\n if vis[i] == 0:\n if s[i] == t[j]:\n j += 1\n if j == len(t):\n return 1\n return 0\n\n\nl, r = 0, len(s)\nwhile l < r:\n mid = (l + r + 1) // 2\n if exist(mid):\n l = mid\n else:\n r = mid - 1\n\nprint(l)\n", "a = input()\nb = input()\np = list(map(int,input().split()))\n\nn = len(p)\nh = [0]*n\nfor i in range(n):\n p[i]-=1\n h[p[i]] = i\n\ndef check(s1,s2,g):\n m1 = len(s1)\n m2 = len(s2)\n j = 0\n i = 0\n \n while j<m1 and i<m2: \n if s1[j] == s2[i] and h[i]>g: \n j = j+1 \n i = i + 1\n return j==m1\n\nl = -1\nr = n-1\n\nwhile l<r:\n md = (l+r+1)//2\n # print(md,p[md],h[p[md]])\n if check(b,a,h[p[md]]):\n # print(md,p[md],h[p[md]])\n l = md\n else:\n r = md-1\n\nprint(l+1)", "s = list(input())\nt = list(input())\narr = list(x-1 for x in map(int, input().split()))\nn, m = len(arr), len(t)\n\ndef binary_search():\n f, e = 0, n\n while f <= e:\n mid = f + e >> 1\n vis = [0] * n\n for i in range(mid):\n vis[arr[i]] = 1\n idx, found = 0, 0\n for i in range(n):\n if not vis[i] and s[i] == t[idx]:\n idx += 1\n if idx == m:\n found = 1\n break\n if found:\n f = mid + 1\n else:\n e = mid - 1\n return f - 1\n\nprint(binary_search())\n"] | {
"inputs": [
"ababcba\nabb\n5 3 4 1 7 6 2\n",
"bbbabb\nbb\n1 6 3 4 2 5\n",
"cacaccccccacccc\ncacc\n10 9 14 5 1 7 15 3 6 12 4 8 11 13 2\n",
"aaaabaaabaabaaaaaaaa\naaaa\n18 5 4 6 13 9 1 3 7 8 16 10 12 19 17 15 14 11 20 2\n",
"aaaaaaaadbaaabbbbbddaaabdadbbbbbdbbabbbabaabdbbdababbbddddbdaabbddbbbbabbbbbabadaadabaaaadbbabbbaddb\naaaaaaaaaaaaaa\n61 52 5 43 53 81 7 96 6 9 34 78 79 12 8 63 22 76 18 46 41 56 3 20 57 21 75 73 100 94 35 69 32 4 70 95 88 44 68 10 71 98 23 89 36 62 28 51 24 30 74 55 27 80 38 48 93 1 19 84 13 11 86 60 87 33 39 29 83 91 67 72 54 2 17 85 82 14 15 90 64 50 99 26 66 65 31 49 40 45 77 37 25 42 97 47 58 92 59 16\n"
],
"outputs": [
"3",
"4",
"9",
"16",
"57"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 14,947 | |
a48d6b0fa8b429912d40da3e9a57e85b | UNKNOWN | A new pack of n t-shirts came to a shop. Each of the t-shirts is characterized by three integers p_{i}, a_{i} and b_{i}, where p_{i} is the price of the i-th t-shirt, a_{i} is front color of the i-th t-shirt and b_{i} is back color of the i-th t-shirt. All values p_{i} are distinct, and values a_{i} and b_{i} are integers from 1 to 3.
m buyers will come to the shop. Each of them wants to buy exactly one t-shirt. For the j-th buyer we know his favorite color c_{j}.
A buyer agrees to buy a t-shirt, if at least one side (front or back) is painted in his favorite color. Among all t-shirts that have colors acceptable to this buyer he will choose the cheapest one. If there are no such t-shirts, the buyer won't buy anything. Assume that the buyers come one by one, and each buyer is served only after the previous one is served.
You are to compute the prices each buyer will pay for t-shirts.
-----Input-----
The first line contains single integer n (1 ≤ n ≤ 200 000) — the number of t-shirts.
The following line contains sequence of integers p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ 1 000 000 000), where p_{i} equals to the price of the i-th t-shirt.
The following line contains sequence of integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 3), where a_{i} equals to the front color of the i-th t-shirt.
The following line contains sequence of integers b_1, b_2, ..., b_{n} (1 ≤ b_{i} ≤ 3), where b_{i} equals to the back color of the i-th t-shirt.
The next line contains single integer m (1 ≤ m ≤ 200 000) — the number of buyers.
The following line contains sequence c_1, c_2, ..., c_{m} (1 ≤ c_{j} ≤ 3), where c_{j} equals to the favorite color of the j-th buyer. The buyers will come to the shop in the order they are given in the input. Each buyer is served only after the previous one is served.
-----Output-----
Print to the first line m integers — the j-th integer should be equal to the price of the t-shirt which the j-th buyer will buy. If the j-th buyer won't buy anything, print -1.
-----Examples-----
Input
5
300 200 400 500 911
1 2 1 2 3
2 1 3 2 1
6
2 3 1 2 1 1
Output
200 400 300 500 911 -1
Input
2
1000000000 1
1 1
1 2
2
2 1
Output
1 1000000000 | ["n = int(input())\n\np = [int(i) for i in input().split()]\na = [int(i) for i in input().split()]\nb = [int(i) for i in input().split()]\n\ns = []\nfor i in range(n):\n s.append([p[i], a[i], b[i]])\n\ns = sorted(s)\n\nm = int(input())\nc = [int(i) for i in input().split()]\n\nidx = [0]*4\n\nans = []\n\nfor i in range(m):\n ci = c[i]\n while idx[ci] < n:\n if s[idx[ci]][1] == ci or s[idx[ci]][2] == ci:\n s[idx[ci]][1] = 0\n s[idx[ci]][2] = 0\n ans.append(s[idx[ci]][0])\n break\n idx[ci]+=1\n if idx[ci] == n:\n ans.append(-1)\n\nprint(*ans)\n", "n = int(input())\np = list(zip(map(int,input().split()),map(int,input().split()),map(int,input().split())))\np.sort()\npointer = [-1,0,0,0]\ninput()\nfor cj in map(int,input().split()):\n while pointer[cj] < n and (p[pointer[cj]] == None or cj not in p[pointer[cj]][1:]):\n pointer[cj]+= 1\n if pointer[cj] == n:\n print(-1, end=' ')\n else:\n print(p[pointer[cj]][0], end=' ')\n p[pointer[cj]] = None", "import sys\n\ndef solve():\n n = int(sys.stdin.readline())\n p = [int(pi) for pi in sys.stdin.readline().split()]\n a = [int(ai) - 1 for ai in sys.stdin.readline().split()]\n b = [int(bi) - 1 for bi in sys.stdin.readline().split()]\n m = int(sys.stdin.readline())\n c = [int(ci) - 1 for ci in sys.stdin.readline().split()]\n\n p_col = [[] for i in range(3)]\n\n for i in range(n):\n p_col[a[i]].append(p[i])\n\n if a[i] != b[i]:\n p_col[b[i]].append(p[i])\n\n for i in range(3):\n p_col[i].sort()\n\n used = set()\n\n l = [0]*3\n ans = [-1]*m\n\n for k, cj in enumerate(c):\n for i in range(l[cj], len(p_col[cj])):\n if p_col[cj][i] not in used:\n ans[k] = p_col[cj][i]\n used.add(p_col[cj][i])\n l[cj] = i + 1\n break\n\n print(*ans)\n\ndef __starting_point():\n solve()\n__starting_point()", "n = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nm = int(input())\nc = list(map(int, input().split()))\n\nt = [[p[i], a[i], b[i], 1] for i in range(n)]\nt = sorted(t, key = lambda x: x[0])\n\np = [0,0,0,0]\nans = []\nfor i in range(m):\n clr = c[i]\n while p[clr] < n and (t[p[clr]][3] == 0 or (t[p[clr]][1] != clr and t[p[clr]][2] != clr)):\n p[clr] += 1\n if p[clr] == n:\n ans.append(-1)\n else:\n t[p[clr]][3] = 0\n ans.append(t[p[clr]][0])\nprint(' '.join([str(a) for a in ans]))", "def main():\n n = int(input())\n p = list(map(int, input().split()))\n a = list(map(int, input().split()))\n b = list(map(int, input().split()))\n m = int(input())\n r, g, bl = [], [], []\n used = set()\n for i in range(n):\n c1, c2 = a[i], b[i]\n if c1 == 1 or c2 == 1:\n r.append([p[i], i])\n if c1 == 2 or c2 == 2:\n g.append([p[i], i])\n if c1 == 3 or c2 == 3:\n bl.append([p[i], i])\n r.sort(reverse=True)\n g.sort(reverse=True)\n bl.sort(reverse=True)\n answer = []\n for i in list(map(int, input().split())):\n if i == 1:\n try:\n while True:\n pop = r.pop()[0]\n if pop not in used:\n answer.append(str(pop))\n used.add(pop)\n break\n except:\n answer.append('-1')\n elif i == 2:\n try:\n while True:\n pop = g.pop()[0]\n if pop not in used:\n answer.append(str(pop))\n used.add(pop)\n break\n except:\n answer.append('-1')\n elif i == 3:\n try:\n while True:\n pop = bl.pop()[0]\n if pop not in used:\n answer.append(str(pop))\n used.add(pop)\n break\n except:\n answer.append('-1')\n print(' '.join(answer))\n\ndef __starting_point():\n main()\n__starting_point()", "n = int(input())\np = list(map(int, input().split(' ')))\na = list(map(int, input().split(' ')))\nb = list(map(int, input().split(' ')))\nused = [False] * n\n\nma = [[], [], []]\nmb = [[], [], []]\n\nfor i in range(n):\n ma[a[i] - 1].append(i)\n mb[b[i] - 1].append(i)\n\nfor i in range(3):\n ma[i].sort(key = lambda x: -p[x])\n mb[i].sort(key = lambda x: -p[x])\n\nm = int(input())\nc = list(map(int, input().split(' ')))\nans = [0] * m\nfor i in range(m):\n x = c[i] - 1\n\n def tryone(a):\n while len(a[x]) > 0 and used[a[x][len(a[x]) - 1]]:\n a[x].pop()\n if len(a[x]) == 0:\n return -1\n else:\n return a[x][len(a[x]) - 1]\n\n c1 = tryone(ma)\n c2 = tryone(mb)\n\n if c1 == -1 and c2 == -1:\n ans[i] = -1\n elif c1 == -1 or (c2 != -1 and p[c2] < p[c1]):\n used[c2] = True\n ans[i] = p[c2]\n else:\n used[c1] = True\n ans[i] = p[c1]\n\nprint(' '.join(list(map(str, ans))))\n", "n=int(input())\np=list(map(int,input().split()))\na=list(map(int,input().split()))\nb=list(map(int,input().split()))\nf=[0]*n\nm=int(input())\nc=list(map(int,input().split()))\nl=[[],[],[],[]]\nfor i in range(n):\n l[a[i]]+=[[p[i],i]]\n if b[i]!=a[i]:\n l[b[i]]+=[[p[i],i]]\nfor i in range(1,4):\n l[i]=sorted(l[i])\ni=[0,0,0,0]\nans=[]\nfor x in c:\n while i[x]<len(l[x]) and f[l[x][i[x]][1]]:\n i[x]+=1\n if i[x]>=len(l[x]): ans+=[-1]\n else: ans+=[l[x][i[x]][0]]; f[l[x][i[x]][1]]=1\nprint(*ans)", "#!/usr/bin/env python3\nfrom sys import stdin,stdout\n\ndef readint():\n return list(map(int, stdin.readline().split()))\n#lines = stdin.readlines()\n\nn = int(input())\np = list(readint())\na = list(readint())\nb = list(readint())\n\nm = int(input())\nc = list(readint())\n\ncc = [[] for i in range(3)]\nfor i in range(n):\n cc[a[i]-1].append(i)\n cc[b[i]-1].append(i)\n\nfor i in range(3):\n cc[i].sort(key=lambda e: p[e])\n\nans = []\nii = [0,0,0]\nfor i in range(m):\n ci = c[i]-1\n while True:\n if ii[ci] >= len(cc[ci]):\n break\n if p[cc[ci][ii[ci]]] == -1:\n ii[ci] += 1\n else:\n break\n\n if ii[ci] >= len(cc[ci]):\n ans.append(-1)\n else:\n ans.append(p[cc[ci][ii[ci]]])\n p[cc[ci][ii[ci]]] = -1\n\nprint(*ans)\n\n\n", "n = int(input())\np = list(map(int, input().split()));\na = list(map(int, input().split()));\nb = list(map(int, input().split()));\n\ntog = [(p[i],a[i],b[i]) for i in range(0,n)];\n\n\ntog.sort();\n\narr = [None,[],[],[]]\n\nus = [None,[],[],[]]\n\nlink = []\n\nfor i in range(0,n):\n if (tog[i][1] == tog[i][2]) :\n arr[tog[i][1]].append(i)\n us[tog[i][1]].append(True)\n\n link.append([(tog[i][1], len(arr[tog[i][1]])-1)])\n else:\n arr[tog[i][1]].append(i)\n us[tog[i][1]].append(True)\n arr[tog[i][2]].append(i)\n us[tog[i][2]].append(True)\n\n link.append([(tog[i][1], len(arr[tog[i][1]])-1),(tog[i][2], len(arr[tog[i][2]])-1)])\n\n\n#print(\"tog arr us link\")\n##print( tog)\n#print( arr)\n#print( us)\n#print(link)\n\nptr = [None, 0, 0, 0];\n\nm = int(input())\n\nbuy = list(map(int, input().split()));\n\nout = []\nfor c in buy:\n while (ptr[c] < len(us[c]) and not us[c][ptr[c]]):\n ptr[c]+=1\n\n if (ptr[c] >= len(arr[c])):\n out.append(-1);\n else:\n v = arr[c][ptr[c]]\n us[c][ptr[c]] = False\n out.append(tog[v][0])\n for (cc, pp) in link[v]:\n us[cc][pp] = False\n\n #print(\"out:\", out[-1]);\n #print(\"ptr:\", ptr)\n #print(\"us:\", us)\n\nprint(\" \".join(map(str, out)))\n \n \n\n\n\n\n", "n = int(input())\np = list(map(int,input().split()))\na = list(map(int,input().split()))\nb = list(map(int,input().split()))\nm = int(input())\npos = list(map(int,input().split()))\n\nfut = list(zip(p,a,b))\nfut=list(fut)\ndef sravni(elem):\n return elem[0]\nfut.sort(key=sravni)\n\nvz = []\nfor i in range(n):\n vz.append(False)\n\nlastc = [0,0,0]\nresult = \"\"\nfor poset in pos:\n ctoim=-1\n for i in range(lastc[poset-1],n):\n if vz[i] == False:\n if fut[i][1] == poset or fut[i][2] ==poset:\n vz[i] = True\n ctoim = fut[i][0]\n lastc[poset - 1] = i+1\n break\n if ctoim == -1:\n lastc[poset-1] = n+1\n result+=str(ctoim)+\" \"\nprint(result)\n\n", "n = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nm = int(input())\nqueue = list(map(int, input().split()))\npointers = [[0 for i in range(3)] for j in range(3)]\nt = [[list() for i in range(3)] for j in range(3)]\nfor i in range(n):\n t[a[i] - 1][b[i] - 1].append(p[i])\nfor i in range(3):\n for j in range(3):\n t[i][j].sort()\nfor i in range(m):\n m1 = 10 ** 10 \n m2 = 10 ** 10\n for j in range(3):\n if len(t[queue[i] - 1][j]) and pointers[queue[i] - 1][j] < len(t[queue[i] - 1][j]) and \\\n t[queue[i] - 1][j][pointers[queue[i] - 1][j]] < m1:\n m1 = t[queue[i] - 1][j][pointers[queue[i] - 1][j]]\n pos_j = j\n for j in range(3):\n if len(t[j][queue[i] - 1]) and pointers[j][queue[i] - 1] < len(t[j][queue[i] - 1]) and \\\n t[j][queue[i] - 1][pointers[j][queue[i] - 1]] < m2:\n m2 = t[j][queue[i] - 1][pointers[j][queue[i] - 1]]\n pos_i = j\n if m1 == 10 ** 10 and m2 == 10 ** 10:\n print(-1, end = ' ')\n elif m1 < m2:\n pointers[queue[i] - 1][pos_j] += 1\n print(m1, end = ' ')\n else:\n pointers[pos_i][queue[i] - 1] += 1\n print(m2, end = ' ')\n", "n = int (input ())\n\np = [int (i) for i in input().split()]\n\na = [int (i) for i in input().split()]\n\nb = [int (i) for i in input().split()]\n\n\nm = int (input())\nc = [int (i) for i in input().split()]\n\nc1 = {}\nc2 = {}\nc3 = {}\n\nfor i in range (n):\n\tif a[i] == 1 or b[i] == 1:\n\t\tc1[p[i]] = 1\n\tif a[i] == 2 or b[i] == 2:\n\t\tc2 [p[i]] = 1\n\tif a[i] == 3 or b[i] == 3:\n\t\tc3 [p[i]] = 1\n\nk1 = sorted (c1)\nk2 = sorted (c2)\nk3 = sorted (c3)\n\nk1s = 0\nk2s = 0\nk3s = 0\n\nfor i in range (m):\n\tch = 0\n\tif c[i] == 1:\n\t\tfor j in range (k1s, len (k1)):\n\t\t\tif c1 [k1[j]] != 0:\n\t\t\t\tc1 [k1[j]] = 0\n\t\t\t\tc2 [k1[j]] = 0\n\t\t\t\tc3 [k1[j]] = 0\n\t\t\t\tch = 1\n\t\t\t\tk1s = j + 1\n\t\t\t\tprint (k1[j], end = ' ')\n\t\t\t\tbreak\n\telse:\n\t\tif c[i] == 2:\n\t\t\tfor j in range (k2s, len (k2)):\n\t\t\t\tif c2 [k2[j]] != 0:\n\t\t\t\t\tc1 [k2[j]] = 0\n\t\t\t\t\tc2 [k2[j]] = 0\n\t\t\t\t\tc3 [k2[j]] = 0\n\t\t\t\t\tch = 1\n\t\t\t\t\tk2s = j + 1\n\t\t\t\t\tprint (k2[j], end = ' ')\n\t\t\t\t\tbreak\n\t\telse:\n\t\t\tif c[i] == 3:\n\t\t\t\tfor j in range (k3s, len (k3)):\n\t\t\t\t\tif c3 [k3[j]] != 0:\n\t\t\t\t\t\tc1 [k3[j]] = 0\n\t\t\t\t\t\tc2 [k3[j]] = 0\n\t\t\t\t\t\tc3 [k3[j]] = 0\n\t\t\t\t\t\tch = 1\n\t\t\t\t\t\tk3s = j + 1\t\n\t\t\t\t\t\tprint (k3[j], end = ' ')\n\t\t\t\t\t\tbreak\n\tif ch == 0:\n\t\tprint (-1, end = ' ')", "n = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nm = int(input())\nc = list(map(int, input().split()))\n\nl = [list() for i in range(1, 4)]\n\nfor i in range(n):\n l[a[i]-1].append((p[i],i))\n if a[i] != b[i]:\n l[b[i]-1].append((p[i],i))\n\nimport operator\nl = list(map(lambda l_ : sorted(l_, key = operator.itemgetter(0)), l))\ninvalid = set()\nys = [0] * 4\n\n\nfor i in range(m):\n y = ys[c[i] -1]\n while (y < len(l[c[i] - 1])) and (l[c[i] - 1][y][1] in invalid):\n y += 1\n if y == len(l[c[i] - 1]):\n print(-1, end=' ')\n else:\n print(l[c[i] - 1][y][0], end=' ')\n invalid.add(l[c[i] - 1][y][1])\n ys[c[i] - 1] = y\n", "import sys\nfrom collections import deque\nread=lambda:sys.stdin.readline().rstrip()\nreadi=lambda:int(sys.stdin.readline())\nwriteln=lambda x:sys.stdout.write(str(x)+\"\\n\")\nwrite=lambda x:sys.stdout.write(x)\n\nN = readi()\nps = list(map(int, read().split()))\ncas = list(map(int, read().split()))\ncbs = list(map(int, read().split()))\nM = readi()\nbs = list(map(int, read().split()))\nresults = []\nts = [[] for _ in range(7)]\ntcnt = [0 for _ in range(7)]\nfor i in range(N):\n price,a,b=ps[i],cas[i],cbs[i]\n color = 2**(a-1) | 2**(b-1)\n ts[color].append(price)\n tcnt[color] += 1\n\ntss = []\nfor i in range(7):\n if tcnt[i]:\n tss.append(deque(list(sorted(ts[i]))))\n else:\n tss.append([])\n\nspots = [[1,3,5],[3,2,6],[5,6,4]]\nfor i in range(M):\n s1,s2,s3 = spots[bs[i]-1]\n \n c1,c2,c3=tcnt[s1],tcnt[s2],tcnt[s3]\n alts = []\n if c1:\n alts.append(s1)\n if c2:\n alts.append(s2)\n if c3:\n alts.append(s3)\n if not alts:\n results.append(\"-1\")\n continue\n \n vals = []\n for alt in alts:\n vals.append((tss[alt][0], alt))\n vals.sort()\n price,cidx = vals[0]\n results.append(str(price))\n tcnt[cidx] -= 1\n tss[cidx].popleft()\nwriteln(\" \".join(results)) \n", "input()\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nd = [[[] for _ in range(3)] for _ in range(3)]\nfor pi, ai, bi in zip(p, a, b):\n d[ai - 1][bi - 1].append(pi)\n\nfor row in d:\n for l in row:\n l.sort(reverse=True)\n \n\nr = []\nfor ci in c:\n pm = 1000000001\n im = -1\n for j, l in enumerate(d[ci - 1]):\n if len(l) > 0 and l[-1] < pm:\n pm = l[-1]\n im = ci - 1\n jm = j\n for i, ll in enumerate(d):\n l = ll[ci - 1]\n if len(l) > 0 and l[-1] < pm:\n pm = l[-1]\n im = i\n jm = ci - 1\n r.append(d[im][jm].pop() if im >= 0 else -1)\nprint(*r, sep=' ')\n", "import collections\ndef mp(): return map(int,input().split())\ndef lt(): return list(map(int,input().split()))\ndef pt(x): print(x)\ndef ip(): return input()\ndef it(): return int(input())\ndef sl(x): return [t for t in x]\ndef spl(x): return x.split()\ndef aj(liste, item): liste.append(item)\ndef bin(x): return \"{0:b}\".format(x)\ndef listring(l): return ' '.join([str(x) for x in l])\ndef ptlist(l): print(' '.join([str(x) for x in l]))\n\nn = it()\np = lt()\na = lt()\nb = lt()\nm = it()\nc = lt()\n\nshirt = list(zip(p,a,b))\nshirt.sort()\npointer = [-1,0,0,0]\nl = []\nfor i in range(m):\n cl = c[i]\n while pointer[cl] < n and (shirt[pointer[cl]] == None or cl not in shirt[pointer[cl]][1:]):\n pointer[cl] += 1\n if pointer[cl] == n:\n l.append(-1)\n else:\n l.append(shirt[pointer[cl]][0])\n shirt[pointer[cl]] = None\nptlist(l)", "input()\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nd = [[[] for _ in range(3)] for _ in range(3)]\nfor pi, ai, bi in zip(p, a, b):\n d[ai - 1][bi - 1].append(pi)\n\nfor row in d:\n for l in row:\n l.sort(reverse=True)\n \n\nr = []\nfor ci in c:\n pm = 1000000001\n im = -1\n for j, l in enumerate(d[ci - 1]):\n if len(l) > 0 and l[-1] < pm:\n pm = l[-1]\n im = ci - 1\n jm = j\n for i, ll in ((i, ll) for i, ll in enumerate(d) if i != ci - 1):\n l = ll[ci - 1]\n if len(l) > 0 and l[-1] < pm:\n pm = l[-1]\n im = i\n jm = ci - 1\n r.append(d[im][jm].pop() if im >= 0 else -1)\nprint(*r, sep=' ')\n", "import operator\n\nn = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = map(int, input().split())\n\nt = sorted(zip(p, a, b), key=operator.itemgetter(0))\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n p[ci] = i\n if i < n:\n t[i][1], t[i][2] = 0, 0\n r.append(t[i][0] if i < n else - 1)\nprint(*r, sep=' ')\n", "import itertools\n\ndef minl(l):\n return l[-1] if len(l) > 0 else 10**9 + 1\n\ninput()\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nd = [[[] for _ in range(3)] for _ in range(3)]\nfor pi, ai, bi in zip(p, a, b):\n d[ai - 1][bi - 1].append(pi)\n\nfor row in d:\n for l in row:\n l.sort(reverse=True)\n \nr = []\nfor ci in c:\n ci -= 1\n row = ((ci, j) for j in range(3))\n col = ((i, ci) for i in range(3))\n i, j = min(itertools.chain(row, col),\n key=lambda p: minl(d[p[0]][p[1]]))\n l = d[i][j]\n r.append(l.pop() if len(l) > 0 else -1)\nprint(*r, sep=' ')\n", "import operator\n\nn = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = map(int, input().split())\n\nt = sorted(zip(p, a, b), key=operator.itemgetter(0))\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n if i == n:\n r.append(-1)\n else:\n r.append(t[i][0])\n t[i][1], t[i][2] = 0, 0\n i += 1\n p[ci] = i\nprint(*r, sep=' ')\n", "import operator\n\nn = int(input())\np = map(int, input().split())\na = map(int, input().split())\nb = map(int, input().split())\ninput()\nc = map(int, input().split())\n\nt = sorted(zip(p, a, b), key=operator.itemgetter(0))\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n if i == n:\n r.append(-1)\n else:\n r.append(t[i][0])\n t[i][1], t[i][2] = 0, 0\n i += 1\n p[ci] = i\nprint(*r, sep=' ')\n", "import operator\n\nn = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nt = sorted(zip(p, a, b), key=operator.itemgetter(0))\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n if i == n:\n r.append('-1')\n else:\n r.append(str(t[i][0]))\n t[i][1], t[i][2] = 0, 0\n i += 1\n p[ci] = i\nprint(' '.join(r))\n", "import operator\n\nn = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nt = sorted(zip(p, a, b), key=operator.itemgetter(0))\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n if i == n:\n r.append(-1)\n else:\n r.append(t[i][0])\n t[i][1], t[i][2] = 0, 0\n i += 1\n p[ci] = i\nprint(' '.join(map(str, r)))\n", "n = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nt = sorted(zip(p, a, b), key=lambda x: x[0])\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n if i == n:\n r.append('-1')\n else:\n r.append(str(t[i][0]))\n t[i][1], t[i][2] = 0, 0\n i += 1\n p[ci] = i\nprint(' '.join(r))\n", "n = int(input())\np = list(map(int, input().split()))\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\ninput()\nc = list(map(int, input().split()))\n\nt = sorted(zip(p, a, b), key=lambda x: x[0])\nt = [list(x) for x in t]\np = [None, 0, 0, 0]\n\nr = []\nfor ci in c:\n i = p[ci]\n while i < n and ci not in (t[i][1], t[i][2]):\n i += 1\n if i == n:\n r.append('-1')\n else:\n r.append(str(t[i][0]))\n t[i][1], t[i][2] = 0, 0\n i += 1\n p[ci] = i\nprint(*r)\n"] | {
"inputs": [
"5\n300 200 400 500 911\n1 2 1 2 3\n2 1 3 2 1\n6\n2 3 1 2 1 1\n",
"2\n1000000000 1\n1 1\n1 2\n2\n2 1\n",
"10\n251034796 163562337 995167403 531046374 341924810 828969071 971837553 183763940 857690534 687685084\n3 2 1 3 2 3 1 3 2 1\n2 3 3 1 2 3 2 3 3 2\n10\n1 3 2 3 2 3 3 1 2 3\n",
"20\n414468312 20329584 106106409 584924603 666547477 670032002 726095027 276840253 368277336 940941705 531635095 213813062 440421387 959075599 240727854 495316522 838268432 786936631 586382273 806443734\n3 1 2 3 3 2 2 1 3 2 3 2 3 3 3 2 1 3 1 2\n3 1 2 2 2 2 3 1 2 3 2 1 1 2 3 1 2 3 3 2\n40\n1 1 2 1 3 2 3 1 3 3 1 2 3 1 1 1 2 3 3 1 3 1 3 1 2 2 3 3 1 2 1 2 3 2 2 1 2 1 2 2\n",
"1\n529469903\n1\n3\n1\n3\n"
],
"outputs": [
"200 400 300 500 911 -1 \n",
"1 1000000000 \n",
"531046374 163562337 251034796 183763940 341924810 828969071 857690534 687685084 971837553 995167403 \n",
"20329584 213813062 106106409 276840253 240727854 368277336 414468312 440421387 531635095 584924603 495316522 666547477 586382273 838268432 -1 -1 670032002 726095027 786936631 -1 940941705 -1 959075599 -1 806443734 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 \n",
"529469903 \n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 20,632 | |
9f1c4343143b2a29afb2fc82c7110116 | UNKNOWN | ZS the Coder is playing a game. There is a number displayed on the screen and there are two buttons, ' + ' (plus) and '$\sqrt{}$' (square root). Initially, the number 2 is displayed on the screen. There are n + 1 levels in the game and ZS the Coder start at the level 1.
When ZS the Coder is at level k, he can : Press the ' + ' button. This increases the number on the screen by exactly k. So, if the number on the screen was x, it becomes x + k. Press the '$\sqrt{}$' button. Let the number on the screen be x. After pressing this button, the number becomes $\sqrt{x}$. After that, ZS the Coder levels up, so his current level becomes k + 1. This button can only be pressed when x is a perfect square, i.e. x = m^2 for some positive integer m.
Additionally, after each move, if ZS the Coder is at level k, and the number on the screen is m, then m must be a multiple of k. Note that this condition is only checked after performing the press. For example, if ZS the Coder is at level 4 and current number is 100, he presses the '$\sqrt{}$' button and the number turns into 10. Note that at this moment, 10 is not divisible by 4, but this press is still valid, because after it, ZS the Coder is at level 5, and 10 is divisible by 5.
ZS the Coder needs your help in beating the game — he wants to reach level n + 1. In other words, he needs to press the '$\sqrt{}$' button n times. Help him determine the number of times he should press the ' + ' button before pressing the '$\sqrt{}$' button at each level.
Please note that ZS the Coder wants to find just any sequence of presses allowing him to reach level n + 1, but not necessarily a sequence minimizing the number of presses.
-----Input-----
The first and only line of the input contains a single integer n (1 ≤ n ≤ 100 000), denoting that ZS the Coder wants to reach level n + 1.
-----Output-----
Print n non-negative integers, one per line. i-th of them should be equal to the number of times that ZS the Coder needs to press the ' + ' button before pressing the '$\sqrt{}$' button at level i.
Each number in the output should not exceed 10^18. However, the number on the screen can be greater than 10^18.
It is guaranteed that at least one solution exists. If there are multiple solutions, print any of them.
-----Examples-----
Input
3
Output
14
16
46
Input
2
Output
999999999999999998
44500000000
Input
4
Output
2
17
46
97
-----Note-----
In the first sample case:
On the first level, ZS the Coder pressed the ' + ' button 14 times (and the number on screen is initially 2), so the number became 2 + 14·1 = 16. Then, ZS the Coder pressed the '$\sqrt{}$' button, and the number became $\sqrt{16} = 4$.
After that, on the second level, ZS pressed the ' + ' button 16 times, so the number becomes 4 + 16·2 = 36. Then, ZS pressed the '$\sqrt{}$' button, levelling up and changing the number into $\sqrt{36} = 6$.
After that, on the third level, ZS pressed the ' + ' button 46 times, so the number becomes 6 + 46·3 = 144. Then, ZS pressed the '$\sqrt{}$' button, levelling up and changing the number into $\sqrt{144} = 12$.
Note that 12 is indeed divisible by 4, so ZS the Coder can reach level 4.
Also, note that pressing the ' + ' button 10 times on the third level before levelling up does not work, because the number becomes 6 + 10·3 = 36, and when the '$\sqrt{}$' button is pressed, the number becomes $\sqrt{36} = 6$ and ZS the Coder is at Level 4. However, 6 is not divisible by 4 now, so this is not a valid solution.
In the second sample case:
On the first level, ZS the Coder pressed the ' + ' button 999999999999999998 times (and the number on screen is initially 2), so the number became 2 + 999999999999999998·1 = 10^18. Then, ZS the Coder pressed the '$\sqrt{}$' button, and the number became $\sqrt{10^{18}} = 10^{9}$.
After that, on the second level, ZS pressed the ' + ' button 44500000000 times, so the number becomes 10^9 + 44500000000·2 = 9·10^10. Then, ZS pressed the '$\sqrt{}$' button, levelling up and changing the number into $\sqrt{9 \cdot 10^{10}} = 300000$.
Note that 300000 is a multiple of 3, so ZS the Coder can reach level 3. | ["\"\"\"\nCodeforces Round 372 Div 1 Problem A\n\nAuthor : chaotic_iak\nLanguage: Python 3.5.2\n\"\"\"\n\n################################################### SOLUTION\n\ndef main():\n n, = read()\n curr = 2\n for lv in range(1, n+1):\n tgt = (lv*(lv+1))**2\n print((tgt - curr) // lv)\n curr = lv*(lv+1)\n return\n\n#################################################### HELPERS\n\ndef read(typ=int):\n # None: String, non-split\n # Not None: Split\n input_line = input().strip()\n if typ is None:\n return input_line\n return list(map(typ, input_line.split()))\n\ndef write(s=\"\\n\"):\n if s is None: s = \"\"\n if isinstance(s, list): s = \" \".join(map(str, s))\n s = str(s)\n print(s, end=\"\")\n\nwrite(main())\n", "\nN = int(input())\n\nx = 2\n\nfor i in range(1, N+1):\n u, v = i, i+1\n p = u**2 * v**2\n d = p - x\n z = d // u\n assert(z <= 10**18)\n print(z)\n x = u*v\n", "N = int(input())\nprint(2)\nfor n in range(2, N+1):\n\tclicks = n*(n+1)**2 - (n-1)\n\tprint(clicks)", "n = int(input())\na = 2\nfor i in range(1, n + 1):\n b = (i * (i + 1)) * (i * (i + 1))\n assert (b - a) % i == 0, str(i)\n c = (b - a) // i\n print(c)\n a = i * (i + 1)\n", "n=int(input())\nret=2\nq=2\nfor k in range(1,n+1):\n if(q%(k+1)!=0):\n q+=k+1-(q%(k+1))\n while 1:\n w=q*q\n if (w-ret)%k==0:\n print((w-ret)//k)\n ret=q\n break\n q+=k+1\n\n", "\nn = int(input())\nprint(2)\nfor i in range(1, n):\n print((i+2)*(i+2)*(i+1)-i)\n", "#!/usr/bin/env python3\nimport math\nn = int(input())\nx = 2\nk = 1\nwhile k <= n:\n assert x % k == 0\n y = ((k+1) * k) ** 2\n assert x <= y and (y - x) % k == 0\n assert (y - x) // k <= 10**18\n print((y - x) // k)\n x = (k+1) * k\n k += 1\n", "def solve(x):\n\treturn ((((x + 1) ** 2) * (x ** 2)) - (x * x - x)) / x\n \ninp = int(input(\"\"))\nlvl = 1\nprint (\"2\")\nwhile(inp >= 2):\n\tops = solve(lvl + 1)\n\tprint (int(ops))\n\tlvl = lvl + 1\n\tinp = inp - 1 ", "import sys\nfrom fractions import gcd\nimport math\ndef lcm(x, y):\n return x * y // gcd(x, y)\n\ndef seive(lim):\n for x in range(2, lim + 1):\n if (len(factors[x]) == 0):\n factors[x].append((x, 1))\n for y in range(x + x, lim + 1, x):\n yy = y\n cnt = 0\n while (yy % x == 0):\n cnt += 1\n yy //= x\n factors[y].append((x, cnt))\nfactors =[]\nfor i in range(10**5 + 2):\n factors.append([])\nseive(10**5 + 1)\nn = int(input())\ncurLvl = 1\ncurValue = 2\nnxtLvl = 2\nans = \"\"\nwhile (curLvl <= n):\n f = factors[curLvl]\n x = 1\n for item in f:\n x *= item[0] ** (item[1] // 2 + item[1] % 2)\n x = lcm(x, nxtLvl)\n ans += str((x * x - curValue) // curLvl) + \"\\n\"\n curValue = x\n curLvl += 1\n nxtLvl += 1\n\nsys.stdout.write(ans)\n\n\n\n\n\n\n", "n = int(input())\nst = 2\ndef sqrt(x):\n lo = 0\n hi = 1000000000000\n while (lo < hi):\n mid = (lo + hi) // 2\n if mid*mid < x:\n lo = mid + 1\n else:\n hi = mid\n return lo\n\nfor i in range(1, n+1):\n a = ((i*(i+1))**2-st)/i\n a = int(a)\n print(a)\n st += i*a\n st = sqrt(st)", "n = int(input())\nst = 2\ndef sqrt(x):\n lo = 0\n hi = x\n while (lo < hi):\n mid = (lo + hi) // 2\n if mid*mid < x:\n lo = mid + 1\n else:\n hi = mid\n return lo\n\nfor i in range(1, n+1):\n a = ((i*(i+1))**2-st)/i\n a = int(a)\n print(a)\n st += i*a\n st = sqrt(st)\n", "n = int( input() )\nprint( 2 )\nfor i in range(2, n+1):\n print( ( i + 1 ) * ( i + 1 ) * i - ( i - 1 ) )\n", "n = int(input())\ncur = 2\nfor i in range(1,n+1):\n\ttmp = ((i*(i+1))**2 - cur)/i;\n\ttmp = int(tmp)\n\tprint(tmp)\n\tcur = i*(i+1)\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nprint(2)\nn=int(input())\nfor i in range(2,1+n):print(1+i*(2+i)*i)\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nprint(2)\nfor k in range(2,1+int(input())):print(1+k*(2+k)*k)\n", "a=2\nn=0\nmax = int(input())\nfor k in range(max+1):\n if(k==0):\n continue\n n = k*(k+1)*(k+1)-a\n a=k\n print(n)\n", "N = int(input())\ntmp1 = 2\ntmp2 = 2\nfor i in range(1, N + 1):\n if i == 1:\n print(2)\n tmp2 *= 3\n else:\n print((tmp2 ** 2 - tmp1) // i)\n tmp1 = tmp2\n tmp2 //= i\n tmp2 *= (i + 2)\n", "import math\n\nn = int(input())\nx = 2\nfor i in range(1, n+1):\n y = i * (i + 1)\n y *= y\n print(round((y-x)/i))\n x = math.sqrt(y)\n", "n = int(input())\nprint(2)\nfor i in range(2, n+1):\n print(i*(i+1)*(i+1) - i+1)\n", "n = int(input())\nfor i in range(2,n+2):\n if i==2:\n print(2)\n else:\n print(i*i*(i-1)-(i-2))", "\"\"\"\nupsolving:\nbrute forcing takes too long\nparlay congruence relation\n\"\"\"\n\nimport math\n\nn = int(input())\nzs = 2\n\nfor lvl in range(1, n+1):\n print(((lvl * (lvl + 1)) ** 2 - zs) // lvl)\n zs = lvl * (lvl + 1)\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nfor k in range(2,1+int(input('2\\n'))):print(1+k*(2+k)*k)\n", "n = int(input())\nprint(2)\nfor i in range(2, n+1):\n print(i*(i+1)*(i+1) - i+1)", "print(2)\nfor i in range(2, int(input())+1):\n print(i*i*i+2*i*i+1)"] | {"inputs": ["3\n", "2\n", "4\n", "1\n", "7\n"], "outputs": ["2\n17\n46\n", "2\n17\n", "2\n17\n46\n97\n", "2\n", "2\n17\n46\n97\n176\n289\n442\n"]} | COMPETITION | PYTHON3 | CODEFORCES | 5,414 | |
b4292e8623e3f6e3fe8862990359861a | UNKNOWN | The Bubble Cup hypothesis stood unsolved for $130$ years. Who ever proves the hypothesis will be regarded as one of the greatest mathematicians of our time! A famous mathematician Jerry Mao managed to reduce the hypothesis to this problem:
Given a number $m$, how many polynomials $P$ with coefficients in set ${\{0,1,2,3,4,5,6,7\}}$ have: $P(2)=m$?
Help Jerry Mao solve the long standing problem!
-----Input-----
The first line contains a single integer $t$ $(1 \leq t \leq 5\cdot 10^5)$ - number of test cases.
On next line there are $t$ numbers, $m_i$ $(1 \leq m_i \leq 10^{18})$ - meaning that in case $i$ you should solve for number $m_i$.
-----Output-----
For each test case $i$, print the answer on separate lines: number of polynomials $P$ as described in statement such that $P(2)=m_i$, modulo $10^9 + 7$.
-----Example-----
Input
2
2 4
Output
2
4
-----Note-----
In first case, for $m=2$, polynomials that satisfy the constraint are $x$ and $2$.
In second case, for $m=4$, polynomials that satisfy the constraint are $x^2$, $x + 2$, $2x$ and $4$. | ["\nimport os\nimport sys\nfrom io import BytesIO, IOBase\n\n\ndef main():\n pass\n\n\n# region fastio\n\nBUFSIZE = 8192\n\n\nclass FastIO(IOBase):\n newlines = 0\n\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n\n\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n\n\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\nMOD = 10 ** 9 + 7\n\nmemo = dict()\ndef solve(m):\n if m not in memo:\n if m < 0:\n memo[m] = 0\n if m == 0:\n memo[m] = 1\n half = m//2\n memo[m] = (solve(half) + solve(half - 1) + solve(half - 2) + solve(half - 3)) % MOD\n return memo[m]\n \n\nt = int(input())\nout = []\nfor m in map(int, input().split()):\n #out.append(solve(m))\n v = m//2\n u = v//2\n w = (v-u)\n out.append((u*w+u+w+1)%MOD)\nprint('\\n'.join(map(str,out)))\n", "t = int(input())\na = list(map(int, input().split()))\nout = []\nfor n in a:\n\tans = (n//2 + 2)\n\tans = ans*ans\n\tans //= 4\n\tout.append(ans%1000000007)\nprint(' '.join(str(x) for x in out))", "T = input()\nmod = int(1e9 + 7)\na = list(map(int, input().split()))\nc = []\nfor n in a:\n b = (n // 2 + 2)\n b = b * b\n b //= 4\n c.append(str(b % mod))\nprint(' '.join(c))\n", "# ===============================================================================================\n# importing some useful libraries.\n\nfrom fractions import Fraction\nimport sys\nimport os\nfrom io import BytesIO, IOBase\nfrom itertools import *\nimport bisect\nfrom heapq import *\nfrom math import ceil, floor\nfrom copy import *\nfrom collections import deque, defaultdict\nfrom collections import Counter as counter # Counter(list) return a dict with {key: count}\nfrom itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]\nfrom itertools import permutations as permutate\nfrom bisect import bisect_left as bl\nfrom operator import *\n# If the element is already present in the list,\n\n# the left most position where element has to be inserted is returned.\nfrom bisect import bisect_right as br\nfrom bisect import bisect\n\n# If the element is already present in the list,\n# the right most position where element has to be inserted is returned\n\n# ==============================================================================================\n# fast I/O region\n\nBUFSIZE = 8192\nfrom sys import stderr\n\n\nclass FastIO(IOBase):\n newlines = 0\n\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n\n\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n\n\ndef print(*args, **kwargs):\n \"\"\"Prints the values to a stream, or to sys.stdout by default.\"\"\"\n sep, file = kwargs.pop(\"sep\", \" \"), kwargs.pop(\"file\", sys.stdout)\n at_start = True\n for x in args:\n if not at_start:\n file.write(sep)\n file.write(str(x))\n at_start = False\n file.write(kwargs.pop(\"end\", \"\\n\"))\n if kwargs.pop(\"flush\", False):\n file.flush()\n\n\nif sys.version_info[0] < 3:\n sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)\nelse:\n sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\n\n# inp = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\n# ===============================================================================================\n### START ITERATE RECURSION ###\nfrom types import GeneratorType\n\n\ndef iterative(f, stack=[]):\n def wrapped_func(*args, **kwargs):\n if stack: return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n continue\n stack.pop()\n if not stack: break\n to = stack[-1].send(to)\n return to\n\n return wrapped_func\n\n\n#### END ITERATE RECURSION ####\n\n# ===============================================================================================\n# some shortcuts\n\nmod = 1000000007\n\n\ndef inp(): return sys.stdin.readline().rstrip(\"\\r\\n\") # for fast input\n\n\ndef out(var): sys.stdout.write(str(var)) # for fast output, always take string\n\n\ndef lis(): return list(map(int, inp().split()))\n\n\ndef stringlis(): return list(map(str, inp().split()))\n\n\ndef sep(): return list(map(int, inp().split()))\n\n\ndef strsep(): return list(map(str, inp().split()))\n\n\ndef fsep(): return list(map(float, inp().split()))\n\n\ndef nextline(): out(\"\\n\") # as stdout.write always print sring.\n\n\ndef testcase(t):\n for p in range(t):\n solve()\n\n\ndef pow(x, y, p):\n res = 1 # Initialize result\n x = x % p # Update x if it is more , than or equal to p\n if (x == 0):\n return 0\n while (y > 0):\n if ((y & 1) == 1): # If y is odd, multiply, x with result\n res = (res * x) % p\n\n y = y >> 1 # y = y/2\n x = (x * x) % p\n return res\n\n\nfrom functools import reduce\n\n\ndef factors(n):\n return set(reduce(list.__add__,\n ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))\n\n\ndef gcd(a, b):\n if a == b: return a\n while b > 0: a, b = b, a % b\n return a\n\n\n# discrete binary search\n# minimise:\n# def search():\n# l = 0\n# r = 10 ** 15\n#\n# for i in range(200):\n# if isvalid(l):\n# return l\n# if l == r:\n# return l\n# m = (l + r) // 2\n# if isvalid(m) and not isvalid(m - 1):\n# return m\n# if isvalid(m):\n# r = m + 1\n# else:\n# l = m\n# return m\n\n# maximise:\n# def search():\n# l = 0\n# r = 10 ** 15\n#\n# for i in range(200):\n# # print(l,r)\n# if isvalid(r):\n# return r\n# if l == r:\n# return l\n# m = (l + r) // 2\n# if isvalid(m) and not isvalid(m + 1):\n# return m\n# if isvalid(m):\n# l = m\n# else:\n# r = m - 1\n# return m\n\n\n##to find factorial and ncr\n# N=100000\n# mod = 10**9 +7\n# fac = [1, 1]\n# finv = [1, 1]\n# inv = [0, 1]\n#\n# for i in range(2, N + 1):\n# fac.append((fac[-1] * i) % mod)\n# inv.append(mod - (inv[mod % i] * (mod // i) % mod))\n# finv.append(finv[-1] * inv[-1] % mod)\n#\n#\n# def comb(n, r):\n# if n < r:\n# return 0\n# else:\n# return fac[n] * (finv[r] * finv[n - r] % mod) % mod\n\n\n##############Find sum of product of subsets of size k in a array\n# ar=[0,1,2,3]\n# k=3\n# n=len(ar)-1\n# dp=[0]*(n+1)\n# dp[0]=1\n# for pos in range(1,n+1):\n# dp[pos]=0\n# l=max(1,k+pos-n-1)\n# for j in range(min(pos,k),l-1,-1):\n# dp[j]=dp[j]+ar[pos]*dp[j-1]\n# print(dp[k])\n\ndef prefix_sum(ar): # [1,2,3,4]->[1,3,6,10]\n return list(accumulate(ar))\n\n\ndef suffix_sum(ar): # [1,2,3,4]->[10,9,7,4]\n return list(accumulate(ar[::-1]))[::-1]\n\n\ndef N():\n return int(inp())\n\n\n# =========================================================================================\nfrom collections import defaultdict\n\n\n\ndef numberOfSetBits(i):\n i = i - ((i >> 1) & 0x55555555)\n i = (i & 0x33333333) + ((i >> 2) & 0x33333333)\n return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24\n\n\n\ndef solve():\n n=N()\n ar=lis()\n for i in range(len(ar)):\n m=ar[i]\n v = m // 2\n u = v // 2\n w = (v - u)\n print((u * w + u + w + 1) % mod)\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nsolve()\n#testcase(int(inp()))\n", "T = input()\nmod = int(1e9 + 7)\na = map(int, input().split())\nc = []\nfor n in a:\n b = (n // 2 + 2)\n b = b * b\n b //= 4\n c.append(str(b % mod))\nprint(' '.join(c))"] | {"inputs": ["2\n2 4\n", "1\n9\n", "5\n4 1 8 3 9\n", "6\n8 7 8 6 8 9\n", "8\n1 1 7 6 1 5 8 7\n", "7\n9 6 3 1 3 1 7\n", "3\n9 2 8\n", "5\n3 7 3 4 7\n", "5\n4 8 3 2 6\n", "5\n2 7 4 8 3\n"], "outputs": ["2\n4\n", "9\n", "4\n1\n9\n2\n9\n", "9\n6\n9\n6\n9\n9\n", "1\n1\n6\n6\n1\n4\n9\n6\n", "9\n6\n2\n1\n2\n1\n6\n", "9\n2\n9\n", "2\n6\n2\n4\n6\n", "4\n9\n2\n2\n6\n", "2\n6\n4\n9\n2\n"]} | COMPETITION | PYTHON3 | CODEFORCES | 10,718 | |
1a322722f00927991581c3d997bc2732 | UNKNOWN | Meanwhile, the kingdom of K is getting ready for the marriage of the King's daughter. However, in order not to lose face in front of the relatives, the King should first finish reforms in his kingdom. As the King can not wait for his daughter's marriage, reforms must be finished as soon as possible.
The kingdom currently consists of n cities. Cities are connected by n - 1 bidirectional road, such that one can get from any city to any other city. As the King had to save a lot, there is only one path between any two cities.
What is the point of the reform? The key ministries of the state should be relocated to distinct cities (we call such cities important). However, due to the fact that there is a high risk of an attack by barbarians it must be done carefully. The King has made several plans, each of which is described by a set of important cities, and now wonders what is the best plan.
Barbarians can capture some of the cities that are not important (the important ones will have enough protection for sure), after that the captured city becomes impassable. In particular, an interesting feature of the plan is the minimum number of cities that the barbarians need to capture in order to make all the important cities isolated, that is, from all important cities it would be impossible to reach any other important city.
Help the King to calculate this characteristic for each of his plan.
-----Input-----
The first line of the input contains integer n (1 ≤ n ≤ 100 000) — the number of cities in the kingdom.
Each of the next n - 1 lines contains two distinct integers u_{i}, v_{i} (1 ≤ u_{i}, v_{i} ≤ n) — the indices of the cities connected by the i-th road. It is guaranteed that you can get from any city to any other one moving only along the existing roads.
The next line contains a single integer q (1 ≤ q ≤ 100 000) — the number of King's plans.
Each of the next q lines looks as follows: first goes number k_{i} — the number of important cities in the King's plan, (1 ≤ k_{i} ≤ n), then follow exactly k_{i} space-separated pairwise distinct numbers from 1 to n — the numbers of important cities in this plan.
The sum of all k_{i}'s does't exceed 100 000.
-----Output-----
For each plan print a single integer — the minimum number of cities that the barbarians need to capture, or print - 1 if all the barbarians' attempts to isolate important cities will not be effective.
-----Examples-----
Input
4
1 3
2 3
4 3
4
2 1 2
3 2 3 4
3 1 2 4
4 1 2 3 4
Output
1
-1
1
-1
Input
7
1 2
2 3
3 4
1 5
5 6
5 7
1
4 2 4 6 7
Output
2
-----Note-----
In the first sample, in the first and the third King's plan barbarians can capture the city 3, and that will be enough. In the second and the fourth plans all their attempts will not be effective.
In the second sample the cities to capture are 3 and 5. | ["import sys\nfrom collections import deque\ndef solve():\n sys.setrecursionlimit(10**6)\n readline = sys.stdin.readline\n writelines = sys.stdout.writelines\n N = int(readline())\n G = [[] for i in range(N)]\n for i in range(N-1):\n u, v = map(int, readline().split())\n G[u-1].append(v-1)\n G[v-1].append(u-1)\n\n # Euler tour technique\n S = []\n FS = [0]*N; LS = [0]*N\n depth = [0]*N\n stk = [-1, 0]\n it = [0]*N\n while len(stk) > 1:\n v = stk[-1]\n i = it[v]\n if i == 0:\n FS[v] = len(S)\n depth[v] = len(stk)\n if i < len(G[v]) and G[v][i] == stk[-2]:\n it[v] += 1\n i += 1\n if i == len(G[v]):\n LS[v] = len(S)\n stk.pop()\n else:\n stk.append(G[v][i])\n it[v] += 1\n S.append(v)\n\n L = len(S)\n lg = [0]*(L+1)\n # Sparse Table\n for i in range(2, L+1):\n lg[i] = lg[i >> 1] + 1\n st = [[L]*(L - (1 << i) + 1) for i in range(lg[L]+1)]\n st[0][:] = S\n b = 1\n for i in range(lg[L]):\n st0 = st[i]\n st1 = st[i+1]\n for j in range(L - (b<<1) + 1):\n st1[j] = (st0[j] if depth[st0[j]] <= depth[st0[j+b]] else st0[j+b])\n b <<= 1\n\n INF = 10**18\n ans = []\n Q = int(readline())\n G0 = [[]]*N\n P = [0]*N\n deg = [0]*N\n KS = [0]*N\n A = [0]*N\n B = [0]*N\n for t in range(Q):\n k, *vs = map(int, readline().split())\n for i in range(k):\n vs[i] -= 1\n KS[vs[i]] = 1\n vs.sort(key=FS.__getitem__)\n for i in range(k-1):\n x = FS[vs[i]]; y = FS[vs[i+1]]\n l = lg[y - x + 1]\n w = st[l][x] if depth[st[l][x]] <= depth[st[l][y - (1 << l) + 1]] else st[l][y - (1 << l) + 1]\n vs.append(w)\n vs.sort(key=FS.__getitem__)\n stk = []\n prv = -1\n for v in vs:\n if v == prv:\n continue\n while stk and LS[stk[-1]] < FS[v]:\n stk.pop()\n if stk:\n G0[stk[-1]].append(v)\n G0[v] = []\n it[v] = 0\n stk.append(v)\n prv = v\n que = deque()\n prv = -1\n P[vs[0]] = -1\n for v in vs:\n if v == prv:\n continue\n for w in G0[v]:\n P[w] = v\n deg[v] = len(G0[v])\n if deg[v] == 0:\n que.append(v)\n prv = v\n\n while que:\n v = que.popleft()\n if KS[v]:\n a = 0\n for w in G0[v]:\n ra = A[w]; rb = B[w]\n if depth[v]+1 < depth[w]:\n a += min(ra, rb+1)\n else:\n a += ra\n A[v] = INF\n B[v] = a\n else:\n a = 0; b = c = INF\n for w in G0[v]:\n ra = A[w]; rb = B[w]\n a, b, c = a + ra, min(a + rb, b + ra), min(b + rb, c + min(ra, rb))\n A[v] = min(a, b+1, c+1)\n B[v] = b\n\n p = P[v]\n if p != -1:\n deg[p] -= 1\n if deg[p] == 0:\n que.append(p)\n v = min(A[vs[0]], B[vs[0]])\n if v >= INF:\n ans.append(\"-1\\n\")\n else:\n ans.append(\"%d\\n\" % v)\n for v in vs:\n KS[v] = 0\n\n writelines(ans)\nsolve()"] | {
"inputs": [
"4\n1 3\n2 3\n4 3\n4\n2 1 2\n3 2 3 4\n3 1 2 4\n4 1 2 3 4\n",
"7\n1 2\n2 3\n3 4\n1 5\n5 6\n5 7\n1\n4 2 4 6 7\n",
"7\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n5\n4 1 3 5 7\n3 2 4 6\n2 1 7\n2 3 4\n3 1 6 7\n",
"30\n1 2\n1 3\n1 4\n2 5\n2 6\n2 7\n4 8\n4 9\n6 10\n6 11\n11 30\n11 23\n30 24\n30 25\n25 26\n25 27\n27 29\n27 28\n23 20\n23 22\n20 21\n20 19\n3 12\n3 13\n13 14\n13 15\n15 16\n15 17\n15 18\n2\n6 17 25 20 5 9 13\n10 2 4 3 14 16 18 22 29 30 19\n",
"4\n1 2\n2 3\n1 4\n1\n3 1 3 4\n"
],
"outputs": [
"1\n-1\n1\n-1\n",
"2\n",
"3\n2\n1\n-1\n-1\n",
"3\n6\n",
"-1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,606 | |
019f8f852f35fa8ee4029d99fd49ec21 | UNKNOWN | Sergey Semyonovich is a mayor of a county city N and he used to spend his days and nights in thoughts of further improvements of Nkers' lives. Unfortunately for him, anything and everything has been done already, and there are no more possible improvements he can think of during the day (he now prefers to sleep at night). However, his assistants have found a solution and they now draw an imaginary city on a paper sheet and suggest the mayor can propose its improvements.
Right now he has a map of some imaginary city with $n$ subway stations. Some stations are directly connected with tunnels in such a way that the whole map is a tree (assistants were short on time and enthusiasm). It means that there exists exactly one simple path between each pair of station. We call a path simple if it uses each tunnel no more than once.
One of Sergey Semyonovich's favorite quality objectives is the sum of all pairwise distances between every pair of stations. The distance between two stations is the minimum possible number of tunnels on a path between them.
Sergey Semyonovich decided to add new tunnels to the subway map. In particular, he connected any two stations $u$ and $v$ that were not connected with a direct tunnel but share a common neighbor, i.e. there exists such a station $w$ that the original map has a tunnel between $u$ and $w$ and a tunnel between $w$ and $v$. You are given a task to compute the sum of pairwise distances between all pairs of stations in the new map.
-----Input-----
The first line of the input contains a single integer $n$ ($2 \leq n \leq 200\,000$) — the number of subway stations in the imaginary city drawn by mayor's assistants. Each of the following $n - 1$ lines contains two integers $u_i$ and $v_i$ ($1 \leq u_i, v_i \leq n$, $u_i \ne v_i$), meaning the station with these indices are connected with a direct tunnel.
It is guaranteed that these $n$ stations and $n - 1$ tunnels form a tree.
-----Output-----
Print one integer that is equal to the sum of distances between all pairs of stations after Sergey Semyonovich draws new tunnels between all pairs of stations that share a common neighbor in the original map.
-----Examples-----
Input
4
1 2
1 3
1 4
Output
6
Input
4
1 2
2 3
3 4
Output
7
-----Note-----
In the first sample, in the new map all pairs of stations share a direct connection, so the sum of distances is $6$.
In the second sample, the new map has a direct tunnel between all pairs of stations except for the pair $(1, 4)$. For these two stations the distance is $2$. | ["def main():\n def countchildren(graph,vert,memo,pard=None):\n dumi=0\n for child in graph[vert]:\n if child!=pard:\n if len(graph[child])==1:\n memo[child]=0\n else:\n memo[child]=countchildren(graph,child,memo,vert)[0]\n dumi+=memo[child]+1\n return((dumi,memo))\n n=int(input())\n neigh=[]\n for i in range(n):\n neigh.append([])\n for i in range(n-1):\n a,b=map(int,input().split())\n neigh[a-1].append(b-1)\n neigh[b-1].append(a-1)\n same=1\n layer=[0]\n pars=[None]\n j=0\n while layer!=[]:\n j+=1\n newlayer=[]\n newpars=[]\n for i in range(len(layer)):\n for vert in neigh[layer[i]]:\n if vert!=pars[i]:\n newlayer.append(vert)\n newpars.append(layer[i])\n layer=newlayer\n pars=newpars\n if j%2==0:\n same+=len(layer)\n bipartite=same*(n-same)\n info=countchildren(neigh,0,[None]*n)[1]\n dist=0\n for guy in info:\n if guy!=None:\n dist+=(guy+1)*(n-guy-1)\n print((dist+bipartite)//2)\n\nimport sys\nimport threading\nsys.setrecursionlimit(2097152)\nthreading.stack_size(134217728)\nmain_thread=threading.Thread(target=main)\nmain_thread.start()\nmain_thread.join()", "def main():\n def countchildren(graph,vert,memo,pard=None):\n dumi=0\n for child in graph[vert]:\n if child!=pard:\n if len(graph[child])==1:\n memo[child]=0\n else:\n memo[child]=countchildren(graph,child,memo,vert)[0]\n dumi+=memo[child]+1\n return((dumi,memo))\n n=int(input())\n neigh=[]\n for i in range(n):\n neigh.append([])\n for i in range(n-1):\n a,b=map(int,input().split())\n neigh[a-1].append(b-1)\n neigh[b-1].append(a-1)\n same=1\n layer=[0]\n pars=[None]\n j=0\n while layer!=[]:\n j+=1\n newlayer=[]\n newpars=[]\n for i in range(len(layer)):\n for vert in neigh[layer[i]]:\n if vert!=pars[i]:\n newlayer.append(vert)\n newpars.append(layer[i])\n layer=newlayer\n pars=newpars\n if j%2==0:\n same+=len(layer)\n bipartite=same*(n-same)\n info=countchildren(neigh,0,[None]*n)[1]\n dist=0\n for guy in info:\n if guy!=None:\n dist+=(guy+1)*(n-guy-1)\n print((dist+bipartite)//2)\n\nimport sys\nimport threading\nsys.setrecursionlimit(2097152)\nthreading.stack_size(134217728)\nmain_thread=threading.Thread(target=main)\nmain_thread.start()\nmain_thread.join()", "import sys\nimport threading\nsys.setrecursionlimit(2097152)\n\ndef main():\n def countchildren(graph,vert,memo,pard=None):\n dumi=0\n for child in graph[vert]:\n if child!=pard:\n if len(graph[child])==1:\n memo[child]=0\n else:\n memo[child]=countchildren(graph,child,memo,vert)[0]\n dumi+=memo[child]+1\n return((dumi,memo))\n n=int(input())\n neigh=[]\n for i in range(n):\n neigh.append([])\n for i in range(n-1):\n a,b=map(int,input().split())\n neigh[a-1].append(b-1)\n neigh[b-1].append(a-1)\n same=1\n layer=[0]\n pars=[None]\n j=0\n while layer!=[]:\n j+=1\n newlayer=[]\n newpars=[]\n for i in range(len(layer)):\n for vert in neigh[layer[i]]:\n if vert!=pars[i]:\n newlayer.append(vert)\n newpars.append(layer[i])\n layer=newlayer\n pars=newpars\n if j%2==0:\n same+=len(layer)\n bipartite=same*(n-same)\n info=countchildren(neigh,0,[None]*n)[1]\n dist=0\n for guy in info:\n if guy!=None:\n dist+=(guy+1)*(n-guy-1)\n print((dist+bipartite)//2)\n \nthreading.stack_size(134217728)\nmain_thread=threading.Thread(target=main)\nmain_thread.start()\nmain_thread.join()", "import sys\nimport threading\nsys.setrecursionlimit(2100000)\n\ndef main():\n def counter(graph,vert,memo,pard=None):\n d = 0\n for c in graph[vert]:\n if c!=pard:\n if len(graph[c])==1:\n memo[c]=0\n else:\n memo[c]=counter(graph, c, memo, vert)[0]\n d += memo[c]+1\n return((d, memo))\n\n n=int(input())\n vizinhos=[]\n\n for _ in range(n):\n vizinhos.append([])\n\n for _ in range(n-1):\n i, j=map(int, input().split())\n vizinhos[i-1].append(j-1)\n vizinhos[j-1].append(i-1)\n\n same=1\n layer=[0]\n par=[None]\n j=0\n while layer:\n j+=1\n n_layer=[]\n n_pars=[]\n for i in range(len(layer)):\n for vert in vizinhos[layer[i]]:\n if vert!=par[i]:\n n_layer.append(vert)\n n_pars.append(layer[i])\n layer=n_layer\n par=n_pars\n if j%2==0:\n same+=len(layer)\n bipartite = same*(n-same)\n info=counter(vizinhos,0,[None]*n)[1]\n dist=0\n for g in info:\n if g!=None:\n dist += (g+1)*(n-g-1)\n print((dist+bipartite)//2)\n \nthreading.stack_size(140000000)\nmain_thread=threading.Thread(target=main)\nmain_thread.start()\nmain_thread.join()", "import sys\nimport threading\nsys.setrecursionlimit(2100000)\n\ndef main():\n def counter(graph,vert,memo,pard=None):\n d = 0\n for c in graph[vert]:\n if c!=pard:\n if len(graph[c])==1:\n memo[c]=0\n else:\n memo[c]=counter(graph, c, memo, vert)[0]\n d += memo[c]+1\n return((d, memo))\n\n n=int(input())\n vizinhos=[]\n\n for _ in range(n):\n vizinhos.append([])\n\n for _ in range(n-1):\n i, j=map(int, input().split())\n vizinhos[i-1].append(j-1)\n vizinhos[j-1].append(i-1)\n\n same=1\n layer=[0]\n par=[None]\n j=0\n while layer:\n j+=1\n n_layer=[]\n n_pars=[]\n for i in range(len(layer)):\n for vert in vizinhos[layer[i]]:\n if vert!=par[i]:\n n_layer.append(vert)\n n_pars.append(layer[i])\n layer=n_layer\n par=n_pars\n if j%2==0:\n same+=len(layer)\n bipartite = same*(n-same)\n info=counter(vizinhos,0,[None]*n)[1]\n dist=0\n for g in info:\n if g!=None:\n dist += (g+1)*(n-g-1)\n print((dist+bipartite)//2)\n \nthreading.stack_size(140000000)\nmain_thread=threading.Thread(target=main)\nmain_thread.start()\nmain_thread.join()"] | {
"inputs": [
"4\n1 2\n1 3\n1 4\n",
"4\n1 2\n2 3\n3 4\n",
"2\n2 1\n",
"3\n2 1\n3 2\n",
"10\n2 3\n3 9\n6 3\n9 8\n9 10\n4 8\n3 1\n3 5\n7 1\n"
],
"outputs": [
"6\n",
"7\n",
"1\n",
"3\n",
"67\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 6,967 | |
c4b712b743ffb7270e10f838ada21c40 | UNKNOWN | There are $n$ lamps on a line, numbered from $1$ to $n$. Each one has an initial state off ($0$) or on ($1$).
You're given $k$ subsets $A_1, \ldots, A_k$ of $\{1, 2, \dots, n\}$, such that the intersection of any three subsets is empty. In other words, for all $1 \le i_1 < i_2 < i_3 \le k$, $A_{i_1} \cap A_{i_2} \cap A_{i_3} = \varnothing$.
In one operation, you can choose one of these $k$ subsets and switch the state of all lamps in it. It is guaranteed that, with the given subsets, it's possible to make all lamps be simultaneously on using this type of operation.
Let $m_i$ be the minimum number of operations you have to do in order to make the $i$ first lamps be simultaneously on. Note that there is no condition upon the state of other lamps (between $i+1$ and $n$), they can be either off or on.
You have to compute $m_i$ for all $1 \le i \le n$.
-----Input-----
The first line contains two integers $n$ and $k$ ($1 \le n, k \le 3 \cdot 10^5$).
The second line contains a binary string of length $n$, representing the initial state of each lamp (the lamp $i$ is off if $s_i = 0$, on if $s_i = 1$).
The description of each one of the $k$ subsets follows, in the following format:
The first line of the description contains a single integer $c$ ($1 \le c \le n$) — the number of elements in the subset.
The second line of the description contains $c$ distinct integers $x_1, \ldots, x_c$ ($1 \le x_i \le n$) — the elements of the subset.
It is guaranteed that: The intersection of any three subsets is empty; It's possible to make all lamps be simultaneously on using some operations.
-----Output-----
You must output $n$ lines. The $i$-th line should contain a single integer $m_i$ — the minimum number of operations required to make the lamps $1$ to $i$ be simultaneously on.
-----Examples-----
Input
7 3
0011100
3
1 4 6
3
3 4 7
2
2 3
Output
1
2
3
3
3
3
3
Input
8 6
00110011
3
1 3 8
5
1 2 5 6 7
2
6 8
2
3 5
2
4 7
1
2
Output
1
1
1
1
1
1
4
4
Input
5 3
00011
3
1 2 3
1
4
3
3 4 5
Output
1
1
1
1
1
Input
19 5
1001001001100000110
2
2 3
2
5 6
2
8 9
5
12 13 14 15 16
1
19
Output
0
1
1
1
2
2
2
3
3
3
3
4
4
4
4
4
4
4
5
-----Note-----
In the first example: For $i = 1$, we can just apply one operation on $A_1$, the final states will be $1010110$; For $i = 2$, we can apply operations on $A_1$ and $A_3$, the final states will be $1100110$; For $i \ge 3$, we can apply operations on $A_1$, $A_2$ and $A_3$, the final states will be $1111111$.
In the second example: For $i \le 6$, we can just apply one operation on $A_2$, the final states will be $11111101$; For $i \ge 7$, we can apply operations on $A_1, A_3, A_4, A_6$, the final states will be $11111111$. | ["import sys\nreadline = sys.stdin.readline\nclass UF():\n def __init__(self, num):\n self.par = [-1]*num\n self.weight = [0]*num\n def find(self, x):\n if self.par[x] < 0:\n return x\n else:\n stack = []\n while self.par[x] >= 0:\n stack.append(x)\n x = self.par[x]\n for xi in stack:\n self.par[xi] = x\n return x\n \n def union(self, x, y):\n rx = self.find(x)\n ry = self.find(y)\n if rx != ry:\n if self.par[rx] > self.par[ry]:\n rx, ry = ry, rx\n self.par[rx] += self.par[ry]\n self.par[ry] = rx\n self.weight[rx] += self.weight[ry]\n return rx\n\nN, K = list(map(int, readline().split()))\nS = list(map(int, readline().strip()))\n\nA = [[] for _ in range(N)]\n\nfor k in range(K):\n BL = int(readline())\n B = list(map(int, readline().split()))\n for b in B:\n A[b-1].append(k)\n\ncnt = 0\nT = UF(2*K)\nused = set()\nAns = [None]*N\ninf = 10**9+7\nfor i in range(N):\n if not len(A[i]):\n Ans[i] = cnt\n continue\n kk = 0\n if len(A[i]) == 2: \n x, y = A[i]\n if S[i]:\n rx = T.find(x)\n ry = T.find(y)\n if rx != ry:\n rx2 = T.find(x+K)\n ry2 = T.find(y+K)\n sp = min(T.weight[rx], T.weight[rx2]) + min(T.weight[ry], T.weight[ry2])\n if x not in used:\n used.add(x)\n T.weight[rx] += 1\n if y not in used:\n used.add(y)\n T.weight[ry] += 1\n rz = T.union(rx, ry)\n rz2 = T.union(rx2, ry2)\n sf = min(T.weight[rz], T.weight[rz2])\n kk = sf - sp\n else:\n rx = T.find(x)\n ry2 = T.find(y+K)\n sp = 0\n if rx != ry2:\n ry = T.find(y)\n rx2 = T.find(x+K)\n sp = min(T.weight[rx], T.weight[rx2]) + min(T.weight[ry], T.weight[ry2])\n if x not in used:\n used.add(x)\n T.weight[rx] += 1\n if y not in used:\n used.add(y)\n T.weight[ry] += 1\n rz = T.union(rx, ry2)\n rz2 = T.union(rx2, ry)\n sf = min(T.weight[rz], T.weight[rz2])\n kk = sf - sp\n else:\n if S[i]:\n x = A[i][0]\n rx = T.find(x)\n rx2 = T.find(x+K)\n sp = min(T.weight[rx], T.weight[rx2])\n T.weight[rx] += inf\n sf = min(T.weight[rx], T.weight[rx2])\n kk = sf - sp\n else:\n x = A[i][0]\n rx = T.find(x)\n rx2 = T.find(x+K)\n sp = min(T.weight[rx], T.weight[rx2])\n T.weight[rx2] += inf\n if x not in used:\n used.add(x)\n T.weight[rx] += 1\n sf = min(T.weight[rx], T.weight[rx2])\n kk = sf-sp\n Ans[i] = cnt + kk\n cnt = Ans[i] \nprint('\\n'.join(map(str, Ans)))\n \n", "import sys\nreadline = sys.stdin.readline\nclass UF():\n def __init__(self, num):\n self.par = [-1]*num\n self.weight = [0]*num\n def find(self, x):\n stack = []\n while self.par[x] >= 0:\n stack.append(x)\n x = self.par[x]\n for xi in stack:\n self.par[xi] = x\n return x\n \n def union(self, x, y):\n rx = self.find(x)\n ry = self.find(y)\n if rx != ry:\n if self.par[rx] > self.par[ry]:\n rx, ry = ry, rx\n self.par[rx] += self.par[ry]\n self.par[ry] = rx\n self.weight[rx] += self.weight[ry]\n return rx\n\n\nN, K = list(map(int, readline().split()))\nS = list(map(int, readline().strip()))\n\nA = [[] for _ in range(N)]\n\nfor k in range(K):\n BL = int(readline())\n B = list(map(int, readline().split()))\n for b in B:\n A[b-1].append(k)\n\ncnt = 0\nT = UF(2*K)\nused = set()\nAns = [None]*N\ninf = 10**9+7\nfor i in range(N):\n if not len(A[i]):\n Ans[i] = cnt\n continue\n kk = 0\n if len(A[i]) == 2: \n x, y = A[i]\n if S[i]:\n rx = T.find(x)\n ry = T.find(y)\n if rx != ry:\n rx2 = T.find(x+K)\n ry2 = T.find(y+K)\n sp = min(T.weight[rx], T.weight[rx2]) + min(T.weight[ry], T.weight[ry2])\n if x not in used:\n used.add(x)\n T.weight[rx] += 1\n if y not in used:\n used.add(y)\n T.weight[ry] += 1\n rz = T.union(rx, ry)\n rz2 = T.union(rx2, ry2)\n sf = min(T.weight[rz], T.weight[rz2])\n kk = sf - sp\n else:\n rx = T.find(x)\n ry2 = T.find(y+K)\n sp = 0\n if rx != ry2:\n ry = T.find(y)\n rx2 = T.find(x+K)\n sp = min(T.weight[rx], T.weight[rx2]) + min(T.weight[ry], T.weight[ry2])\n if x not in used:\n used.add(x)\n T.weight[rx] += 1\n if y not in used:\n used.add(y)\n T.weight[ry] += 1\n rz = T.union(rx, ry2)\n rz2 = T.union(rx2, ry)\n sf = min(T.weight[rz], T.weight[rz2])\n kk = sf - sp\n else:\n if S[i]:\n x = A[i][0]\n rx = T.find(x)\n rx2 = T.find(x+K)\n sp = min(T.weight[rx], T.weight[rx2])\n T.weight[rx] += inf\n sf = min(T.weight[rx], T.weight[rx2])\n kk = sf - sp\n else:\n x = A[i][0]\n rx = T.find(x)\n rx2 = T.find(x+K)\n sp = min(T.weight[rx], T.weight[rx2])\n T.weight[rx2] += inf\n if x not in used:\n used.add(x)\n T.weight[rx] += 1\n sf = min(T.weight[rx], T.weight[rx2])\n kk = sf-sp\n Ans[i] = cnt + kk\n cnt = Ans[i] \nprint('\\n'.join(map(str, Ans)))\n \n"] | {
"inputs": [
"7 3\n0011100\n3\n1 4 6\n3\n3 4 7\n2\n2 3\n",
"8 6\n00110011\n3\n1 3 8\n5\n1 2 5 6 7\n2\n6 8\n2\n3 5\n2\n4 7\n1\n2\n",
"5 3\n00011\n3\n1 2 3\n1\n4\n3\n3 4 5\n",
"19 5\n1001001001100000110\n2\n2 3\n2\n5 6\n2\n8 9\n5\n12 13 14 15 16\n1\n19\n",
"1 1\n1\n1\n1\n"
],
"outputs": [
"1\n2\n3\n3\n3\n3\n3\n",
"1\n1\n1\n1\n1\n1\n4\n4\n",
"1\n1\n1\n1\n1\n",
"0\n1\n1\n1\n2\n2\n2\n3\n3\n3\n3\n4\n4\n4\n4\n4\n4\n4\n5\n",
"0\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 6,442 | |
96cd550a714643735a6f48906200d7af | UNKNOWN | You are given a permutation $p_1, p_2, \ldots, p_n$.
In one move you can swap two adjacent values.
You want to perform a minimum number of moves, such that in the end there will exist a subsegment $1,2,\ldots, k$, in other words in the end there should be an integer $i$, $1 \leq i \leq n-k+1$ such that $p_i = 1, p_{i+1} = 2, \ldots, p_{i+k-1}=k$.
Let $f(k)$ be the minimum number of moves that you need to make a subsegment with values $1,2,\ldots,k$ appear in the permutation.
You need to find $f(1), f(2), \ldots, f(n)$.
-----Input-----
The first line of input contains one integer $n$ ($1 \leq n \leq 200\,000$): the number of elements in the permutation.
The next line of input contains $n$ integers $p_1, p_2, \ldots, p_n$: given permutation ($1 \leq p_i \leq n$).
-----Output-----
Print $n$ integers, the minimum number of moves that you need to make a subsegment with values $1,2,\ldots,k$ appear in the permutation, for $k=1, 2, \ldots, n$.
-----Examples-----
Input
5
5 4 3 2 1
Output
0 1 3 6 10
Input
3
1 2 3
Output
0 0 0 | ["import sys\nreader = (s.rstrip() for s in sys.stdin)\ninput = reader.__next__\n\nclass Binary_Indexed_Tree():\n def __init__(self, n):\n self.n = n\n self.data = [0]*(n+1)\n\n def add(self, i, x):\n while i <= self.n:\n self.data[i] += x\n i += i & -i\n\n def get(self, i):\n return self.sum_range(i, i)\n\n def sum(self, i):\n ret = 0\n while i:\n ret += self.data[i]\n i &= i-1\n return ret\n\n def sum_range(self, l, r):\n return self.sum(r)-self.sum(l-1)\n\n def lower_bound(self, w):\n if w<=0:\n return 0\n i = 0\n k = 1<<(self.n.bit_length())\n while k:\n if i+k <= self.n and self.data[i+k] < w:\n w -= self.data[i+k]\n i += k\n k >>= 1\n return i+1\n\nn = int(input())\na = list(map(int, input().split()))\nd = {j:i for i,j in enumerate(a)}\nBIT1 = Binary_Indexed_Tree(n)\nBIT2 = Binary_Indexed_Tree(n)\nBIT3 = Binary_Indexed_Tree(n)\n\ntentou = 0\nans = []\nfor i in range(n):\n tmp = 0\n p = d[i+1]\n inv_p = n-p\n tentou += BIT1.sum(inv_p)\n BIT1.add(inv_p, 1)\n\n BIT2.add(p+1, 1)\n BIT3.add(p+1, p+1)\n m = i//2+1\n mean = BIT2.lower_bound(i//2+1)\n tmp = 0\n if i%2 == 0:\n tmp -= m*(m-1)\n else:\n tmp -= m*m\n tmp += tentou\n left = BIT3.sum_range(1, mean)\n right = BIT3.sum_range(mean, n)\n if i%2 == 0:\n left = mean*m - left\n right = right - mean*m\n else:\n left = mean*m - left\n right = right - mean*(m+1)\n tmp += left + right\n ans.append(tmp)\nprint(*ans)\n\n", "import heapq\n\n\nclass DynamicMedian():\n def __init__(self):\n self.l_q = [] \n self.r_q = []\n self.l_sum = 0\n self.r_sum = 0\n \n def add(self, val):\n if len(self.l_q) == len(self.r_q):\n self.l_sum += val\n val = -heapq.heappushpop(self.l_q, -val)\n self.l_sum -= val\n heapq.heappush(self.r_q, val)\n self.r_sum += val\n else:\n self.r_sum += val\n val = heapq.heappushpop(self.r_q, val)\n self.r_sum -= val\n heapq.heappush(self.l_q, -val)\n self.l_sum += val\n \n def median_low(self):\n if len(self.l_q) + 1 == len(self.r_q):\n return self.r_q[0]\n else:\n return -self.l_q[0]\n \n def median_high(self):\n return self.r_q[0]\n \n def minimum_query(self):\n res1 = (len(self.l_q) * self.median_high() - self.l_sum)\n res2 = (self.r_sum - len(self.r_q) * self.median_high())\n return res1 + res2\n\n#Binary Indexed Tree (Fenwick Tree)\nclass BIT():\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n \n def add(self, i, val):\n i = i + 1\n while i <= self.n:\n self.bit[i] += val\n i += i & -i\n \n def _sum(self, i):\n s = 0\n while i > 0:\n s += self.bit[i]\n i -= i & -i\n return s\n \n def sum(self, i, j):\n return self._sum(j) - self._sum(i)\n \n \nimport sys\ninput = sys.stdin.readline\n\nn = int(input())\na = list(map(int, input().split()))\nbit = BIT(n)\ndm = DynamicMedian()\n \nmemo = {}\nfor i in range(n):\n memo[a[i] - 1] = i\n\nb = [0] * n\nfor i in range(n):\n dm.add(memo[i])\n b[i] = dm.minimum_query() - (i+1)**2 // 4\n\nans = [0] * n\ntmp = 0\nfor i in range(len(a)):\n bit.add(memo[i], 1)\n tmp += bit.sum(memo[i] + 1, n)\n ans[i] = tmp + b[i]\nprint(*ans)\n \n"] | {
"inputs": [
"5\n5 4 3 2 1\n",
"3\n1 2 3\n",
"1\n1\n",
"10\n5 1 6 2 8 3 4 10 9 7\n",
"100\n98 52 63 2 18 96 31 58 84 40 41 45 66 100 46 71 26 48 81 20 73 91 68 76 13 93 17 29 64 95 79 21 55 75 19 85 54 51 89 78 15 87 43 59 36 1 90 35 65 56 62 28 86 5 82 49 3 99 33 9 92 32 74 69 27 22 77 16 44 94 34 6 57 70 23 12 61 25 8 11 67 47 83 88 10 14 30 7 97 60 42 37 24 38 53 50 4 80 72 39\n"
],
"outputs": [
"0 1 3 6 10 \n",
"0 0 0 \n",
"0 \n",
"0 1 2 3 8 9 12 12 13 13 \n",
"0 42 52 101 101 117 146 166 166 188 194 197 249 258 294 298 345 415 445 492 522 529 540 562 569 628 628 644 684 699 765 766 768 774 791 812 828 844 863 931 996 1011 1036 1040 1105 1166 1175 1232 1237 1251 1282 1364 1377 1409 1445 1455 1461 1534 1553 1565 1572 1581 1664 1706 1715 1779 1787 1837 1841 1847 1909 1919 1973 1976 2010 2060 2063 2087 2125 2133 2192 2193 2196 2276 2305 2305 2324 2327 2352 2361 2417 2418 2467 2468 2510 2598 2599 2697 2697 2770 \n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,704 | |
05c7940bd91dafa4b6de21e231df8888 | UNKNOWN | Let's denote as $\text{popcount}(x)$ the number of bits set ('1' bits) in the binary representation of the non-negative integer x.
You are given multiple queries consisting of pairs of integers l and r. For each query, find the x, such that l ≤ x ≤ r, and $\text{popcount}(x)$ is maximum possible. If there are multiple such numbers find the smallest of them.
-----Input-----
The first line contains integer n — the number of queries (1 ≤ n ≤ 10000).
Each of the following n lines contain two integers l_{i}, r_{i} — the arguments for the corresponding query (0 ≤ l_{i} ≤ r_{i} ≤ 10^18).
-----Output-----
For each query print the answer in a separate line.
-----Examples-----
Input
3
1 2
2 4
1 10
Output
1
3
7
-----Note-----
The binary representations of numbers from 1 to 10 are listed below:
1_10 = 1_2
2_10 = 10_2
3_10 = 11_2
4_10 = 100_2
5_10 = 101_2
6_10 = 110_2
7_10 = 111_2
8_10 = 1000_2
9_10 = 1001_2
10_10 = 1010_2 | ["def popcount(n):\n\tres = 0\n\twhile n > 0:\n\t\tres += n & 1\n\t\tn >>= 2\n\ndef A(l, r):\n\tr += 1\n\tt = 1 << 64\n\twhile t & (l ^ r) == 0:\n\t\tt >>= 1\n\tres = l | (t - 1)\n\t#print(t, res)\n\treturn res\n\ndef __starting_point():\n\t\"\"\"assert(A(1, 2) == 1)\n\tassert(A(2, 4) == 3)\n\tassert(A(1, 10) == 7)\n\tassert(A(13, 13) == 13)\n\tassert(A(1, 7) == 7)\"\"\"\n\n\tn = int(input())\n\tfor _ in range(n):\n\t\tl, r = list(map(int, input().split()))\n\t\tres = A(l, r)\n\t\tprint(res)\n\n__starting_point()", "for i in range(int(input())):\n l,r=list(map(int,input().split()))\n while(l|(l+1)<=r): l|=l+1\n print(l)\n", "from math import log2\ndef solve(a, b):\n if a == b:\n return a\n x = int(log2(b))\n if 2**x <= a:\n return solve(a - 2**x, b - 2**x) + 2**x\n\n if 2**(x+1) - 1 <= b:\n return 2**(x+1) - 1\n\n return 2**x - 1\n\nx = int(input())\nfor i in range(x):\n a, b = list(map(int, input().split(' ')))\n print(solve(a, b))\n", "def main():\n for _ in range(int(input())):\n l, r = list(map(int, input().split()))\n mask = 1\n while l <= r:\n x = l\n l |= mask\n mask <<= 1\n print(x)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n=int(input())\nwhile(n):\n n=n-1\n s=input()\n li=s.split(' ')\n l=int(li[0])\n r=int(li[1])\n ans=r\n while(r>=l):\n ans=r\n r=r&(r+1)\n r=r-1\n print(ans)\n", "def solve():\n\ta, b = [int(x) for x in input().split()]\n\tl = b - a + 1\n\tfor i in range(64):\n\t\tif a & (1 << i):\n\t\t\tcontinue\n\t\tif (a | (1 << i)) > b:\n\t\t\tbreak\n\t\ta |= 1 << i\n\tprint(a)\n\nn = int(input())\nfor i in range(n):\n\tsolve()\n", "# 484A\n\nfrom sys import stdin\n\n__author__ = 'artyom'\n\nn = int(stdin.readline().strip())\nfor i in range(n):\n l, r = list(map(int, stdin.readline().strip().split()))\n x, p = l, 1\n while 1:\n x |= p\n if x > r:\n break\n p = p << 1 | 1\n l = x\n\n print(l)", "def f():\n l, r = map(int, input().split())\n if l == r: return l\n a, b = bin(l)[2:], bin(r)[2:]\n i, k = 0, len(b)\n a = a.zfill(k)\n while a[i] == b[i]: i += 1\n d = k - i\n if b[i:].count('1') == d: return r\n return ((r >> d) << d) + (1 << d - 1) - 1\n\nfor i in range(int(input())): print(f())", "for i in range(int(input())):\n l, r = map(int, input().split())\n if l == r: print(l)\n else:\n k = len(bin(l ^ r)) - 2\n s = ((r >> k) + 1 << k) - 1\n if s > r: s -= 1 << k - 1\n print(s)", "for i in range(int(input())):\n l, r = map(int, input().split())\n k = 0 if l == r else len(bin(l ^ r)) - 2\n s = ((r >> k) + 1 << k) - 1\n if s > r: s -= 1 << k - 1\n print(s)", "import math\ndef f(l,r):\n if l == r:\n return l\n else:\n b = int(math.log(r,2))\n if p[b] <= l:\n return f(l-p[b],r-p[b])+p[b]\n elif p[b+1]-1 <= r:\n return p[b+1]-1\n else:\n return p[b]-1\np = [1]\nfor i in range(64):\n p.append(p[-1]*2)\nn = int(input())\nfor i in range(n):\n l, r = [int(i) for i in input().split()]\n print(f(l,r))\n", "n = int(input())\nfor i in range(n):\n a, b = list(map(int, input().split()))\n m = a; bits = str(a).count('1')\n x = 0\n while a <= b:\n a |= (1 << x)\n z = bin(a).count('1')\n if z > bits and a <= b:\n m = a\n bits = z\n elif z == bits and a < m:\n m = a\n x += 1\n print(m)\n", "n = int(input())\n\nfor i in range(n):\n\tl, r = list(map(int, input().split()))\n\tbits = 0\n\tresult = 0\n\twhile True:\n\t\tcount_bit = len(str(bin(r))) - 2\n\t\tif (1 << count_bit) - 1 == r:\n\t\t\tresult += (1 << count_bit) - 1\n\t\t\tbreak\n\t\texp = (1 << (count_bit - 1)) - 1\n\t\tif exp >= l:\n\t\t\tresult += exp\n\t\t\tbreak\n\t\telse:\n\t\t\tbits += 1\n\t\t\texp = 1 << (count_bit - 1)\n\t\t\tresult += exp\n\t\t\tl -= exp\n\t\t\tr -= exp\n\tprint(result)\n", "import sys\nL = lambda x : len(bin(x)) - 2\nn = int(input())\nwhile n > 0:\n n -= 1\n l, r = list(map(int, sys.stdin.readline().split()))\n a = 0\n while L(l) == L(r) and r > 0:\n u = 1 << (L(r) - 1)\n l-= u\n r-= u\n a+= u\n u = 1 << (L(r) - 1)\n if u + u - 1 == r and r > 1:\n u<<=1\n print(a+u-1)\n\n", "import sys\nL = lambda x : x.bit_length() if x > 0 else 1\nn = int(input())\nwhile n > 0:\n n -= 1\n l, r = list(map(int, sys.stdin.readline().split()))\n a = 0\n while L(l) == L(r) and r > 0:\n u = 1 << (L(r) - 1)\n l-= u\n r-= u\n a+= u\n u = 1 << (L(r) - 1)\n if u + u - 1 == r and r > 1:\n u<<=1\n print(a+u-1)\n\n", "def fun(x,y):\n if x==y:\n return x\n if (y&(y+1)) == 0:\n return y\n [a,b] = [len(bin(x))-3,len(bin(y))-3]\n if a==b:\n return (1<<a)| fun((1<<a)^x, (1<<a)^y)\n return (1<<b) - 1\n \ndef main():\n mode=\"filee\"\n if mode==\"file\":f=open(\"test.txt\",\"r\")\n get = lambda :[int(x) for x in (f.readline() if mode==\"file\" else input()).split()]\n [n]=get()\n for z in range(n):\n [x,y]=get()\n print(fun(x,y))\n\n\n if mode==\"file\":f.close()\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "for i in range(int(input())):\n l,r=list(map(int,input().split()))\n while(l|(l+1)<=r): l|=l+1\n print(l)\n", "for i in range(int(input())):\n l,r=map(int,input().split())\n while(l|(l+1)<=r): l|=l+1\n print(l)", "def get_near_power_of_two(x):\n b = 1\n while b <= x:\n b <<= 1\n return b >> 1\n\nn = int(input())\nfor _ in range(n):\n l, r = list(map(int, input().split()))\n xor = l ^ r\n d = get_near_power_of_two(xor) - (0 if xor == 0 else 1)\n ld = l | d\n rd = r | d\n print(rd if rd == r else ld)\n", "n = int(input())\nfor kase in range(n):\n l, r = map(int, input().split())\n bit = 0\n while l | (1 << bit) <= r:\n l = (l | (1 << bit))\n bit += 1\n print(l)", "n=int(input())\nfor j in range(0,n):\n\tl,r=map(int,input().split(\" \"))\n\twhile(l|(l+1)<=r):\n\t\tl=l|(l+1)\n\tprint(l)", "q=int(input())\nfor i in range(q):\n x,y=list(map(int,input().split()))\n diff=y-x\n x=bin(x)[2:]\n y=bin(y)[2:]\n x='0'*(len(y)-len(x))+x\n newString=''\n for j in range(len(x)):\n if x[len(x)-j-1]=='0':\n if diff>=2**j:\n newString+='1'\n diff-=2**j\n else:\n newString+='0'\n else:\n newString+='1'\n newString=newString[::-1]\n tot=0\n ns=len(newString)\n for i in range(ns):\n tot+=int(newString[ns-i-1])*(2**i)\n print(tot)\n", "import sys\n#sys.stdin = open(\"input\", \"r\")\nn = int(input())\nfor x in range(n):\n l, r = list(map(int, input().split()))\n a = 0\n while l <= r:\n a = l\n l += (~l) & (-~l)\n sys.stdout.write(str(a) + '\\n')\n", "def get(l, r):\n while l | (l + 1) <= r:\n l |= (l + 1)\n return l\n\nq = int(input())\nfor i in range(q):\n l, r = list(map(int, input().split()))\n print(get(l, r))\n", "def maxi(a,b):\n\tif(bin(a).count(\"1\")==bin(b).count(\"1\")):\n\t\treturn(min(a,b))\t\n\telif(bin(a).count(\"1\")>bin(b).count(\"1\")):\n\t\treturn a\n\telse:\n\t\treturn b\nt=int(input().rstrip())\nfor i in range(t):\n\ta,b=list(map(int,(input().rstrip().split(\" \"))))\n\tx=bin(a)[2:]\n\ty=bin(b)[2:]\n\tw=max(len(x),len(y))\n\tx=\"0\"*(w-len(x))+x\n\ty=\"0\"*(w-len(y))+y\n\tq=[0 for i in range(w)]\n\tfor j in range(w):\n\t\tif(x[j]!=y[j]):\n\t\t\tq[j]=\"0\"\n\t\t\tbreak\n\t\telse:\n\t\t\tq[j]=x[j]\n\tfor o in range(j+1,w):\n\t\tq[o]=\"1\"\n\te=int(\"0b\"+\"\".join(q),2)\n\tprint(maxi(e,b))\t\t\t "] | {
"inputs": [
"3\n1 2\n2 4\n1 10\n",
"55\n1 1\n1 2\n1 3\n1 4\n1 5\n1 6\n1 7\n1 8\n1 9\n1 10\n2 2\n2 3\n2 4\n2 5\n2 6\n2 7\n2 8\n2 9\n2 10\n3 3\n3 4\n3 5\n3 6\n3 7\n3 8\n3 9\n3 10\n4 4\n4 5\n4 6\n4 7\n4 8\n4 9\n4 10\n5 5\n5 6\n5 7\n5 8\n5 9\n5 10\n6 6\n6 7\n6 8\n6 9\n6 10\n7 7\n7 8\n7 9\n7 10\n8 8\n8 9\n8 10\n9 9\n9 10\n10 10\n",
"18\n1 10\n1 100\n1 1000\n1 10000\n1 100000\n1 1000000\n1 10000000\n1 100000000\n1 1000000000\n1 10000000000\n1 100000000000\n1 1000000000000\n1 10000000000000\n1 100000000000000\n1 1000000000000000\n1 10000000000000000\n1 100000000000000000\n1 1000000000000000000\n",
"3\n0 0\n1 3\n2 4\n",
"17\n0 0\n0 8\n1 8\n36 39\n3 4\n3 7\n2 17\n8 12\n9 12\n10 12\n10 15\n6 14\n8 15\n9 15\n15 15\n100000000000000000 1000000000000000000\n99999999999999999 1000000000000000000\n"
],
"outputs": [
"1\n3\n7\n",
"1\n1\n3\n3\n3\n3\n7\n7\n7\n7\n2\n3\n3\n3\n3\n7\n7\n7\n7\n3\n3\n3\n3\n7\n7\n7\n7\n4\n5\n5\n7\n7\n7\n7\n5\n5\n7\n7\n7\n7\n6\n7\n7\n7\n7\n7\n7\n7\n7\n8\n9\n9\n9\n9\n10\n",
"7\n63\n511\n8191\n65535\n524287\n8388607\n67108863\n536870911\n8589934591\n68719476735\n549755813887\n8796093022207\n70368744177663\n562949953421311\n9007199254740991\n72057594037927935\n576460752303423487\n",
"0\n3\n3\n",
"0\n7\n7\n39\n3\n7\n15\n11\n11\n11\n15\n7\n15\n15\n15\n576460752303423487\n576460752303423487\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 7,849 | |
6e9d9463365e59cd86b706ade6889d65 | UNKNOWN | A tree is a graph with n vertices and exactly n - 1 edges; this graph should meet the following condition: there exists exactly one shortest (by number of edges) path between any pair of its vertices.
A subtree of a tree T is a tree with both vertices and edges as subsets of vertices and edges of T.
You're given a tree with n vertices. Consider its vertices numbered with integers from 1 to n. Additionally an integer is written on every vertex of this tree. Initially the integer written on the i-th vertex is equal to v_{i}. In one move you can apply the following operation: Select the subtree of the given tree that includes the vertex with number 1. Increase (or decrease) by one all the integers which are written on the vertices of that subtree.
Calculate the minimum number of moves that is required to make all the integers written on the vertices of the given tree equal to zero.
-----Input-----
The first line of the input contains n (1 ≤ n ≤ 10^5). Each of the next n - 1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i}, b_{i} ≤ n; a_{i} ≠ b_{i}) indicating there's an edge between vertices a_{i} and b_{i}. It's guaranteed that the input graph is a tree.
The last line of the input contains a list of n space-separated integers v_1, v_2, ..., v_{n} (|v_{i}| ≤ 10^9).
-----Output-----
Print the minimum number of operations needed to solve the task.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
-----Examples-----
Input
3
1 2
1 3
1 -1 1
Output
3 | ["n = int(input())\nr = [[] for i in range(n + 1)]\nr[1] = [0]\nfor i in range(n - 1):\n a, b = map(int, input().split())\n r[a].append(b)\n r[b].append(a)\nt = list(map(int, input().split()))\nu, v = [0] * (n + 1), [0] * (n + 1)\nfor i, j in enumerate(t, 1):\n if j < 0: u[i] = - j\n else: v[i] = j\nt, p = [1], [0] * (n + 1)\nwhile t:\n a = t.pop()\n for b in r[a]:\n if p[b]: continue\n p[b] = a\n t.append(b)\nk = [len(t) for t in r]\nt = [a for a in range(2, n + 1) if k[a] == 1]\nx, y = [0] * (n + 1), [0] * (n + 1)\nwhile t:\n a = t.pop()\n b = p[a]\n x[b] = max(x[b], u[a])\n y[b] = max(y[b], v[a])\n k[b] -= 1\n if k[b] == 1:\n t.append(b)\n if u[b] > 0:\n if x[b] - y[b] > u[b]:\n u[b], v[b] = x[b], x[b] - u[b]\n else: u[b], v[b] = y[b] + u[b], y[b]\n else:\n if y[b] - x[b] > v[b]:\n u[b], v[b] = y[b] - v[b], y[b]\n else: u[b], v[b] = x[b], x[b] + v[b]\nprint(u[1] + v[1])", "n = int(input())\nr = [[] for i in range(n + 1)]\nr[1] = [0]\nfor i in range(n - 1):\n a, b = map(int, input().split())\n r[a].append(b)\n r[b].append(a)\nt = list(map(int, input().split()))\nu, v = [0] * (n + 1), [0] * (n + 1)\nfor i, j in enumerate(t, 1):\n if j < 0: u[i] = - j\n else: v[i] = j\n# print(u,v)\nt, p = [1], [0] * (n + 1)\nwhile t:\n a = t.pop()\n for b in r[a]:\n if p[b]: continue\n p[b] = a\n t.append(b)\nk = [len(t) for t in r]\nt = [a for a in range(2, n + 1) if k[a] == 1]\nx, y = [0] * (n + 1), [0] * (n + 1)\nwhile t:\n a = t.pop()\n b = p[a]\n x[b] = max(x[b], u[a])\n y[b] = max(y[b], v[a])\n k[b] -= 1\n if k[b] == 1:\n t.append(b)\n if u[b] > 0:\n if x[b] - y[b] > u[b]:\n u[b], v[b] = x[b], x[b] - u[b]\n else: u[b], v[b] = y[b] + u[b], y[b]\n else:\n if y[b] - x[b] > v[b]:\n u[b], v[b] = y[b] - v[b], y[b]\n else: u[b], v[b] = x[b], x[b] + v[b]\nprint(u[1] + v[1])", "from sys import stdin, stdout,setrecursionlimit\nfrom collections import defaultdict,deque,Counter,OrderedDict\nfrom heapq import heappop,heappush\nimport threading\n\nn = int(stdin.readline())\n\ngraph = [set() for x in range(n)]\n\nfor x in range(n-1):\n a,b = [int(x) for x in stdin.readline().split()]\n a -= 1\n b -= 1\n\n graph[a].add(b)\n graph[b].add(a)\n\nvals = [int(x) for x in stdin.readline().split()]\n\nbruh = [(0,-1)]\n\nfor x in range(n):\n num,p = bruh[x]\n for y in graph[num]:\n if y != p:\n bruh.append((y,num))\n\nresult = [-1 for x in range(n)]\n\nfor v,parent in bruh[::-1]:\n nP = 0\n nN = 0\n for x in graph[v]:\n if x != parent:\n p,n = result[x]\n nP = max(nP,p)\n nN = max(nN, n)\n nN = max(nN, nP+vals[v])\n nP = max(nP, nN-vals[v])\n \n result[v] = (nP,nN)\n\nng, ps = result[0]\n\nvals[0] += ps - ng\n\nstdout.write(str(ng+ps))\n"] | {
"inputs": [
"3\n1 2\n1 3\n1 -1 1\n",
"5\n2 3\n4 5\n2 5\n1 3\n0 2 1 4 3\n",
"10\n5 6\n8 2\n9 3\n4 1\n6 10\n9 8\n7 10\n7 4\n5 2\n0 -6 -9 -1 -5 -4 -2 -7 -8 -3\n",
"5\n3 1\n2 4\n3 4\n2 5\n0 -3 -1 2 4\n",
"12\n1 6\n10 1\n4 1\n7 1\n1 2\n5 1\n1 8\n1 11\n3 1\n12 1\n9 1\n580660007 861441526 -264928594 488291045 253254575 -974301934 709266786 926718320 87511873 514836444 -702876508 848928657\n"
],
"outputs": [
"3\n",
"8\n",
"18\n",
"20\n",
"2529263875\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,071 | |
b2aab701275d255961407231f7be2744 | UNKNOWN | 12:17 (UTC): The sample input 1 and 2 were swapped. The error is now fixed. We are very sorry for your inconvenience.
There are N children in AtCoder Kindergarten, conveniently numbered 1 through N. Mr. Evi will distribute C indistinguishable candies to the children.
If child i is given a candies, the child's happiness will become x_i^a, where x_i is the child's excitement level. The activity level of the kindergarten is the product of the happiness of all the N children.
For each possible way to distribute C candies to the children by giving zero or more candies to each child, calculate the activity level of the kindergarten. Then, calculate the sum over all possible way to distribute C candies. This sum can be seen as a function of the children's excitement levels x_1,..,x_N, thus we call it f(x_1,..,x_N).
You are given integers A_i,B_i (1≦i≦N). Find modulo 10^9+7.
-----Constraints-----
- 1≦N≦400
- 1≦C≦400
- 1≦A_i≦B_i≦400 (1≦i≦N)
-----Partial Score-----
- 400 points will be awarded for passing the test set satisfying A_i=B_i (1≦i≦N).
-----Input-----
The input is given from Standard Input in the following format:
N C
A_1 A_2 ... A_N
B_1 B_2 ... B_N
-----Output-----
Print the value of modulo 10^9+7.
-----Sample Input-----
2 3
1 1
1 1
-----Sample Output-----
4
This case is included in the test set for the partial score, since A_i=B_i.
We only have to consider the sum of the activity level of the kindergarten where the excitement level of both child 1 and child 2 are 1 (f(1,1)).
- If child 1 is given 0 candy, and child 2 is given 3 candies, the activity level of the kindergarten is 1^0*1^3=1.
- If child 1 is given 1 candy, and child 2 is given 2 candies, the activity level of the kindergarten is 1^1*1^2=1.
- If child 1 is given 2 candies, and child 2 is given 1 candy, the activity level of the kindergarten is 1^2*1^1=1.
- If child 1 is given 3 candies, and child 2 is given 0 candy, the activity level of the kindergarten is 1^3*1^0=1.
Thus, f(1,1)=1+1+1+1=4, and the sum over all f is also 4. | ["MOD=10**9+7\nN,C=map(int, input().split())\nA=list(map(int, input().split()))\nB=list(map(int, input().split()))\nP=[[1] for _ in range(401)]\nfor _ in range(1,401):\n for i in range(1,401):\n P[i].append(P[i][-1]*i%MOD)\nR=[[] for _ in range(N)]\nfor i,AB in enumerate(zip(A, B)):\n AA,BB=AB\n for a in range(401):\n tmp=0\n for x in range(AA,BB+1):\n tmp+=P[x][a]\n tmp%=MOD\n R[i].append(tmp)\ndp=[[0]*(C+1) for _ in range(N+1)]\ndp[0][0]=1\nfor n in range(1,N+1):\n for k in range(C+1):\n for l in range(k+1):\n dp[n][k]+=dp[n-1][k-l]*R[n-1][l]\n dp[n][k]%=MOD\nprint(dp[N][C])", "n,c = map(int,input().split())\na = list(map(int,input().split()))\nb = list(map(int,input().split()))\nab = list(zip(a,b))\ntable = [[0 for i in range(c+1)] for j in range(401)]\nmod = 10**9+7\nfor j in range(c+1):\n if j == 0:\n for i in range(401):\n table[i][j] = 1\n else:\n for i in range(401):\n table[i][j] = table[i][j-1]*i%mod\ndp = [[0 for i in range(c+1)] for j in range(n+1)]\nfor i in range(c+1):\n dp[0][i] = 1\nfor i in range(1,n+1):\n a,b = ab[i-1]\n for j in range(a,b+1):\n for k in range(c+1):\n dp[i][k] = (dp[i][k]+table[j][k])%mod\nans = [[0 for i in range(c+1)] for j in range(n+1)]\nans[0][0] = 1\nfor i in range(1,n+1):\n for j in range(c+1):\n for k in range(j+1):\n ans[i][j] = (ans[i][j]+dp[i][k]*ans[i-1][j-k])%mod\nprint(ans[n][c])", "import sys\ninput = sys.stdin.readline\nimport numpy as np\nMOD = 10**9+7\n\nn, c = map(int, input().split())\nA = np.array(tuple(map(int, input().split())))\nB = np.array(tuple(map(int, input().split())))\nE = np.zeros((n, c+1), dtype=np.int64)\nfor j in range(c+1):\n cum = np.array(tuple(pow(k, j, MOD) for k in range(401))).cumsum()%MOD\n E[:, j] = cum[B] - cum[A-1]\n\ndp = np.zeros((n+1, c+1), dtype=np.int64)\ndp[0, 0] = 1\nfor i, e in enumerate(E):\n for j, f in enumerate(e):\n dp[i+1, j:] += dp[i, :c+1-j]*f\n dp[i+1] %= MOD\nans = dp[n, c]\nprint(ans)", "'''\n\u7814\u7a76\u5ba4PC\u3067\u306e\u89e3\u7b54\n'''\nimport math\n#import numpy as np\nimport queue\nimport bisect\nfrom collections import deque,defaultdict\nimport heapq as hpq\nfrom sys import stdin,setrecursionlimit\n#from scipy.sparse.csgraph import dijkstra\n#from scipy.sparse import csr_matrix\nipt = stdin.readline\nsetrecursionlimit(10**7)\nmod = 10**9+7\n\ndef main():\n n,c = list(map(int,ipt().split()))\n a = [int(i) for i in ipt().split()]\n b = [int(i) for i in ipt().split()]\n nj = [[] for j in range(c+1)]\n nj[0] = [1]*401\n for j in range(1,c+1):\n for i in range(401):\n nj[j].append(nj[j-1][i]*i%mod)\n snj = [[0] for j in range(c+1)] #\u7d2f\u7a4d\u548c,snj[j][b]-snj[j][a-1]\u3067\u4f7f\u7528\n for j in range(c+1):\n sj = snj[j]\n ssj = nj[j]\n for i in range(1,401):\n sj.append((sj[-1]+ssj[i])%mod)\n dp = [snj[k][b[0]]-snj[k][a[0]-1] for k in range(c+1)]\n for i in range(1,n):\n# print(dp)\n ai = a[i]\n bi = b[i]\n for j in range(c,-1,-1):\n dp[j] = dp[j]*(bi-ai+1)%mod\n for k in range(1,j+1):\n dp[j] = (dp[j]+dp[j-k]*(snj[k][bi]-snj[k][ai-1]))%mod\n\n print((dp[c]%mod))\n\n\n return None\n\ndef __starting_point():\n main()\n\n__starting_point()", "import sys\ninput = sys.stdin.readline\nimport numpy as np\n\nMOD = 10 ** 9 + 7\n\nN,C = map(int,input().split())\nA = [int(x) for x in input().split()]\nB = [int(x) for x in input().split()]\n\n# (i,j) \u306b j^i \u3092\u5165\u308c\u308b\nkth_pow = np.ones((1024, 401), dtype=np.int64)\nrng = np.arange(401, dtype=np.int64)\nfor i in range(1,C+1):\n kth_pow[i] = kth_pow[i-1] * rng % MOD\nkth_pow_cum = kth_pow.cumsum(axis = 1) % MOD\nkth_pow_cum[C+1:] = 0\n\ndef convolve(A,B,n=32):\n if n == 8:\n return np.rint(np.fft.irfft(np.fft.rfft(A) * np.fft.rfft(B))).astype(np.int64)\n n //= 2\n M = 1 << n\n A1 = A // M\n A2 = A - M * A1\n B1 = A // M\n B2 = B - M * B1\n X = convolve(A1,B1,n)\n Y = convolve(A1-A2,B1-B2,n)\n Z = convolve(A2,B2,n)\n return (X * (M * M % MOD) + (X + Z - Y) * M + Z) % MOD\n\ndp = np.zeros(1024, dtype=np.int64) # \u3053\u308c\u307e\u3067\u914d\u3063\u305f\u500b\u6570\u3001\u5408\u8a08\u70b9\ndp[0] = 1\nfor a,b in zip(A,B):\n arr = kth_pow_cum[:,b] - kth_pow_cum[:,a-1]\n dp = convolve(dp,arr)\n dp[C+1:] = 0\n\nanswer = dp[C]\nprint(answer)", "import sys\nN,C=list(map(int,input().split()))\nA=[int(i) for i in input().split()]\nB=[int(i) for i in input().split()]\nmod=10**9+7\ntable=[[ pow(j,i,mod) for j in range(405)] for i in range(405)]\nntable=[[0]*405 for i in range(405)]\nfor i in range(405):\n t=0\n for j in range(1,405):\n t+=table[i][j]\n t%=mod\n ntable[i][j]=t\nF=[B[i]-A[i]+1 for i in range(N)]\nG=[0]*N\nt=1\nfor i in range(N):\n t*=F[i]\n t%=mod\nfor i in range(N):\n G[i]=(t*pow(F[i],mod-2,mod))%mod\n#print(G)\ndp=[[0]*(C+1) for i in range(N)]\nfor i in range(C+1):\n dp[0][i]=((ntable[i][B[0]]-ntable[i][A[0]-1]))%mod#*G[0]\nfor i in range(1,N):\n for k in range(C+1):\n for l in range(k+1):\n dp[i][k]+=dp[i-1][l]*(ntable[k-l][B[i]]-ntable[k-l][A[i]-1])#*G[i]\n dp[i][k]%=mod\n#print(dp)\nprint((dp[N-1][C]))\n\n", "MOD=10**9+7\n# 0 to q no i\u4e57\u548c\ntab=[]\nfor i in range(401):\n now=[]\n cnt=0\n for q in range(401):\n cnt+=pow(q,i,MOD)\n now.append(cnt)\n tab.append(now[:])\n \nn,c=map(int,input().split())\nA=[int(i) for i in input().split()]\nB=[int(i) for i in input().split()]\n\nenji=[]\nfor i in range(n):\n now=[]\n for q in range(c+1):\n now.append(tab[q][B[i]]-tab[q][A[i]-1])\n enji.append(now[:])\n\ndp=[0 for i in range(c+1)]\ndp[0]=1\nndp=[0 for i in range(c+1)]\nfor i in range(n):\n for step in range(c+1):\n val=enji[i][step]%MOD\n for fr in range(c+1-step):\n ndp[fr+step]+=dp[fr]*val%MOD\n ndp[fr+step]%=MOD\n #print(ndp)\n dp=ndp[:]\n ndp=[0 for i in range(c+1)]\n #print(dp)\nprint(dp[-1])", "import sys\nN,C=list(map(int,input().split()))\nA=[int(i) for i in input().split()]\nB=[int(i) for i in input().split()]\nmod=10**9+7\ntable=[[ pow(j,i,mod) for j in range(405)] for i in range(405)]\nntable=[[0]*405 for i in range(405)]\nfor i in range(405):\n t=0\n for j in range(1,405):\n t+=table[i][j]\n t%=mod\n ntable[i][j]=t\ndp=[[0]*(C+1) for i in range(N)]\nfor i in range(C+1):\n dp[0][i]=((ntable[i][B[0]]-ntable[i][A[0]-1]))%mod\nfor i in range(1,N):\n for k in range(C+1):\n for l in range(k+1):\n dp[i][k]+=dp[i-1][l]*(ntable[k-l][B[i]]-ntable[k-l][A[i]-1])\n dp[i][k]%=mod\nprint((dp[N-1][C]))\n\n", "N, C = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\nMOD = 10**9 + 7\n\ndef gen_poly(a, b, c):\n poly = [0 for _ in range(c+1)]\n for x in range(a, b+1):\n xpow = 1\n for i in range(c+1):\n poly[i] += xpow\n xpow = (xpow * x) % MOD\n for i in range(c+1):\n poly[i] %= MOD\n return poly\n\ndef mult_polys(p1, p2, dmax):\n ans = [0 for _ in range(dmax+1)]\n for i, c in enumerate(p1):\n for i2, c2 in enumerate(p2):\n if i + i2 <= dmax:\n ans[i+i2] += c*c2\n else:\n break\n ans = [x % MOD for x in ans]\n return ans\n\npolys = [gen_poly(a, b, C) for a, b in zip(A, B)]\nprodpoly = [1]\nfor poly in polys:\n prodpoly = mult_polys(prodpoly, poly, C)\n\nprint(prodpoly[C])", "N, C = list(map(int,input().split()))\nA = list(map(int,input().split()))\nB = list(map(int,input().split()))\nMOD = 10**9 + 7\nMB = max(B)\n\nSm = [[1 for _ in range(MB+1)]]\nfor c in range(1,C+1):\n Sm.append([])\n s = Sm[-1]\n sp = Sm[-2]\n for i in range(MB+1):\n s.append((i*sp[i]) % MOD)\n \nfor c in range(C+1):\n s = Sm[c]\n for i in range(1,MB+1):\n s[i] += s[i-1]\n s[i] %= MOD\n \nDP = [[0 for _ in range(C+1)] for _ in range(N+1)]\nDP[0][0] = 1\nfor n in range(1,N+1):\n dp = DP[n]\n dpp = DP[n-1]\n for c in range(C+1):\n for cc in range(C+1-c):\n dp[c+cc] += dpp[c] * (Sm[cc][B[n-1]] - Sm[cc][A[n-1]-1])\n dp[c+cc] %= MOD\nprint((DP[N][C] % MOD))\n \n", "#!usr/bin/env python3\nfrom collections import defaultdict,deque\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\nimport random\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef I(): return int(sys.stdin.readline())\ndef LS():return [list(x) for x in sys.stdin.readline().split()]\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res\ndef IR(n):\n return [I() for i in range(n)]\ndef LIR(n):\n return [LI() for i in range(n)]\ndef SR(n):\n return [S() for i in range(n)]\ndef LSR(n):\n return [LS() for i in range(n)]\n\nsys.setrecursionlimit(1000000)\nmod = 1000000007\n\n#A\ndef A():\n\n return\n\n#B\ndef B():\n\n return\n\n#C\ndef C():\n n,c = LI()\n a = LI()\n b = LI()\n s = [[0]*(c+1) for i in range(n)]\n for i in range(n):\n ai,bi = a[i],b[i]\n for x in range(ai,bi+1):\n e = 1\n for k in range(c+1):\n s[i][k] += e\n if s[i][k] >= mod:\n s[i][k] %= mod\n e *= x\n if e >= mod:\n e %= mod\n dp = [[0]*(c+1) for i in range(n)]\n for k in range(c+1):\n dp[0][k] = s[0][k]\n\n for i in range(1,n):\n for k in range(c+1):\n for j in range(k+1):\n dp[i][k] += dp[i-1][j]*s[i][k-j]\n if dp[i][k] >= mod:\n dp[i][k] %= mod\n print((dp[-1][c]))\n return\n\n#D\ndef D():\n\n return\n\n#E\ndef E():\n\n return\n\n#F\ndef F():\n\n return\n\n#Solve\ndef __starting_point():\n C()\n\n__starting_point()", "import sys\ninput = sys.stdin.readline\n\n# mod\u3092\u53d6\u308a\u306a\u304c\u3089\u3079\u304d\u4e57\u3059\u308b\ndef power_func(a,n,mod):\n bi=str(format(n,\"b\"))#2\u9032\u8868\u73fe\u306b\n res=1\n for i in range(len(bi)):\n res=(res*res) %mod\n if bi[i]==\"1\":\n res=(res*a) %mod\n return res\n\ndef main():\n N, C = map(int, input().split())\n A = list(map(int, input().split()))\n B = list(map(int, input().split()))\n mod = 10**9+7\n L = 400\n\n dp = [[0]*(L+1) for _ in range(C+1)]\n count = B[0] - A[0] + 1\n for c in range(C+1):\n a, b = A[0], B[0]\n dp[c][0] = power_func(a, c, mod)\n for k in range(1, b-a+1):\n dp[c][k] = (dp[c][k-1] + power_func(a+k, c, mod)) % mod\n dp[c][L] = dp[c][b-a]\n\n for i, (a, b) in enumerate(zip(A, B)):\n if i == 0: continue\n for k in range(b-a+1):\n dp[0][k] = count * (k+1) % mod\n dp[0][L] = dp[0][b-a]\n for c in range(1, C+1):\n dp[c][0] = (dp[c][L] + a*dp[c-1][0]) % mod\n for k in range(1, b-a+1):\n R = dp[c][k-1] + dp[c][L] + (a+k)*(dp[c-1][k]-dp[c-1][k-1])\n if R < 0: R += mod\n dp[c][k] = R%mod\n dp[c][L] = dp[c][b-a]\n count = (count * (b-a+1)) % mod\n\n print(dp[C][L])\n\n\ndef __starting_point():\n main()\n__starting_point()", "import sys\ninput = sys.stdin.readline\nfrom itertools import accumulate\n\nMOD = 10**9+7\n\nn, c = map(int, input().split())\nA = tuple(map(int, input().split()))\nB = tuple(map(int, input().split()))\nE = [[0]*(c+1) for _ in range(n)]\nfor j in range(c+1):\n cumsum = tuple(pow(k, j, MOD) for k in range(401))\n cumsum = tuple(i%MOD for i in accumulate(cumsum))\n for i, (a, b) in enumerate(zip(A, B)):\n E[i][j] = cumsum[b] - cumsum[a-1]\n\ndp = [[0]*(c+1) for _ in range(n+1)]\ndp[0][0] = 1\nfor i, e in enumerate(E):\n for j, f in enumerate(e):\n for k in range(c+1):\n if j+k <= c:\n dp[i+1][j+k] += dp[i][k]*f\n dp[i+1][j+k] %= MOD\nans = dp[n][c]\nprint(ans)", "n,c = map(int,input().split())\na = list(map(int,input().split()))\nb = list(map(int,input().split()))\nmod = 10**9+7\n\nex400 = [[1] * 401 for _ in range(401)]\nfor i in range(2,401):\n for j in range(1,401):\n ex400[i][j] = (ex400[i][j-1] * i) % mod\n\ncumsum400 = [[1] * 401 for _ in range(401)]\nfor i in range(1,401):\n for j in range(401):\n cumsum400[i][j] = (cumsum400[i-1][j] + ex400[i][j]) % mod\n\ndp = [[0] * (c+1) for _ in range(n+1)]\ndp[0][0] = 1\n\n\nfor i in range(1,n+1):\n for j in range(c+1):\n for k in range(j+1):\n dp[i][j] += dp[i-1][j-k] * (cumsum400[b[i-1]][k] - cumsum400[a[i-1]-1][k])\n dp[i][j] %= mod\n\nprint(dp[-1][-1])", "MOD = 10**9 + 7\nn, m = [int(item) for item in input().split()]\na = [int(item) for item in input().split()]\nb = [int(item) for item in input().split()]\n\ncumsum = [[1] * 410 for _ in range(410)]\nfor order in range(405):\n for i in range(1, 405):\n cumsum[order][i] = pow(i, order, MOD) + cumsum[order][i-1]\n cumsum[order][i] %= MOD\n\ndp = [[0] * (m + 1) for _ in range(n + 1)]\ndp[0][0] = 1\nfor i in range(1, n+1):\n for j in range(0, m+1):\n for k in range(j+1):\n l = a[i - 1]\n r = b[i - 1]\n x = (cumsum[j-k][r] - cumsum[j-k][l-1] + MOD) % MOD\n dp[i][j] += dp[i-1][k] * x \n dp[i][j] %= MOD\n\nprint(dp[-1][-1])", "N, C = list(map(int, input().split()))\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\nmod = 10**9+7\n\nacc = [[0] for _ in range(401)]\nfor i in range(401):\n for j in range(1, 401):\n acc[i].append(((acc[i][-1] + pow(j, i, mod)) % mod))\n\ndp = [[0 for _ in range(C+1)] for _ in range(N+1)]\ndp[0][0] = 1\nfor i in range(N):\n for candy_cur in range(C+1):\n for candy_plus in range(C - candy_cur+1):\n dp[i+1][candy_cur + candy_plus] = (dp[i+1][candy_cur + candy_plus] + (dp[i][candy_cur]\\\n * ((acc[candy_plus][B[i]] - acc[candy_plus][A[i]-1])%mod)%mod)) % mod\n\nprint((dp[-1][C]))\n", "import sys\ninput = sys.stdin.readline\nimport numpy as np\nMOD = 10**9+7\n\nn, c = map(int, input().split())\nA = np.array(tuple(map(int, input().split())))\nB = np.array(tuple(map(int, input().split())))\nE = np.zeros((n, c+1), dtype=np.int64)\nfor j in range(c+1):\n cum = np.array(tuple(pow(k, j, MOD) for k in range(401))).cumsum()%MOD\n E[:, j] = cum[B] - cum[A-1]\n\ndp = np.zeros((n+1, c+1), dtype=np.int64)\ndp[0, 0] = 1\nfor i, e in enumerate(E):\n for j, f in enumerate(e):\n dp[i+1][j:] += dp[i][:c+1-j]*f\n dp[i+1] %= MOD\nans = dp[n, c]\nprint(ans)", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nn,c = list(map(int,readline().split()))\n*a, = list(map(int,readline().split()))\n*b, = list(map(int,readline().split()))\n\nM = 401\nMOD = 10**9+7\n\npowsum = []\nfor i in range(M):\n res = [pow(j,i,MOD) for j in range(M)]\n for j in range(1,M):\n res[j] = (res[j]+res[j-1])%MOD\n powsum.append(res)\n\ndp = [0]*(c+1) # dp[i][k] = i \u307e\u3067\u898b\u3066 k\u6b21\u6589\u6b21\u5f0f\ndp[0] = 1\n\nfor ai,bi in zip(a,b):\n ndp = [0]*(c+1)\n for k in range(c+1):\n for j in range(k+1):\n ndp[k] += (powsum[j][bi]-powsum[j][ai-1])*dp[k-j]%MOD\n ndp[k] %= MOD\n\n dp = ndp\n\nprint((dp[c]%MOD))\n\n\n", "# \u30ad\u30e3\u30f3\u30c7\u30a3\u30fc\u3068N\u4eba\u306e\u5b50\u4f9b\n\nmod = 10**9 + 7\nN, C = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n\ndef rev(X):\n return pow(X, mod-2, mod)\n\n\npow_sum = [[B[i]-A[i]+1 for j in range(C+1)] for i in range(N)]\npow_table = [[1 for j in range(401)] for i in range(401)]\nfor i in range(401):\n for j in range(401):\n pow_table[i][j] = pow(i, j, mod)\n\nfor cnt in range(C):\n for i in range(N):\n pow_sum[i][cnt+1] = 0\n for j in range(A[i], B[i]+1):\n pow_sum[i][cnt+1] += pow_table[j][cnt+1]\n pow_sum[i][cnt+1] %= mod\n\nans_dp = [[0 for i in range(C+1)] for j in range(N+1)]\n# ans_dp[x][y] = 0<=x<=N,0<=y<=C \u306e\u5834\u5408\u306edp\nans_dp[0][0] = 1\nfor n in range(1, N+1):\n # ans_dp[n]\u306e\u66f4\u65b0\n for c in range(C+1):\n # ans_dp[n][c]\u306e\u66f4\u65b0\n for k in range(c+1):\n ans_dp[n][c] += ans_dp[n-1][k]*pow_sum[n-1][c-k]\n ans_dp[n][c] %= mod\nprint(ans_dp[N][C] % mod)", "from itertools import accumulate\nN, C = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\nmod = 10**9 + 7\nX = [list(accumulate([pow(x, d, mod) for x in range(401)])) for d in range(C+1)]\ndp = [[0]*(C+1) for _ in range(N+1)]\ndp[0][0] = 1\nfor i in range(1, N+1):\n for d in range(C+1):\n dp[i][d] = sum([dp[i-1][d-k]*(X[k][B[i-1]] - X[k][A[i-1]-1]) for k in range(d+1)])%mod\n \nprint(dp[-1][-1])", "import sys\ninput = sys.stdin.readline\nimport numpy as np\n\nMOD = 10 ** 9 + 7\n\nN,C = list(map(int,input().split()))\nA = [int(x) for x in input().split()]\nB = [int(x) for x in input().split()]\n\n# (i,j) \u306b j^i \u3092\u5165\u308c\u308b\nkth_pow = np.ones((C+1, 401), dtype=np.int64)\nrng = np.arange(401, dtype=np.int64)\nfor i in range(1,C+1):\n kth_pow[i] = kth_pow[i-1] * rng % MOD\nkth_pow_cum = kth_pow.cumsum(axis = 1) % MOD\n\ndp = np.zeros((C+1), dtype=np.int64) # \u3053\u308c\u307e\u3067\u914d\u3063\u305f\u500b\u6570\u3001\u5408\u8a08\u70b9\ndp[0] = 1\nfor a,b in zip(A,B):\n arr = kth_pow_cum[:,b] - kth_pow_cum[:,a-1]\n prev = dp\n dp = np.zeros(C+1, dtype=np.int64)\n for n in range(C+1):\n dp[n:] += arr[n] * prev[:C+1-n] % MOD\n dp %= MOD\n\nanswer = dp[C]\nprint(answer)\n\n", "n, c = map(int, input().split())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nmod = pow(10, 9) + 7\npowlist = [[1] * 405 for _ in range(405)]\nfor i in range(1, 405):\n for j in range(1, 405):\n powlist[i][j] = j * powlist[i - 1][j] % mod\nfor i in range(405):\n for j in range(1, 405):\n powlist[i][j] += powlist[i][j - 1]\n powlist[i][j] %= mod\nx = [[0] * (c + 1) for _ in range(n + 1)]\nfor i in range(1, n + 1):\n for j in range(c + 1):\n x[i][j] = powlist[j][b[i - 1]] - powlist[j][a[i - 1] - 1]\n x[i][j] %= mod\ndp = [[0] * (c + 1) for _ in range(n + 1)]\ndp[0][0] = 1\nfor i in range(1, n + 1):\n for j in range(c + 1):\n s = 0\n for k in range(j + 1):\n s += dp[i - 1][k] * x[i][j - k]\n s %= mod\n dp[i][j] = s\nans = dp[n][c]\nprint(ans)", "import sys\nfrom itertools import accumulate\nreadline = sys.stdin.readline\nMOD = 10**9+7\n\nN, C = map(int, readline().split())\nA = [0] + list(map(int, readline().split()))\nB = [0] + list(map(int, readline().split()))\n\nacsq = []\nlb = max(B)+1\nfor j in range(C+1):\n ac = [0]*lb\n ac[0] = 1\n for i in range(1, lb):\n ac[i] = (ac[i-1] + pow(i, j, MOD)) % MOD\n acsq.append(ac)\ndp = [[0]*(C+1) for _ in range(N+1)]\ndp[0][0] = 1\nfor i in range(1, N+1):\n a, b = A[i], B[i]\n for c in range(C+1):\n res = 0\n for j in range(c+1):\n res = (res + (acsq[c-j][b] - acsq[c-j][a-1])*dp[i-1][j]) % MOD\n dp[i][c] = res\nprint(dp[N][C])", "N,C=map(int,input().split())\nA=[int(i) for i in input().split()]\nB=[int(i) for i in input().split()]\nmod=10**9+7\nexponen=[[0 for j in range(401)]for i in range(401)]\nfor i in range(401):\n exponen[i][0]=1\n for j in range(400):\n exponen[i][j+1]=(exponen[i][j]*i)%mod\nexpsum=[[0 for j in range(401)] for i in range(402)]\nfor j in range(401):\n for i in range(401):\n expsum[i+1][j]=(expsum[i][j]+exponen[i][j])%mod\nfunc=[[0 for j in range(C+1)] for i in range(N)]\ndp=[[0 for j in range(C+1)] for i in range(N+1)]\ndp[0][0]=1\nfor i in range(N):\n for j in range(C+1):\n func[i][j]=(expsum[B[i]+1][j]-expsum[A[i]][j])%mod\nfor i in range(N):\n for x in range(C+1):\n for y in range(C+1):\n if (x+y>C):\n continue\n dp[i+1][x+y]+=dp[i][x]*func[i][y]\n dp[i+1][x+y]%=mod\nprint(dp[N][C])", "N,C=map(int,input().split())\nA=list(map(int,input().split()))\nB=list(map(int,input().split()))\nMod=10**9+7\n\nB_max=max(B)\nP=[[0]*(C+1) for _ in range(B_max+1)]\n\nfor x in range(B_max+1):\n E=P[x]\n E[0]=1\n t=1\n for k in range(1,C+1):\n E[k]=t=(t*x)%Mod\n\nT=[]\nfor i in range(N):\n U=[0]*(C+1)\n for x in range(A[i],B[i]+1):\n for k in range(C+1):\n U[k]+=P[x][k]\n U[k]%=Mod\n T.append(U)\n\nP=[1]+[0]*C\nfor Q in T:\n X=[0]*(C+1)\n\n for i in range(C+1):\n for j in range(C+1):\n if i+j>C:\n break\n X[i+j]+=P[i]*Q[j]\n X[i+j]%=Mod\n P=X.copy()\n\nprint(X[C])", "mod = 10**9+7\nN, C = list(map(int, input().split()))\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\ndp = [[0]*(C+1) for i in range(N+1)]\ndp[-1][0] = 1\nS = [[0]*(C+1) for _ in range(N+1)]\nfor i in range(N):\n power = [1]*(400+1)\n for j in range(C+1):\n for x in range(A[i], B[i]+1):\n S[i][j]+=power[x]\n S[i][j]%=mod\n power[x]*=x\n power[x]%=mod\nfor i in range(N):#i\u3070\u3093\u3081\n for j in range(C+1):#j\u3053\u306e\u30ad\u30e3\u30f3\u30c7\u30a3\u30fc\n for k in range(j+1):#i\u3070\u3093\u3081\u306bk\u5b50\u304f\u3070\u308b\n dp[i][j] += dp[i-1][j-k]*S[i][k]\n dp[i][j]%=mod\nprint((dp[-2][-1]))\n\n", "N,C=map(int,input().split())\nA=list(map(int,input().split()))\nB=list(map(int,input().split()))\nDP=[[0]*(C+1) for i in range(N+1)]\nDP[0][0]=1\nmod=10**9+7\nX=[[0] for i in range(401)]\nfor i in range(401):\n for j in range(401):\n X[i].append((X[i][j]+pow(j,i,mod))%mod)\nfor i in range(N):\n for j in range(C+1):\n for k in range(j+1):\n DP[i+1][j]=(DP[i][j-k]*(X[k][B[i]+1]-X[k][A[i]])+DP[i+1][j])%mod\nprint(DP[N][C])", "MOD = 10**9+7\nn, c = map(int, input().split())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\n\nsig = [[0 for _ in range(max(b)+1)] for _ in range(c+1)]\nfor i in range(c+1):\n\tfor j in range(1, max(b)+1):\n\t\tsig[i][j] = sig[i][j-1] + pow(j, i, MOD)\n\t\tsig[i][j] %= MOD\n\ndef sigma(C, A, B):\n\treturn (sig[C][B] - sig[C][A-1]) % MOD\n\ndp = [[0 for _ in range(c+1)] for _ in range(n)]\nfor j in range(c+1):\n\tdp[0][j] = sigma(j, a[0], b[0])\n\nfor i in range(1, n):\n\tfor j in range(c+1):\n\t\tfor k in range(j+1):\n\t\t\tdp[i][j] += dp[i-1][k] * sigma(j-k, a[i], b[i])\n\t\t\tdp[i][j] %= MOD\n\nprint(dp[n-1][c])", "mod=10**9+7\n\ntable=[[0 for i in range(401)] for j in range(401)]\nfor i in range(401):\n S=0\n for j in range(1,401):\n S+=pow(j,i,mod)\n S%=mod\n table[i][j]=S\n\nN,C=map(int,input().split())\nA=list(map(int,input().split()))\nB=list(map(int,input().split()))\n\n\ndp=[[0 for i in range(C+1)] for j in range(N)]\n\nfor i in range(C+1):\n dp[0][i]=table[i][B[0]]-table[i][A[0]-1]\n dp[0][i]%=mod\n\nfor i in range(1,N):\n for j in range(C+1):\n dp[i][j]=sum(dp[i-1][j-k]*(table[k][B[i]]-table[k][A[i]-1]) for k in range(j+1))\n dp[i][j]%=mod\n\nprint(dp[N-1][C])", "n, c = map(int, input().split())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nMOD = 10**9 + 7\n\ndp = [[0]*(c+1) for i in range(n+1)]\ndp[0][0] = 1\n\nruiseki = [[0] * (410) for _ in range(c+1)]\nfor i in range(c + 1):\n for j in range(409):\n ruiseki[i][j + 1] = ruiseki[i][j] + pow(j, i, MOD)\n ruiseki[i][j + 1] %= MOD\n \nfor i in range(n):\n for all_num in range(c + 1):\n for j in range(all_num + 1):\n # i\u756a\u76ee\u306e\u5b50\u4f9b\u306b\u3001j\u500b\u306e\u98f4\u3092\u914d\u308b\n dp[i+1][all_num] += (ruiseki[j][b[i]+1] - ruiseki[j][a[i]]) * dp[i][all_num - j]\n dp[i+1][all_num] %= MOD\nprint(dp[-1][-1])", "import sys\ndef MI(): return list(map(int,sys.stdin.readline().rstrip().split()))\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split()))\n\n\nN,C = MI()\nA,B = [0]+LI(),[0]+LI()\nmod = 10**9+7\n\nX = [[0]*401 for _ in range(401)]\n# X[k][l] = 0**k+1**k+\u2026+l**k\nfor k in range(401):\n for l in range(1,401):\n X[k][l] = X[k][l-1]+pow(l,k,mod)\n X[k][l] %= mod\n\ndp = [[0]*(C+1) for _ in range(N+1)]\n# dp[i][j] = \u5b50\u4f9b1~i\u306b\u5408\u8a08j\u500b\u306e\u98f4\u3092\u914d\u308b\u3068\u304d\u306e\u7b54\u3048\ndp[0][0] = 1\nfor i in range(1,N+1):\n a,b = A[i],B[i]\n for j in range(C+1):\n x = 0\n for k in range(j+1):\n x += dp[i-1][j-k]*(X[k][b]-X[k][a-1])\n x %= mod\n dp[i][j] = x\n\nprint((dp[-1][-1]))\n", "import os\nimport sys\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\n\ndef ModInt(mod):\n class _ModInt:\n def __init__(self, value):\n self.value = value % mod\n\n def __add__(self, other):\n if isinstance(other, _ModInt):\n return _ModInt(self.value + other.value)\n else:\n return _ModInt(self.value + other)\n\n def __sub__(self, other):\n if isinstance(other, _ModInt):\n return _ModInt(self.value - other.value)\n else:\n return _ModInt(self.value - other)\n\n def __radd__(self, other):\n return self.__add__(other)\n\n def __mul__(self, other):\n if isinstance(other, _ModInt):\n return _ModInt(self.value * other.value)\n else:\n return _ModInt(self.value * other)\n\n def __truediv__(self, other):\n # TODO: \u5b9f\u88c5\n raise NotImplementedError()\n\n def __repr__(self):\n return str(self.value)\n\n return _ModInt\n\n\nMI = ModInt(MOD)\n# \u89e3\u8aacAC\nN, C = list(map(int, sys.stdin.readline().split()))\nA = list(map(int, sys.stdin.readline().split()))\nB = list(map(int, sys.stdin.readline().split()))\n\n\ndef solve():\n # P[n][c]: n^c\n P = [[1] * (C + 1) for _ in range(max(B) + 1)]\n P[0] = [MI(0)] * (C + 1)\n for i in range(1, len(P)):\n for c in range(1, C + 1):\n P[i][c] = P[i][c - 1] * i\n\n # cs[n][c]: 0^c + 1^c + ... + n^c\n cs = [[0] * (C + 1) for _ in range(max(B) + 1)]\n for c in range(C + 1):\n s = 0\n for i in range(len(P)):\n s += P[i][c]\n cs[i][c] = s\n\n # S[i][c]: X[i]^c (A[i]<=X[i]<=B[i]) \u306e\u5408\u8a08\n S = [[0] * (C + 1) for _ in range(N)]\n for i in range(N):\n for c in range(C + 1):\n S[i][c] = cs[B[i]][c] - cs[A[i] - 1][c]\n\n # dp[c]: \u5404\u9805\u306e\u6b21\u6570\u304c c \u3067\u3001i \u756a\u76ee\u306e\u5b50\u4f9b\u307e\u3067\u898b\u305f\u3068\u304d\u306e f(X) \u306e\u5024\n dp = S[0][:]\n for i in range(1, N):\n for c in reversed(list(range(C + 1))):\n s = 0\n for j in range(c + 1):\n s += dp[c - j] * S[i][j]\n dp[c] = s\n return dp[-1]\n\n\n# print(f_partial([1, 1]))\n# print(f_partial([1, 2]))\n# print(f_partial([2, 1]))\n# print(f_partial([2, 2]))\nprint((solve()))\n", "n, c = map(int, input().split())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nMOD = 10 ** 9 + 7\n\ndp = [[0] * (c + 1) for i in range(n + 1)]\ndp[0][0] = 1\n\nru = [[0] * 410 for i in range(410)]\nfor cnt in range(410):\n for x in range(409):\n ru[cnt][x + 1] += ru[cnt][x] + pow(x, cnt, MOD)\n ru[cnt][x + 1] %= MOD\n \nfor ni in range(n):\n for cnt in range(c + 1):\n for ci in range(cnt, c + 1):\n dp[ni + 1][ci] += (ru[cnt][b[ni] + 1] - ru[cnt][a[ni]]) * dp[ni][ci - cnt] \n dp[ni + 1][ci] %= MOD\nprint(dp[-1][-1])", "from itertools import accumulate\nmod = 10 ** 9 + 7\n\nN, C = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\nmemo = []\nfor p in range(C + 1):\n tmp = [pow(i, p, mod) for i in range(401)]\n memo.append(tuple(accumulate(tmp)))\n\n\ndp = [[0] * (C + 1) for _ in range(N + 1)]\ndp[0][0] = 1\nfor i, (a, b) in enumerate(zip(A, B)):\n for j in range(C + 1): # \u7d2f\u8a08\u3067j\u500b\u914d\u3063\u305f\u3053\u3068\u306b\u3059\u308b\n for k in range(j + 1): # i\u756a\u76ee\u306e\u5b50\u306bk\u500b\u3042\u3052\u308b\n dp[i + 1][j] += dp[i][k] * (memo[j-k][b] - memo[j-k][a-1])\n dp[i + 1][j] %= mod\n\nprint(dp[N][C])", "N, C = map(int, input().split())\nA = [int(a) for a in input().split()]\nB = [int(a) for a in input().split()]\nP = 10**9+7\nY = [[pow(i, j, P) for j in range(401)] for i in range(401)]\nfor i in range(1, 401):\n for j in range(401):\n Y[i][j] = (Y[i][j] + Y[i-1][j]) % P\nX = [[0] * (C+1) for _ in range(N+1)]\nX[0][0] = 1\nfor i in range(1, N+1):\n for j in range(C+1):\n X[i][j] = sum([X[i-1][k] * (Y[B[i-1]][j-k] - Y[A[i-1]-1][j-k]) % P for k in range(j+1)]) % P\nprint(X[N][C])", "import sys\ninput = sys.stdin.readline\nimport numpy as np\nMOD = 10**9+7\n\nn, c = map(int, input().split())\nA = np.array(tuple(map(int, input().split())))\nB = np.array(tuple(map(int, input().split())))\nE = np.zeros((n, c+1), dtype=np.int64)\nfor j in range(c+1):\n cum = np.array(tuple(pow(k, j, MOD) for k in range(401))).cumsum()%MOD\n E[:, j] = cum[B] - cum[A-1]\n\ndp = np.zeros((n+1, c+1), dtype=np.int64)\ndp[0, 0] = 1\nfor i, e in enumerate(E):\n for j, f in enumerate(e):\n dp[i+1, j:] += dp[i, :c+1-j]*f\n dp[i+1, j:] %= MOD\nans = dp[n, c]\nprint(ans)", "def main(N,C,A,B):\n import sys\n input = sys.stdin.readline\n #N,C = map(int,input().split())\n #A = list(map(int,input().split()))\n #B = list(map(int,input().split()))\n mod = 10**9+7\n powA = [[0]*(401) for i in range(401)]\n for i in range(401):\n for j in range(401):\n powA[i][j] = pow(i,j,mod)\n \n S = [[0]*401 for i in range(C+1)]\n for i in range(C+1):\n S[i][0] = 0\n for i in range(C+1):\n for j in range(1,401):\n S[i][j] = (S[i][j-1] + powA[j][i])%mod\n \n dp = [[0]*(C+1) for i in range(N)]\n for i in range(C+1):\n dp[0][i] = S[i][B[0]] - S[i][A[0]-1]\n for i in range(1,N):\n for j in range(C+1):\n tmp = 0\n for k in range(j+1):\n tmp = (tmp + (S[k][B[i]] - S[k][A[i]-1])*dp[i-1][j-k])%mod\n dp[i][j] = tmp\n print(dp[N-1][C])\n #print(S[1])\n \ndef main2(N,C,A,B):\n import sys\n input = sys.stdin.readline\n #N,C = map(int,input().split())\n #A = list(map(int,input().split()))\n #B = list(map(int,input().split()))\n mod = 10**9+7\n powA = [[0]*(401) for i in range(401)]\n for i in range(401):\n for j in range(401):\n powA[i][j] = pow(i,j,mod)\n \n S = [[0]*400 for i in range(C+1)]\n for i in range(C+1):\n S[i][0] = 1\n for i in range(C+1):\n for j in range(1,400):\n S[i][j] = (S[i][j-1] + powA[j+1][i])%mod\n \n dp = [[0]*(C+1) for i in range(N)]\n for i in range(C+1):\n dp[0][i] = pow(A[0],i,mod)\n for i in range(1,N):\n for j in range(C+1):\n tmp = 0\n for k in range(j+1):\n tmp = (tmp + powA[A[i]][k]*dp[i-1][j-k])%mod\n dp[i][j] = tmp\n print(dp[N-1][C])\n \nimport sys\ninput = sys.stdin.readline\nN,C = map(int,input().split())\nA = list(map(int,input().split()))\nB = list(map(int,input().split()))\n\nif A==B:\n main2(N,C,A,B)\nelse:\n main(N,C,A,B)", "import sys\ninput=sys.stdin.readline\n\nN,C=map(int,input().split())\nA=list(map(int,input().split()))\nB=list(map(int,input().split()))\nMod=10**9+7\n\nB_max=max(B)\nP=[[0]*(C+1) for _ in range(B_max+1)]\n\nfor x in range(B_max+1):\n E=P[x]\n E[0]=1\n t=1\n for k in range(1,C+1):\n E[k]=t=(t*x)%Mod\n\nT=[]\nfor i in range(N):\n U=[0]*(C+1)\n for x in range(A[i],B[i]+1):\n for k in range(C+1):\n U[k]+=P[x][k]\n U[k]%=Mod\n T.append(U)\n\nP=[1]+[0]*C\nfor Q in T:\n X=[0]*(C+1)\n\n for i in range(C+1):\n for j in range(C+1):\n if i+j>C:\n break\n X[i+j]+=P[i]*Q[j]\n X[i+j]%=Mod\n P=X.copy()\n\nprint(X[C])", "def main():\n mod = 10**9+7\n n, c = map(int, input().split())\n A = list(map(int, input().split()))\n B = list(map(int, input().split()))\n dp = [0]*(c+1)\n dp[0] = 1\n ans = 0\n\n p = [[0]*(401) for _ in [0]*401] # p[i][j]\u3067j^i\n for i in range(401):\n for j in range(401):\n p[i][j] = pow(j, i, mod)\n\n for a, b in zip(A, B):\n dp2 = [0]*(c+1)\n q = [0]*(c+1)\n for i in range(c+1):\n q[i] = sum(p[i][a:b+1]) % mod\n for i in range(c+1):\n temp = 0\n for j in range(i+1):\n temp += dp[i-j]*q[j]\n dp2[i] = temp % mod\n dp = dp2\n ans += dp[-1]\n print(ans % mod)\n\n\nmain()", "import sys\ninput = sys.stdin.readline\n\nmod = 10**9 + 7\nN, C = map(int, input().split())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\ndp = [0] * (C + 1)\ndp[0] = 1\nfor i in range(N):\n X = [0] * (C + 1)\n for j in range(A[i], B[i] + 1):\n x = 1\n for k in range(C+1):\n X[k] = (X[k] + x) % mod\n x = x * j % mod\n ndp = [0] * (C + 1)\n for j in range(C+1):\n for k in range(C+1-j):\n ndp[j + k] = (ndp[j + k] + dp[j] * X[k]) % mod\n dp = ndp\nprint(dp[C])", "def main1(n,c,a,b):\n mod=10**9+7\n # a[0],..,a[n-1]\u304c\u305d\u308c\u305e\u308c\u7121\u9650\u500b\u3042\u308b\u3002\u91cd\u8907\u6709\u3067\u597d\u304d\u306bc\u500b\u9078\u3093\u3067\u7a4d\u3092\u53d6\u3063\u305f\u6642\u306e\u548c\u3002\n # dp[i+1][j]:idx=i\u307e\u3067\u306e\u4e2d\u304b\u3089\u597d\u304d\u306bj\u500b\u9078\u3093\u3067\u7a4d\u3092\u53d6\u3063\u305f\u6642\u306e\u548c\u3002\n # a[i]~b[i]\u3092\u540c\u6642\u306b\u8a08\u7b97\u3059\u308b\u3002\n dp=[[0]*(c+1) for i in range(n+1)]\n dp[0][0]=1\n for i in range(n):\n ary=[0]*(b[i]+1-a[i])\n tmp=0\n for j in range(c+1):\n tmp+=dp[i][j]*(b[i]+1-a[i])\n tmp%=mod\n dp[i+1][j]+=tmp\n dp[i+1][j]%=mod\n tmp=0\n for k in range(b[i]+1-a[i]):\n ary[k]+=dp[i][j]\n ary[k]*=a[i]+k\n ary[k]%=mod\n tmp+=ary[k]\n tmp%=mod\n return dp[n][c]\n\ndef __starting_point():\n n,c=map(int,input().split())\n a=list(map(int,input().split()))\n b=list(map(int,input().split()))\n print(main1(n,c,a,b))\n__starting_point()", "import numpy as np\nN, C = list(map(int, input().split()))\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\nmod = 10**9+7\nP = np.empty((404, 404), dtype=np.int64)\nP[0, :] = 1\nar = np.arange(404, dtype=np.int64)\nfor i in range(1, 404):\n P[i] = P[i-1] * ar % mod\n# \u3053\u306e\u6642\u70b9\u3067 # P[i, c] = i**c % mod\n\nP = P.cumsum(axis=1, dtype=np.int64) % mod # P[i, c] = \u03a3_{k=0}^i k**c % mod\nP = P.T\n\ndp = np.zeros(C+1, dtype=np.int64)\ndp[0] = 1\nfor a, b in zip(A, B):\n dp_new = np.zeros(C+1, dtype=np.int64)\n p = (P[b] - P[a-1]) % mod\n for c in range(C+1):\n dp_new[c] = (dp[:c+1] * p[c::-1] % mod).sum()\n dp = dp_new % mod\nprint((dp[C]))\n"] | {"inputs": ["2 3\n1 1\n1 1\n", "1 2\n1\n3\n", "2 3\n1 1\n2 2\n", "4 8\n3 1 4 1\n3 1 4 1\n", "3 100\n7 6 5\n9 9 9\n"], "outputs": ["4\n", "14\n", "66\n", "421749\n", "139123417\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 35,961 | |
6af9dcdcbed46e5e48da91f17e6ce90b | UNKNOWN | There are 2N balls in the xy-plane. The coordinates of the i-th of them is (x_i, y_i).
Here, x_i and y_i are integers between 1 and N (inclusive) for all i, and no two balls occupy the same coordinates.
In order to collect these balls, Snuke prepared 2N robots, N of type A and N of type B.
Then, he placed the type-A robots at coordinates (1, 0), (2, 0), ..., (N, 0), and the type-B robots at coordinates (0, 1), (0, 2), ..., (0, N), one at each position.
When activated, each type of robot will operate as follows.
- When a type-A robot is activated at coordinates (a, 0), it will move to the position of the ball with the lowest y-coordinate among the balls on the line x = a, collect the ball and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
- When a type-B robot is activated at coordinates (0, b), it will move to the position of the ball with the lowest x-coordinate among the balls on the line y = b, collect the ball and deactivate itself. If there is no such ball, it will just deactivate itself without doing anything.
Once deactivated, a robot cannot be activated again. Also, while a robot is operating, no new robot can be activated until the operating robot is deactivated.
When Snuke was about to activate a robot, he noticed that he may fail to collect all the balls, depending on the order of activating the robots.
Among the (2N)! possible orders of activating the robots, find the number of the ones such that all the balls can be collected, modulo 1 000 000 007.
-----Constraints-----
- 2 \leq N \leq 10^5
- 1 \leq x_i \leq N
- 1 \leq y_i \leq N
- If i ≠ j, either x_i ≠ x_j or y_i ≠ y_j.
-----Inputs-----
Input is given from Standard Input in the following format:
N
x_1 y_1
...
x_{2N} y_{2N}
-----Outputs-----
Print the number of the orders of activating the robots such that all the balls can be collected, modulo 1 000 000 007.
-----Sample Input-----
2
1 1
1 2
2 1
2 2
-----Sample Output-----
8
We will refer to the robots placed at (1, 0) and (2, 0) as A1 and A2, respectively, and the robots placed at (0, 1) and (0, 2) as B1 and B2, respectively.
There are eight orders of activation that satisfy the condition, as follows:
- A1, B1, A2, B2
- A1, B1, B2, A2
- A1, B2, B1, A2
- A2, B1, A1, B2
- B1, A1, B2, A2
- B1, A1, A2, B2
- B1, A2, A1, B2
- B2, A1, B1, A2
Thus, the output should be 8. | ["import sys\ninput = sys.stdin.readline\n\nMOD = 10**9 + 7\n\nN = int(input())\nball = (tuple(int(x) for x in row.split()) for row in sys.stdin.readlines())\n\n# x\u5ea7\u6a19\u30921,2,...,N\n# y\u5ea7\u6a19\u3092N+1,N+2,...,N+N\n\ngraph = [set() for _ in range(N+N+1)]\nfor x,y in ball:\n graph[x].add(y+N)\n graph[y+N].add(x)\n\nvisited = [False] * (N+N+1)\ncomponents = []\nfor x in range(1,N+N+1):\n if visited[x]:\n continue\n V = set([x])\n E = []\n q = [x]\n visited[x] = True\n while q:\n y = q.pop()\n for z in graph[y]:\n if y < z:\n E.append((y,z))\n if visited[z]:\n continue\n V.add(z)\n visited[z] = True\n q.append(z)\n components.append((V,E))\n\ndef make_get_pattern(V):\n deg1 = [x for x in V if len(graph[x]) == 1]\n get = {}\n while deg1:\n x = deg1.pop()\n if not graph[x]:\n continue\n y = graph[x].pop()\n se = graph[y]; se.remove(x)\n if len(se) == 1: deg1.append(y)\n if x < y:\n get[(x,y)] = 0\n else:\n get[(y,x)] = 1\n for x in V:\n if graph[x]:\n y = graph[x].pop()\n break\n # \u6b8b\u308a\u306f\u30b5\u30a4\u30af\u30eb\n graph[y].remove(x)\n if x > y: x,y = y,x\n get[(x,y)] = 2\n while graph[x]:\n y = graph[x].pop()\n graph[y].remove(x)\n if x < y:\n get[(x,y)] = 3\n else:\n get[(y,x)] = 2\n x = y\n return get\n\ndef F(V,E):\n # V is connected\n if len(E) != len(V):\n return 0\n ret = 0\n E.sort()\n get = make_get_pattern(V)\n den1,den2 = 1,1\n dp1 = {x:0 for x in V}\n dp2 = {x:0 for x in V}\n for x,y in E:\n if get[(x,y)] == 0:\n k1 = dp1[x] + 1; k2 = dp2[x] + 1\n elif get[(x,y)] == 1:\n k1 = dp1[y] + 1; k2 = dp2[y] + 1\n elif get[(x,y)] == 2:\n k1 = dp1[x] + 1; k2 = dp2[y] + 1\n else:\n k1 = dp1[y] + 1; k2 = dp2[x] + 1\n dp1[x] += k1; dp1[y] += k1\n dp2[x] += k2; dp2[y] += k2\n den1 *= k1; den2 *= k2\n den1 %= MOD; den2 %= MOD\n return sum(pow(x,MOD-2,MOD) for x in (den1,den2))\n\nprob = 1\nfor c in components:\n prob *= F(*c)\n prob %= MOD\n\nanswer = prob\nfor n in range(1,N+N+1):\n answer *= n\n answer %= MOD\nprint(answer)", "import sys\ninput = sys.stdin.readline\n\nMOD = 10**9 + 7\n\nN = int(input())\nball = [tuple(int(x) for x in input().split()) for _ in range(N+N)]\n\n# x\u5ea7\u6a19\u30921,2,...,N\n# y\u5ea7\u6a19\u3092N+1,N+2,...,N+N\n\ngraph = [set() for _ in range(N+N+1)]\nfor x,y in ball:\n graph[x].add(y+N)\n graph[y+N].add(x)\n\nvisited = set()\ncomponents = []\nfor x in range(1,N+N+1):\n if x in visited:\n continue\n V = set([x])\n q = [x]\n while q:\n y = q.pop()\n for z in graph[y]:\n if z in V:\n continue\n V.add(z)\n q.append(z)\n visited |= V\n components.append(V)\n\ndef make_get_patterns(V):\n deg1 = [x for x in V if len(graph[x]) == 1]\n get = {},{}\n while deg1:\n x = deg1.pop()\n if not graph[x]:\n continue\n y = graph[x].pop()\n se = graph[y]; se.remove(x)\n if len(se) == 1: deg1.append(y)\n if x < y:\n get[0][(x,y)] = 0; get[1][(x,y)] = 0\n else:\n pass\n get[0][(y,x)] = 1; get[1][(y,x)] = 1\n for x in V:\n if graph[x]:\n y = graph[x].pop()\n break\n # \u6b8b\u308a\u306f\u30b5\u30a4\u30af\u30eb\n graph[y].remove(x)\n if x > y: x,y = y,x\n get[0][(x,y)] = 0; get[1][(x,y)] = 1\n while True:\n if not graph[x]:\n break\n y = graph[x].pop()\n graph[y].remove(x)\n if x < y:\n get[0][(x,y)] = 1; get[1][(x,y)] = 0\n else:\n get[0][(y,x)] = 0; get[1][(y,x)] = 1\n x = y\n return get\n\ndef F(V):\n # V is connected\n E = sorted((x,y) for x in V if x <= N for y in graph[x])\n if len(E) != len(V):\n return 0\n ret = 0\n for get in make_get_patterns(V):\n den = 1\n dp = {x:0 for x in V}\n for x,y in E:\n if get[(x,y)] == 0:\n k = dp[x] + 1\n else:\n k = dp[y] + 1\n dp[x] += k\n dp[y] += k\n den *= k\n den %= MOD\n ret += pow(den,MOD-2,MOD)\n return ret % MOD\n\nprob = 1\nfor c in components:\n prob *= F(c)\n prob %= MOD\n\nanswer = prob\nfor n in range(1,N+N+1):\n answer *= n\n answer %= MOD\nprint(answer)\n", "import sys\ninput = sys.stdin.readline\n\nMOD = 10**9 + 7\n\nN = int(input())\nball = (tuple(int(x) for x in row.split()) for row in sys.stdin.readlines())\n\n# x\u5ea7\u6a19\u30921,2,...,N\n# y\u5ea7\u6a19\u3092N+1,N+2,...,N+N\n\ngraph = [set() for _ in range(N+N+1)]\nfor x,y in ball:\n graph[x].add(y+N)\n graph[y+N].add(x)\n\nvisited = [False] * (N+N+1)\ncomponents = []\nfor x in range(1,N+N+1):\n if visited[x]:\n continue\n V = set([x])\n E = []\n q = [x]\n visited[x] = True\n while q:\n y = q.pop()\n for z in graph[y]:\n if y < z:\n E.append((y,z))\n if visited[z]:\n continue\n V.add(z)\n visited[z] = True\n q.append(z)\n components.append((V,E))\n\ndef make_get_pattern(V):\n deg1 = [x for x in V if len(graph[x]) == 1]\n get = {}\n while deg1:\n x = deg1.pop()\n if not graph[x]:\n continue\n y = graph[x].pop()\n se = graph[y]; se.remove(x)\n if len(se) == 1: deg1.append(y)\n if x < y:\n get[(x,y)] = 0\n else:\n get[(y,x)] = 1\n for x in V:\n if graph[x]:\n y = graph[x].pop()\n break\n # \u6b8b\u308a\u306f\u30b5\u30a4\u30af\u30eb\n graph[y].remove(x)\n if x > y: x,y = y,x\n get[(x,y)] = 2\n while graph[x]:\n y = graph[x].pop()\n graph[y].remove(x)\n if x < y:\n get[(x,y)] = 3\n else:\n get[(y,x)] = 2\n x = y\n return get\n\ndef F(V,E):\n # V is connected\n if len(E) != len(V):\n return 0\n ret = 0\n E.sort()\n get = make_get_pattern(V)\n den1,den2 = 1,1\n dp1 = {x:0 for x in V}\n dp2 = {x:0 for x in V}\n for x,y in E:\n if get[(x,y)] == 0:\n k1 = dp1[x] + 1; k2 = dp2[x] + 1\n elif get[(x,y)] == 1:\n k1 = dp1[y] + 1; k2 = dp2[y] + 1\n elif get[(x,y)] == 2:\n k1 = dp1[x] + 1; k2 = dp2[y] + 1\n else:\n k1 = dp1[y] + 1; k2 = dp2[x] + 1\n dp1[x] += k1; dp1[y] += k1\n dp2[x] += k2; dp2[y] += k2\n den1 *= k1; den2 *= k2\n den1 %= MOD; den2 %= MOD\n return sum(pow(x,MOD-2,MOD) for x in (den1,den2))\n\nprob = 1\nfor c in components:\n prob *= F(*c)\n prob %= MOD\n\nanswer = prob\nfor n in range(1,N+N+1):\n answer *= n\n answer %= MOD\nprint(answer)"] | {"inputs": ["2\n1 1\n1 2\n2 1\n2 2\n", "4\n3 2\n1 2\n4 1\n4 2\n2 2\n4 4\n2 1\n1 3\n", "4\n1 1\n2 2\n3 3\n4 4\n1 2\n2 1\n3 4\n4 3\n", "8\n6 2\n5 1\n6 8\n7 8\n6 5\n5 7\n4 3\n1 4\n7 6\n8 3\n2 8\n3 6\n3 2\n8 5\n1 5\n5 8\n", "3\n1 1\n1 2\n1 3\n2 1\n2 2\n2 3\n"], "outputs": ["8\n", "7392\n", "4480\n", "82060779\n", "0\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 7,233 | |
57e386b2a0cb8119219213e9192fef11 | UNKNOWN | There are N robots and M exits on a number line.
The N + M coordinates of these are all integers and all distinct.
For each i (1 \leq i \leq N), the coordinate of the i-th robot from the left is x_i.
Also, for each j (1 \leq j \leq M), the coordinate of the j-th exit from the left is y_j.
Snuke can repeatedly perform the following two kinds of operations in any order to move all the robots simultaneously:
- Increment the coordinates of all the robots on the number line by 1.
- Decrement the coordinates of all the robots on the number line by 1.
Each robot will disappear from the number line when its position coincides with that of an exit, going through that exit.
Snuke will continue performing operations until all the robots disappear.
When all the robots disappear, how many combinations of exits can be used by the robots?
Find the count modulo 10^9 + 7.
Here, two combinations of exits are considered different when there is a robot that used different exits in those two combinations.
-----Constraints-----
- 1 \leq N, M \leq 10^5
- 1 \leq x_1 < x_2 < ... < x_N \leq 10^9
- 1 \leq y_1 < y_2 < ... < y_M \leq 10^9
- All given coordinates are integers.
- All given coordinates are distinct.
-----Input-----
Input is given from Standard Input in the following format:
N M
x_1 x_2 ... x_N
y_1 y_2 ... y_M
-----Output-----
Print the number of the combinations of exits that can be used by the robots when all the robots disappear, modulo 10^9 + 7.
-----Sample Input-----
2 2
2 3
1 4
-----Sample Output-----
3
The i-th robot from the left will be called Robot i, and the j-th exit from the left will be called Exit j.
There are three possible combinations of exits (the exit used by Robot 1, the exit used by Robot 2) as follows:
- (Exit 1, Exit 1)
- (Exit 1, Exit 2)
- (Exit 2, Exit 2) | ["from bisect import bisect\nfrom collections import defaultdict\n\n\nclass Bit:\n def __init__(self, n, MOD):\n self.size = n\n self.tree = [0] * (n + 1)\n self.depth = n.bit_length()\n self.mod = MOD\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s % self.mod\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] = (self.tree[i] + x) % self.mod\n i += i & -i\n\n def debug_print(self):\n for i in range(1, self.size + 1):\n j = (i & -i).bit_length()\n print((' ' * j, self.tree[i]))\n\n def lower_bound(self, x):\n sum_ = 0\n pos = 0\n for i in range(self.depth, -1, -1):\n k = pos + (1 << i)\n if k <= self.size and sum_ + self.tree[k] < x:\n sum_ += self.tree[k]\n pos += 1 << i\n return pos + 1, sum_\n\n\nn, m = list(map(int, input().split()))\nxxx = list(map(int, input().split()))\nyyy = list(map(int, input().split()))\nab = defaultdict(set)\ncoordinates = set()\n\nfor x in xxx:\n if x < yyy[0] or yyy[-1] < x:\n continue\n i = bisect(yyy, x)\n a = x - yyy[i - 1]\n b = yyy[i] - x\n ab[a].add(b)\n coordinates.add(b)\n\n# Bit\u306eindex\u306f1\u304b\u3089\u59cb\u307e\u308b\u3088\u3046\u306b\u4f5c\u3063\u3066\u3044\u308b\u304c\u3001\"0\"\u3092\u53d6\u308c\u308b\u3088\u3046\u306b\u3059\u308b\u305f\u3081\u3001\u5168\u4f53\u30921\u305a\u3089\u3059\ncor_dict = {b: i for i, b in enumerate(sorted(coordinates), start=2)}\ncdg = cor_dict.get\nMOD = 10 ** 9 + 7\nbit = Bit(len(coordinates) + 1, MOD)\nbit.add(1, 1)\n\nfor a in sorted(ab):\n bbb = sorted(map(cdg, ab[a]), reverse=True)\n for b in bbb:\n bit.add(b, bit.sum(b - 1))\n\nprint((bit.sum(bit.size)))\n", "from bisect import bisect\nfrom collections import defaultdict\n\n\nclass Bit:\n def __init__(self, n, MOD):\n self.size = n\n self.tree = [0] * (n + 1)\n self.depth = n.bit_length()\n self.mod = MOD\n\n def sum(self, i):\n s = 0\n while i > 0:\n s = (s + self.tree[i]) % self.mod\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] = (self.tree[i] + x) % self.mod\n i += i & -i\n\n def debug_print(self):\n for i in range(1, self.size + 1):\n j = (i & -i).bit_length()\n print((' ' * j, self.tree[i]))\n\n def lower_bound(self, x):\n sum_ = 0\n pos = 0\n for i in range(self.depth, -1, -1):\n k = pos + (1 << i)\n if k <= self.size and sum_ + self.tree[k] < x:\n sum_ += self.tree[k]\n pos += 1 << i\n return pos + 1, sum_\n\n\nn, m = list(map(int, input().split()))\nxxx = list(map(int, input().split()))\nyyy = list(map(int, input().split()))\nab = defaultdict(set)\ncoordinates = set()\n\nfor x in xxx:\n if x < yyy[0] or yyy[-1] < x:\n continue\n i = bisect(yyy, x)\n a = x - yyy[i - 1]\n b = yyy[i] - x\n ab[a].add(b)\n coordinates.add(b)\n\n# Bit\u306eindex\u306f1\u304b\u3089\u59cb\u307e\u308b\u3088\u3046\u306b\u4f5c\u3063\u3066\u3044\u308b\u304c\u3001\"0\"\u3092\u53d6\u308c\u308b\u3088\u3046\u306b\u3059\u308b\u305f\u3081\u3001\u5168\u4f53\u30921\u305a\u3089\u3059\ncor_dict = {b: i for i, b in enumerate(sorted(coordinates), start=2)}\ncdg = cor_dict.get\nMOD = 10 ** 9 + 7\nbit = Bit(len(coordinates) + 1, MOD)\nbit.add(1, 1)\n\nfor a in sorted(ab):\n bbb = sorted(map(cdg, ab[a]), reverse=True)\n for b in bbb:\n bit.add(b, bit.sum(b - 1))\n\nprint((bit.sum(bit.size)))\n", "from bisect import bisect\nfrom collections import defaultdict\n\n\nclass Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n self.depth = n.bit_length()\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n def debug_print(self):\n for i in range(1, self.size + 1):\n j = (i & -i).bit_length()\n print((' ' * j, self.tree[i]))\n\n def lower_bound(self, x):\n sum_ = 0\n pos = 0\n for i in range(self.depth, -1, -1):\n k = pos + (1 << i)\n if k <= self.size and sum_ + self.tree[k] < x:\n sum_ += self.tree[k]\n pos += 1 << i\n return pos + 1, sum_\n\n\nn, m = list(map(int, input().split()))\nxxx = list(map(int, input().split()))\nyyy = list(map(int, input().split()))\nab = defaultdict(set)\ncoordinates = set()\n\nfor x in xxx:\n if x < yyy[0] or yyy[-1] < x:\n continue\n i = bisect(yyy, x)\n a = x - yyy[i - 1]\n b = yyy[i] - x\n ab[a].add(b)\n coordinates.add(b)\n\n# Bit\u306eindex\u306f1\u304b\u3089\u59cb\u307e\u308b\u3088\u3046\u306b\u4f5c\u3063\u3066\u3044\u308b\u304c\u3001\"0\"\u3092\u53d6\u308c\u308b\u3088\u3046\u306b\u3059\u308b\u305f\u3081\u3001\u5168\u4f53\u30921\u305a\u3089\u3059\ncor_dict = {b: i for i, b in enumerate(sorted(coordinates), start=2)}\ncdg = cor_dict.get\nbit = Bit(len(coordinates) + 1)\nbit.add(1, 1)\n\nfor a in sorted(ab):\n bbb = sorted(map(cdg, ab[a]), reverse=True)\n for b in bbb:\n bit.add(b, bit.sum(b - 1))\n\nprint((bit.sum(bit.size) % (10 ** 9 + 7)))\n"] | {"inputs": ["2 2\n2 3\n1 4\n", "3 4\n2 5 10\n1 3 7 13\n", "4 1\n1 2 4 5\n3\n", "4 5\n2 5 7 11\n1 3 6 9 13\n", "10 10\n4 13 15 18 19 20 21 22 25 27\n1 5 11 12 14 16 23 26 29 30\n"], "outputs": ["3\n", "8\n", "1\n", "6\n", "22\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 5,582 | |
8ff44f84d0418218d1f6f412aec37ab1 | UNKNOWN | AtCoDeer the deer found N rectangle lying on the table, each with height 1.
If we consider the surface of the desk as a two-dimensional plane, the i-th rectangle i(1≤i≤N) covers the vertical range of [i-1,i] and the horizontal range of [l_i,r_i], as shown in the following figure:
AtCoDeer will move these rectangles horizontally so that all the rectangles are connected.
For each rectangle, the cost to move it horizontally by a distance of x, is x.
Find the minimum cost to achieve connectivity.
It can be proved that this value is always an integer under the constraints of the problem.
-----Constraints-----
- All input values are integers.
- 1≤N≤10^5
- 1≤l_i<r_i≤10^9
-----Partial Score-----
- 300 points will be awarded for passing the test set satisfying 1≤N≤400 and 1≤l_i<r_i≤400.
-----Input-----
The input is given from Standard Input in the following format:
N
l_1 r_1
l_2 r_2
:
l_N r_N
-----Output-----
Print the minimum cost to achieve connectivity.
-----Sample Input-----
3
1 3
5 7
1 3
-----Sample Output-----
2
The second rectangle should be moved to the left by a distance of 2. | ["# seishin.py\nN = int(input())\nP = [list(map(int, input().split())) for i in range(N)]\n\nfrom heapq import heappush, heappop\n\nl0, r0 = P[0]\n\nL = [-l0+1]\nR = [l0-1]\ns = t = 0\n\nres = 0\nfor i in range(N-1):\n l0, r0 = P[i]\n l1, r1 = P[i+1]\n s += (r1 - l1); t += (r0 - l0)\n if -s-L[0] <= l1-1 <= t+R[0]:\n heappush(L, -l1+1-s)\n heappush(R, l1-1-t)\n elif l1-1 < -s-L[0]:\n heappush(L, -l1+1-s)\n heappush(L, -l1+1-s)\n p = -heappop(L)-s\n heappush(R, p-t)\n res += (p - (l1-1))\n elif t+R[0] < l1-1:\n heappush(R, l1-1-t)\n heappush(R, l1-1-t)\n p = heappop(R) + t\n heappush(L, -p-s)\n res += ((l1-1) - p)\nprint(res)", "N = int(input())\nP = [list(map(int, input().split())) for i in range(N)]\n \nINF = 10**18\n \nfrom heapq import heappush, heappop\n \nl0, r0 = P[0]\n \nL = [-l0+1]\nR = [l0-1]\ns = t = 0\n \nres = 0\nfor i in range(N-1):\n l0, r0 = P[i]\n l1, r1 = P[i+1]\n s += (r1 - l1); t += (r0 - l0)\n if -s-L[0] <= l1-1 <= t+R[0]:\n heappush(L, -l1+1-s)\n heappush(R, l1-1-t)\n elif l1-1 < -s-L[0]:\n heappush(L, -l1+1-s)\n heappush(L, -l1+1-s)\n p = -heappop(L)-s\n heappush(R, p-t)\n res += (p - (l1-1))\n elif t+R[0] < l1-1:\n heappush(R, l1-1-t)\n heappush(R, l1-1-t)\n p = heappop(R) + t\n heappush(L, -p-s)\n res += (l1-1 - p)\nprint(res)", "# seishin.py\nN = int(input())\nP = [list(map(int, input().split())) for i in range(N)]\n\nINF = 10**18\n\nfrom heapq import heappush, heappop\n\nl0, r0 = P[0]\n\nL = [-l0+1]\nR = [l0-1]\ns = t = 0\n\nres = 0\nfor i in range(N-1):\n l0, r0 = P[i]\n l1, r1 = P[i+1]\n s += (r1 - l1); t += (r0 - l0)\n if -s-L[0] <= l1-1 <= t+R[0]:\n heappush(L, -l1+1-s)\n heappush(R, l1-1-t)\n elif l1-1 < -s-L[0]:\n heappush(L, -l1+1-s)\n heappush(L, -l1+1-s)\n p = -heappop(L)-s\n heappush(R, p-t)\n res += (p - (l1-1))\n elif t+R[0] < l1-1:\n heappush(R, l1-1-t)\n heappush(R, l1-1-t)\n p = heappop(R) + t\n heappush(L, -p-s)\n res += (l1-1 - p)\nprint(res)", "# seishin.py\nN = int(input())\nP = [list(map(int, input().split())) for i in range(N)]\n\nINF = 10**18\n\nfrom heapq import heappush, heappop\n\nl0, r0 = P[0]\n\nL = [-l0+1]\nR = [l0-1]\ns = t = 0\n\ndef debug(L, s, t, R):\n L0 = L[:]\n Q1 = []; Q2 = []\n while L0:\n Q1.append(-s-heappop(L0))\n R0 = R[:]\n while R0:\n Q2.append(t+heappop(R0))\n print((\"debug:\", *Q1[::-1]+Q2))\n\n\n#print(L, s, t, R)\nres = 0\nfor i in range(N-1):\n l0, r0 = P[i]\n l1, r1 = P[i+1]\n #print(\">\", l1, r1)\n s += (r1 - l1); t += (r0 - l0)\n if -s-L[0] <= l1-1 <= t+R[0]:\n #print(0)\n heappush(L, -l1+1-s)\n heappush(R, l1-1-t)\n # res += 0\n elif l1-1 < -s-L[0]:\n #print(1)\n heappush(L, -l1+1-s)\n heappush(L, -l1+1-s)\n p = -heappop(L)-s\n #d = (-L[0]-s) - p\n heappush(R, p-t)\n #print(d)\n #res += d\n res += (p - (l1-1))\n elif t+R[0] < l1-1:\n #print(2)\n heappush(R, l1-1-t)\n heappush(R, l1-1-t)\n p = heappop(R) + t\n #d = R[0]+t - p\n heappush(L, -p-s)\n #print(d)\n res += (l1-1 - p)\n #print(L, s, t, R, -s-L[0], R[0]+t, res)\n #debug(L, s, t, R)\nprint(res)\n", "import sys\ninput = sys.stdin.readline\nfrom heapq import heappop, heappush\n\n\"\"\"\nf(x) = \uff08\u4e00\u756a\u4e0a\u306e\u9577\u65b9\u5f62\u306e\u5de6\u7aef\u304cx\u306b\u6765\u308b\u3068\u304d\u306e\u30b3\u30b9\u30c8\u306e\u6700\u5c0f\u5024\uff09 \u3092\u95a2\u6570\u3054\u3068\u66f4\u65b0\u3057\u3066\u3044\u304d\u305f\u3044\n\u66f4\u65b0\u5f8c\u3092g(x)\u3068\u3059\u308b\ng(x) = |x-L| + min_{-width_1 \\leq t\\leq width_2} f(x+t), \u524d\u56de\u306e\u5e45\u3001\u4eca\u56de\u306e\u5e45\n\u5e38\u306b\u3001\u533a\u9593\u4e0a\u3067\u6700\u5c0f\u5024\u3092\u6301\u3061\u50be\u304d\u304c1\u305a\u3064\u5909\u308f\u308b\u51f8\u306a\u95a2\u6570\u3067\u3042\u308b\u3053\u3068\u304c\u7dad\u6301\u3055\u308c\u308b\u3002\uff08\u533a\u9593\u306f1\u70b9\u304b\u3082\uff09\n\u50be\u304d\u304c\u5909\u308f\u308b\u70b9\u306e\u96c6\u5408S_f = S_f_lower + S_f_upper\u3092\u6301\u3063\u3066\u3044\u304f\u3002\nS_f_lower, S_upper\u306f\u4e00\u6589\u306b\u5b9a\u6570\u3092\u8db3\u3059\uff1a\u5909\u5316\u91cf\u306e\u307f\u6301\u3064\n\"\"\"\n\nN = int(input())\nLR = [[int(x) for x in input().split()] for _ in range(N)]\n\n# initialize\nL,R = LR[0]\nS_lower = [-L]\nS_upper = [L]\nmin_f = 0\nadd_lower = 0\nadd_upper = 0\nprev_w = R - L\n\npush_L = lambda x: heappush(S_lower, -x)\npush_R = lambda x: heappush(S_upper, x)\npop_L = lambda: -heappop(S_lower)\npop_R = lambda: heappop(S_upper)\n\nfor L,R in LR[1:]:\n w = R - L\n # \u5e73\u884c\u79fb\u52d5\u3068\u306emin\u3092\u3068\u308b\u30b9\u30c6\u30c3\u30d7\n add_lower -= w\n add_upper += prev_w\n # abs(x-L) \u3092\u52a0\u3048\u308b\u30b9\u30c6\u30c3\u30d7\n # abs \u306f\u77ac\u9593\u306b2\u50be\u304d\u304c\u5909\u308f\u308b\u306e\u3067\n x = pop_L() + add_lower\n y = pop_R() + add_upper\n a,b,c,d = sorted([x,y,L,L])\n push_L(a - add_lower)\n push_L(b - add_lower)\n push_R(c - add_upper)\n push_R(d - add_upper)\n min_f += c-b\n prev_w = w\n\nprint(min_f)\n\n"] | {"inputs": ["3\n1 3\n5 7\n1 3\n", "3\n2 5\n4 6\n1 4\n", "5\n999999999 1000000000\n1 2\n314 315\n500000 500001\n999999999 1000000000\n", "5\n123456 789012\n123 456\n12 345678901\n123456 789012\n1 23\n", "1\n1 400\n"], "outputs": ["2\n", "0\n", "1999999680\n", "246433\n", "0\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 5,454 | |
85358017593906f9f39d79f47ce3e793 | UNKNOWN | Greg has an array a = a_1, a_2, ..., a_{n} and m operations. Each operation looks as: l_{i}, r_{i}, d_{i}, (1 ≤ l_{i} ≤ r_{i} ≤ n). To apply operation i to the array means to increase all array elements with numbers l_{i}, l_{i} + 1, ..., r_{i} by value d_{i}.
Greg wrote down k queries on a piece of paper. Each query has the following form: x_{i}, y_{i}, (1 ≤ x_{i} ≤ y_{i} ≤ m). That means that one should apply operations with numbers x_{i}, x_{i} + 1, ..., y_{i} to the array.
Now Greg is wondering, what the array a will be after all the queries are executed. Help Greg.
-----Input-----
The first line contains integers n, m, k (1 ≤ n, m, k ≤ 10^5). The second line contains n integers: a_1, a_2, ..., a_{n} (0 ≤ a_{i} ≤ 10^5) — the initial array.
Next m lines contain operations, the operation number i is written as three integers: l_{i}, r_{i}, d_{i}, (1 ≤ l_{i} ≤ r_{i} ≤ n), (0 ≤ d_{i} ≤ 10^5).
Next k lines contain the queries, the query number i is written as two integers: x_{i}, y_{i}, (1 ≤ x_{i} ≤ y_{i} ≤ m).
The numbers in the lines are separated by single spaces.
-----Output-----
On a single line print n integers a_1, a_2, ..., a_{n} — the array after executing all the queries. Separate the printed numbers by spaces.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams of the %I64d specifier.
-----Examples-----
Input
3 3 3
1 2 3
1 2 1
1 3 2
2 3 4
1 2
1 3
2 3
Output
9 18 17
Input
1 1 1
1
1 1 1
1 1
Output
2
Input
4 3 6
1 2 3 4
1 2 1
2 3 2
3 4 4
1 2
1 3
2 3
1 2
1 3
2 3
Output
5 18 31 20 | ["from sys import stdin, stdout\n\nrd = lambda: list(map(int, stdin.readline().split()))\n\nn, m, k = rd()\na = rd()\nb = [rd() for _ in range(m)]\nx = [0]*(m+1)\ny = [0]*(n+1)\n\nfor _ in range(k):\n l, r = rd()\n x[l-1] += 1\n x[r ] -= 1\n\ns = 0\nfor i in range(m):\n l, r, d = b[i]\n s += x[i]\n y[l-1] += s*d\n y[r ] -= s*d\n\ns = 0\nfor i in range(n):\n s += y[i]\n a[i] += s\nprint(' '.join(map(str, a)))", "n, m, k = map(int, input().split())\nt = list(map(int, input().split()))\np = [tuple(map(int, input().split())) for i in range(m)]\n\nr, s = [0] * (m + 1), [0] * (n + 1)\nR, S = 0, 0\n\nfor i in range(k):\n x, y = map(int, input().split())\n r[x - 1] += 1\n r[y] -= 1\n\nfor i, (x, y, d) in enumerate(p):\n R += r[i]\n d = d * R\n s[x - 1] += d\n s[y] -= d\n\nfor i in range(n):\n S += s[i]\n t[i] = str(t[i] + S)\n\nprint(' '.join(map(str, t)))", "read_input = lambda: list(map(int, input().split()))\n\nn, m, k = read_input()\ninit_array = read_input()\noperations = [read_input() for _ in range(m)]\nadditionals = [0]*(m+1)\nsums = [0]*(n+1)\n\n# Calculates the number of operations needed by using increments and decrements\nfor _ in range(k):\n x, y = read_input()\n additionals[x-1] += 1\n additionals[y ] -= 1\n\n# Calculates the operations times the number of times the operation is executed\nsum_so_far = 0\nfor i in range(m):\n l, r, val_to_add = operations[i]\n sum_so_far += additionals[i]\n sums[l-1] += sum_so_far*val_to_add\n sums[r ] -= sum_so_far*val_to_add\n\n# Calculates the final number. Positives add while negatives remove\nsum_so_far = 0\nfor i in range(n):\n sum_so_far += sums[i]\n init_array[i] += sum_so_far\nprint(' '.join(map(str, init_array)))", "#import sys; sys.stdin = open(\"TF.txt\")\n\nR = lambda: list(map(int,input().split()))\ndef modif(lst):\n lst[0]-=1\n lst[1]-=1\n return lst\nn,m,k = R()\na = R()\nop = [modif(R()) for i in range(m)]\nb = [0]*(n)\ncnt = [0]*(m)\nfor i in range(k):\n l,r = R()\n l-=1;r-=1\n cnt[l] += 1\n try: cnt[r+1] -= 1\n except: pass\nq = [0]*(m)\ntoadd = 0\nfor i,v in enumerate(cnt):\n toadd += v\n q[i] += toadd\nfor i,v in enumerate(q):\n b[op[i][0]] += op[i][2] * v\n try: b[op[i][1]+1] -= op[i][2] * v\n except: pass\ntoadd = 0\nfor i,v in enumerate(b):\n toadd += v\n a[i] += toadd\nprint(*a)", "def main():\n n, m, k = list(map(int, input().split()))\n aa = list(map(int, input().split()))\n lrd = list(tuple(map(int, input().split())) for _ in range(m))\n cnt = [0] * (m + 1)\n for _ in range(k):\n x, y = list(map(int, input().split()))\n cnt[x - 1] += 1\n cnt[y] -= 1\n delta, c = [0] * (n + 1), 0\n for (l, r, d), dc in zip(lrd, cnt):\n c += dc\n d *= c\n delta[l - 1] += d\n delta[r] -= d\n da = 0\n for i, a, d in zip(list(range(n)), aa, delta):\n da += d\n aa[i] = a + da\n print(\" \".join(map(str, aa)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n, m, k = [int(n) for n in input().split()]\na = [int(n) for n in input().split()]\ninstructions = []\ntemp = []\nfor i in range(n+1):\n\ttemp.append(0)\nfor i in range(m):\n\tinstructions.append([int(n) for n in input().split()])\nqueries = []\nfor i in range(m+1):\n\tqueries.append(0)\nfor i in range(k):\n\tx, y = [int(n) for n in input().split()]\n\tx-=1\n\ty-=1\n\tqueries[x]+=1\n\tqueries[y+1]-=1\n\nnum_queries = 0\nfor i in range(m):\n\tnum_queries += queries[i]\n\ttemp[instructions[i][0]-1] += num_queries*instructions[i][2]\n\ttemp[instructions[i][1]] -= num_queries*instructions[i][2]\n#print(temp[0]+a[0], end=\" \")\nx = temp[0]\nprint(x + a[0], end=\" \")\nfor i in range(1, n):\n\tx += temp[i]\n\tprint(x + a[i], end=\" \")\nprint()", "# -------\n# imports\n# -------\n\nimport sys\n\n\n# -------\n# solve\n# -------\n\ndef solve(r, w):\n \"\"\"\n :param r:\n :param w:\n :return:\n \"\"\"\n data = r.readline().split()\n num_elems = int(data[0])\n num_ops = int(data[1])\n num_queries = int(data[2])\n\n elem_list = [int(x) for x in r.readline().split()]\n a = [0] * (num_ops + 1)\n b = [0] * (num_elems + 1)\n\n # get operations\n op_list = []\n for _ in range(num_ops):\n op_list.append(tuple([int(x) for x in r.readline().split()]))\n\n for _ in range(num_queries):\n query = [int(x) for x in r.readline().split()]\n a[query[0] - 1] += 1\n a[query[1]] -= 1\n\n c = 0\n for i, cur_op in enumerate(op_list):\n cur_op = op_list[i]\n c += a[i]\n b[cur_op[0] - 1] += c * cur_op[2]\n b[cur_op[1]] -= c * cur_op[2]\n\n c = 0\n for i, elem in enumerate(elem_list):\n c += b[i]\n print(elem + c, end=' ')\n\n\n# -------\n# main\n# -------\n\ndef __starting_point():\n solve(sys.stdin, sys.stdout)\n\n__starting_point()", "from sys import *\n\nrd = lambda: list(map(int, stdin.readline().split()))\n\nn, m, k = rd()\na = rd()\nb = [rd() for _ in range(m)]\nx = [0]*(m+1)\ny = [0]*(n+1)\n\nfor _ in range(k):\n l, r = rd()\n x[l-1] += 1\n x[r] -= 1\n\ns = 0\nfor i in range(m):\n l, r, d = b[i]\n s += x[i]\n y[l-1] += s*d\n y[r] -= s*d\n\ns = 0\nfor i in range(n):\n s += y[i]\n a[i] += s\nprint(*a)", "#!/usr/bin/env python3\n\nimport sys\n\n(n, m, k) = list(map(int, sys.stdin.readline().split(' ')))\n\na = list(map(int, sys.stdin.readline().split(' ')))\nb = [0] * ((int)(1e5) + 1)\nc = [0] * ((int)(1e5) + 1)\nl = []\nr = []\nd = []\n\nfor i in range(m):\n (li, ri, di) = list(map(int, sys.stdin.readline().split(' ')))\n l.append(li)\n r.append(ri)\n d.append(di)\n\nfor i in range(k):\n (xi, yi) = list(map(int, sys.stdin.readline().split(' ')))\n c[xi - 1] += 1\n c[yi] -= 1\n\ncur = 0\nfor i in range(0, m):\n cur += c[i]\n b[l[i]-1] += (cur*d[i])\n b[r[i]] -= (cur*d[i])\n\nret = []\ncur = 0\nfor i in range(len(a)):\n num = b[i]\n cur += num\n ret.append(str(cur + a[i]))\n\nsys.stdout.write(' '.join(ret) + '\\n')\n", "import sys\n\n(n, m, k) = list(map(int, sys.stdin.readline().split(' ')))\n\na = list(map(int, sys.stdin.readline().split(' ')))\nb = [0] * ((int)(1e5) + 1)\nc = [0] * ((int)(1e5) + 1)\nl = []\nr = []\nd = []\n\nfor i in range(m):\n (li, ri, di) = list(map(int, sys.stdin.readline().split(' ')))\n l.append(li)\n r.append(ri)\n d.append(di)\n\nfor i in range(k):\n (xi, yi) = list(map(int, sys.stdin.readline().split(' ')))\n c[xi - 1] += 1\n c[yi] -= 1\n\ncur = 0\nfor i in range(0, m):\n cur += c[i]\n b[l[i]-1] += (cur*d[i])\n b[r[i]] -= (cur*d[i])\n\nret = []\ncur = 0\nfor i in range(n):\n cur += b[i]\n ret.append(str(cur + a[i]))\n\nsys.stdout.write(' '.join(ret) + '\\n')\n", "def GregAndArray():\n lenArray, numOperations, numQueries = map(int, input().split())\n initialArray = list(map(int, input().split()))\n \n instructions = [list(map(int, input().split())) for _ in range(numOperations)]\n \n modifiedArray = [0 for _ in range(lenArray + 1)]\n queries = [0 for _ in range(numOperations + 1)]\n \n for _ in range(numQueries):\n \tx, y = map(int, input().split())\n \t\n \tqueries[x-1] += 1\n \tqueries[y] -= 1\n \n temp = 0\n for i in range(numOperations):\n \ttemp += queries[i]\n \tmodifiedArray[instructions[i][0]-1] += temp*instructions[i][2]\n \tmodifiedArray[instructions[i][1]] -= temp*instructions[i][2]\n \n temp = 0\n toReturn = \"\"\n for i in range(lenArray):\n temp += modifiedArray[i]\n toReturn += (str(temp + initialArray[i]) + \" \")\n \n print(toReturn)\n\nGregAndArray()", "int_list = lambda s: [int(n) for n in s.split(\" \")]\nn,m,k = int_list(input())\narr = int_list(input())\noperations = [int_list(input()) for _ in range(m)]\n\nincrs = [0]*len(arr) # Amount to increment running total when traversing arr\nfreq = [0]*m # The number of times the corresponding operation is used\n # stored in the same format as incrs\n\nfor _ in range(k):\n l,r = int_list(input())\n freq[l-1] += 1\n if r < len(freq): freq[r] -= 1\n \ntimes = 0 # number of times to apply current operation\nfor i, op in enumerate(operations):\n l,r,d = op\n times += freq[i] # update running total\n incrs[l-1] += times*d # encode operation in incrs\n if r < len(incrs): incrs[r] -= times*d\n \nprev = 0\nfor i,n in enumerate(arr):\n arr[i] = prev + n + incrs[i]\n prev += incrs[i]\n \nprint(\" \".join([str(n) for n in arr]))", "def solve():\n n, m, k = list(map(int, input().strip().split()))\n array = list(map(int, input().strip().split()))\n ops = [tuple(map(int, input().strip().split())) for _ in range(m)]\n applied = [0 for _ in range(m + 1)]\n qs = [tuple(map(int, input().strip().split())) for _ in range(k)]\n for x, y in qs:\n applied[x - 1] += 1\n applied[y] -= 1\n cumadds = [0 for _ in range(n + 1)]\n repeats = 0\n for i, (l, r, d) in enumerate(ops):\n repeats += applied[i]\n cumadds[l - 1] += repeats * d\n cumadds[r] -= repeats * d\n cum = 0\n for i, cumadd in zip(list(range(n)), cumadds):\n cum += cumadd\n array[i] += cum\n print(*array)\n\nsolve()\n", "int_list = lambda s: [int(n) for n in s.split(\" \")]\nn,m,k = int_list(input())\narr = int_list(input())\noperations = [int_list(input()) for _ in range(m)]\n\nincrs = [0]*len(arr) # Amount to increment running total when traversing arr\nfreq = [0]*m # The number of times the corresponding operation is used\n # stored in the same format as incrs\n\nfor _ in range(k):\n l,r = int_list(input())\n freq[l-1] += 1\n if r < len(freq): freq[r] -= 1\n \ntimes = 0 # number of times to apply current operation\nfor i, op in enumerate(operations):\n l,r,d = op\n times += freq[i] # update running total\n incrs[l-1] += times*d # encode operation in incrs\n if r < len(incrs): incrs[r] -= times*d\n \nprev = 0\nfor i,n in enumerate(arr):\n arr[i] = prev + n + incrs[i]\n prev += incrs[i]\n \nprint(\" \".join([str(n) for n in arr]))", "from itertools import accumulate\n\nn, m, k = list(map(int, input().split()))\na = list(map(int, input().split()))\noper = [tuple(map(int, input().split())) for i in range(m)]\nzapr = [tuple(map(int, input().split())) for i in range(k)]\n\ncount_ = [0 for i in range(m + 1)]\n\nfor el in zapr:\n x, y = el\n\n count_[x - 1] += 1\n count_[y] -= 1\n\ncounter_ = list(accumulate(count_))[:-1]\n\na.append(0)\na_count = [a[0]]\n\nfor i, el in enumerate(a[1:]):\n a_count.append(el - a[i])\n\nfor i, el in enumerate(oper):\n l, r, d = el\n d *= counter_[i]\n\n a_count[l - 1] += d\n a_count[r] -= d\n\na = list(accumulate(a_count))[:-1]\n\nprint(' '.join(map(str, a)))\n", "def process_query(queries,m):\n n = len(queries)\n a = [0]*(m+1)\n for q in queries:\n a[q[0]-1] += 1; a[q[1]] -= 1\n for i in range(1,m):\n a[i] += a[i-1]\n return a[:-1]\n\ndef apply_query(times,updates,n):\n a = [0]*(n+1)\n # print(len(a),len(times),len(updates))\n for i in range(len(updates)):\n a[updates[i][0]-1] += times[i]*updates[i][2]\n a[updates[i][1]] -= times[i]*updates[i][2]\n for i in range(1,n):\n a[i] += a[i-1]\n return a[:-1]\n\n\ndef main():\n n, m, k = list(map(int, input().split()))\n a = list(map(int, input().split()))\n updates = [list(map(int, input().split())) for i in range(m)]\n queries = [list(map(int, input().split())) for i in range(k)]\n times_query = process_query(queries,m)\n # print(\"times_query\",*times_query);\n updated_a = apply_query(times_query,updates,n)\n\n print(*[a[i] + updated_a[i] for i in range(n)])\n\ndef __starting_point():\n main()\n\n__starting_point()", "from sys import stdin, stdout\nn,m,k = map(int,stdin.readline().split())\na = [0]\na = a + list(map(int,stdin.readline().split()))\nop=[0]\nmn = [0]*(m+2)\nkp = [0]*(n+2)\n\nfor i in range(m):\n op.append(list(map(int,stdin.readline().split())))\nfor i in range(k):\n x,y = map(int,stdin.readline().split())\n mn[x]+=1\n mn[y+1]-=1\nfor i in range(1,m+1):\n mn[i]+=mn[i-1]\n op[i][2]*=mn[i]\n kp[op[i][0]]+=op[i][2]\n kp[op[i][1]+1]-=op[i][2]\nfor i in range(1,n+1):\n kp[i]+=kp[i-1]\nfor i in range(1,n+1):\n print(str(a[i]+kp[i]),end=\" \")\n ", "def __starting_point():\n\n n, m, k = list(map(int, input().split()))\n\n nums = list(map(int, input().split()))\n\n operations = [tuple(map(int, input().split())) for _ in range(m)]\n op_counter = [0] * (m+1)\n # queries\n for _ in range(k):\n x, y = list(map(int, input().split()))\n op_counter[x-1] += 1\n op_counter[y] -= 1\n\n acc = 0\n offset = [0]*(n+1)\n for i in range(m):\n l, r, d = operations[i]\n acc += op_counter[i]\n offset[l-1] += acc * d\n offset[r] -= acc * d\n\n acc = 0\n for i in range(n):\n acc += offset[i]\n nums[i] += acc\n print(' '.join(map(str, nums)))\n\n\n__starting_point()"] | {
"inputs": [
"3 3 3\n1 2 3\n1 2 1\n1 3 2\n2 3 4\n1 2\n1 3\n2 3\n",
"1 1 1\n1\n1 1 1\n1 1\n",
"4 3 6\n1 2 3 4\n1 2 1\n2 3 2\n3 4 4\n1 2\n1 3\n2 3\n1 2\n1 3\n2 3\n",
"1 1 1\n0\n1 1 0\n1 1\n"
],
"outputs": [
"9 18 17\n",
"2\n",
"5 18 31 20\n",
"0\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 13,287 | |
0078f3d5819f723e02e341afaaf9207d | UNKNOWN | Alan decided to get in shape for the summer, so he created a precise workout plan to follow. His plan is to go to a different gym every day during the next N days and lift $X[i]$ grams on day $i$. In order to improve his workout performance at the gym, he can buy exactly one pre-workout drink at the gym he is currently in and it will improve his performance by $A$ grams permanently and immediately. In different gyms these pre-workout drinks can cost different amounts $C[i]$ because of the taste and the gym's location but its permanent workout gains are the same. Before the first day of starting his workout plan, Alan knows he can lift a maximum of $K$ grams. Help Alan spend a minimum total amount of money in order to reach his workout plan. If there is no way for him to complete his workout plan successfully output $-1$.
-----Input-----
The first one contains two integer numbers, integers $N$ $(1 \leq N \leq 10^5)$ and $K$ $(1 \leq K \leq 10^5)$ – representing number of days in the workout plan and how many grams he can lift before starting his workout plan respectively. The second line contains $N$ integer numbers $X[i]$ $(1 \leq X[i] \leq 10^9)$ separated by a single space representing how many grams Alan wants to lift on day $i$. The third line contains one integer number $A$ $(1 \leq A \leq 10^9)$ representing permanent performance gains from a single drink. The last line contains $N$ integer numbers $C[i]$ $(1 \leq C[i] \leq 10^9)$ , representing cost of performance booster drink in the gym he visits on day $i$.
-----Output-----
One integer number representing minimal money spent to finish his workout plan. If he cannot finish his workout plan, output -1.
-----Examples-----
Input
5 10000
10000 30000 30000 40000 20000
20000
5 2 8 3 6
Output
5
Input
5 10000
10000 40000 30000 30000 20000
10000
5 2 8 3 6
Output
-1
-----Note-----
First example: After buying drinks on days 2 and 4 Alan can finish his workout plan. Second example: Alan cannot lift 40000 grams on day 2. | ["from sys import stdin\nfrom heapq import heappop,heappush\ndef main():\n\tn,k = map(int,stdin.readline().split())\n\tX = list(map(int,stdin.readline().split()))\n\tA = int(stdin.readline().strip())\n\tC = list(map(int,stdin.readline().split()))\n\tl = list()\n\ti = 0;g = k;ans = 0;flag = True\n\twhile i < n and flag:\n\t\theappush(l,C[i])\n\t\tif X[i] > g:\n\t\t\twhile len(l)!= 0 and X[i] > g:\n\t\t\t\tans+= heappop(l)\n\t\t\t\tg+= A\n\t\t\tif len(l) == 0 and X[i] > g:\n\t\t\t\tflag = False\n\t\ti+=1\n\tif flag:\n\t\tprint(ans)\n\telse:\n\t\tprint(-1)\nmain()", "from heapq import *\ndef main():\n n, k = input().split()\n n = int(n)\n k = int(k)\n req = list(map(lambda x:int(x),input().split()))\n each = int(input())\n prices = list(map(lambda x:int(x),input().split()))\n total = 0\n hp = []\n heapify(hp)\n for i in range(n):\n heappush(hp,prices[i])\n #print(f\"day{i}, max{k}\")\n needed = (req[i] - k + each -1) // each\n needed = max(0,needed)\n if len(hp) < needed:\n print(-1)\n return\n for j in range(needed):\n total += heappop(hp)\n k += each\n print(total)\n\nmain()", "from queue import PriorityQueue\n\nn, k = map(int, input(). split())\nx = list(map(int, input().split()))\na = int(input())\nc = list(map(int, input(). split()))\ntot = 0\npq = PriorityQueue()\nfor i in range(0, n):\n if (k >= x[i]):\n pq.put(c[i])\n else:\n pq.put(c[i])\n while (pq.qsize()):\n ans = pq.get()\n k += a\n tot += ans\n if (k >= x[i]):\n break;\n if (k < x[i]):\n tot = -1\n break;\nprint(tot)", "from queue import PriorityQueue \nN, K = tuple(map(int, input().split()))\nX = list(map(int, input().split()))\nA = int(input())\nC = list(map(int, input().split()))\nm_q = PriorityQueue()\nm = 0\nfor i in range(N):\n if K < X[i]:\n m_q.put(C[i])\n while m_q.qsize() > 0:\n K += A\n m += m_q.get()\n if K >= X[i]:\n break\n if K < X[i]:\n m=-1\n break \n else:\n m_q.put(C[i])\nprint(m)\n", "import math\nimport heapq\n\n\ndef solve_workout(n_days, strength, plan, gain, costs):\n total_cost = 0\n heap = list()\n\n for i in range(n_days):\n heapq.heappush(heap, costs[i])\n n_doses = int(math.ceil((plan[i] - strength) / gain))\n while n_doses > 0 and heap:\n total_cost += heapq.heappop(heap)\n strength += gain\n n_doses -= 1\n if strength < plan[i]:\n return -1\n return total_cost\n\n\ndef __starting_point():\n N, K = tuple(map(int, input().split()))\n X = list(map(int, input().split()))\n A = int(input())\n C = list(map(int, input().split()))\n print(solve_workout(N, K, X, A, C))\n\n__starting_point()", "import sys\nfrom queue import PriorityQueue\n\nn, k = (list(map(int, input().split())))\n\nt = list(map(int, input().split()))\na = int(input())\nc = list(map(int, input().split()))\nf = 1\ncost = 0\nm_q = PriorityQueue()\n\nfor i in range(n):\n if k + a * (i + 1) < t[i]:\n print(-1)\n break\nelse:\n for j in range(n):\n\n if k < t[j]:\n m_q.put(c[j])\n while m_q.qsize()>0:\n cost += m_q.get()\n\n\n\n # print(m_q)\n k = k + a\n if k>=t[j]:\n\n break\n\n\n\n\n\n #print(cost, j)\n\n\n else:\n\n m_q.put(c[j])\n print(cost)\n", "import heapq\nimport sys\nn,k=list(map(int,input().split()))\nl=k\narr=list(map(int,input().split()))\nadd=int(input())\nprice=list(map(int,input().split()))\nans=0\nsize=0\ns=[9999999999999999999]\nheapq.heapify(s)\nfor i in range(n):\n heapq.heappush(s,price[i])\n size+=1\n if (arr[i]>l):\n #print(l)\n b=(arr[i]-l-1)//add + 1\n if size<b:\n print(-1)\n return\n else:\n if b==0:\n break\n for j in range(b):\n ans+=heapq.heappop(s)\n l+=add\n #print(ans)\n size-=1\n #print(\"helo\")\nprint(ans)\n \n", "import heapq\ndef process(n, k, X, a, C):\n res=0\n A=[]\n for i in range(len(X)):\n heapq.heappush(A, C[i])\n if k+len(A)*a < X[i]:\n return -1\n else:\n while k <X[i]:\n res+=heapq.heappop(A)\n k+=a\n\n\n return res\nn, k=[int(x) for x in input().split()]\nX=[int(x) for x in input().split()]\na=int(input())\nC=[int(x) for x in input().split()]\nprint(process(n,k,X,a,C))\n", "import heapq as hp\n\nN, K = map(int, input().split())\nX = list(map(int, input().split()))\nA = int(input())\nC = list(map(int, input().split()))\n\nlimit = K\nq = []\ncost = 0\nfor i, x in enumerate(X):\n hp.heappush(q, C[i])\n if x > limit:\n while limit < x and q:\n limit += A\n nc = hp.heappop(q)\n cost += nc\n if limit < x:\n cost = -1\n break\n\nprint(cost)", "import math\nimport heapq\ndef solve_workout(n_days, strength, plan, gain, costs):\n total_cost = 0\n heap = list()\n for i in range(n_days):\n heapq.heappush(heap, costs[i])\n n_doses = int(math.ceil((plan[i] - strength) / gain))\n while n_doses > 0 and heap:\n total_cost += heapq.heappop(heap)\n strength += gain\n n_doses -= 1\n if strength < plan[i]:\n return -1\n return total_cost\ndef __starting_point():\n N, K = tuple(map(int, input().split()))\n X = list(map(int, input().split()))\n A = int(input())\n C = list(map(int, input().split()))\n print(solve_workout(N, K, X, A, C))\n__starting_point()", "R = lambda: map(int ,input().split())\nn, k = R()\nxs = list(R())\na = int(input())\ncs = list(R())\nr = j = 0\ntry:\n for i, x in enumerate(xs):\n if x > k:\n while x > k:\n s = min(cs[:i+1-j])\n cs.remove(s)\n r += s\n j += 1\n k += a\n if x > k:\n raise\nexcept:\n print(-1)\n quit()\nprint(r)", "R = lambda: map(int ,input().split())\nn, k = R()\nxs = list(R())\na = int(input())\ncs = list(R())\nr = j = 0\ntry:\n for i, x in enumerate(xs):\n while x > k:\n s = min(cs[:i+1-j])\n cs.remove(s)\n j += 1\n k += a\n r += s\nexcept:\n print(-1)\n quit()\nprint(r)", "import heapq as hp\nR = lambda: map(int ,input().split())\nn, k = R()\nxs = list(R())\na, r, h = int(input()), 0, []\ncs = list(R())\nfor i, x in enumerate(xs):\n hp.heappush(h, cs[i])\n while x > k and h:\n s = hp.heappop(h)\n k += a\n r += s\n if x > k:\n r = -1\n break\nprint(r)", "import heapq\nn, k = map(int, input().split(' '))\nx = list(map(int, input().split(' ')))\na = int(input())\nc = list(map(int, input().split(' ')))\npq, ans = [], 0\nfor i in range(n):\n\theapq.heappush(pq, c[i])\n\twhile x[i] > k and len(pq) > 0:\n\t\tk += a\n\t\tans += heapq.heappop(pq)\n\tif k < x[i]:\n\t\tprint(\"-1\")\n\t\treturn\nprint(ans)", "import heapq\ndef smaller_by_1(num):\n return num-1\ndef main():\n N,k = list(map(int,input().split(\" \")))\n X = list(map(int,input().split(\" \")))\n A = int(input())\n C = list(map(int,input().split(\" \")))\n #drunk = [0]*N\n money_needed = 0\n drinks_needed = []\n drunk_to_now = 0\n for i in range(N):\n objective = X[i]\n drinks_needed.append(((objective - k)+A-1) // A)\n possible_drinks = []\n for i in range(len(drinks_needed)):\n heapq.heappush(possible_drinks,C[i])\n if drinks_needed[i] - drunk_to_now<= 0:\n continue\n else:\n while drinks_needed[i] - drunk_to_now != 0:\n if len(possible_drinks) == 0:\n print(-1)\n return 0\n else:\n money_needed += heapq.heappop(possible_drinks)\n drunk_to_now += 1\n \n print(money_needed)\n \n \n\n\n\nmain()\n \n", "import sys, math\nfrom heapq import heappush, heappop\n\nreadline = sys.stdin.readline\nmr = lambda:map(int,readline().split())\nn, k = mr()\ntmp = list(mr())\na = int(readline())\ncost = list(mr())\nfor i in range(n):\n tmp[i] -= k\nbuyIndexes = []\nenergy = 0\nans = 0\nfor i in range(n):\n heappush(buyIndexes,cost[i])\n if energy < tmp[i]:\n ordered = []\n while energy < tmp[i]:\n energy += a\n if len(buyIndexes) == 0:\n ans = -1\n break\n ans += heappop(buyIndexes)\n if ans == -1:\n break\nprint(ans)", "import heapq\n\n\nclass Input:\n def __init__(self):\n from sys import stdin\n lines = stdin.readlines()\n self.lines = list([line.rstrip('\\n') for line in reversed(lines) if line != '\\n'])\n\n def input(self):\n return self.lines.pop()\n\n def input_int_list(self):\n return list(map(int, self.input().split()))\n\n def __bool__(self):\n return bool(self.lines)\n\n\ndef workout_plan(n, k, xs, a, cs):\n choices = []\n cs.reverse()\n total_cost = 0\n for x in xs:\n heapq.heappush(choices, cs.pop())\n while k < x:\n if choices:\n k += a\n total_cost += heapq.heappop(choices)\n else:\n return -1\n return total_cost\n\n\ninp = Input()\nn, k = inp.input_int_list()\nxs = inp.input_int_list()\na = int(inp.input())\ncs = inp.input_int_list()\nprint(workout_plan(n, k, xs, a, cs))\n", "import heapq as hp\nimport sys\nn, k = map(int, input().split())\narr = list(map(int, input().split()))\np = int(input())\narrx = list(map(int, input().split()))\nprev = []\nhp.heapify(prev)\ncost = 0\nflag = 0\nfor i in range(n):\n hp.heappush(prev, arrx[i])\n while arr[i] > k and len(prev) > 0:\n k += p\n cost += hp.heappop(prev)\n if k < arr[i]:\n flag = 1\n break\nif flag == 1:\n print(-1)\nelse:\n print(cost)", "from heapq import *\n\nn, k = list(map(int, input().split()))\narr = list(map(int, input().split()))\na = int(input())\nc = list(map(int, input().split()))\ncur = []\nres = 0\nfor i, p in enumerate(arr):\n heappush(cur, c[i])\n if p <= k:\n continue\n if len(cur) * a + k < p:\n print(-1)\n return\n while p > k:\n res += heappop(cur)\n k += a\nprint(res)\n\n", "from heapq import *\n\nn, k = list(map(int, input().split()))\narr = list(map(int, input().split()))\na = int(input())\nc = list(map(int, input().split()))\ncur = []\nres = 0\nfor i, p in enumerate(arr):\n heappush(cur, c[i])\n if p <= k:\n continue\n if len(cur) * a + k < p:\n print(-1)\n return\n while p > k:\n res += heappop(cur)\n k += a\nprint(res)\n", "import heapq \nn,initial=list(map(int,input().split()))\ntarget=list(map(int,input().split()))\ngain=int(input())\nprices=list(map(int,input().split()))\nflag=True\nfor i in range(n):\n if target[i]>(i+1)*gain+initial:\n flag=False\n print(-1)\n break \nif flag:\n a=[10**18]\n heapq.heapify(a)\n maxx=-1\n ans=0\n for i in range(n):\n heapq.heappush(a,prices[i])\n if target[i]>initial:\n moves=(target[i] - initial - 1)//gain + 1\n if moves==0:\n break \n else:\n for i in range(moves):\n ans+=heapq.heappop(a)\n initial+=gain \n print(ans) \n \n \n"] | {
"inputs": [
"5 10000\n10000 30000 30000 40000 20000\n20000\n5 2 8 3 6\n",
"5 10000\n10000 40000 30000 30000 20000\n10000\n5 2 8 3 6\n",
"5 49\n22 23 11 17 49\n50\n102 55 77 34 977\n",
"5 1\n1 1 1 2 9\n1000000000\n10 20 30 40 50\n"
],
"outputs": [
"5\n",
"-1\n",
"0\n",
"10\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 11,991 | |
c8b0442234183a827d4b0d3c80d126fe | UNKNOWN | Momiji has got a rooted tree, consisting of n nodes. The tree nodes are numbered by integers from 1 to n. The root has number 1. Momiji decided to play a game on this tree.
The game consists of several steps. On each step, Momiji chooses one of the remaining tree nodes (let's denote it by v) and removes all the subtree nodes with the root in node v from the tree. Node v gets deleted as well. The game finishes when the tree has no nodes left. In other words, the game finishes after the step that chooses the node number 1.
Each time Momiji chooses a new node uniformly among all the remaining nodes. Your task is to find the expectation of the number of steps in the described game.
-----Input-----
The first line contains integer n (1 ≤ n ≤ 10^5) — the number of nodes in the tree. The next n - 1 lines contain the tree edges. The i-th line contains integers a_{i}, b_{i} (1 ≤ a_{i}, b_{i} ≤ n; a_{i} ≠ b_{i}) — the numbers of the nodes that are connected by the i-th edge.
It is guaranteed that the given graph is a tree.
-----Output-----
Print a single real number — the expectation of the number of steps in the described game.
The answer will be considered correct if the absolute or relative error doesn't exceed 10^{ - 6}.
-----Examples-----
Input
2
1 2
Output
1.50000000000000000000
Input
3
1 2
1 3
Output
2.00000000000000000000
-----Note-----
In the first sample, there are two cases. One is directly remove the root and another is remove the root after one step. Thus the expected steps are: 1 × (1 / 2) + 2 × (1 / 2) = 1.5
In the second sample, things get more complex. There are two cases that reduce to the first sample, and one case cleaned at once. Thus the expected steps are: 1 × (1 / 3) + (1 + 1.5) × (2 / 3) = (1 / 3) + (5 / 3) = 2 | ["# https://codeforces.com/problemset/problem/280/C\nfrom collections import defaultdict, deque\nimport sys\n\nnodes = int(sys.stdin.readline())\nedges = defaultdict(list)\nfor line in sys.stdin:\n a, b = line.split()\n a = int(a)\n b = int(b)\n edges[a].append(b)\n edges[b].append(a)\nbfs = deque([(1, 1)])\ndepths = {}\nwhile bfs:\n nid, depth = bfs.popleft()\n if nid in depths:\n continue\n depths[nid] = depth\n for n2 in edges[nid]:\n bfs.append((n2, depth + 1))\nprint(sum(1.0 / d for d in sorted(depths.values(), reverse=True)))"] | {
"inputs": [
"2\n1 2\n",
"3\n1 2\n1 3\n",
"10\n1 2\n2 3\n3 4\n1 5\n2 6\n6 7\n4 8\n6 9\n9 10\n",
"6\n1 3\n2 4\n5 6\n3 6\n5 4\n"
],
"outputs": [
"1.50000000000000000000\n",
"2.00000000000000000000\n",
"3.81666666666666690000\n",
"2.45000000000000020000\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 580 | |
a016e3a391efb2acfe1795f880fe7db1 | UNKNOWN | Oleg's favorite subjects are History and Math, and his favorite branch of mathematics is division.
To improve his division skills, Oleg came up with $t$ pairs of integers $p_i$ and $q_i$ and for each pair decided to find the greatest integer $x_i$, such that: $p_i$ is divisible by $x_i$; $x_i$ is not divisible by $q_i$. Oleg is really good at division and managed to find all the answers quickly, how about you?
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 50$) — the number of pairs.
Each of the following $t$ lines contains two integers $p_i$ and $q_i$ ($1 \le p_i \le 10^{18}$; $2 \le q_i \le 10^{9}$) — the $i$-th pair of integers.
-----Output-----
Print $t$ integers: the $i$-th integer is the largest $x_i$ such that $p_i$ is divisible by $x_i$, but $x_i$ is not divisible by $q_i$.
One can show that there is always at least one value of $x_i$ satisfying the divisibility conditions for the given constraints.
-----Example-----
Input
3
10 4
12 6
179 822
Output
10
4
179
-----Note-----
For the first pair, where $p_1 = 10$ and $q_1 = 4$, the answer is $x_1 = 10$, since it is the greatest divisor of $10$ and $10$ is not divisible by $4$.
For the second pair, where $p_2 = 12$ and $q_2 = 6$, note that $12$ is not a valid $x_2$, since $12$ is divisible by $q_2 = 6$; $6$ is not valid $x_2$ as well: $6$ is also divisible by $q_2 = 6$. The next available divisor of $p_2 = 12$ is $4$, which is the answer, since $4$ is not divisible by $6$. | ["mod = 1000000007\neps = 10**-9\n\n\ndef main():\n import sys\n input = sys.stdin.readline\n\n def PrimeDecomposition(N):\n ret = {}\n n = int(N ** 0.5)\n for d in range(2, n + 1):\n while N % d == 0:\n if d not in ret:\n ret[d] = 1\n else:\n ret[d] += 1\n N //= d\n if N == 1:\n break\n if N != 1:\n ret[N] = 1\n return ret\n\n for _ in range(int(input())):\n p, q = list(map(int, input().split()))\n if p % q != 0:\n print(p)\n continue\n prime = PrimeDecomposition(q)\n C = {}\n mi = p\n for pr in prime:\n C = 0\n tmp = p\n while tmp % pr == 0:\n C += 1\n tmp //= pr\n mi = min(mi, pr ** (C - prime[pr] + 1))\n print(p // mi)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "for _ in range(int(input())):\n p, q = list(map(int, input().split()))\n if p % q != 0:\n print(p)\n continue\n pr = {}\n i = 2\n while i*i <= q:\n if q % i == 0:\n x = 0\n while q % i == 0:\n q //= i\n x += 1\n pr[i] = x\n i += 1\n if q != 1:\n pr[q] = 1\n\n res = 1\n for k in pr:\n v = pr[k]\n pp = p\n x = 0\n while pp % k == 0:\n pp //= k\n x += 1\n res = max(res, p//k**(x-(v-1)))\n print(res)\n", "import sys\ninput = sys.stdin.readline\nfor f in range(int(input())):\n p,q=list(map(int,input().split()))\n d=2\n facs=[]\n facsm=[]\n while q>=d*d:\n if q%d==0:\n facs.append(d)\n x=0\n while q%d==0:\n x+=1\n q//=d\n facsm.append(x-1)\n d+=1\n if q>1:\n facs.append(q)\n facsm.append(0)\n mc=p\n pc=p\n for i in range(len(facs)):\n x=0\n while pc%facs[i]==0:\n x+=1\n pc//=facs[i]\n mc=min(mc,facs[i]**(x-min(x,facsm[i])))\n p//=mc\n print(p)\n", "import sys\nfrom sys import stdin\n\ntt = int(stdin.readline())\n\nfor loop in range(tt):\n\n p,q = map(int,stdin.readline().split())\n\n if p % q != 0:\n print (p)\n continue\n\n bk = {}\n for i in range(2,10**5):\n if q % i == 0:\n bk[i] = 0\n while q % i == 0:\n bk[i] += 1\n q //= i\n if bk == 1:\n break\n\n if q != 1:\n bk[q] = 1\n\n #print (bk)\n\n ans = float(\"-inf\")\n for i in bk:\n cnt = 0\n tp = p\n while tp % i == 0:\n tp //= i\n cnt += 1\n ans = max(ans , p // (i**(cnt-bk[i]+1)))\n\n print (ans)"] | {
"inputs": [
"3\n10 4\n12 6\n179 822\n",
"10\n246857872446986130 713202678\n857754240051582063 933416507\n873935277189052612 530795521\n557307185726829409 746530097\n173788420792057536 769449696\n101626841876448103 132345797\n598448092106640578 746411314\n733629261048200000 361714100\n981271355542147402 38\n559754147245184151 431517529\n",
"10\n228282288 228282288\n1000000000000000000 1000000000\n1244094302301841 35271721\n998005893107997601 999002449\n999999874000003969 999999937\n956980859148255595 5\n1 323\n1 1000000000\n424001357601318819 537974673\n100000000 1000000000\n",
"1\n42034266112 80174\n"
],
"outputs": [
"10\n4\n179\n",
"123428936223493065\n918940509\n37932865019708\n1\n57929473597352512\n767888699\n299224046053320289\n31896924393400000\n490635677771073701\n26946235365387\n",
"114141144\n976562500000000\n5939\n31607\n1\n191396171829651119\n1\n1\n424001357601318819\n100000000\n",
"1048576\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 2,925 | |
deb688ce6a1c8d4af052764aaaa78c66 | UNKNOWN | After learning a lot about space exploration, a little girl named Ana wants to change the subject.
Ana is a girl who loves palindromes (string that can be read the same backwards as forward). She has learned how to check for a given string whether it's a palindrome or not, but soon she grew tired of this problem, so she came up with a more interesting one and she needs your help to solve it:
You are given an array of strings which consist of only small letters of the alphabet. Your task is to find how many palindrome pairs are there in the array. A palindrome pair is a pair of strings such that the following condition holds: at least one permutation of the concatenation of the two strings is a palindrome. In other words, if you have two strings, let's say "aab" and "abcac", and you concatenate them into "aababcac", we have to check if there exists a permutation of this new string such that it is a palindrome (in this case there exists the permutation "aabccbaa").
Two pairs are considered different if the strings are located on different indices. The pair of strings with indices $(i,j)$ is considered the same as the pair $(j,i)$.
-----Input-----
The first line contains a positive integer $N$ ($1 \le N \le 100\,000$), representing the length of the input array.
Eacg of the next $N$ lines contains a string (consisting of lowercase English letters from 'a' to 'z') — an element of the input array.
The total number of characters in the input array will be less than $1\,000\,000$.
-----Output-----
Output one number, representing how many palindrome pairs there are in the array.
-----Examples-----
Input
3
aa
bb
cd
Output
1
Input
6
aab
abcac
dffe
ed
aa
aade
Output
6
-----Note-----
The first example: aa $+$ bb $\to$ abba.
The second example: aab $+$ abcac $=$ aababcac $\to$ aabccbaa aab $+$ aa $=$ aabaa abcac $+$ aa $=$ abcacaa $\to$ aacbcaa dffe $+$ ed $=$ dffeed $\to$ fdeedf dffe $+$ aade $=$ dffeaade $\to$ adfaafde ed $+$ aade $=$ edaade $\to$ aeddea | ["#!/usr/bin/env python3\n\"\"\"\nCreated on Wed Feb 28 11:47:12 2018\n\n@author: mikolajbinkowski\n\"\"\"\nimport sys\n\nN = int(input())\n\nstring_count = {}\nfor _ in range(N):\n s = str(input())\n char_count = {}\n for c in s:\n char_count[c] = char_count.get(c, 0) + 1\n s0 = []\n for a in 'abcdefghijklmnopqrstuvwxyz':\n if char_count.get(a, 0) % 2 == 1:\n s0.append(a)\n s1 = ''.join(s0)\n string_count[s1] = string_count.get(s1, 0) + 1\n\npairs = 0\nfor s, v in list(string_count.items()):\n pairs += v * (v-1) // 2\n for i in range(len(s)):\n pairs += v * string_count.get(s[:i] + s[i+1:], 0)\n\nprint(pairs)\n\n \n \n", "def main():\n n = int(input())\n ans = 0\n d = {}\n for i in range(n):\n s = input()\n cur = 0\n for c in s:\n cur ^= (1 << (ord(c) - ord('a')))\n ans += d.get(cur, 0)\n for j in range(26):\n ans += d.get(cur ^ (1 << j), 0)\n t = d.get(cur, 0) + 1\n d[cur] = t\n print(ans)\n return\n\ndef __starting_point():\n main()\n__starting_point()", "# -*- coding:utf-8 -*-\n\n\"\"\"\n\ncreated by shuangquan.huang at 11/20/18\n\n\n\nAfter learning a lot about space exploration, a little girl named Ana wants to change the subject.\n\nAna is a girl who loves palindromes (string that can be read the same backwards as forward).\nShe has learned how to check for a given string whether it's a palindrome or not, but soon she grew tired of this problem,\nso she came up with a more interesting one and she needs your help to solve it:\n\nYou are given an array of strings which consist of only small letters of the alphabet.\nYour task is to find how many palindrome pairs are there in the array.\nA palindrome pair is a pair of strings such that the following condition holds:\nat least one permutation of the concatenation of the two strings is a palindrome.\nIn other words, if you have two strings, let's say \"aab\" and \"abcac\",\nand you concatenate them into \"aababcac\", we have to check if there exists a permutation of this new string such that\nit is a palindrome (in this case there exists the permutation \"aabccbaa\").\n\nTwo pairs are considered different if the strings are located on different indices.\nThe pair of strings with indices (\ud835\udc56,\ud835\udc57) is considered the same as the pair (\ud835\udc57,\ud835\udc56).\n\nInput\nThe first line contains a positive integer \ud835\udc41 (1\u2264\ud835\udc41\u2264100 000), representing the length of the input array.\n\nEacg of the next \ud835\udc41 lines contains a string (consisting of lowercase English letters from 'a' to 'z') \u2014 an element of the input array.\n\nThe total number of characters in the input array will be less than 1000000.\n\nOutput\nOutput one number, representing how many palindrome pairs there are in the array.\n\n\n\n# a, b can be transform to palindrome only when number of every characters in a+b is even, or only one is odd.\n# only odd+even => odd\n\n\n\"\"\"\n\nimport collections\n\nN = int(input())\n\n\ndef hash(s):\n wc = collections.Counter(s)\n x = ''\n for i in range(26):\n w = chr(ord('a') + i)\n c = wc[w]\n if c % 2 == 0:\n x += '0'\n else:\n x += '1'\n \n return x\n\n\ndef neighbor(s):\n for i in range(len(s)):\n yield s[:i] + ('1' if s[i] == '0' else '0') + s[i + 1:]\n\n\ndef isneighbor(a, b):\n return sum([0 if a[i] == b[i] else 1 for i in range(len(a))]) == 1\n\nm = collections.defaultdict(list)\nfor i in range(N):\n s = input()\n m[hash(s)].append(i)\n\neven = 0\nodd = 0\nfor k, v in list(m.items()):\n lv = len(v)\n even += lv * (lv - 1) // 2\n \n for b in neighbor(k):\n if b in m:\n odd += lv * len(m[b])\n\nprint(even + odd // 2)\n\n", "from collections import Counter\n\nn = int(input())\n\nmp = Counter({'': 0})\n\nfor i in range(n):\n string = input()\n occ = [0] * 26\n for c in string:\n occ[ord(c) - ord('a')] += 1\n if occ[ord(c) - ord('a')] == 2:\n occ[ord(c) - ord('a')] = 0\n clean = []\n for idx in range(26):\n while occ[idx] > 0:\n clean.append(chr(idx + ord('a')))\n occ[idx] -= 1\n\n mp[''.join(clean)] += 1\n\nans = 0\n\n\ndef combs(n):\n return n * (n - 1) // 2\n\n\nfor key in mp:\n if len(key) == 1:\n ans += combs(mp[key]) + mp[key] * mp['']\n elif len(key) == 0:\n ans += combs(mp[key])\n else:\n ans += combs(mp[key])\n for idx in range(len(key)):\n ans += mp[key] * mp[key[0:idx] + key[idx + 1:]]\n\nprint(ans)\n", "from collections import Counter\n\nn = int(input())\nstrings = []\n\nfor i in range(0,n):\n counter = { x: 0 for x in range(ord('a'), ord('z')+1) }\n napis = input()\n for val in napis:\n counter[ord(val)] = (counter[ord(val)] + 1) % 2\n \n napis = \"\"\n for key, val in list(counter.items()):\n if val != 0:\n napis+=chr(key)\n \n strings.append(napis)\n\nc = Counter(strings)\nstrings = sorted(c.most_common(), key=lambda i: i[0])\n#print(strings)\n\ncount = 0\nfor key, val in strings:\n if val > 1:\n count += val*(val-1)/2\n\nfor charInt in range(ord('a'), ord('z')+1):\n char = chr(charInt)\n copy = {}\n for key, val in strings:\n if char in key:\n copy[key.replace(char, \"\")] = copy.get(key.replace(char, \"\"), 0) + val\n #print(copy)\n for key, val in strings:\n if copy.get(key,0) != 0:\n count+=val * copy[key]\n #print(\"pokrywa : \", key, \" \", val*copy[key])\n\nprint(int(count))\n", "n = int(input())\nstring_count = {}\nfor _ in range(n):\n s = str(input())\n item_count={}\n for i,c in enumerate(s):\n item_count[c]=item_count.get(c,0)+1\n s0=[]\n for i,x in enumerate('abcdefghijklmnopqrstuvwxyz'):\n if item_count.get(x,0)%2==1:\n s0.append(x)\n s1 = ''.join(s0)\n string_count[s1]=string_count.get(s1,0)+1\npoints=0\nfor j,a in enumerate(string_count):\n x = string_count[a]\n points+=x*(x-1)//2\n for i in range(len(a)):\n points+=x*string_count.get(a[:i]+a[i+1:],0)\nprint(points)", "n = int(input())\nstring_count = {}\nfor _ in range(n):\n s = str(input())\n item_count={}\n for i,c in enumerate(s):\n item_count[c]=item_count.get(c,0)+1\n s0=[]\n for x in 'abcdefghijklmnopqrstuvwxyz':\n if item_count.get(x,0)%2==1:\n s0.append(x)\n s1 = ''.join(s0)\n string_count[s1]=string_count.get(s1,0)+1\npoints=0\nfor a,x in string_count.items():\n points+=x*(x-1)//2\n for i in range(len(a)):\n points+=x*string_count.get(a[:i]+a[i+1:],0)\nprint(points)", "n=int(input())\ns=[0]*n\nfor i in range (n):\n s[i]=input()\ndic={}\nans=0\nfor i in range (n):\n temp=0\n for k in range(len(s[i])):\n temp^=(1<<(ord(s[i][k])-ord('a')))\n #print(temp,s[i])\n if temp in list(dic.keys()):\n ans=ans+dic[temp]\n for j in range (26):\n chk=temp\n chk^=(1<<j)\n if chk in list(dic.keys()):\n ans=ans+dic[chk]\n if temp in list(dic.keys()):\n dic[temp]+=1\n else:\n dic[temp]=1\n # print(dic[temp])\nprint(ans)\n", "aw=[2**i for i in range(26)]\nn=int(input())\nd=dict()\nans=0\nfor ir in range(n):\n st=input()\n es=0\n for j in st:\n es=es^aw[ord(j)-97]\n if es in d:\n ans+=d[es]\n for j in range(26):\n es=es^aw[j]\n if es in d:\n ans+=d[es]\n es=es^aw[j]\n if es in d:\n d[es]+=1\n else:\n d.update({es:1})\nprint(ans)\n", "import sys\n\ninput = sys.stdin.readline\n\n\ndef gcd(a, b):\n if a == 0:\n return b\n return gcd(b % a, a)\n\n\ndef lcm(a, b):\n return (a * b) / gcd(a, b)\n\n\n\n\ndef main():\n comp=[]\n c=1\n for i in range(27):\n comp.append(c)\n c*=2\n n=int(input())\n d={}\n table=[]\n for i in range(n):\n k=[0]*27\n s=input()\n for j in s:\n if ord(j)-ord('a')>=0:\n k[ord(j)-ord('a')]+=1\n #print(ord(j)-ord('a'))\n key=0\n for i in range(26):\n if k[i]%2:\n key+=comp[i]\n table.append([k,key])\n if key in d:\n d[key]+=1\n else:\n d[key]=1\n ans=0\n for i in list(d.values()):\n ans+=(i)*(i-1)//2\n #print(ans)\n for i in table:\n #print(i)\n for j in range(len(i[0])):\n if i[0][j]%2:\n if i[1]-comp[j] in list(d.keys()):\n #print(i[1],i[1]-comp[j] )\n ans+=(d[i[1]-comp[j]])\n\n print(int(ans))\n\n\n return\n\n\ndef __starting_point():\n main()\n\n__starting_point()"] | {
"inputs": [
"3\naa\nbb\ncd\n",
"6\naab\nabcac\ndffe\ned\naa\naade\n",
"20\niw\nix\nudb\nbg\noi\nuo\njsm\num\ns\nquy\nqo\nbxct\nng\nrmr\nnu\nps\nio\nkh\nw\nk\n",
"17\npo\nuej\ndtc\nj\ncnj\ncn\nbt\nnrj\nyye\nkol\nz\ntm\narb\ne\nzq\nj\nk\n"
],
"outputs": [
"1\n",
"6\n",
"5\n",
"4\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 8,840 | |
40a62cc1b737a54cd5d4bf36e5de7fe9 | UNKNOWN | Thor is getting used to the Earth. As a gift Loki gave him a smartphone. There are n applications on this phone. Thor is fascinated by this phone. He has only one minor issue: he can't count the number of unread notifications generated by those applications (maybe Loki put a curse on it so he can't).
q events are about to happen (in chronological order). They are of three types: Application x generates a notification (this new notification is unread). Thor reads all notifications generated so far by application x (he may re-read some notifications). Thor reads the first t notifications generated by phone applications (notifications generated in first t events of the first type). It's guaranteed that there were at least t events of the first type before this event. Please note that he doesn't read first t unread notifications, he just reads the very first t notifications generated on his phone and he may re-read some of them in this operation.
Please help Thor and tell him the number of unread notifications after each event. You may assume that initially there are no notifications in the phone.
-----Input-----
The first line of input contains two integers n and q (1 ≤ n, q ≤ 300 000) — the number of applications and the number of events to happen.
The next q lines contain the events. The i-th of these lines starts with an integer type_{i} — type of the i-th event. If type_{i} = 1 or type_{i} = 2 then it is followed by an integer x_{i}. Otherwise it is followed by an integer t_{i} (1 ≤ type_{i} ≤ 3, 1 ≤ x_{i} ≤ n, 1 ≤ t_{i} ≤ q).
-----Output-----
Print the number of unread notifications after each event.
-----Examples-----
Input
3 4
1 3
1 1
1 2
2 3
Output
1
2
3
2
Input
4 6
1 2
1 4
1 2
3 3
1 3
1 3
Output
1
2
3
0
1
2
-----Note-----
In the first sample: Application 3 generates a notification (there is 1 unread notification). Application 1 generates a notification (there are 2 unread notifications). Application 2 generates a notification (there are 3 unread notifications). Thor reads the notification generated by application 3, there are 2 unread notifications left.
In the second sample test: Application 2 generates a notification (there is 1 unread notification). Application 4 generates a notification (there are 2 unread notifications). Application 2 generates a notification (there are 3 unread notifications). Thor reads first three notifications and since there are only three of them so far, there will be no unread notification left. Application 3 generates a notification (there is 1 unread notification). Application 3 generates a notification (there are 2 unread notifications). | ["#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nimport sys,collections\nn,q=list(map(int,input().split()))\nM=collections.defaultdict(collections.deque)\nQ=collections.deque()\nL=[]\ns=n=m=0\nfor _ in range(q):\n\ty,x=list(map(int,input().split()))\n\tif 2>y:\n\t\ts+=1\n\t\tQ.append(x)\n\t\tM[x].append(n)\n\t\tn+=1\n\telif 3>y:\n\t\ty=M.get(x)\n\t\tif y:\n\t\t\ts-=len(y)\n\t\t\tdel M[x]\n\telse:\n\t\twhile x>m:\n\t\t\tz=Q.popleft()\n\t\t\ty=M.get(z)\n\t\t\tif y and y[0]<x:\n\t\t\t\ts-=1\n\t\t\t\ty.popleft()\n\t\t\t\tif not y:del M[z]\n\t\t\tm+=1\n\tL.append(s)\nsys.stdout.write('\\n'.join(map(str,L)))\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nimport collections\nn,q=list(map(int,input().split()))\nM=collections.defaultdict(collections.deque)\nQ=collections.deque()\nL=[]\ns=n=m=0\nfor _ in range(q):\n\ty,x=list(map(int,input().split()))\n\tif 2>y:\n\t\ts+=1\n\t\tQ.append(x)\n\t\tM[x].append(n)\n\t\tn+=1\n\telif 3>y:\n\t\ty=M.get(x)\n\t\tif y:\n\t\t\ts-=len(y)\n\t\t\tdel M[x]\n\telse:\n\t\twhile x>m:\n\t\t\tz=Q.popleft()\n\t\t\ty=M.get(z)\n\t\t\tif y and y[0]<x:\n\t\t\t\ts-=1\n\t\t\t\ty.popleft()\n\t\t\t\tif not y:del M[z]\n\t\t\tm+=1\n\tL.append(s)\nprint('\\n'.join(map(str,L)))\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nimport collections\nn,q=list(map(int,input().split()))\nQ=collections.deque()\nA=n*[0]\nB=A[:]\nL=[]\ns=n=0\nfor _ in range(q):\n\ty,x=list(map(int,input().split()))\n\tif 2>y:\n\t\tx-=1\n\t\tQ.append(x)\n\t\tB[x]+=1\n\t\tA[x]+=1\n\t\ts+=1\n\telif 3>y:\n\t\tx-=1\n\t\ts-=A[x]\n\t\tA[x]=0\n\telse:\n\t\twhile x>n:\n\t\t\tn+=1\n\t\t\ty=Q.popleft()\n\t\t\tB[y]-=1\n\t\t\tif(B[y]<A[y]):\n\t\t\t\tA[y]-=1\n\t\t\t\ts-=1\n\tL.append(s)\nprint('\\n'.join(map(str,L)))\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nimport collections\nn,q=list(map(int,input().split()))\nQ=collections.deque()\nA=n*[0]\nB=A[:]\nL=[]\ns=n=0\nfor _ in range(q):\n\ty,x=list(map(int,input().split()))\n\tif 2>y:\n\t\tx-=1\n\t\tQ.append(x)\n\t\tB[x]+=1\n\t\tA[x]+=1\n\t\ts+=1\n\telif 3>y:\n\t\tx-=1\n\t\ts-=A[x]\n\t\tA[x]=0\n\telse:\n\t\twhile x>n:\n\t\t\tn+=1\n\t\t\ty=Q.popleft()\n\t\t\tB[y]-=1\n\t\t\tif(B[y]<A[y]):\n\t\t\t\tA[y]-=1\n\t\t\t\ts-=1\n\tL.append(str(s))\nprint('\\n'.join(L))\n", "n,q = map(int,input().split())\nxi = [[0]*(n+1) for i in range(2)]\nnoti = []\nans = \"\"\nnum = 0\nnum2 = 0\nnum3 = 0\nwhile q > 0:\n typ,xt = map(int,input().split())\n if typ == 1:\n xi[0][xt] += 1\n noti += [xt]\n num += 1\n num2 += 1\n elif typ == 3:\n for i in range(num3,xt):\n if i+1 > xi[1][noti[i]]:\n xi[0][noti[i]] -= 1\n num -= 1\n num3 = max(num3,xt)\n else:\n num -= xi[0][xt]\n xi[0][xt] = 0\n xi[1][xt] = num2\n ans += str(num)\n ans += \"\\n\"\n q -= 1\nprint(ans)", "def main():\n n, q = list(map(int, input().split()))\n vol, tot, l, res = [0] * (n + 1), [0] * (n + 1), [], []\n z = m = 0\n for _ in range(q):\n t, x = list(map(int, input().split()))\n if t == 1:\n l.append(x)\n tot[x] += 1\n vol[x] += 1\n z += 1\n elif t == 2:\n z -= vol[x]\n vol[x] = 0\n else:\n if m < x:\n r, m = list(range(m, x)), x\n for i in r:\n x = l[i]\n tot[x] -= 1\n if vol[x] > tot[x]:\n vol[x] -= 1\n z -= 1\n res.append(z)\n print('\\n'.join(map(str, res)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n , q = map(int, input().split())\nstacks = [[] for i in range(n + 1)]\nqueue = []\nq_start = 0\nunread = 0\nans = []\n\nfor i in range(q):\n action, num = map(int, input().split())\n if action == 1:\n queue.append(0)\n stacks[num].append(len(queue) - 1)\n unread += 1\n \n elif action == 2:\n for i in range(len(stacks[num])):\n if stacks[num][i] >= q_start and queue[stacks[num][i]] == 0:\n queue[stacks[num][i]] = 1\n unread -= 1\n stacks[num] = []\n else:\n for i in range(q_start, num):\n if queue[i] == 0:\n queue[i] = 1\n unread -= 1\n q_start = max(q_start, num)\n ans.append(unread)\n\nprint(\"\\n\".join(map(str, ans)))", "from sqlite3 import collections\nn, q = list(map(int, input().split()))\nQ = collections.deque()\nA = n*[0]\nB = A[: ]\nL = []\ns=n=0\nfor _ in range(q):\n y, x = list(map(int, input().split()))\n if y<2 :\n x-=1\n Q.append(x)\n B[x]+=1\n A[x]+=1\n s+=1\n elif y<3 :\n x-=1\n s-=A[x]\n A[x]=0\n else :\n while x>n :\n n+=1\n y=Q.popleft()\n B[y]-=1\n if B[y]<A[y] :\n A[y]-=1\n s-=1\n L.append(str(s))\nprint('\\n'.join(L))\n", "import collections\nn, q = list(map(int ,input().split()))\nQ = collections.deque()\nA = [0] * n\nB = A[:]\nL = []\ns = n = 0\nfor k in range(q):\n type1, x = list(map(int, input().split()))\n if type1 == 1:\n x -= 1\n Q.append(x)\n B[x] += 1\n A[x] += 1\n s += 1\n if type1 == 2:\n x -= 1\n s -= A[x]\n A[x] = 0\n if type1 == 3:\n while x > n:\n n += 1\n y = Q.popleft()\n B[y] -= 1\n if B[y] < A[y]:\n A[y] -= 1\n s -= 1\n L.append(str(s))\nprint('\\n'.join(L))\n", "n,q = map(int, input().split())\nl = []\na = [[] for _ in range(n)]\ntp = 0\nans = 0\nanss = []\nfor i in range(q):\n x,b = map(int, input().split())\n if x == 1:\n l.append(1)\n a[b-1].append(len(l) -1)\n ans +=1\n elif x == 2:\n while len(a[b-1]) > 0:\n z = a[b-1].pop()\n ans -= l[z]\n l[z] = 0\n else:\n while tp < b:\n ans -=l[tp]\n l[tp] = 0\n tp += 1\n anss.append(str(ans))\nprint('\\n'.join(anss))", "import collections \nn,q=map(int,input().split())\ndq=collections.deque()\nl=n*[0]\np=list(l)\nans=0\nt=0\nansl=[]\nwhile(q):\n a,b=map(int,input().split())\n if a==1:\n dq.append(b-1)\n l[b-1],p[b-1]=l[b-1]+1,p[b-1]+1\n ans=ans+1\n elif a==2:\n ans=ans-l[b-1]\n l[b-1]=0\n else:\n while b>t:\n t=t+1\n j=dq.popleft()\n p[j]=p[j]-1\n if l[j]>p[j]:\n l[j]=l[j]-1\n ans=ans-1\n ansl.append(str(ans)) \n q=q-1\nprint(\"\\n\".join(ansl)) ", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nimport collections\nn,q=list(map(int,input().split()))\nQ=collections.deque()\nA=n*[0]\nB=A[:]\nL=[]\ns=n=0\nfor _ in range(q):\n\ty,x=list(map(int,input().split()))\n\tif 2>y:\n\t\tx-=1\n\t\tQ.append(x)\n\t\tB[x]+=1\n\t\tA[x]+=1\n\t\ts+=1\n\telif 3>y:\n\t\tx-=1\n\t\ts-=A[x]\n\t\tA[x]=0\n\telse:\n\t\twhile x>n:\n\t\t\tn+=1\n\t\t\ty=Q.popleft()\n\t\t\tB[y]-=1\n\t\t\tif(B[y]<A[y]):\n\t\t\t\tA[y]-=1\n\t\t\t\ts-=1\n\tL.append(s)\nprint('\\n'.join(map(str,L)))\n\n\n\n\n# Made By Mostafa_Khaled\n", "#!/usr/bin/env\tpython\n#-*-coding:utf-8 -*-\nimport sys,collections\nn,q=map(int,input().split())\nM=collections.defaultdict(collections.deque)\nQ=collections.deque()\nL=[]\ns=n=m=0\nfor _ in range(q):\n\ty,x=map(int,input().split())\n\tif 2>y:\n\t\ts+=1\n\t\tQ.append(x)\n\t\tM[x].append(n)\n\t\tn+=1\n\telif 3>y:\n\t\ty=M.get(x)\n\t\tif y:\n\t\t\ts-=len(y)\n\t\t\tdel M[x]\n\telse:\n\t\twhile x>m:\n\t\t\tz=Q.popleft()\n\t\t\ty=M.get(z)\n\t\t\tif y and y[0]<x:\n\t\t\t\ts-=1\n\t\t\t\ty.popleft()\n\t\t\t\tif not y:del M[z]\n\t\t\tm+=1\n\tL.append(s)\nsys.stdout.write('\\n'.join(map(str,L)))", "\nimport sys\nimport collections\nn, q = list(map(int, input().split()))\n\n# Key: app number, value: list of indexes in the arr\nM = collections.defaultdict(collections.deque)\n\n# arr = []\nQ = collections.deque()\nn = 0\ns = 0\nm = 0\nL = []\nfor i in range(q):\n c, x = list(map(int, input().split()))\n\n if c == 1:\n # if x not in M:\n # M[x] = collections.deque()\n # M[x] = set()\n\n # M[x].add(n)\n M[x].append(n)\n Q.append(x)\n\n n += 1\n s += 1\n\n # print(\"case 1\")\n\n elif c == 2:\n y = M.get(x)\n if y:\n s -= len(y)\n\n del M[x]\n\n # print(\"case 2\")\n\n else:\n while x > m:\n z = Q.popleft()\n y = M.get(z)\n if y and y[0] < x:\n s -= 1\n y.popleft()\n\n if not y:\n del M[z]\n # M[app].remove(message)\n\n m += 1\n # print(\"case 3\")\n L.append(s)\nsys.stdout.write('\\n'.join(map(str, L)))\n\n# for i in range(q):\n# c, x = map(int, input().split())\n\n# if c == 1:\n# if x not in hash:\n# hash[x] = collections.deque()\n# # hash[x] = set()\n\n# # hash[x].add(messageNumber)\n# hash[x].append(messageNumber)\n# deque.append((x, messageNumber))\n\n# messageNumber += 1\n# unread += 1\n\n# # print(\"case 1\")\n# print(unread)\n\n# elif c == 2:\n# if x in hash:\n# xUnread = len(hash[x])\n# hash[x] = set()\n# unread -= xUnread\n# # print(\"case 2\")\n# print(unread)\n\n# else:\n# t = x\n# read = 0\n# while len(deque) != 0 and deque[0][1] <= t:\n# app, message = deque.popleft()\n\n# if message in hash[app]:\n# read += 1\n# hash[app].remove(message)\n\n# unread -= read\n\n# # print(\"case 3\")\n# print(unread)\n", "import sys\nimport collections\nn, q = list(map(int, input().split()))\n\n# Key: app number, value: list of indexes in the arr\nM = {}\n\n# arr = []\nQ = collections.deque()\nn = 1\ns = 0\nm = 0\nL = []\nfor i in range(q):\n c, x = list(map(int, input().split()))\n\n if c == 1:\n if x not in M:\n M[x] = collections.deque()\n # M[x] = set()\n\n # M[x].add(n)\n M[x].append(n)\n Q.append(x)\n\n n += 1\n s += 1\n\n # print(\"case 1\")\n\n elif c == 2:\n if x in M:\n s -= len(M[x])\n\n M[x] = collections.deque()\n\n # print(\"case 2\")\n\n else:\n while x > m:\n z = Q.popleft()\n\n if z in M and len(M[z]) > 0 and M[z][0] <= x:\n s -= 1\n M[z].popleft()\n # M[app].remove(message)\n\n m += 1\n # print(\"case 3\")\n L.append(s)\nsys.stdout.write('\\n'.join(map(str, L)))\n# for i in range(q):\n# c, x = map(int, input().split())\n\n# if c == 1:\n# if x not in hash:\n# hash[x] = collections.deque()\n# # hash[x] = set()\n\n# # hash[x].add(messageNumber)\n# hash[x].append(messageNumber)\n# deque.append((x, messageNumber))\n\n# messageNumber += 1\n# unread += 1\n\n# # print(\"case 1\")\n# print(unread)\n\n# elif c == 2:\n# if x in hash:\n# xUnread = len(hash[x])\n# hash[x] = set()\n# unread -= xUnread\n# # print(\"case 2\")\n# print(unread)\n\n# else:\n# t = x\n# read = 0\n# while len(deque) != 0 and deque[0][1] <= t:\n# app, message = deque.popleft()\n\n# if message in hash[app]:\n# read += 1\n# hash[app].remove(message)\n\n# unread -= read\n\n# # print(\"case 3\")\n# print(unread)\n", "import collections\nimport sys\n\nn, q = list(map(int, input().split()))\n# Key: app number, value: list of indexes in the arr\nhash = {}\n\n# arr = []\ndeque = collections.deque()\nmessageNumber = 1\nunread = 0\nL = []\n\nfor i in range(q):\n c, x = list(map(int, input().split()))\n\n if c == 1:\n if x not in hash:\n hash[x] = set()\n\n hash[x].add(messageNumber)\n deque.append((x, messageNumber))\n\n messageNumber += 1\n unread += 1\n\n # print(\"case 1\")\n # print(unread)\n\n elif c == 2:\n if x in hash:\n xUnread = len(hash[x])\n hash[x] = set()\n unread -= xUnread\n # print(\"case 2\")\n # print(unread)\n\n else:\n t = x\n read = 0\n while len(deque) != 0 and deque[0][1] <= t:\n app, message = deque.popleft()\n\n if message in hash[app]:\n read += 1\n hash[app].remove(message)\n\n unread -= read\n\n # print(\"case 3\")\n # print(unread)\n L.append(unread)\nsys.stdout.write('\\n'.join(map(str, L)))\n", "import collections\nimport sys\n\nn, q = map(int, input().split())\n# Key: app number, value: list of indexes in the arr\nhash = {}\n\ndeque = collections.deque()\nmessageNumber = 1\nunread = 0\nL = []\n\nfor i in range(q):\n c, x = map(int, input().split())\n\n if c == 1:\n if x not in hash:\n hash[x] = set()\n\n hash[x].add(messageNumber)\n deque.append((x, messageNumber))\n\n messageNumber += 1\n unread += 1\n\n\n elif c == 2:\n if x in hash:\n xUnread = len(hash[x])\n hash[x] = set()\n unread -= xUnread\n\n\n else:\n t = x\n read = 0\n while len(deque) != 0 and deque[0][1] <= t:\n app, message = deque.popleft()\n\n if message in hash[app]:\n read += 1\n hash[app].remove(message)\n\n unread -= read\n\n\n L.append(unread)\nprint('\\n'.join(map(str, L)))", "import sys\nn,m=list(map(int,input().split()))\nk=0\npos=0\nL=[]\nL1=[]\nd={i:[0,-1] for i in range(1,n+1)}\nfor i in range(m) :\n a,b=list(map(int,input().split()))\n if a==1 :\n d[b][0]+=1\n \n k+=1\n L.append(b)\n elif a==2 :\n k-=d[b][0]\n d[b][0]=0\n d[b][1]=len(L)\n else :\n for j in range(pos,b) :\n \n if d[L[j]][0]>0 and d[L[j]][1]<j+1 :\n \n k-=1\n d[L[j]][0]-=1\n \n pos=max(pos,b)\n L1.append(k)\nsys.stdout.write('\\n'.join(map(str,L1)))\n \n \n \n \n \n \n \n \n", "import sys\nn,m=list(map(int,input().split()))\nk=0\npos=0\nL=[]\nL1=[]\nd={i:[0,-1] for i in range(1,n+1)}\nfor i in range(m) :\n a,b=list(map(int,sys.stdin.readline()[:-1].split()))\n if a==1 :\n d[b][0]+=1\n \n k+=1\n L.append(b)\n elif a==2 :\n k-=d[b][0]\n d[b][0]=0\n d[b][1]=len(L)\n else :\n for j in range(pos,b) :\n \n if d[L[j]][0]>0 and d[L[j]][1]<j+1 :\n \n k-=1\n d[L[j]][0]-=1\n \n pos=max(pos,b)\n L1.append(k)\nsys.stdout.write('\\n'.join(map(str,L1)))\n \n \n \n \n \n \n \n \n", "'''input\n4 6\n1 2\n1 4\n1 2\n3 3\n1 3\n1 3\n\n\n'''\n\nn, q = list(map(int, input().split()))\n\ncount = [0 for i in range(n + 1)]\nqueue = []\nread = set()\nunread = 0\nans = []\nlast_q_idx = 0\nlast_app_idx = [1 for i in range(n + 1)]\n\nfor i in range(q):\n action, num = list(map(int, input().split()))\n if action == 1:\n queue.append((num, count[num] + 1))\n count[num] += 1\n unread += 1\n elif action == 2:\n for number in range(last_app_idx[num], count[num] + 1):\n if (num, number) not in read:\n read.add((num, number))\n unread -= 1\n last_app_idx[num] = max(last_app_idx[num], count[num])\n else:\n for idx in range(last_q_idx, num):\n app, number = queue[idx]\n if (app, number) not in read:\n read.add((app, number))\n last_app_idx[app] = max(last_app_idx[app], number)\n unread -= 1\n last_q_idx = max(last_q_idx, num)\n # print(action, num, last_q_idx, last_app_idx, queue)\n ans.append(unread)\n \nprint(\"\\n\".join(map(str, ans)))\n\n\n", "import sys,collections\nn,q=map(int,input().split())\nM=collections.defaultdict(collections.deque)\nQ=collections.deque()\nL=[]\ns=n=m=0\nfor _ in range(q):\n\ty,x=map(int,input().split())\n\tif 2>y:\n\t\ts+=1\n\t\tQ.append(x)\n\t\tM[x].append(n)\n\t\tn+=1\n\telif 3>y:\n\t\ty=M.get(x)\n\t\tif y:\n\t\t\ts-=len(y)\n\t\t\tdel M[x]\n\telse:\n\t\twhile x>m:\n\t\t\tz=Q.popleft()\n\t\t\ty=M.get(z)\n\t\t\tif y and y[0]<x:\n\t\t\t\ts-=1\n\t\t\t\ty.popleft()\n\t\t\t\tif not y:del M[z]\n\t\t\tm+=1\n\tL.append(s)\nsys.stdout.write('\\n'.join(map(str,L)))", "import sys, collections\ndef inp():\n return map(int, input().split())\nn, q = inp()\nQ = collections.deque()\nA = n * [0]\nB = A[:]\nL = []\ns = n = 0\nfor _ in range(q):\n typeq, x = inp()\n if typeq == 1:\n x -= 1\n Q.append(x)\n B[x] += 1\n A[x] += 1\n s += 1\n elif typeq == 2:\n x -= 1\n s -= A[x]\n A[x] = 0\n else:\n while x > n:\n n += 1\n y = Q.popleft()\n B[y] -= 1\n if (B[y] < A[y]):\n A[y] -= 1\n s -= 1\n L.append(s)\nsys.stdout.write('\\n'.join(map(str,L)))", "from sys import stdin\ninput = stdin.readline\n\nn, q, = list(map(int, input().split()))\narr = [tuple(map(int, input().split())) for _ in range(q)]\nadj = [[] for _ in range(n+1)]\ncurr, cnt, res, vis = 0, 0, [], []\n \nfor t, v in arr:\n if t == 1:\n adj[v].append(len(vis))\n vis.append(0)\n cnt += 1\n elif t == 2:\n for u in adj[v]:\n if not vis[u]:\n vis[u] = 1\n cnt -= 1\n adj[v] = []\n else:\n while v > curr:\n if not vis[curr]:\n vis[curr] = 1\n cnt -= 1\n curr += 1\n res.append(cnt)\nprint('\\n'.join(map(str, res)))\n", "import sys\ninput = sys.stdin.readline\n\nn, q = map(int, input().split())\nl = [[] for _ in range(n)]\nis_read = []\nis_read_idx = 0\nans = 0\nprev_t = 0\n\nfor _ in range(q):\n ty, v = map(int, input().split())\n \n if ty==1:\n l[v-1].append(is_read_idx)\n is_read_idx += 1\n is_read.append(False)\n ans += 1\n elif ty==2:\n for idx in l[v-1]:\n if not is_read[idx]:\n is_read[idx] = True\n ans -= 1\n \n l[v-1] = []\n else:\n if v>prev_t:\n for idx in range(prev_t, v):\n if not is_read[idx]:\n is_read[idx] = True\n ans -= 1\n \n prev_t = v\n \n print(ans)"] | {
"inputs": [
"3 4\n1 3\n1 1\n1 2\n2 3\n",
"4 6\n1 2\n1 4\n1 2\n3 3\n1 3\n1 3\n",
"10 85\n2 2\n1 10\n1 1\n2 6\n1 2\n1 4\n1 7\n2 1\n1 1\n3 3\n1 9\n1 6\n1 8\n1 10\n3 8\n2 8\n1 6\n1 3\n1 9\n1 6\n1 3\n1 8\n1 1\n1 6\n1 10\n2 1\n2 10\n1 10\n1 1\n1 10\n1 6\n1 2\n1 8\n1 3\n1 4\n1 9\n1 5\n1 5\n2 2\n2 4\n1 7\n1 1\n2 4\n1 9\n1 1\n1 7\n1 8\n3 33\n1 10\n2 2\n1 3\n1 10\n1 6\n3 32\n2 3\n1 5\n2 10\n2 2\n2 4\n2 3\n3 16\n1 3\n2 2\n1 1\n3 18\n2 2\n2 5\n1 5\n1 9\n2 4\n1 3\n1 4\n1 3\n1 6\n1 10\n2 2\n1 7\n1 7\n2 8\n1 1\n3 1\n1 8\n1 10\n1 7\n1 8\n",
"300000 1\n1 300000\n"
],
"outputs": [
"1\n2\n3\n2\n",
"1\n2\n3\n0\n1\n2\n",
"0\n1\n2\n2\n3\n4\n5\n4\n5\n3\n4\n5\n6\n7\n2\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n9\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n17\n16\n17\n18\n18\n19\n20\n21\n22\n3\n4\n4\n5\n6\n7\n7\n6\n7\n5\n5\n5\n5\n5\n6\n6\n7\n7\n7\n6\n7\n8\n8\n9\n10\n11\n12\n13\n13\n14\n15\n14\n15\n15\n16\n17\n18\n19\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 18,471 | |
63d8126c8be2324b833ab9a03f3fa42c | UNKNOWN | Sasha likes programming. Once, during a very long contest, Sasha decided that he was a bit tired and needed to relax. So he did. But since Sasha isn't an ordinary guy, he prefers to relax unusually. During leisure time Sasha likes to upsolve unsolved problems because upsolving is very useful.
Therefore, Sasha decided to upsolve the following problem:
You have an array $a$ with $n$ integers. You need to count the number of funny pairs $(l, r)$ $(l \leq r)$. To check if a pair $(l, r)$ is a funny pair, take $mid = \frac{l + r - 1}{2}$, then if $r - l + 1$ is an even number and $a_l \oplus a_{l+1} \oplus \ldots \oplus a_{mid} = a_{mid + 1} \oplus a_{mid + 2} \oplus \ldots \oplus a_r$, then the pair is funny. In other words, $\oplus$ of elements of the left half of the subarray from $l$ to $r$ should be equal to $\oplus$ of elements of the right half. Note that $\oplus$ denotes the bitwise XOR operation.
It is time to continue solving the contest, so Sasha asked you to solve this task.
-----Input-----
The first line contains one integer $n$ ($2 \le n \le 3 \cdot 10^5$) — the size of the array.
The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i < 2^{20}$) — array itself.
-----Output-----
Print one integer — the number of funny pairs. You should consider only pairs where $r - l + 1$ is even number.
-----Examples-----
Input
5
1 2 3 4 5
Output
1
Input
6
3 2 2 3 7 6
Output
3
Input
3
42 4 2
Output
0
-----Note-----
Be as cool as Sasha, upsolve problems!
In the first example, the only funny pair is $(2, 5)$, as $2 \oplus 3 = 4 \oplus 5 = 1$.
In the second example, funny pairs are $(2, 3)$, $(1, 4)$, and $(3, 6)$.
In the third example, there are no funny pairs. | ["ii = lambda: int(input())\nmi = lambda: map(int, input().split())\nli = lambda: list(mi())\nfrom collections import Counter as C\nn = ii()\na = li()\noe = [C(), C()]\noe[1][0] = 1\nx = 0\nans = 0\nfor i in range(n):\n x ^= a[i]\n ans += oe[i % 2][x]\n oe[i % 2][x] += 1\nprint(ans)", "maxn = int(3e5) + 3\nmaxa = (1 << 20) + 3\nnb_element = int(input())\narr = [int(x) for x in input().split()]\ncnt = [[0 for _ in range(maxa)] for _ in range(2)]\ncnt[1][0] = 1\nxors = 0\nres = 0\nfor i in range(nb_element):\n xors ^= arr[i]\n x = i % 2\n res += cnt[x][xors]\n cnt[x][xors] += 1\nprint(res)", "n = int(input())\nl = list(map(int, input().strip().split()))\neven = [0 for i in range(2**21)]\nodd = [0 for i in range(2**21)]\ncur = 0\neven[0] = 1\nfor i in range(n):\n cur = cur^l[i]\n if i%2:\n even[cur] += 1\n else:\n odd[cur] += 1\nans = 0\nfor i in range(2**21):\n if even[i] >= 2: ans += (even[i]*(even[i]-1))/2\n if odd[i] >= 2: ans += (odd[i]*(odd[i]-1))/2\nprint(int(ans))\n", "'''\nn=int(input())\na=list(map(int,input().split()))#a^b^b=a\uff0cb^b=0\ndef lastcount(r):\n nonlocal a\n right=a[r]\n left=a[r-1]\n i=r\n j=r-1\n k=0\n while j>=0:\n k+=left==right\n j-=2\n i-=1\n left=left^a[i]^a[j]^a[j+1]\n right=right^a[i]\n return k\ndp=0\nfor i in range(n-1,0,-1):\n dp+=lastcount(i)\nprint(dp)\n'''\nn=int(input())\na=list(map(int,input().split()))\no={}\ne={}\nt=a[0]\ne[t]=1\no[0]=1\nans,i=0,1\nodd=True\nwhile i<n:\n t^=a[i]\n if odd:\n ans+=o.get(t,0)\n o[t]=o.get(t,0)+1\n else:\n ans+=e.get(t,0)\n e[t]=e.get(t,0)+1\n i+=1\n odd=1-odd\nprint(ans)\n \n\n", "n = int(input())\na = [int(x) for x in input().split()]\npred = [0]\nfor i in range(n):\n pred.append(a[i] ^ pred[-1])\nd = {}\nd1 = {}\na = pred[::2]\nb = pred[1::2]\nans = 0\nfor i in a:\n d[i] = d.get(i, 0) + 1\nfor i in b:\n d1[i] = d1.get(i, 0) + 1\nfor i in d:\n ans += d[i] * (d[i] - 1) // 2\nfor i in d1:\n ans += d1[i] * (d1[i] - 1) // 2\nprint(ans)", "n = int(input())\na = list(map(int, input().split()))\nprev = [0]\n\nfor i in range(n):\n\tprev.append(a[i] ^ prev[-1])\n\nvar = {}\nvar1 = {}\na = prev[::2]\nb = prev[1::2]\nans = 0\n\nfor c in a:\n\tvar[c] = var.get(c, 0) + 1\n\nfor x in b:\n\tvar1[x] = var1.get(x, 0) + 1\n\nfor c in var:\n\tans += var[c] * (var[c] - 1) // 2\n\nfor c in var1:\n\tans += var1[c] * (var1[c] - 1) // 2\n\nprint(ans)\n", "n=int(input())\nnlist=[int(x) for x in input().split()]\nxor=[[0]*2**21 for xor in range(2)]\nx=counter=0\nxor[1][0]=1\nfor i in range(n):\n x^=nlist[i]\n counter+=xor[i%2][x]\n xor[i%2][x]+=1\nprint(counter)\n", "import math\nimport sys\nfrom bisect import bisect_right, bisect_left, insort_right\nfrom collections import Counter, defaultdict\nfrom heapq import heappop, heappush\nfrom itertools import accumulate, permutations, combinations\nfrom sys import stdout\n\nR = lambda: map(int, input().split())\nn = int(input())\ndp = defaultdict(lambda: [0, 0])\ndp[0] = [1, 0]\nxor = res = 0\nfor i, x in enumerate(R()):\n xor ^= x\n res += dp[xor][(i + 1) & 1]\n dp[xor][(i + 1) & 1] += 1\nprint(res)", "from collections import Counter\n\nn = int(input())\na = [*map(int, input().split())]\n\npre = [[0] * (2 ** 20), [1] + [0] * (2 ** 20 - 1)]\nt = ans = 0\n\nfor i in range(n):\n t ^= a[i]\n ans += pre[i & 1][t]\n pre[i & 1][t] += 1\n\nprint(ans)", "def count(arr):\n even = 0\n odd = 0\n for i in arr:\n if i % 2 == 1:\n even += 1\n else:\n odd += 1\n return (even-1) * even //2 + (odd - 1) * odd //2\n\ndef solve(a):\n sums = []\n x = 0\n for i in a:\n x = x ^ i\n sums.append(x)\n # print(sums)\n d = {}\n d[0] = [-1]\n for i in range(len(sums)):\n if sums[i] in d:\n d[sums[i]].append(i)\n else:\n d[sums[i]] = [i]\n # print(d)\n res = 0\n for sums in d:\n res += count(d[sums])\n return res\n\nn = int(input())\nx = input().split()\na = []\nfor i in x:\n a.append(int(i))\nprint(solve(a))\n", "n=int(input())\ng=[int(g) for g in input().split()]\nxor=0\narr=[[0]*(2**20),[1]+[0]*(2**20-1)]\ncount=0\nfor i in range(len(g)):\n xor^=g[i]\n count+=arr[i%2][xor]\n arr[i%2][xor]+=1\nprint(count)\n", "n = int(input())\na = list(map(int, input().split()))\n\ndp = [[0 for _ in range(1 << 20)] for _ in range(2)]\ndp[1][0] = 1\nxor = 0\nret = 0\nfor i in range(n):\n xor ^= a[i]\n ret += dp[i & 1][xor]\n dp[i & 1][xor] += 1\nprint(ret)\n", "from collections import Counter\n\ndef check_funny(n, nums):\n cnt = {0: Counter(), 1: Counter()}\n cnt[1][0] = 1\n x = 0\n res = 0\n for i in range(n):\n x ^= nums[i]\n res += cnt[i % 2][x]\n cnt[i % 2][x] += 1\n return res\n\n\nn = int(input())\nnums = list(map(int, input().split()))\nprint(check_funny(n, nums))\n", "from collections import Counter\nn = int(input())\nx = [0]\nfor v in map(int, input().split()):\n x.append(x[-1] ^ v)\nc0 = Counter(x[::2])\nc1 = Counter(x[1::2])\nr = 0\nfor v in c0.values():\n r += v*(v-1)//2\nfor v in c1.values():\n r += v*(v-1)//2\nprint(r) ", "n, d, curr = int(input()), {(0, 1) : 1}, 0\nfor i, e in enumerate(map(int, input().split())):\n curr ^= e\n p = (curr, i & 1)\n d[p] = d.get(p, 0) + 1\nres = sum((n * (n - 1)) // 2 for n in list(d.values()))\nprint(res)\n", "from itertools import accumulate\nfrom collections import Counter\nfrom operator import xor\nprint(sum((n * (n - 1)) // 2 for n in list((Counter((i & 1, e) for i, e in enumerate(accumulate([list(map(int, input().split())) for _ in range(2)][1], xor))) + Counter([(1, 0)])).values())))\n", "n = int(input())\na = [int(x) for x in input().split()]\ncnt = [[0, 0] for x in range((1 << 20) + 3)]\ncnt[0][1] = 1\nx = 0\nres = 0\nfor j in range(n):\n x ^= a[j]\n res += cnt[x][j % 2]\n cnt[x][j % 2] += 1\nprint(res)\n", "from collections import defaultdict\nN = int(input())\na = list(map(int, input().split()))\ns = [0]\nfor i in range(N):\n s.append(s[-1] ^ a[i])\n\nD1 = defaultdict(int)\nD2 = defaultdict(int)\nans = 0\nfor i in range(N + 1):\n if i % 2 == 0:\n ans += D1[s[i]]\n D1[s[i]] += 1\n else:\n ans += D2[s[i]]\n D2[s[i]] += 1\n\n\nprint(ans)", "n = int(input())\na = list(map(int,input().split()))\npreXor = [0]*n\npreXor[0] = a[0]\nfor i in range(1,n):\n preXor[i] = a[i]^preXor[i-1]\neven = {}\nodd = {}\ncount = 0\nfor i in range(n):\n m = preXor[i]\n if (m==0):\n if (i%2==1):\n count += 1\n if (i%2==0):\n if m in even:\n count += even[m]\n even[m] += 1\n else:\n even[m] = 1\n else:\n if m in odd:\n count += odd[m]\n odd[m] += 1\n else:\n odd[m] = 1\nprint(count)\n", "n = int(input())\na = list(map(int, input().split()))\na = [0] + a\n\nx = [0] * (n+1)\nc = {0:1}\nsol = 0\nfor i in range(1, n+1):\n x[i] = x[i-1] ^ a[i]\n if x[i]*2 + i%2 in c:\n sol += c[x[i]*2 + i%2]\n try:\n c[x[i]*2 + i%2] += 1\n except KeyError:\n c[x[i]*2 + i%2] = 1\n\nprint(sol)\n", "from math import *\nfrom collections import *\nimport sys\nsys.setrecursionlimit(10**9)\n \nn = int(input())\na = list(map(int,input().split()))\npre = [0]\nfor i in range(n):\n\tpre.append(pre[-1]^a[i])\nde = dict()\ndo = dict()\nfor i in range(n+1):\n\tif(i % 2 == 0):\n\t\tif pre[i] not in de:\n\t\t\tde[pre[i]] = 1\n\t\telse:\n\t\t\tde[pre[i]] += 1\n\telse:\n\t\tif pre[i] not in do:\n\t\t\tdo[pre[i]] = 1\n\t\telse:\n\t\t\tdo[pre[i]] += 1\nans = 0\nfor x in list(de.values()): \n\tans += x*(x-1)//2\nfor x in list(do.values()): \n\tans += x*(x-1)//2\nprint(ans)\n", "n = int(input())\na = list(map(int,input().split()))\nxor = 0\narr=[[0]*(2**20),[1]+[0]*(2**20-1)]\ncount = 0\nfor i in range(n):\n xor = xor^a[i]\n count += arr[i%2][xor]\n arr[i%2][xor]+=1\nprint(count)", "n=int(input())\npref=[0]\napp=pref.append\nfor i,x in enumerate(map(int,input().split())):\n app(pref[-1]^x)\nd,di={},{}\nfor i,x in enumerate(pref):\n if i%2==0:\n if d.get(x)==None:d[x]=0\n d[x]+=1\n else:\n if di.get(x)==None:di[x]=0\n di[x]+=1\nres=0\nfor i,x in enumerate(d):res+=(d[x]*(d[x]-1)//2)\nfor i,x in enumerate(di):res+=(di[x]*(di[x]-1)//2)\nprint(res)", "n=int(input())\npref=[0]\napp=pref.append\nfor i,x in enumerate(map(int,input().split())):\n app(pref[-1]^x)\nfrom collections import Counter\nd=Counter(pref[::2])\ndi=Counter(pref[1::2])\nres=0\nfor i,x in enumerate(d):res+=(d[x]*(d[x]-1)//2)\nfor i,x in enumerate(di):res+=(di[x]*(di[x]-1)//2)\nprint(res)", "n=int(input())\npref=[0]\napp=pref.append\nfor i,x in enumerate(map(int,input().split())):app(pref[-1]^x)\nfrom collections import Counter\nd=Counter(pref[::2])\ndi=Counter(pref[1::2])\nres=0\nfor i,x in enumerate(d.values()):res+=(x*(x-1)//2)\nfor i,x in enumerate(di.values()):res+=(x*(x-1)//2)\nprint(res)"] | {
"inputs": [
"5\n1 2 3 4 5\n",
"6\n3 2 2 3 7 6\n",
"3\n42 4 2\n",
"2\n60202 951227\n"
],
"outputs": [
"1\n",
"3\n",
"0\n",
"0\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 9,125 | |
9f42c4385bb7c3742598d09089b18eb8 | UNKNOWN | This morning Tolik has understood that while he was sleeping he had invented an incredible problem which will be a perfect fit for Codeforces! But, as a "Discuss tasks" project hasn't been born yet (in English, well), he decides to test a problem and asks his uncle.
After a long time thinking, Tolik's uncle hasn't any ideas on how to solve it. But, he doesn't want to tell Tolik about his inability to solve it, so he hasn't found anything better than asking you how to solve this task.
In this task you are given a cell field $n \cdot m$, consisting of $n$ rows and $m$ columns, where point's coordinates $(x, y)$ mean it is situated in the $x$-th row and $y$-th column, considering numeration from one ($1 \leq x \leq n, 1 \leq y \leq m$). Initially, you stand in the cell $(1, 1)$. Every move you can jump from cell $(x, y)$, which you stand in, by any non-zero vector $(dx, dy)$, thus you will stand in the $(x+dx, y+dy)$ cell. Obviously, you can't leave the field, but also there is one more important condition — you're not allowed to use one vector twice. Your task is to visit each cell of the field exactly once (the initial cell is considered as already visited).
Tolik's uncle is a very respectful person. Help him to solve this task!
-----Input-----
The first and only line contains two positive integers $n, m$ ($1 \leq n \cdot m \leq 10^{6}$) — the number of rows and columns of the field respectively.
-----Output-----
Print "-1" (without quotes) if it is impossible to visit every cell exactly once.
Else print $n \cdot m$ pairs of integers, $i$-th from them should contain two integers $x_i, y_i$ ($1 \leq x_i \leq n, 1 \leq y_i \leq m$) — cells of the field in order of visiting, so that all of them are distinct and vectors of jumps between them are distinct too.
Notice that the first cell should have $(1, 1)$ coordinates, according to the statement.
-----Examples-----
Input
2 3
Output
1 1
1 3
1 2
2 2
2 3
2 1
Input
1 1
Output
1 1
-----Note-----
The vectors from the first example in the order of making jumps are $(0, 2), (0, -1), (1, 0), (0, 1), (0, -2)$. | ["import sys\ninput = sys.stdin.readline\n\nn,m=list(map(int,input().split()))\nANS=[]\n\nfor i in range(1,n//2+1):\n for j in range(1,m+1):\n sys.stdout.write(\"\".join((str(i),\" \",str(j),\"\\n\")))\n sys.stdout.write(\"\".join((str(n-i+1),\" \",str(m-j+1),\"\\n\")))\n\n\n\nif n%2==1:\n for j in range(1,m//2+1):\n sys.stdout.write(\"\".join((str(n//2+1),\" \",str(j),\"\\n\")))\n sys.stdout.write(\"\".join((str(n//2+1),\" \",str(m-j+1),\"\\n\")))\n\n if m%2==1:\n sys.stdout.write(\"\".join((str(n//2+1),\" \",str(m//2+1),\"\\n\")))\n\n", "import sys\ninput = sys.stdin.readline\n\nn,m=list(map(int,input().split()))\nANS=[]\n\nfor i in range(1,n//2+1):\n for j in range(1,m+1):\n sys.stdout.write((str(i)+\" \"+str(j)+\"\\n\"))\n sys.stdout.write((str(n-i+1)+\" \"+str(m-j+1)+\"\\n\"))\n\n\nif n%2==1:\n for j in range(1,m//2+1):\n sys.stdout.write((str(n//2+1)+\" \"+str(j)+\"\\n\"))\n sys.stdout.write((str(n//2+1)+\" \"+str(m-j+1)+\"\\n\"))\n\n if m%2==1:\n sys.stdout.write((str(n//2+1)+\" \"+str(m//2+1)+\"\\n\"))\n\n", "def main():\n n, m = list(map(int, input().split()))\n\n r = []\n rappend = r.append\n for i in range(1, (n >> 1) + 1):\n for j in range(1, m + 1):\n rappend(str(i) + ' ' + str(j))\n rappend(str(n + 1 - i) + ' ' + str(m + 1 - j))\n\n if n & 1:\n for i in range(1, (m >> 1) + 1):\n rappend(str((n + 1) >> 1) + ' ' + str(i))\n rappend(str((n + 1) >> 1) + ' ' + str(m + 1 - i))\n if m & 1:\n rappend(str((n + 1) >> 1) + ' ' + str((m + 1) >> 1))\n\n print('\\n'.join(r))\n\n\nmain()\n", "def main():\n n, m = list(map(int, input().split()))\n\n r = []\n rappend = r.append\n for i in range(1, (n >> 1) + 1):\n for j in range(1, m + 1):\n rappend(str(i) + ' ' + str(j))\n rappend(str(n + 1 - i) + ' ' + str(m + 1 - j))\n\n if n & 1:\n for i in range(1, (m >> 1) + 1):\n rappend(str((n + 1) >> 1) + ' ' + str(i))\n rappend(str((n + 1) >> 1) + ' ' + str(m + 1 - i))\n if m & 1:\n rappend(str((n + 1) >> 1) + ' ' + str((m + 1) >> 1))\n\n print('\\n'.join(r))\n\n\nmain()\n", "import sys\nN, M = list(map(int, input().split()))\n\nAns = [(0, 0) for _ in range(N*M)]\nfor i in range(1, N*M+1):\n if i % 2:\n a, b = divmod(i//2, M)\n else:\n a, b = divmod(N*M - i//2, M)\n Ans[i-1] = ' '.join((str(a+1), str(b+1)))\n\nfor a in Ans:\n sys.stdout.write(f'{a}\\n') \n", "import sys\nN, M = map(int, input().split())\n\nAns = [(0, 0) for _ in range(N*M)]\nfor i in range(1, N*M+1):\n if i % 2:\n a, b = divmod(i//2, M)\n else:\n a, b = divmod(N*M - i//2, M)\n Ans[i-1] = (a+1, b+1)\nfor a in Ans:\n sys.stdout.write('{} {}\\n'.format(*a))", "import sys\nN, M = map(int, input().split())\n\nAns = [None]*(N*M)\nfor i in range(1, N*M+1):\n if i % 2:\n a, b = divmod(i//2, M)\n else:\n a, b = divmod(N*M - i//2, M)\n Ans[i-1] = (a+1, b+1)\nfor a in Ans:\n sys.stdout.write('{} {}\\n'.format(*a))", "import math\n\ninp = input().split(' ')\nm = int(inp[0])\nn = int(inp[1])\n\nresult = []\n\nfor column in range(1, math.ceil(m/2) + 1):\n\n rowRange = list(range(1, n + 1))\n if column == math.ceil(m / 2) and m % 2 == 1:\n rowRange = list(range(1, math.ceil(n/2) + 1))\n\n for row in rowRange:\n result.append(str(column) + ' ' + str(row))\n if row == math.ceil(n/2) and n % 2 == 1 and column == math.ceil(m / 2) and m % 2 == 1:\n continue\n result.append(str(m + 1 - column) + ' ' + str(n + 1 - row))\n\nprint('\\n'.join(result))\n", "\nn, m = map(int, input().split())\nbuf = []\nfor i in range(n//2):\n for j in range(m):\n buf.append(f'{i + 1} {j + 1}\\n')\n buf.append(f'{n - i} {m - j}\\n')\n\nif n % 2 == 1:\n for j in range(m // 2):\n buf.append(f'{n // 2 + 1} {j + 1}\\n')\n buf.append(f'{n // 2 + 1} {m - j}\\n')\n if m % 2 == 1:\n buf.append(f'{n//2 + 1} {m//2 + 1}\\n')\nprint(*buf, sep='')", "n, m = list(map(int, input().split()))\n\nnp1 = n + 1\nmp1 = m + 1\n\nfor i in range(1, 1 + n // 2):\n for j in range(1, mp1):\n # print(i, j)\n # print(np1 - i, mp1 - j)\n print('%d %d\\n%d %d' % (i,j,np1-i,mp1-j))\n\nif n & 1:\n i = 1 + n // 2\n for j in range(1, 1 + m // 2):\n # print(i, j)\n # print(i, mp1 - j)\n print('%d %d\\n%d %d' % (i,j,i,mp1-j))\n\n if m & 1:\n print(i, 1 + m // 2)\n", "import sys\nimport math\nfrom collections import defaultdict\nn,m=list(map(int,sys.stdin.readline().split()))\n#cur=[1,1]\n#ans=[-1 for _ in range(2*n*m)]\nup,down=1,n\ncount=0\nwhile up<=down:\n left,right=1,m\n #ans.append(cur)\n while left<=m and count<n*m:\n #ans.append([up,left])\n #ans[count]=[up,left]\n if count<n*m:\n sys.stdout.write((str(up)+\" \"+str(left)+\"\\n\"))\n count+=1\n left+=1\n #ans[count]=[down,right]\n if count<n*m:\n sys.stdout.write((str(down)+\" \"+str(right)+\"\\n\"))\n count+=1\n #ans.append([down,right])\n right-=1\n up+=1\n down-=1\n'''if n==1:\n a=len(ans)\n #print(a,'a')\n for i in range(a//2):\n print(ans[i][0],ans[i][1])\nelse:\n a=len(ans)\n for i in range(a//2):\n print(ans[i][0],ans[i][1])\n #print(ans)'''\n \n", "import sys\ninput=sys.stdin.readline\nn,m=map(int,input().split())\nfor i in range(n//2+n%2):\n x1=i+1\n x2=n-i\n if(x1==x2):\n for j in range(m//2+m%2):\n if(j+1==m-j):\n sys.stdout.write((str(x1)+\" \"+str(j+1)+\"\\n\"))\n else:\n sys.stdout.write((str(x1)+\" \"+str(j+1)+\"\\n\"))\n sys.stdout.write((str(x2)+\" \"+str(m-j)+\"\\n\"))\n else:\n if(i%2==0):\n for j in range(m):\n sys.stdout.write((str(x1)+\" \"+str(j+1)+\"\\n\"))\n sys.stdout.write((str(x2)+\" \"+str(m-j)+\"\\n\"))\n else:\n for j in range(m):\n sys.stdout.write((str(x1)+\" \"+str(m-j)+\"\\n\"))\n sys.stdout.write((str(x2)+\" \"+str(j+1)+\"\\n\"))"] | {"inputs": ["2 3\n", "1 1\n", "8 8\n", "6 8\n"], "outputs": ["1 1\n1 3\n1 2\n2 2\n2 3\n2 1", "1 1\n", "1 1\n8 8\n1 2\n8 7\n1 3\n8 6\n1 4\n8 5\n1 5\n8 4\n1 6\n8 3\n1 7\n8 2\n1 8\n8 1\n2 1\n7 8\n2 2\n7 7\n2 3\n7 6\n2 4\n7 5\n2 5\n7 4\n2 6\n7 3\n2 7\n7 2\n2 8\n7 1\n3 1\n6 8\n3 2\n6 7\n3 3\n6 6\n3 4\n6 5\n3 5\n6 4\n3 6\n6 3\n3 7\n6 2\n3 8\n6 1\n4 1\n5 8\n4 2\n5 7\n4 3\n5 6\n4 4\n5 5\n4 5\n5 4\n4 6\n5 3\n4 7\n5 2\n4 8\n5 1\n", "1 1\n6 8\n1 2\n6 7\n1 3\n6 6\n1 4\n6 5\n1 5\n6 4\n1 6\n6 3\n1 7\n6 2\n1 8\n6 1\n2 1\n5 8\n2 2\n5 7\n2 3\n5 6\n2 4\n5 5\n2 5\n5 4\n2 6\n5 3\n2 7\n5 2\n2 8\n5 1\n3 1\n4 8\n3 2\n4 7\n3 3\n4 6\n3 4\n4 5\n3 5\n4 4\n3 6\n4 3\n3 7\n4 2\n3 8\n4 1\n"]} | COMPETITION | PYTHON3 | CODEFORCES | 6,309 | |
76fe34d465a0f07c822a0c4e61a4f1f8 | UNKNOWN | Note that the only difference between String Transformation 1 and String Transformation 2 is in the move Koa does. In this version the letter $y$ Koa selects must be strictly greater alphabetically than $x$ (read statement for better understanding). You can make hacks in these problems independently.
Koa the Koala has two strings $A$ and $B$ of the same length $n$ ($|A|=|B|=n$) consisting of the first $20$ lowercase English alphabet letters (ie. from a to t).
In one move Koa:
selects some subset of positions $p_1, p_2, \ldots, p_k$ ($k \ge 1; 1 \le p_i \le n; p_i \neq p_j$ if $i \neq j$) of $A$ such that $A_{p_1} = A_{p_2} = \ldots = A_{p_k} = x$ (ie. all letters on this positions are equal to some letter $x$).
selects a letter $y$ (from the first $20$ lowercase letters in English alphabet) such that $y>x$ (ie. letter $y$ is strictly greater alphabetically than $x$).
sets each letter in positions $p_1, p_2, \ldots, p_k$ to letter $y$. More formally: for each $i$ ($1 \le i \le k$) Koa sets $A_{p_i} = y$.
Note that you can only modify letters in string $A$.
Koa wants to know the smallest number of moves she has to do to make strings equal to each other ($A = B$) or to determine that there is no way to make them equal. Help her!
-----Input-----
Each test contains multiple test cases. The first line contains $t$ ($1 \le t \le 10$) — the number of test cases. Description of the test cases follows.
The first line of each test case contains one integer $n$ ($1 \le n \le 10^5$) — the length of strings $A$ and $B$.
The second line of each test case contains string $A$ ($|A|=n$).
The third line of each test case contains string $B$ ($|B|=n$).
Both strings consists of the first $20$ lowercase English alphabet letters (ie. from a to t).
It is guaranteed that the sum of $n$ over all test cases does not exceed $10^5$.
-----Output-----
For each test case:
Print on a single line the smallest number of moves she has to do to make strings equal to each other ($A = B$) or $-1$ if there is no way to make them equal.
-----Example-----
Input
5
3
aab
bcc
4
cabc
abcb
3
abc
tsr
4
aabd
cccd
5
abcbd
bcdda
Output
2
-1
3
2
-1
-----Note----- In the $1$-st test case Koa: selects positions $1$ and $2$ and sets $A_1 = A_2 = $ b ($\color{red}{aa}b \rightarrow \color{blue}{bb}b$). selects positions $2$ and $3$ and sets $A_2 = A_3 = $ c ($b\color{red}{bb} \rightarrow b\color{blue}{cc}$).
In the $2$-nd test case Koa has no way to make string $A$ equal $B$.
In the $3$-rd test case Koa: selects position $1$ and sets $A_1 = $ t ($\color{red}{a}bc \rightarrow \color{blue}{t}bc$). selects position $2$ and sets $A_2 = $ s ($t\color{red}{b}c \rightarrow t\color{blue}{s}c$). selects position $3$ and sets $A_3 = $ r ($ts\color{red}{c} \rightarrow ts\color{blue}{r}$). | ["import sys\ninput = lambda: sys.stdin.readline().rstrip()\nT = int(input())\nfor _ in range(T):\n N = int(input())\n A = [ord(a) - 97 for a in input()]\n B = [ord(a) - 97 for a in input()]\n X = [[0] * 20 for _ in range(20)]\n for a, b in zip(A, B):\n X[a][b] = 1\n if a > b:\n print(-1)\n break\n else:\n ans = 0\n for i in range(20):\n for j in range(i+1, 20):\n if X[i][j]:\n ans += 1\n for jj in range(j+1, 20):\n if X[i][jj]:\n X[j][jj] = 1\n break\n print(ans)\n", "import sys\ninput = sys.stdin.readline\n\nt=int(input())\nfor tests in range(t):\n n=int(input())\n A=input().strip()\n B=input().strip()\n\n for i in range(n):\n if A[i]>B[i]:\n print(-1)\n break\n else:\n DICT=dict()\n\n for i in range(n):\n a=A[i]\n b=B[i]\n\n if a==b:\n continue\n\n if a in DICT:\n DICT[a].add(b)\n else:\n DICT[a]={b}\n\n #print(DICT)\n\n ANS=0\n\n for x in \"abcdefghijklmnopqrst\":\n if x in DICT and DICT[x]!=set():\n ANS+=1\n MIN=min(DICT[x])\n if MIN in DICT:\n DICT[MIN]=DICT[MIN]|DICT[x]-{MIN}\n else:\n DICT[MIN]=DICT[x]-{MIN}\n print(ANS)\n \n\n \n", "import sys\ninput = sys.stdin.readline\n\n\nclass UnionFind:\n def __init__(self, n):\n self.parent = [-1] * n\n self.cnt = n\n\n def root(self, x):\n if self.parent[x] < 0:\n return x\n else:\n self.parent[x] = self.root(self.parent[x])\n return self.parent[x]\n\n def merge(self, x, y):\n x = self.root(x)\n y = self.root(y)\n if x == y:\n return\n if self.parent[x] > self.parent[y]:\n x, y = y, x\n self.parent[x] += self.parent[y]\n self.parent[y] = x\n self.cnt -= 1\n\n def is_same(self, x, y):\n return self.root(x) == self.root(y)\n\n def get_size(self, x):\n return -self.parent[self.root(x)]\n\n def get_cnt(self):\n return self.cnt\n\n\nt = int(input())\nalph = \"abcdefghijklmnopqrstuvwxyz\"\nto_ind = {char: i for i, char in enumerate(alph)}\n\n\nfor _ in range(t):\n n = int(input())\n a = list(input())\n b = list(input())\n \n flag = False\n for i in range(n):\n if a[i] > b[i]:\n print(-1)\n flag = True\n break\n if flag:\n continue\n\n uf = UnionFind(26)\n for i in range(n):\n u = to_ind[a[i]]\n v = to_ind[b[i]]\n uf.merge(u, v)\n print(26 - uf.get_cnt())", "import sys\nreadline = sys.stdin.readline\n\nT = int(readline())\nAns = [None]*T\ngeta = 20\nfor qu in range(T):\n N = int(readline())\n A = list(map(lambda x: ord(x)-97, readline().strip()))\n B = list(map(lambda x: ord(x)-97, readline().strip()))\n if any(a > b for a, b in zip(A, B)):\n Ans[qu] = -1\n continue\n res = 0\n table = [[0]*geta for _ in range(geta)]\n for a, b in zip(A, B):\n if a != b:\n table[a][b] = 1\n \n for al in range(geta):\n if sum(table[al]):\n res += 1\n bl = table[al].index(1)\n for cl in range(bl+1, geta):\n table[bl][cl] = table[bl][cl] | table[al][cl]\n Ans[qu] = res\nprint('\\n'.join(map(str, Ans)))"] | {
"inputs": [
"5\n3\naab\nbcc\n4\ncabc\nabcb\n3\nabc\ntsr\n4\naabd\ncccd\n5\nabcbd\nbcdda\n",
"10\n1\na\nb\n1\nb\na\n3\nabc\ndef\n1\nt\nt\n2\nrt\ntr\n2\nrt\ntt\n2\nrt\nrr\n3\nasd\nqrt\n1\ns\nt\n1\nr\nt\n",
"3\n2\nab\nab\n1\nc\nd\n4\nqqqq\nrrrr\n",
"4\n2\nee\nfe\n3\nlml\nmji\n3\nqoq\nqpp\n1\nd\ne\n"
],
"outputs": [
"2\n-1\n3\n2\n-1\n",
"1\n-1\n3\n0\n-1\n1\n-1\n-1\n1\n1\n",
"0\n1\n1\n",
"1\n-1\n-1\n1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,680 | |
1f09df7ba9b06736439bec0abaf7f08c | UNKNOWN | You are given a rectangular parallelepiped with sides of positive integer lengths $A$, $B$ and $C$.
Find the number of different groups of three integers ($a$, $b$, $c$) such that $1\leq a\leq b\leq c$ and parallelepiped $A\times B\times C$ can be paved with parallelepipeds $a\times b\times c$. Note, that all small parallelepipeds have to be rotated in the same direction.
For example, parallelepiped $1\times 5\times 6$ can be divided into parallelepipeds $1\times 3\times 5$, but can not be divided into parallelepipeds $1\times 2\times 3$.
-----Input-----
The first line contains a single integer $t$ ($1 \leq t \leq 10^5$) — the number of test cases.
Each of the next $t$ lines contains three integers $A$, $B$ and $C$ ($1 \leq A, B, C \leq 10^5$) — the sizes of the parallelepiped.
-----Output-----
For each test case, print the number of different groups of three points that satisfy all given conditions.
-----Example-----
Input
4
1 1 1
1 6 1
2 2 2
100 100 100
Output
1
4
4
165
-----Note-----
In the first test case, rectangular parallelepiped $(1, 1, 1)$ can be only divided into rectangular parallelepiped with sizes $(1, 1, 1)$.
In the second test case, rectangular parallelepiped $(1, 6, 1)$ can be divided into rectangular parallelepipeds with sizes $(1, 1, 1)$, $(1, 1, 2)$, $(1, 1, 3)$ and $(1, 1, 6)$.
In the third test case, rectangular parallelepiped $(2, 2, 2)$ can be divided into rectangular parallelepipeds with sizes $(1, 1, 1)$, $(1, 1, 2)$, $(1, 2, 2)$ and $(2, 2, 2)$. | ["N=100001\nfac=[0 for i in range(N)]\nfor i in range(1,N):\n for j in range(i,N,i):\n fac[j]+=1\ndef gcd(a,b):\n if a<b:\n a,b=b,a\n while b>0:\n a,b=b,a%b\n return a\ndef ctt(A,B,C):\n la=fac[A]\n lb=fac[B]\n lc=fac[C]\n ab=gcd(A,B)\n ac=gcd(A,C)\n bc=gcd(B,C)\n abc=gcd(ab,C)\n dupabc=fac[abc]\n dupac=fac[ac]-dupabc\n dupbc=fac[bc]-dupabc\n dupab=fac[ab]-dupabc\n lax=la-dupabc-dupab-dupac\n lbx=lb-dupabc-dupab-dupbc\n lcx=lc-dupabc-dupac-dupbc\n ctx=lax*lbx*lcx\n ctx+=lax*lbx*(lc-lcx)\n ctx+=lax*lcx*(lb-lbx)\n ctx+=lcx*lbx*(la-lax)\n ctx+=lax*((lb-lbx)*(lc-lcx)-(dupabc+dupbc)*(dupabc+dupbc-1)/2)\n ctx+=lbx*((la-lax)*(lc-lcx)-(dupabc+dupac)*(dupabc+dupac-1)/2)\n ctx+=lcx*((la-lax)*(lb-lbx)-(dupabc+dupab)*(dupabc+dupab-1)/2)\n ctx+=dupab*dupac*dupbc\n ctx+=dupab*dupac*(dupab+dupac+2)/2\n ctx+=dupab*dupbc*(dupab+dupbc+2)/2\n ctx+=dupbc*dupac*(dupbc+dupac+2)/2\n ctx+=dupabc*(dupab*dupac+dupab*dupbc+dupbc*dupac)\n ctx+=dupabc*(dupab*(dupab+1)+(dupbc+1)*dupbc+(dupac+1)*dupac)/2\n ctx+=(dupabc+1)*dupabc*(dupab+dupac+dupbc)/2\n ctx+=(dupabc*dupabc+dupabc*(dupabc-1)*(dupabc-2)/6)\n return int(ctx)\nn=int(input())\nfor _ in range(n):\n a,b,c = map(int,input().split())\n print(ctt(a,b,c))\nreturn"] | {
"inputs": [
"4\n1 1 1\n1 6 1\n2 2 2\n100 100 100\n",
"10\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n1 1 1\n",
"10\n9 6 8\n5 5 2\n8 9 2\n2 7 9\n6 4 10\n1 1 8\n2 8 1\n10 6 3\n7 5 2\n9 5 4\n",
"1\n100000 100000 100000\n"
],
"outputs": [
"1\n4\n4\n165\n",
"1\n1\n1\n1\n1\n1\n1\n1\n1\n1\n",
"41\n6\n21\n12\n39\n4\n7\n26\n8\n18\n",
"8436\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,357 | |
657fdfb957871383c29206498faa9fdf | UNKNOWN | Let $a_1, \ldots, a_n$ be an array of $n$ positive integers. In one operation, you can choose an index $i$ such that $a_i = i$, and remove $a_i$ from the array (after the removal, the remaining parts are concatenated).
The weight of $a$ is defined as the maximum number of elements you can remove.
You must answer $q$ independent queries $(x, y)$: after replacing the $x$ first elements of $a$ and the $y$ last elements of $a$ by $n+1$ (making them impossible to remove), what would be the weight of $a$?
-----Input-----
The first line contains two integers $n$ and $q$ ($1 \le n, q \le 3 \cdot 10^5$) — the length of the array and the number of queries.
The second line contains $n$ integers $a_1$, $a_2$, ..., $a_n$ ($1 \leq a_i \leq n$) — elements of the array.
The $i$-th of the next $q$ lines contains two integers $x$ and $y$ ($x, y \ge 0$ and $x+y < n$).
-----Output-----
Print $q$ lines, $i$-th line should contain a single integer — the answer to the $i$-th query.
-----Examples-----
Input
13 5
2 2 3 9 5 4 6 5 7 8 3 11 13
3 1
0 0
2 4
5 0
0 12
Output
5
11
6
1
0
Input
5 2
1 4 1 2 4
0 0
1 0
Output
2
0
-----Note-----
Explanation of the first query:
After making first $x = 3$ and last $y = 1$ elements impossible to remove, $a$ becomes $[\times, \times, \times, 9, 5, 4, 6, 5, 7, 8, 3, 11, \times]$ (we represent $14$ as $\times$ for clarity).
Here is a strategy that removes $5$ elements (the element removed is colored in red): $[\times, \times, \times, 9, \color{red}{5}, 4, 6, 5, 7, 8, 3, 11, \times]$ $[\times, \times, \times, 9, 4, 6, 5, 7, 8, 3, \color{red}{11}, \times]$ $[\times, \times, \times, 9, 4, \color{red}{6}, 5, 7, 8, 3, \times]$ $[\times, \times, \times, 9, 4, 5, 7, \color{red}{8}, 3, \times]$ $[\times, \times, \times, 9, 4, 5, \color{red}{7}, 3, \times]$ $[\times, \times, \times, 9, 4, 5, 3, \times]$ (final state)
It is impossible to remove more than $5$ elements, hence the weight is $5$. | ["from sys import stdin\n\ndef bitadd(a,w,bit):\n \n x = a\n while x <= (len(bit)-1):\n bit[x] += w\n x += x & (-1 * x)\n \ndef bitsum(a,bit):\n \n ret = 0\n x = a\n while x > 0:\n ret += bit[x]\n x -= x & (-1 * x)\n return ret\n\nclass RangeBIT:\n\n def __init__(self,N,indexed):\n self.bit1 = [0] * (N+2)\n self.bit2 = [0] * (N+2)\n self.mode = indexed\n\n def bitadd(self,a,w,bit):\n \n x = a\n while x <= (len(bit)-1):\n bit[x] += w\n x += x & (-1 * x)\n \n def bitsum(self,a,bit):\n \n ret = 0\n x = a\n while x > 0:\n ret += bit[x]\n x -= x & (-1 * x)\n return ret\n \n def add(self,l,r,w):\n\n l = l + (1-self.mode)\n r = r + (1-self.mode)\n self.bitadd(l,-1*w*l,self.bit1)\n self.bitadd(r,w*r,self.bit1)\n self.bitadd(l,w,self.bit2)\n self.bitadd(r,-1*w,self.bit2)\n\n def sum(self,l,r):\n l = l + (1-self.mode)\n r = r + (1-self.mode)\n ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2)\n ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2)\n\n return ret\n\nn,q = list(map(int,stdin.readline().split()))\na = list(map(int,stdin.readline().split()))\n\nqs = [ [] for i in range(n+1) ]\nans = [None] * q\n\nfor loop in range(q):\n x,y = list(map(int,stdin.readline().split()))\n l = x+1\n r = n-y\n qs[r].append((l,loop))\n\nBIT = [0] * (n+1)\n\nfor r in range(1,n+1):\n\n b = r-a[r-1]\n\n if b >= 0:\n\n L = 1\n R = r+1\n while R-L != 1:\n M = (L+R)//2\n\n if bitsum(M,BIT) >= b:\n L = M\n else:\n R = M\n\n if bitsum(L,BIT) >= b:\n bitadd(1,1,BIT)\n bitadd(L+1,-1,BIT)\n\n\n for ql,qind in qs[r]:\n ans[qind] = bitsum(ql,BIT)\n\nfor i in ans:\n print (i)\n"] | {
"inputs": [
"13 5\n2 2 3 9 5 4 6 5 7 8 3 11 13\n3 1\n0 0\n2 4\n5 0\n0 12\n",
"5 2\n1 4 1 2 4\n0 0\n1 0\n",
"1 1\n1\n0 0\n",
"30 10\n1 1 3 3 5 2 1 8 2 6 11 5 2 6 12 11 8 5 11 3 14 8 16 13 14 25 16 2 8 17\n6 3\n0 15\n1 0\n9 2\n12 16\n1 0\n17 3\n14 13\n0 22\n3 10\n"
],
"outputs": [
"5\n11\n6\n1\n0\n",
"2\n0\n",
"1\n",
"3\n15\n16\n2\n0\n16\n0\n0\n8\n4\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,984 | |
05c9d718dff5ee2e4fb052804f3ed7af | UNKNOWN | A festival will be held in a town's main street. There are n sections in the main street. The sections are numbered 1 through n from left to right. The distance between each adjacent sections is 1.
In the festival m fireworks will be launched. The i-th (1 ≤ i ≤ m) launching is on time t_{i} at section a_{i}. If you are at section x (1 ≤ x ≤ n) at the time of i-th launching, you'll gain happiness value b_{i} - |a_{i} - x| (note that the happiness value might be a negative value).
You can move up to d length units in a unit time interval, but it's prohibited to go out of the main street. Also you can be in an arbitrary section at initial time moment (time equals to 1), and want to maximize the sum of happiness that can be gained from watching fireworks. Find the maximum total happiness.
Note that two or more fireworks can be launched at the same time.
-----Input-----
The first line contains three integers n, m, d (1 ≤ n ≤ 150000; 1 ≤ m ≤ 300; 1 ≤ d ≤ n).
Each of the next m lines contains integers a_{i}, b_{i}, t_{i} (1 ≤ a_{i} ≤ n; 1 ≤ b_{i} ≤ 10^9; 1 ≤ t_{i} ≤ 10^9). The i-th line contains description of the i-th launching.
It is guaranteed that the condition t_{i} ≤ t_{i} + 1 (1 ≤ i < m) will be satisfied.
-----Output-----
Print a single integer — the maximum sum of happiness that you can gain from watching all the fireworks.
Please, do not write the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
-----Examples-----
Input
50 3 1
49 1 1
26 1 4
6 1 10
Output
-31
Input
10 2 1
1 1000 4
9 1000 4
Output
1992 | ["from collections import deque\n\ndef rollingmax(x, y, r, a):\n k = 2 * r + 1\n d = deque()\n lx = len(x)\n for i in range(lx + r):\n if i < lx:\n while d and d[-1][1] <= x[i]:\n d.pop()\n d.append((i, x[i]))\n while d and d[0][0] <= i - k:\n d.popleft()\n if i >= r:\n y[i - r] = d[0][1] - abs(i - r - a)\n\nn, m, d = [int(x) for x in input().split()]\na, ball, t0 = [int(x) for x in input().split()]\nf = [-abs(i - a) for i in range(1, n + 1)]\ng = [0] * n\nfor _ in range(m - 1):\n a, b, t = [int(x) for x in input().split()]\n ball += b\n r = min(n - 1, (t - t0) * d)\n t0 = t \n rollingmax(f, g, r, a - 1)\n f, g = g, f\n\nprint(max(f) + ball) \n\n", "from collections import deque\nn,m,v=map(int,input().split())\nx,t,b,bt,dp,mi,mi2,mi3,dpmin,dp2=[0]*300,[0]*300,0,0,[[0]*2for i in range(150001)],0,100000000000000,10000000000000,0,[0]*150001\nd=deque()\nfor i in range(m):\n x[i],b,t[i]=map(int,input().split())\n bt+=b\nfor i2 in range(m-1):\n if i2==0:\n for i in range(1,n+1):\n dp[i][0]=abs(i-x[0])\n if mi2>dp[i][0]:\n mi2=dp[i][0]\n if m==1:\n break\n if(t[i2+1]-t[i2])*v>=n:\n mi3=mi2\n mi2=1000000000000000000\n for i in range(1,n+1):\n dp[i][0]=mi3+abs(i-x[i2+1])\n if mi2>dp[i][0]:\n mi2=dp[i][0]\n continue\n mi2=1000000000000000000\n for i in range(1,n+1+(t[i2+1]-t[i2])*v):\n if i<=n:\n while (len(d)>0 and dp[i][0]<=d[len(d)-1][0]):\n d.pop()\n dp[i][1]=i+2*(t[i2+1]-t[i2])*v+1\n d.append(dp[i])\n if d[0][1]==i:\n d.popleft()\n if i-(t[i2+1]-t[i2])*v>=1:\n dp2[i-(t[i2+1]-t[i2])*v]=d[0][0]+abs(x[i2+1]-(i-(t[i2+1]-t[i2])*v))\n for i in range(1,n+1):\n dp[i][0]=dp2[i]\n if dp2[i]<mi2:\n mi2=dp2[i]\n d.clear()\nfor i in range(1,n+1):\n if i==1:\n mi=dp[i][0]\n if dp[i][0]<mi:\n mi=dp[i][0]\nprint(bt-mi)", "class SortedList(list):\n\n def add(self, other):\n left = -1\n right = len(self)\n while right - left > 1:\n mid = (right + left) >> 1\n if other < self[mid]:\n right = mid\n else:\n left = mid\n super().insert(right, other)\n\n\nINF = int(3e18)\n\n\ndef solve_good(n, m, d, a, b, t):\n left = SortedList()\n left.append(-INF)\n right = SortedList()\n right.append(INF)\n lborder = -INF\n rborder = INF\n tprev = 0\n ans = 0\n for ai, bi, ti in zip(a, b, t):\n ans += bi\n dt = ti - tprev\n interval = dt * d\n tprev = ti\n\n lborder += interval\n rborder -= interval\n\n lefta = lborder + ai\n righta = rborder - (n - ai)\n\n if lefta < left[-1]:\n top = left.pop()\n ans -= abs(top - lefta)\n left.add(lefta)\n left.add(lefta)\n right.add(rborder - (n - abs(top - lborder)))\n elif righta > right[0]:\n top = right.pop(0)\n ans -= abs(top - righta)\n right.add(righta)\n right.add(righta)\n left.add(lborder + n - abs(top - rborder))\n else:\n left.add(lefta)\n right.add(righta)\n return ans\n\n\nn, m, d = [int(elem) for elem in input().split()]\na, b, t = [], [], []\nfor i in range(m):\n ai, bi, ti = [int(elem) for elem in input().split()]\n a.append(ai)\n b.append(bi)\n t.append(ti)\n\nprint(solve_good(n, m, d, a, b, t))\n"] | {
"inputs": [
"50 3 1\n49 1 1\n26 1 4\n6 1 10\n",
"10 2 1\n1 1000 4\n9 1000 4\n",
"30 8 2\n15 97 3\n18 64 10\n20 14 20\n16 18 36\n10 23 45\n12 60 53\n17 93 71\n11 49 85\n",
"100 20 5\n47 93 3\n61 49 10\n14 69 10\n88 2 14\n35 86 18\n63 16 20\n39 49 22\n32 45 23\n66 54 25\n77 2 36\n96 85 38\n33 28 45\n29 78 53\n78 13 60\n58 96 64\n74 39 71\n18 80 80\n18 7 85\n97 82 96\n74 99 97\n"
],
"outputs": [
"-31\n",
"1992\n",
"418\n",
"877\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,706 | |
15794fbcf81c8ccaaae6b74861778896 | UNKNOWN | Snuke is playing a puzzle game.
In this game, you are given a rectangular board of dimensions R × C, filled with numbers. Each integer i from 1 through N is written twice, at the coordinates (x_{i,1},y_{i,1}) and (x_{i,2},y_{i,2}).
The objective is to draw a curve connecting the pair of points where the same integer is written, for every integer from 1 through N.
Here, the curves may not go outside the board or cross each other.
Determine whether this is possible.
-----Constraints-----
- 1 ≤ R,C ≤ 10^8
- 1 ≤ N ≤ 10^5
- 0 ≤ x_{i,1},x_{i,2} ≤ R(1 ≤ i ≤ N)
- 0 ≤ y_{i,1},y_{i,2} ≤ C(1 ≤ i ≤ N)
- All given points are distinct.
- All input values are integers.
-----Input-----
Input is given from Standard Input in the following format:
R C N
x_{1,1} y_{1,1} x_{1,2} y_{1,2}
:
x_{N,1} y_{N,1} x_{N,2} y_{N,2}
-----Output-----
Print YES if the objective is achievable; print NO otherwise.
-----Sample Input-----
4 2 3
0 1 3 1
1 1 4 1
2 0 2 2
-----Sample Output-----
YES
The above figure shows a possible solution. | ["import sys\ninput = sys.stdin.readline\n\ndef main():\n R, C, N = map(int, input().split())\n xyxy = [list(map(int, input().split())) for i in range(N)]\n\n r = []\n\n for i in range(N):\n x1, y1, x2, y2 = xyxy[i]\n # \u3069\u3061\u3089\u3082\u5468\u4e0a\u306b\u3042\u308b\u5834\u5408\u306f\u5468\u4e0a\u306e\u5ea7\u6a19\u306b\u5909\u63db\u3057\u3066\u304b\u3089\u8a18\u9332\n if ((x1 == 0 or x1 == R) or (y1 == 0 or y1 == C)) and ((x2 == 0 or x2 == R) or (y2 == 0 or y2 == C)):\n # \uff11\u3064\u76ee\n if x1 == 0:\n r.append((y1, i))\n elif x1 == R:\n r.append((C - y1 + C + R, i))\n elif y1 == 0:\n r.append((R - x1 + C * 2 + R, i))\n else:\n r.append((x1 + C, i))\n # 2\u3064\u76ee\n if x2 == 0:\n r.append((y2, i))\n elif x2 == R:\n r.append((C - y2 + C + R, i))\n elif y2 == 0:\n r.append((R - x2 + C * 2 + R, i))\n else:\n r.append((x2 + C, i))\n \n r = sorted(r)\n # print(r)\n stack = []\n for i in range(len(r)):\n if len(stack) > 0:\n if stack[-1] == r[i][1]:\n stack.pop()\n else:\n stack.append(r[i][1])\n else:\n stack.append(r[i][1])\n \n if len(stack) > 0:\n print(\"NO\")\n else:\n print(\"YES\")\n \n\n\n\ndef __starting_point():\n main()\n__starting_point()", "# coding: utf-8\n\nimport heapq\n\n\ndef coord_on_edge(x, y, R, C):\n if y == 0:\n return x\n if x == R:\n return R + y\n if y == C:\n return R + C + R - x\n if x == 0:\n return 2 * (R + C) - y\n return None\n\n\ndef on_edge(x1, y1, x2, y2, R, C, i, edge_points):\n c1 = coord_on_edge(x1, y1, R, C)\n c2 = coord_on_edge(x2, y2, R, C)\n if c1 is not None and c2 is not None:\n heapq.heappush(edge_points, (c1, i))\n heapq.heappush(edge_points, (c2, i))\n\n\ndef solve():\n R, C, N = list(map(int, input().split()))\n edge_points = [] # (coord, point#)\n for i in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n on_edge(x1, y1, x2, y2, R, C, i, edge_points)\n q = []\n while edge_points:\n c, i = heapq.heappop(edge_points)\n # print((c, i)) # dbg\n if len(q) and q[-1] == i:\n q.pop()\n else:\n q.append(i)\n if len(q):\n return \"NO\"\n return \"YES\"\n\n\nprint((solve()))\n", "import sys, math, collections, heapq, itertools\nF = sys.stdin\ndef single_input(): return F.readline().strip(\"\\n\")\ndef line_input(): return F.readline().strip(\"\\n\").split()\n\ndef solve():\n R, C, N = map(int, line_input())\n u, l, r, d = [], [], [], []\n for i in range(N):\n x, y, z, w = map(int, line_input())\n if x == 0:\n if z == 0: \n u.append((y, i))\n u.append((w, i))\n elif w == C:\n u.append((y, i))\n r.append((z, i))\n elif z == R:\n u.append((y, i))\n d.append((w, i))\n elif w == 0:\n u.append((y, i))\n l.append((z, i))\n elif x == R:\n if z == 0: \n d.append((y, i))\n u.append((w, i))\n elif w == C:\n d.append((y, i))\n r.append((z, i))\n elif z == R:\n d.append((y, i))\n d.append((w, i))\n elif w == 0:\n d.append((y, i))\n l.append((z, i))\n elif y == 0:\n if z == 0: \n l.append((x, i))\n u.append((w, i))\n elif w == C:\n l.append((x, i))\n r.append((z, i))\n elif z == R:\n l.append((x, i))\n d.append((w, i))\n elif w == 0:\n l.append((x, i))\n l.append((z, i))\n elif y == C:\n if z == 0: \n r.append((x, i))\n u.append((w, i))\n elif w == C:\n r.append((x, i))\n r.append((z, i))\n elif z == R:\n r.append((x, i))\n d.append((w, i))\n elif w == 0:\n r.append((x, i))\n l.append((z, i))\n u.sort()\n r.sort()\n d.sort(reverse = True)\n l.sort(reverse = True)\n\n s = []\n used = set()\n crossed = True\n for point, n in u:\n if n not in used:\n s.append(n)\n used |= {n}\n else:\n if s[-1] != n: break\n else: s.pop()\n else:\n for point, n in r:\n if n not in used:\n s.append(n)\n used |= {n}\n else:\n if s[-1] != n: break\n else: s.pop()\n else:\n for point, n in d:\n if n not in used:\n s.append(n)\n used |= {n}\n else:\n if s[-1] != n: break\n else: s.pop()\n else:\n for point, n in l:\n if n not in used:\n s.append(n)\n used |= {n}\n else:\n if s[-1] != n: break\n else: s.pop()\n else: crossed = False\n\n print(\"NO\" if crossed else \"YES\")\n \n return 0\n \ndef __starting_point():\n solve()\n__starting_point()", "R,C,N=list(map(int,input().split()))\nE=[]\nfor i in range(N):\n x1,y1,x2,y2=list(map(int,input().split()))\n if (0<x1<R and 0<y1<C) or (0<x2<R and 0<y2<C):\n continue\n if y1==0:\n E.append((x1,i))\n elif x1==R:\n E.append((R+y1,i))\n elif y1==C:\n E.append((2*R+C-x1,i))\n elif x1==0:\n E.append((2*R+2*C-y1,i))\n if y2==0:\n E.append((x2,i))\n elif x2==R:\n E.append((R+y2,i))\n elif y2==C:\n E.append((2*R+C-x2,i))\n elif x2==0:\n E.append((2*R+2*C-y2,i))\nE.sort()\nvisited=[False]*N\nstack=[]\nfor p in E:\n if not visited[p[1]]:\n stack.append(p[1])\n visited[p[1]]=True\n elif visited[p[1]]:\n if stack[-1]==p[1]:\n stack.pop()\n else:\n print(\"NO\")\n return\nprint(\"YES\")\n \n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\nmod = 10**9 + 7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\n\n\ndef main():\n R,C,N = LI()\n a = []\n def ff(x,y):\n if x == 0:\n return (0,y)\n if x == R:\n return (R,-y)\n if y == 0:\n return (R+1, -x)\n return (1, x)\n\n for _ in range(N):\n x1,y1,x2,y2 = LI()\n if (0 < x1 < R and 0 < y1 < C) or (0 < x2 < R and 0 < y2 < C):\n continue\n a.append((ff(x1,y1),_))\n a.append((ff(x2,y2),_))\n a.sort()\n b = [a[i][1] for i in range(len(a))]\n s = [None] * (len(b))\n si = -1\n for c in b:\n if si < -1:\n si += 1\n s[0] = c\n continue\n if s[si] == c:\n si -= 1\n else:\n si += 1\n s[si] = c\n\n if si > 1:\n return 'NO'\n return 'YES'\n\nprint((main()))\n\n\n\n\n\n\n", "class BIT():\n \"\"\"\u533a\u9593\u52a0\u7b97\u3001\u4e00\u70b9\u53d6\u5f97\u30af\u30a8\u30ea\u3092\u305d\u308c\u305e\u308cO(logN)\u3067\u7b54\u3048\u308b\n add: \u533a\u9593[l, r)\u306bval\u3092\u52a0\u3048\u308b\n get_val: i\u756a\u76ee\u306e\u5024\u3092\u6c42\u3081\u308b\n i, l, r\u306f0-indexed\n \"\"\"\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def _add(self, i, val):\n while i > 0:\n self.bit[i] += val\n i -= i & -i\n\n def get_val(self, i):\n \"\"\"i\u756a\u76ee\u306e\u5024\u3092\u6c42\u3081\u308b\"\"\"\n i = i + 1\n s = 0\n while i <= self.n:\n s += self.bit[i]\n i += i & -i\n return s\n\n def add(self, l, r, val):\n \"\"\"\u533a\u9593[l, r)\u306bval\u3092\u52a0\u3048\u308b\"\"\"\n self._add(r, val)\n self._add(l, -val)\n\n\nfrom operator import itemgetter\n\n\ndef compress(array):\n \"\"\"\u5ea7\u6a19\u5727\u7e2e\u3057\u305f\u30ea\u30b9\u30c8\u3092\u8fd4\u3059\"\"\"\n set_ = set()\n for num in array:\n set_.add(num[0])\n set_.add(num[1])\n array2 = sorted(set_)\n memo = {value: index for index, value in enumerate(array2)}\n for i in range(len(array)):\n array[i] = (memo[array[i][0]], memo[array[i][1]])\n return array\n\ndef on_line(x, y):\n return x == 0 or x == r or y == 0 or y == c\n\ndef val(x, y):\n if y == 0:\n return x\n if x == r:\n return r + y\n if y == c:\n return r + c + (r - x)\n if x == 0:\n return r + c + r + (c - y)\n\nr, c, n = list(map(int, input().split()))\ninfo = [list(map(int, input().split())) for i in range(n)]\n\nres = []\nfor i in range(n):\n x1, y1, x2, y2 = info[i]\n if on_line(x1, y1) and on_line(x2, y2):\n left = val(x1, y1)\n right = val(x2, y2)\n if left > right:\n left, right = right, left\n res.append((left, right))\n\n\nres = sorted(res, key=itemgetter(1))\nres = compress(res)\n\nbit = BIT(2 * len(res))\nfor left, right in res:\n if bit.get_val(left) != 0:\n print(\"NO\")\n return\n else:\n bit.add(left, right + 1, 1)\nprint(\"YES\")\n\n\n", "from operator import itemgetter\nimport collections\nr,c,n=map(int,input().split())\nl=[list(map(int,input().split())) for i in range(n)]\ne1=[];e2=[];e3=[];e4=[]\nfor i in range(n):\n if (l[i][0]==0 or l[i][0]==r or l[i][1]==0 or l[i][1]==c) and (l[i][2]==0 or l[i][2]==r or l[i][3]==0 or l[i][3]==c):\n if l[i][0]==0 and l[i][1]!=c:\n e1.append([i+1,l[i][0],l[i][1]])\n elif l[i][1]==c and l[i][0]!=r:\n e2.append([i+1,l[i][0],l[i][1]])\n elif l[i][0]==r and l[i][1]!=0:\n e3.append([i+1,l[i][0],l[i][1]])\n else:\n e4.append([i+1,l[i][0],l[i][1]])\n if l[i][2]==0 and l[i][3]!=c:\n e1.append([i+1,l[i][2],l[i][3]])\n elif l[i][3]==c and l[i][2]!=r:\n e2.append([i+1,l[i][2],l[i][3]])\n elif l[i][2]==r and l[i][3]!=0:\n e3.append([i+1,l[i][2],l[i][3]])\n else:\n e4.append([i+1,l[i][2],l[i][3]])\ne1=sorted(e1,key=itemgetter(2))\ne2=sorted(e2,key=itemgetter(1))\ne3=sorted(e3,key=itemgetter(2))\ne4=sorted(e4,key=itemgetter(1))\ne3.reverse()\ne4.reverse()\ne=e1+e2+e3+e4\n\nq=[]\nq=collections.deque(q)\nfor i in range(len(e)):\n if len(q)==0:\n q.append(e[i][0])\n else:\n if q[-1]==e[i][0]:\n q.pop()\n else:\n q.append(e[i][0])\nif len(q)==0:\n print('YES')\nelse:\n print('NO')", "from sys import setrecursionlimit, stderr\nfrom functools import reduce\nfrom itertools import *\nfrom collections import *\nfrom bisect import *\n\ndef read():\n return int(input())\n \ndef reads():\n return [int(x) for x in input().split()]\n\nR, C, N = reads()\n\ndef edge(x, y):\n return x == 0 or x == R or y == 0 or y == C\n\ndef flat(x, y):\n assert edge(x, y)\n if y == 0:\n return x\n elif x == R:\n return R + y\n elif y == C:\n return R + C + (R - x)\n else:\n assert x == 0\n return 2 * R + C + (C - y)\n\nps = []\nfor i in range(N):\n x1, y1, x2, y2 = reads()\n if edge(x1, y1) and edge(x2, y2):\n ps.append((flat(x1, y1), i))\n ps.append((flat(x2, y2), i))\nps.sort()\n\nstack = []\nfor _, i in ps:\n if len(stack) > 0 and stack[-1] == i:\n stack.pop()\n else:\n stack.append(i)\n\nprint(\"YES\" if len(stack) == 0 else \"NO\")", "R,C,N = list(map(int,input().split()))\n\npoint = []\n\ndef XtoZ(x,y):\n if x==0:\n if y==0:\n return 0\n else:\n return 2*R + 2*C - y\n elif x==R:\n return R + y\n elif y==0:\n return x\n elif y==C:\n return 2*R + C - x\n\nfor i in range(N):\n x1,y1,x2,y2 = list(map(int,input().split()))\n if ((x1==0 or x1==R) or (y1==0 or y1==C)) and ((x2==0 or x2==R) or (y2==0 or y2==C)):\n point.append([XtoZ(x1,y1),i])\n point.append([XtoZ(x2,y2),i])\n\npoint.sort(key = lambda x:x[0])\n\nflag = [0]*N\n\nfrom collections import deque\n\nQ = deque()\n\nflag = [True]*N\nflag2=False\nfor p in point:\n if flag[p[1]]:\n Q.append(p[1])\n flag[p[1]] = False\n else:\n if Q.pop()!=p[1]:\n flag2=True\n break\n\nif flag2:\n print(\"NO\")\nelse:\n print(\"YES\")", "import sys\ninput = sys.stdin.readline\nfrom operator import itemgetter\n\nX, Y, N = map(int, input().split())\nU = []\nD = []\nR = []\nL = []\n\ndef mustconsider(x, y):\n return (x in [0, X]) or (y in [0, Y])\n\ndef divide(x, y, i):\n if x == 0 and y != Y:\n L.append((y, i))\n if x == X and y != 0:\n R.append((y, i))\n if y == 0 and x != 0:\n D.append((x, i))\n if y == Y and x != X:\n U.append((x, i))\n\nfor i in range(N):\n x1, y1, x2, y2 = map(int, input().split())\n if mustconsider(x1, y1) and mustconsider(x2, y2):\n divide(x1, y1, i)\n divide(x2, y2, i)\n\nD.sort()\nR.sort()\nU.sort(reverse=True)\nL.sort(reverse=True)\n\nArounds = []\nfor _, ind in D:\n Arounds.append(ind)\nfor _, ind in R:\n Arounds.append(ind)\nfor _, ind in U:\n Arounds.append(ind)\nfor _, ind in L:\n Arounds.append(ind)\n\nstack = []\nfor a in Arounds:\n if not stack:\n stack.append(a)\n else:\n if stack[-1] == a:\n stack.pop()\n else:\n stack.append(a)\n\nprint(\"YES\" if not stack else \"NO\")", "from collections import deque\nr, c, n = [int(item) for item in input().split()]\non_edge = [[] for _ in range(4)]\nfor i in range(n):\n x1, y1, x2, y2 = [int(item) for item in input().split()]\n v1_on_edge = x1 == 0 or x1 == r or y1 == 0 or y1 == c \n v2_on_edge = x2 == 0 or x2 == r or y2 == 0 or y2 == c \n if v1_on_edge and v2_on_edge:\n if x1 == 0:\n on_edge[0].append([y1, i])\n elif x1 == r:\n on_edge[2].append([y1, i])\n elif y1 == 0:\n on_edge[3].append([x1, i])\n elif y1 == c:\n on_edge[1].append([x1, i])\n if x2 == 0:\n on_edge[0].append([y2, i])\n elif x2 == r:\n on_edge[2].append([y2, i])\n elif y2 == 0:\n on_edge[3].append([x2, i])\n elif y2 == c:\n on_edge[1].append([x2, i])\nfor i in range(4):\n if i <= 1:\n on_edge[i].sort()\n else:\n on_edge[i].sort(reverse=True)\ntotal = [item for line in on_edge for item in line] \nst = deque()\nst.append(-1)\nfor val, item in total:\n if st[-1] == item:\n st.pop()\n else:\n st.append(item)\nif st[-1] == -1:\n print(\"YES\")\nelse:\n print(\"NO\")\n\n", "# coding: utf-8\n# Your code here!\n\nimport sys\nsys.setrecursionlimit(10**6)\nreadline = sys.stdin.readline #\u6587\u5b57\u5217\u5165\u529b\u306e\u3068\u304d\u306f\u6ce8\u610f\n\n\nr,c,n = [int(i) for i in readline().split()]\n#xyxy = [[int(i) for i in readline().split()] for _ in range(n)] \n#for i,(x1,y1,x2,y2) in enumerate(xyxy):\n\ndef addedge(x1,y1):\n if y1 == 0:\n edge.append((x1,i))\n elif x1 == r:\n edge.append((r+y1,i))\n elif y1 == c:\n edge.append((r+c+(r-x1),i))\n else:\n edge.append((r+c+r+(c-y1),i))\n return \n\n\nedge = []\nfor i in range(n):\n x1,y1,x2,y2 = [int(i) for i in readline().split()]\n if (x1 not in (0,r) and y1 not in (0,c)) or (x2 not in (0,r) and y2 not in (0,c)):\n continue\n \n addedge(x1,y1)\n addedge(x2,y2)\n\n \nedge.sort()\n#print(edge)\n\nans = []\nfor d,i in edge:\n if ans and ans[-1] == i:\n ans.pop()\n else:\n ans.append(i)\n\nif ans:\n print(\"NO\")\nelse:\n print(\"YES\")\n \n\n\n \n\n\n\n\n", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\n\ndef calc(a, b):\n if b == 0: return a\n if a == R: return b + R\n if b == C: return R + C + (R - a)\n if a == 0: return R + C + R + (C - b)\n\nR, C, N = map(int, input().split())\nA = []\nfor i in range(N):\n x1, y1, x2, y2 = map(int, input().split())\n if (x1 == 0 or x1 == R or y1 == 0 or y1 == C) and (x2 == 0 or x2 == R or y2 == 0 or y2 == C):\n A.append((calc(x1, y1), i))\n A.append((calc(x2, y2), i))\n\nA = [l[1] for l in sorted(A, key = lambda x: x[0])]\nB = []\n\nwhile A:\n while len(B) and A[-1] == B[-1]:\n A.pop()\n B.pop()\n if A:\n B.append(A.pop())\n\nprint(\"NO\" if len(B) else \"YES\")", "R, C, N = map(int, input().split())\n\nconsider = []\n\ndef dist(x, y):\n if x == 0:\n return R * 2 + C + (C - y)\n if x == R:\n return R + y\n if y == 0:\n return x\n if y == C:\n return R + C + (R - x)\n \n \nfor i in range(N):\n x1, y1, x2, y2 = map(int, input().split())\n if ((x1 == 0 or x1 == R) or (y1 == 0 or y1 == C)) and ((x2 == 0 or x2 == R) or (y2 == 0 or y2 == C)):\n consider.append((i, dist(x1, y1)))\n consider.append((i, dist(x2, y2)))\n\nl = []\nconsider = sorted(consider, key=lambda p:p[1])\n\nfor c in consider:\n if len(l) == 0:\n l.append(c[0])\n continue\n elif c[0] == l[-1]:\n l.pop()\n else:\n l.append(c[0])\n\nif len(l) == 0:\n print(\"YES\")\nelse:\n print(\"NO\")", "def calc_pos(x, y, R, C):\n if y == 0:\n return x\n if y == C:\n return 2 * R + C - x\n if x == R:\n return R + y\n if x == 0:\n return 2 * R + 2 * C - y\n\ndef read_data():\n R, C, N = list(map(int, input().split()))\n pairs = []\n xys = []\n idx = 0\n for i in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n xys.append((x1, y1))\n xys.append((x2, y2))\n if (x1 != 0 and x1 != R and y1 != 0 and y1 != C) or (x2 != 0 and x2 != R and y2 != 0 and y2 != C):\n continue\n a = calc_pos(x1, y1, R, C)\n b = calc_pos(x2, y2, R, C)\n pairs.append((a, idx))\n pairs.append((b, idx))\n idx += 1\n pairs.sort()\n return pairs, xys\n\ndef is_valid(xys):\n xys.sort()\n prev_x, prev_y = xys[0]\n for x, y in xys[1:]:\n if prev_x == x and prev_y == y:\n return False\n prev_x = x\n prev_y = y\n return True\n\ndef solve(pairs, xys):\n if len(xys) == 2:\n return \"YES\"\n if not is_valid(xys):\n return \"NO\" \n idxs = [i for a, i in pairs]\n stack = []\n for idx in idxs:\n if stack and stack[-1] == idx:\n stack.pop()\n continue\n stack.append(idx)\n if stack:\n return \"NO\"\n else:\n return \"YES\"\n\npairs, xys = read_data()\nprint((solve(pairs, xys)))\n", "import sys\ninput = sys.stdin.readline\nfrom collections import deque\nR,C,N=map(int,input().split())\ntable=[]\ndef f(i,j):\n if i==0:\n return j\n if j==C:\n return C+i\n if i==R:\n return R+C+C-j\n if j==0:\n return R+R+C+C-i\nfor i in range(N):\n a,b,c,d=map(int,input().split())\n if (0<a<R and 0<b<C) or (0<c<R and 0<d<C):\n continue\n table.append((f(a,b),i))\n table.append((f(c, d), i))\ntable.sort()\nH=deque()\nfor i in range(len(table)):\n if len(H)!=0 and H[-1]==table[i][1]:\n H.pop()\n else:\n H.append(table[i][1])\n#print(H,table)\nwhile len(H)!=0 and H[0]==H[-1]:\n H.popleft()\n H.pop()\nif len(H)==0:\n print('YES')\nelse:\n print('NO')", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\n\ndef calc(a, b):\n if b == 0: return a\n if a == R: return b + R\n if b == C: return R + C + (R - a)\n if a == 0: return R + C + R + (C - b)\n\nR, C, N = map(int, input().split())\nA = []\nfor i in range(N):\n x1, y1, x2, y2 = map(int, input().split())\n if (x1 == 0 or x1 == R or y1 == 0 or y1 == C) and (x2 == 0 or x2 == R or y2 == 0 or y2 == C):\n A.append((calc(x1, y1), i))\n A.append((calc(x2, y2), i))\n\nA = [l[1] for l in sorted(A, key = lambda x: x[0])]\nB = []\n\nwhile A:\n while len(B) and A[-1] == B[-1]:\n A.pop()\n B.pop()\n if A:\n B.append(A.pop())\n\nprint(\"NO\" if len(B) else \"YES\")", "#!/usr/bin/env python3\nw, h, n = list(map(int, input().split()))\ndef proj(x, y):\n if y == 0:\n return x\n elif x == w:\n return w + y\n elif y == h:\n return w + h + (w - x)\n elif x == 0:\n return w + h + w + (h - y)\n else:\n return None\nps = []\nfor i in range(n):\n x1, y1, x2, y2 = list(map(int, input().split()))\n p1 = proj(x1, y1)\n p2 = proj(x2, y2)\n if p1 is not None and p2 is not None:\n ps += [ (p1, i), (p2, i) ]\nps.sort()\nstk = []\nfor _, i in ps:\n if stk and stk[-1] == i:\n stk.pop()\n else:\n stk.append(i)\nresult = not stk\nprint(([ 'NO', 'YES' ][ result ]))\n", "# coding: utf-8\nimport array, bisect, collections, copy, heapq, itertools, math, random, re, string, sys, time\nsys.setrecursionlimit(10 ** 7)\nINF = 10 ** 20\nMOD = 10 ** 9 + 7\n\n\ndef II(): return int(input())\ndef ILI(): return list(map(int, input().split()))\ndef IAI(LINE): return [ILI() for __ in range(LINE)]\ndef IDI(): return {key: value for key, value in ILI()}\n\n\ndef read():\n R, C, N = ILI()\n num_point = []\n for __ in range(N):\n x_1, y_1, x_2, y_2 = ILI()\n num_point.append([(x_1, y_1), (x_2, y_2)])\n return R, C, N, num_point\n\n\n# \u5468\u4e0a\u3092 (0, 0) \u3092\u539f\u70b9\u3068\u3057\u3066\u53cd\u6642\u8a08\u56de\u308a\u306b 1 \u672c\u306e\u6570\u76f4\u7dda\u3068\u3057\u305f\u6642\u306e point \u306e\u5ea7\u6a19\u3092\u8fd4\u3059\uff0e\n# \u5468\u4e0a\u306b\u3042\u308b\u304b\u306e\u5224\u5b9a\u3082\u884c\u3046\uff0e\ndef change_edge_point(R, C, point):\n x, y = point\n if x == 0:\n return R * 2 + C + (C - y)\n if x == R:\n return R + y\n if y == 0:\n return x\n if y == C:\n return R + C + (R - x)\n\n\ndef solve(R, C, N, num_point):\n point_double = []\n for ind, point in enumerate(num_point):\n p_1, p_2 = point\n if ((p_1[0] == 0 or p_1[0] == R) or (p_1[1] == 0 or p_1[1] == C)) and ((p_2[0] == 0 or p_2[0] == R) or (p_2[1] == 0 or p_2[1] == C)):\n point_double.append((ind + 1, change_edge_point(R, C, p_1)))\n point_double.append((ind + 1, change_edge_point(R, C, p_2)))\n point_double.sort(key=lambda x: x[1])\n stack = []\n for point in point_double:\n if len(stack) == 0:\n stack.append(point[0])\n continue\n if point[0] == stack[-1]:\n stack.pop()\n else:\n stack.append(point[0])\n \n if len(stack) == 0:\n return \"YES\"\n else:\n return \"NO\"\n \n\ndef main():\n params = read()\n print((solve(*params)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\nmod = 10**9 + 7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\n\n\ndef main():\n R,C,N = LI()\n a = []\n def ff(x,y):\n if x == 0:\n return (0,y)\n if x == R:\n return (R,-y)\n if y == 0:\n return (R+1, -x)\n return (1, x)\n\n for _ in range(N):\n x1,y1,x2,y2 = LI()\n if (0 < x1 < R and 0 < y1 < C) or (0 < x2 < R and 0 < y2 < C):\n continue\n a.append((ff(x1,y1),_))\n a.append((ff(x2,y2),_))\n a.sort()\n b = [a[i][1] for i in range(len(a))]\n s = [None] * (len(b))\n si = -1\n for c in b:\n if si < -1:\n si += 1\n s[0] = c\n continue\n if s[si] == c:\n si -= 1\n else:\n si += 1\n s[si] = c\n\n if si > 1:\n return 'NO'\n return 'YES'\n\nprint((main()))\n\n\n\n\n\n\n", "def put(i, x, y):\n if x == 0:\n on_top.append((y, i))\n elif x == r:\n on_bottom.append((y, i))\n elif y == 0:\n on_left.append((x, i))\n else:\n on_right.append((x, i))\n\n\non_top, on_bottom, on_left, on_right = [], [], [], []\n\nr, c, n = list(map(int, input().split()))\nfor i in range(n):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if 0 < x1 < r and 0 < y1 < c:\n continue\n if 0 < x2 < r and 0 < y2 < c:\n continue\n put(i, x1, y1)\n put(i, x2, y2)\non_top.sort()\non_bottom.sort(reverse=True)\non_left.sort(reverse=True)\non_right.sort()\nstack = []\nfor on_edge in [on_top, on_right, on_bottom, on_left]:\n for p, i in on_edge:\n if stack and stack[-1] == i:\n stack.pop()\n else:\n stack.append(i)\n\nprint(('NO' if stack else 'YES'))\n", "def main():\n import sys\n input = sys.stdin.readline\n \n R,C,N = map(int,input().split())\n P = []\n X = {0,R}\n Y = {0,C}\n M = 0\n for i in range(N):\n x1,y1,x2,y2 = map(int,input().split())\n if (x1 in X or y1 in Y) and (x2 in X or y2 in Y):\n if y1==0:\n L1 = x1\n elif x1==R:\n L1 = R+y1\n elif y1==C:\n L1 = 2*R + C - x1\n else:\n L1 = 2*(R+C) - y1\n \n if y2==0:\n L2 = x2\n elif x2==R:\n L2 = R+y2\n elif y2==C:\n L2 = 2*R + C - x2\n else:\n L2 = 2*(R+C) - y2\n \n P.append([min(L1,L2), max(L1,L2)])\n P = sorted(P, key = lambda a:a[0])\n M = len(P)\n \n flag = 0\n Q = []\n for i in range(M):\n x1,x2 = P[i]\n if Q == []:\n Q.append([x1,x2])\n else:\n while Q!=[] and Q[-1][1] < x1:\n Q.pop()\n if Q==[]:\n Q.append([x1,x2])\n else:\n y1,y2 = Q[-1]\n if y2 < x2:\n flag = 1\n break\n else:\n Q.append([x1,x2])\n if flag == 1:\n print(\"NO\")\n else:\n print(\"YES\")\n \nmain()", "r, c, n = map(int, input().split())\ndots = []\nnum = 0\nfor i in range(n):\n\tx1, y1, x2, y2 = map(int, input().split())\n\tif (0 < x1 < r and 0 < y1 < c) or (0 < x2 < r and 0 < y2 < c):\n\t\tcontinue\n\telse:\n\t\tnum += 1\n\t\td1 = (x1, y1)\n\t\td2 = (x2, y2)\n\t\tif x1 == 0:\n\t\t\tdots.append((y1, i))\n\t\telif y1 == c:\n\t\t\tdots.append((c + x1, i))\n\t\telif x1 == r:\n\t\t\tdots.append((2 * c + r - y1, i))\n\t\telse:\n\t\t\tdots.append((2 * (r + c) - x1, i))\n\n\t\tif x2 == 0:\n\t\t\tdots.append((y2, i))\n\t\telif y2 == c:\n\t\t\tdots.append((c + x2, i))\n\t\telif x2 == r:\n\t\t\tdots.append((2 * c + r - y2, i))\n\t\telse:\n\t\t\tdots.append((2 * (r + c) - x2, i))\n\n#print(dots)\nif num <= 1:\n\tprint(\"YES\")\nelse:\n\tdots.sort(key=lambda x: x[0])\n\tstack = []\n\tfor i in range(num * 2):\n\t\tif stack == []:\n\t\t\tstack.append(dots[i][1])\n\t\telse:\n\t\t\tif stack[-1] == dots[i][1]:\n\t\t\t\tstack.pop()\n\t\t\telse:\n\t\t\t\tstack.append(dots[i][1])\n\tif stack:\n\t\tprint(\"NO\")\n\telse:\n\t\tprint(\"YES\")", "w, h, n = list(map(int, input().split()))\n\nvec = []\n\nl = []\nb = []\nr = []\nt = []\nfor i in range(n):\n x, y, x1, y1 = list(map(int, input().split()))\n c = [x, y, x1, y1]\n if( ((c[0] == 0 or c[0] == w) or (c[1] == 0 or c[1] == h)) and ((c[2] == 0 or c[2] == w) or (c[3] == 0 or c[3] == h)) ):\n if x == 0:\n l.append([x, y, i])\n elif y == 0:\n t.append([x, y, i])\n elif x == w:\n r.append([x, y, i])\n elif y == h:\n b.append([x, y, i])\n if x1 == 0:\n l.append([x1, y1, i])\n elif y1 == 0:\n t.append([x1, y1, i])\n elif x1 == w:\n r.append([x1, y1, i])\n elif y1 == h:\n b.append([x1, y1, i])\n\nsorted_node = (\n sorted(l, key=lambda x: x[1])\n + sorted(b, key=lambda x: x[0])\n + sorted(r, key=lambda x: x[1], reverse=True)\n + sorted(t, key=lambda x: x[0], reverse=True)\n )\n\n\nstack = []\n\nfor node in sorted_node:\n if not stack or stack[-1] != node[2]:\n stack.append(node[2])\n else:\n stack.pop()\n\nprint((\"NO\" if stack else \"YES\"))\n", "import sys\ninput = sys.stdin.readline\nr,c,n = map(int,input().split())\nxy = [list(map(int,input().split())) for i in range(n)]\nls = []\nfor x1,y1,x2,y2 in xy:\n if (x1 in (0,r) or y1 in (0,c)) and (x2 in (0,r) or y2 in (0,c)):\n k = []\n for x,y in ((x1,y1),(x2,y2)):\n if x == 0:\n s = 2*r+2*c-y\n if x == r:\n s = r+y\n if y == 0:\n s = x\n if y == c:\n s = 2*r+c-x\n k.append(s)\n t = len(ls)//2+1\n ls.append((k[0],t))\n ls.append((k[1],t))\nif not ls:\n print(\"YES\")\n return\nls.sort()\nlsi = list(map(list,zip(*ls)))[1]\nm = len(lsi)\nstack = []\nfor i in lsi:\n if not stack:\n stack.append(i)\n else:\n if stack[-1] == i:\n stack.pop()\n else:\n stack.append(i)\nif stack:\n print(\"NO\")\nelse:\n print(\"YES\")", "from collections import deque\n\ndef f(x, y):\n if x == 0:\n return y\n if y == 0:\n return -x\n if x == r:\n return -(x + y)\n if y == c:\n return x + y\n\nr, c, n = map(int, input().split())\nxy = []\nlxy = 0\nfor i in range(n):\n x1, y1, x2, y2 = map(int, input().split())\n d = []\n if min(x1, y1) == 0 or x1 == r or y1 == c:\n d.append([f(x1, y1), i])\n if min(x2, y2) == 0 or x2 == r or y2 == c:\n d.append([f(x2, y2), i])\n if len(d) == 2:\n xy.append(d[0])\n xy.append(d[1])\n lxy += 2\nxy.sort()\nq = deque()\nfor i in range(lxy):\n if not q:\n q.append(xy[i][1])\n else:\n if q[-1] == xy[i][1]:\n q.pop()\n else:\n q.append(xy[i][1])\nprint(\"YES\" if not q else \"NO\")", "R,C,N = map(int,input().split())\n\nedges = []\n\ndef convert(x,y):\n if y == 0:\n return x\n if x == R:\n return R+y\n if y == C:\n return R+C+R-x\n if x == 0:\n return R+C+R+C-y\n else:\n return -1\n\n\nfor i in range(N):\n a,b,c,d = map(int, input().split())\n \n p,q = convert(a,b),convert(c,d)\n if p >= 0 and q >= 0:\n edges.append((p,q) if p < q else (q,p))\n\nedges.sort()\n\n# print(edges)\n\n\nstack = [R+R+C+C]\nflag = 'YES'\nfor a,b in edges:\n while a >= stack[-1]:\n stack.pop()\n\n if b > stack[-1]:\n flag = 'NO'\n break\n else:\n stack.append(b)\n\nprint(flag)", "R, C, N = list(map(int, input().split()))\n\ndef makexy(x1, y1):\n if y1 == 0:\n return x1\n elif x1==R:\n return R+y1\n elif y1 == C:\n return R*2 + C - x1\n else:\n return R*2 + C*2 - y1\n\n\nXY = []\nXY2 = []\nD = []\nfor _ in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if (x1 in [0, R] or y1 in [0, C]) and (x2 in [0, R] or y2 in [0, C]):\n xy1 = makexy(x1, y1)\n xy2 = makexy(x2, y2)\n xy1, xy2 = sorted((xy1, xy2))\n XY.append((xy1, xy2))\n XY2.append((xy1, 0))\n XY2.append((xy2, 1))\n D.append(xy2-xy1)\n\n#print(XY)\nXY.sort()\nXY2.sort()\nD.sort()\n\nD2 = []\nStack = []\nfor xy in XY2:\n if xy[1] == 0:\n Stack.append(xy)\n else:\n D2.append(xy[0]-Stack[-1][0])\n del Stack[-1]\n\nD2.sort()\n#print(D, D2)\nif D == D2:\n print(\"YES\")\nelse:\n print(\"NO\")\n", "def calc(x,y):\n\tif y==0:\n\t\treturn x\n\telif x==r:\n\t\treturn r+y\n\telif y==c:\n\t\treturn r*2+c-x\n\telif x==0:\n\t\treturn r*2+c*2-y\n\telse:\n\t\treturn -1\nr,c,n=map(int,input().split())\npts=[]\nfor i in range(n):\n\tx1,y1,x2,y2=map(int,input().split())\n\tu,v=calc(x1,y1),calc(x2,y2)\n\tif u>=0 and v>=0:\n\t\tpts.append((u,i))\n\t\tpts.append((v,i))\npts=sorted(pts)\nstk=[]\nfor a,b in pts:\n\tif len(stk)==0 or stk[-1]!=b:\n\t\tstk.append(b)\n\telse:\n\t\tstk.pop()\nif len(stk):\n\tprint(\"NO\")\nelse:\n\tprint(\"YES\")", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nh,w,n, *xyxy = list(map(int,read().split()))\n\ndef f(x,y):\n if y==0: return x\n elif x==h: return h+y\n elif y==w: return h+w+h-x\n else: return h+w+h+w-y \n\nm = iter(xyxy)\nres = []\nidx = 0\nfor x1,y1,x2,y2 in zip(m,m,m,m):\n if (x1*(h-x1)==0 or y1*(w-y1)==0) and (x2*(h-x2)==0 or y2*(w-y2)==0):\n res.append((f(x1,y1),idx))\n res.append((f(x2,y2),idx))\n idx += 1\n\n\nres.sort()\n#print(res)\n\nst = []\nfor d,i in res:\n if st and st[-1] == i:\n st.pop()\n else:\n st.append(i)\n\nif st:\n print(\"NO\")\nelse:\n print(\"YES\")\n\n\n\n\n\n\n\n\n\n", "import sys\ninput = sys.stdin.readline\n\ndef main():\n r, c, n = map(int, input().split())\n L = []\n def trans(x, y):\n z = None\n if x == 0:\n z = y\n if y == c:\n z = c + x\n if x == r:\n z = c + r + c - y\n if y == 0:\n z = 2*r + 2*c - x\n return z\n\n for _ in range(n):\n x1, y1, x2, y2 = map(int, input().split())\n z1 = trans(x1, y1)\n z2 = trans(x2, y2)\n if z1 is not None and z2 is not None:\n L.append((z1, z2))\n L.append((z2, z1))\n L.sort()\n cnt = 0\n D = dict()\n for z1, z2 in L:\n if z1 < z2:\n cnt += 1\n D[z1] = cnt\n else:\n if D[z2] != cnt:\n print(\"NO\")\n return\n cnt -= 1\n print(\"YES\")\ndef __starting_point():\n main()\n__starting_point()", "import sys\nfrom collections import deque\ndef MI(): return list(map(int,sys.stdin.readline().rstrip().split()))\n\n\nR,C,N = MI()\nA1,A2,A3,A4 = [],[],[],[]\n\n\ndef f(x,y): # (x,y)\u304c\u5468\u4e0a\u306b\u3042\u308b\u304b\u5224\u5b9a\n if x == 0 or x == R or y == 0 or y == C:\n return True\n return False\n\n\nfor i in range(1,N+1):\n x1,y1,x2,y2 = MI()\n if not (f(x1,y1) and f(x2,y2)):\n continue\n if y1 == 0:\n A1.append((x1,i))\n elif y1 == C:\n A3.append((-x1,i))\n elif x1 == 0:\n A4.append((-y1,i))\n else:\n A2.append((y1,i))\n if y2 == 0:\n A1.append((x2,i))\n elif y2 == C:\n A3.append((-x2,i))\n elif x2 == 0:\n A4.append((-y2,i))\n else:\n A2.append((y2,i))\n\nA1.sort()\nA2.sort()\nA3.sort()\nA4.sort()\nA = A1+A2+A3+A4\n\ndeq = deque([])\nflag = [0]*(N+1)\nfor z,i in A:\n if flag[i] == 0:\n flag[i] = 1\n deq.append(i)\n else:\n j = deq.pop()\n if j != i:\n print('NO')\n return\nelse:\n print('YES')\n", "def main(r,c,n,xy):\n ary=[]\n for i,(x1,y1,x2,y2) in enumerate(xy):\n if x1 in (0,r) or y1 in (0,c):\n if x2 in (0,r) or y2 in (0,c):\n for x,y in ((x1,y1),(x2,y2)):\n tmp=0\n if x==0:\n tmp=y\n elif x==r:\n tmp=r+c+(c-y)\n elif y==0:\n tmp=2*r+2*c-x\n elif y==c:\n tmp=c+x\n ary.append([i,tmp])\n ary.sort(key=lambda x:x[1])\n #print(ary)\n stc=[]\n for i,x in ary:\n if stc and stc[-1]==i:\n stc.pop()\n else:\n stc.append(i)\n if stc:\n return 'NO'\n else:\n return 'YES'\n\ndef __starting_point():\n r,c,n=map(int,input().split())\n xy=[list(map(int,input().split())) for _ in range(n)]\n print(main(r,c,n,xy))\n__starting_point()", "import sys\n\ninput=sys.stdin.readline\n\nR,C,N=list(map(int,input().split()))\n\ndef is_on_edge(x,y):\n return x==0 or x==R or y==0 or y==C\n\nline=[]\nfor i in range(0,N):\n x1,y1,x2,y2=list(map(int,input().split()))\n if is_on_edge(x1,y1) and is_on_edge(x2,y2):\n line.append([x1,y1,x2,y2])\n\nn=len(line)\nquery=[]\nfor i in range(n):\n x1,y1,x2,y2=line[i]\n if y1==0:\n query.append([x1,i])\n elif x1==R:\n query.append([R+y1,i])\n elif y1==C:\n query.append([R+C+(R-x1),i])\n else:\n query.append([2*R+2*C-y1,i])\n\n if y2==0:\n query.append([x2,i])\n elif x2==R:\n query.append([R+y2,i])\n elif y2==C:\n query.append([R+C+(R-x2),i])\n else:\n query.append([2*R+2*C-y2,i])\n\nquery.sort(reverse=True)\nque=[]\ndic=[0 for i in range(n)]\nwhile query:\n t,num=query.pop()\n if dic[num]==0:\n que.append(num)\n dic[num]=1\n else:\n if que[-1]!=num:\n print(\"NO\")\n return\n else:\n dic[num]=2\n que.pop()\nprint(\"YES\")\n", "import sys\ninput = sys.stdin.readline\n\nr, c, n = map(int, input().split())\nL = []\ndef trans(x, y):\n z = None\n if x == 0:\n z = y\n if y == c:\n z = c + x\n if x == r:\n z = c + r + c - y\n if y == 0:\n z = 2*r + 2*c - x\n return z\n\nfor _ in range(n):\n x1, y1, x2, y2 = map(int, input().split())\n z1 = trans(x1, y1)\n z2 = trans(x2, y2)\n if z1 is not None and z2 is not None:\n if z1 > z2:\n z1, z2 = z2, z1\n L.append((z1, z2))\n L.append((z2, z1))\nL.sort()\ncnt = 0\nD = dict()\nfor z1, z2 in L:\n if z1 < z2:\n cnt += 1\n D[z1] = cnt\n else:\n if D[z2] != cnt:\n print(\"NO\")\n return\n cnt -= 1\nprint(\"YES\")", "from cmath import phase\n\nr,c,n = list(map(int,input().split()))\nl = list()\nfor i in range(n):\n w,x,y,z = list(map(int,input().split())) \n if (w in (0,r) or x in (0,c)) and (y in (0,r) or z in (0,c)):\n l.append((i,w-r/2+(x-c/2)*1j))\n l.append((i,y-r/2+(z-c/2)*1j))\nl.sort(key=lambda t: phase(t[1]))\np = list()\nfor x,c in l:\n if p == [] or p[-1] != x:\n p.append(x)\n else:\n p.pop()\nans = [\"NO\", \"YES\"]\nprint((ans[p==[]]))\n", "R,C,n=list(map(int,input().split()))\npair=[list(map(int,input().split())) for _ in range(n)]\nu=[]\nr=[]\nd=[]\nl=[]\nfor i in range(n):\n x1,y1,x2,y2=pair[i]\n if 0<x1<R and 0<y1<C:continue\n if 0<x2<R and 0<y2<C:continue\n if x1==0:\n u.append([y1,i])\n if x1==R:\n d.append([y1,i])\n if y1==0:\n if x1!=0 and x1!=R:\n l.append([x1,i])\n if y1==C:\n if x1!=0 and x1!=R:\n r.append([x1,i])\n if x2==0:\n u.append([y2,i])\n if x2==R:\n d.append([y2,i])\n if y2==0:\n if x2!=0 and x2!=R:\n l.append([x2,i])\n if y2==C:\n if x2!=0 and x2!=R:\n r.append([x2,i])\nu.sort()\nr.sort()\nd.sort(reverse=True)\nl.sort(reverse=True)\nurdl=u+r+d+l\nstack=[]\nfor i in range(len(urdl)):\n if len(stack)==0:\n stack.append(urdl[i][1])\n elif stack[-1]==urdl[i][1]:\n stack.pop()\n else:\n stack.append(urdl[i][1])\nprint(\"YES\" if len(stack)==0 else \"NO\")\n", "import sys\ninput = sys.stdin.readline\n\ndef main():\n r, c, n = map(int, input().split())\n L = []\n def trans(x, y):\n z = None\n if x == 0:\n z = y\n if y == c:\n z = c + x\n if x == r:\n z = c + r + c - y\n if y == 0:\n z = 2*r + 2*c - x\n return z\n\n for _ in range(n):\n x1, y1, x2, y2 = map(int, input().split())\n z1 = trans(x1, y1)\n z2 = trans(x2, y2)\n if z1 is not None and z2 is not None:\n L.append((z1, z2))\n L.append((z2, z1))\n L.sort()\n cnt = 0\n D = dict()\n for z1, z2 in L:\n if z1 < z2:\n cnt += 1\n D[z1] = cnt\n else:\n if D[z2] != cnt:\n print(\"NO\")\n return\n cnt -= 1\n print(\"YES\")\ndef __starting_point():\n main()\n__starting_point()", "R, C, N = list(map(int, input().split()))\nUP, RIGHT, DOWN, LEFT = [], [], [], []\nfor i in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n\n # 2\u3064\u3068\u3082\u5468\u4e0a\u306b\u306a\u3044\n if 0 < x1 < R and 0 < y1 < C:\n continue\n if 0 < x2 < R and 0 < y2 < C:\n continue\n\n # 2\u3064\u3068\u3082\u5468\u56de\u4e0a\u306b\u3042\u308b\n if x1 == 0: UP.append([i, y1])\n elif x1 == R: DOWN.append([i, y1])\n elif y1 == 0: LEFT.append([i, x1])\n elif y1 == C: RIGHT.append([i, x1])\n\n if x2 == 0: UP.append([i, y2])\n elif x2 == R: DOWN.append([i, y2])\n elif y2 == 0: LEFT.append([i, x2])\n elif y2 == C: RIGHT.append([i, x2])\n\n\n# \u6642\u8a08\u56de\u308a\u306b\u63a2\u7d22\u3067\u304d\u308b\u3088\u3046\u306b\u3059\u308b\nUP.sort(key=lambda x: x[1])\nRIGHT.sort(key=lambda x: x[1])\nDOWN.sort(key=lambda x: x[1], reverse=True)\nLEFT.sort(key=lambda x: x[1], reverse=True)\n\n# \u5168\u4f53\u3092\u9023\u7d50\nNumbers = UP + RIGHT + DOWN + LEFT\n\n# \u6642\u8a08\u56de\u308a\u306b\u63a2\u7d22\nstack = []\nfor n, z in Numbers:\n if stack and stack[-1] == n:\n stack.pop()\n\n else:\n stack.append(n)\nprint((\"NO\" if stack else \"YES\"))\n", "import sys\ninput = sys.stdin.readline\nR, C, N = map(int, input().split())\na = []\n\ndef conv(i, j):\n res = 0\n if i == 0:\n res = j\n elif j == C:\n res = C + i\n elif i == R:\n res = C + R + (C - j)\n elif j == 0: res = 2 * C + R + (R - i)\n else: res = -1\n return res\n\nfor i in range(N):\n x, y, u, v = map(int, input().split())\n d, dd = conv(x, y), conv(u, v)\n if d >= 0 and (dd >= 0):\n a.append((d, i))\n a.append((dd, i))\na.sort()\ns = []\nfor _, i in a:\n if len(s) and s[-1] == i: s.pop()\n else: s.append(i)\nif len(s): print(\"NO\")\nelse: print(\"YES\")", "from collections import deque\n\ndef f(x, y):\n if x == 0:\n return y\n if y == 0:\n return -x\n if x == r:\n return -(x + y)\n if y == c:\n return x + y\n\nr, c, n = map(int, input().split())\nxy = []\nlxy = 0\nfor i in range(n):\n x1, y1, x2, y2 = map(int, input().split())\n d = []\n if min(x1, y1) == 0 or x1 == r or y1 == c:\n d.append([f(x1, y1), i])\n if min(x2, y2) == 0 or x2 == r or y2 == c:\n d.append([f(x2, y2), i])\n if len(d) == 2:\n xy.append(d[0])\n xy.append(d[1])\n lxy += 2\nxy.sort()\nq = deque()\nlq = -1\nfor i in range(lxy):\n if not q:\n q.append(xy[i][1])\n lq += 1\n else:\n if q[lq] == xy[i][1]:\n q.pop()\n lq -= 1\n else:\n q.append(xy[i][1])\n lq += 1\nprint(\"YES\" if not q else \"NO\")", "import sys\nfrom collections import defaultdict\n\n# sys.stdin = open('c1.in')\n\n\ndef read_int_list():\n return list(map(int, input().split()))\n\n\ndef read_int():\n return int(input())\n\n\ndef read_str_list():\n return input().split()\n\n\ndef read_str():\n return input()\n\n\ndef pos(X, Y):\n if Y == 0:\n return X\n if X == r:\n return r + Y\n if Y == c:\n return r + c + r - X\n if X == 0:\n return r + c + r + c - Y\n\n\nr, c, n, = read_int_list()\nx = [0, 0]\ny = [0, 0]\na = []\nfor i in range(n):\n x[0], y[0], x[1], y[1] = read_int_list()\n if (x[0] in [0, r] or y[0] in [0, c]) and (x[1] in [0, r] or y[1] in [0, c]):\n for k in range(2):\n a.append((pos(x[k], y[k]), i))\nm = len(a) // 2\na.sort()\n\nres = 'YES'\nstarted = set()\ns = []\nfor p, i in a:\n if i not in started:\n started.add(i)\n s.append(i)\n else:\n if s[-1] != i:\n res = 'NO'\n break\n s.pop()\n\nprint(res)\n", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\nR, C, N = map(int, input().split())\nX = {0, R}\nY = {0, C}\n\nZ = []\nfor i in range(N):\n x1, y1, x2, y2 = map(int, input().split())\n if (x1 == 0 or x1 == R or y1 == 0 or y1 == C) and (x2 == 0 or x2 == R or y2 == 0 or y2 == C):\n Z.append((x1, y1, x2, y2))\n X.add(x1)\n X.add(x2)\n Y.add(y1)\n Y.add(y2)\n\nDX = {a: i for i, a in enumerate(sorted(list(X)))}\nDY = {a: i for i, a in enumerate(sorted(list(Y)))}\nR, C = DX[R], DY[C]\n\ndef calc(a, b):\n if b == 0:\n return a\n if a == R:\n return b + R\n if b == C:\n return R + C + (R - a)\n if a == 0:\n return R + C + R + (C - b)\n\nA = []\nfor i, (x1, y1, x2, y2) in enumerate(Z):\n x3, y3, x4, y4 = DX[x1], DY[y1], DX[x2], DY[y2]\n A.append((calc(x3, y3), i))\n A.append((calc(x4, y4), i))\n\nA = [l[1] for l in sorted(A, key = lambda x: x[0])]\nB = []\n\nwhile A:\n while len(B) and A[-1] == B[-1]:\n A.pop()\n B.pop()\n if A:\n B.append(A.pop())\n\nprint(\"NO\" if len(B) else \"YES\")", "R, C, N = list(map(int, input().split()))\npts = []\nfor i in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n zs = []\n for x, y in [(x1, y1), (x2, y2)]:\n if y == 0:\n zs.append((x, i))\n elif x == R:\n zs.append((R+y, i))\n elif y == C:\n zs.append((2*R+C-x, i))\n elif x == 0:\n zs.append((2*R+2*C-y, i))\n if len(zs) == 2:\n pts += zs\n\npts.sort()\n\nstack = []\nfor z, i in pts:\n if not stack:\n stack.append(i)\n else:\n if stack[-1] == i:\n stack.pop()\n else:\n stack.append(i)\n\nif not stack:\n print('YES')\nelse:\n print('NO')\n", "r,c,n=map(int,input().split())\ndef po(x,y):\n if y==0:return x\n if x==r:return r+y\n if y==c:return r+c+(r-x)\n if x==0:return r+c+r+(c-y)\nq=[]\nfor i in range(n):\n x1,y1,x2,y2=map(int,input().split())\n if (x1 in [0,r] or y1 in [0,c])and(x2 in [0,r] or y2 in [0,c]):\n q.append((po(x1,y1),i))\n q.append((po(x2,y2),i))\nif len(q)==0:print(\"YES\");return\nq.sort()\nd=[]\nfor _,i in q:\n if len(d)==0:d.append(i)\n elif d[-1]==i:del d[-1]\n else:d.append(i)\nif len(d)==0:print('YES')\nelse:print('NO')", "r, c, n = list(map(int, input().split()))\nl = []\nfor i in range(n):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if (x1 == 0 or x1 == r or y1 == 0 or y1 == c) and (x2 == 0 or x2 == r or y2 == 0 or y2 == c):\n if x1 == 0:\n l.append((y1, i))\n elif y1 == c:\n l.append((c + x1, i))\n elif x1 == r:\n l.append((c * 2 + r - y1, i))\n else:\n l.append((r * 2 + c * 2 - x1, i))\n if x2 == 0:\n l.append((y2, i))\n elif y2 == c:\n l.append((c + x2, i))\n elif x2 == r:\n l.append((c * 2 + r - y2, i))\n else:\n l.append((r * 2 + c * 2 - x2, i))\nl.sort()\ns = []\nd = [False] * n\nfor x, i in l:\n if d[i]:\n if s[-1] != i:\n print('NO')\n return\n s.pop()\n else:\n s.append(i)\n d[i] = True\nprint('YES')\n", "R,C,N = map(int,input().split())\n\ndef outer_pos(x,y):\n if (0 < x < R) and (0 < y < C): return -1\n if y == 0: return x\n if x == R: return R + y\n if y == C: return R + C + (R-x)\n return R + C + R + (C-y)\n\nouter = []\nfor i in range(N):\n x1,y1,x2,y2 = map(int,input().split())\n p1 = outer_pos(x1,y1)\n p2 = outer_pos(x2,y2)\n if p1 < 0 or p2 < 0: continue\n outer.append((p1,i))\n outer.append((p2,i))\nouter.sort()\n\nstack = []\nfor p,i in outer:\n if len(stack) == 0 or stack[-1] != i:\n stack.append(i)\n else:\n stack.pop()\nprint('NO' if stack else 'YES')", "r, c, n = list(map(int, input().split()))\npoints = []\nxx = [0, r]\nyy = [0, c]\ndef add(x, y):\n if x == 0:\n points.append(r*2+c+c-y)\n elif x == r:\n points.append(r+y)\n elif y == 0:\n points.append(x)\n else:\n points.append(r+c+r-x)\nfor i in range(n):\n x0, y0, x1, y1 = list(map(int, input().split()))\n if (x0 in xx or y0 in yy) and (x1 in xx or y1 in yy):\n add(x0, y0)\n add(x1, y1)\nindex = list(range(len(points)))\nindex.sort(key = lambda a:points[a])\nque = []\nflag = True\nfor i in index:\n if que and que[-1]//2 == i//2:\n que.pop()\n else:\n que.append(i)\nif que:\n print('NO')\nelse:\n print('YES')\n", "def main():\n from bisect import bisect_left as bl\n\n class BIT():\n def __init__(self, member):\n self.member_list = sorted(member)\n self.member_dict = {v: i+1 for i, v in enumerate(self.member_list)}\n self.n = len(member)\n self.maxmember = self.member_list[-1]\n self.minmember = self.member_list[0]\n self.maxbit = 2**(len(bin(self.n))-3)\n self.bit = [0]*(self.n+1)\n self.allsum = 0\n\n # \u8981\u7d20i\u306bv\u3092\u8ffd\u52a0\u3059\u308b\n def add(self, i, v):\n x = self.member_dict[i]\n self.allsum += v\n while x < self.n + 1:\n self.bit[x] += v\n x += x & (-x)\n\n # \u4f4d\u7f6e0\u304b\u3089i\u307e\u3067\u306e\u548c(sum(bit[:i]))\u3092\u8a08\u7b97\u3059\u308b\n def sum(self, i):\n ret = 0\n x = i\n while x > 0:\n ret += self.bit[x]\n x -= x & (-x)\n return ret\n\n # \u4f4d\u7f6ei\u304b\u3089j\u307e\u3067\u306e\u548c(sum(bit[i:j]))\u3092\u8a08\u7b97\u3059\u308b\n def sum_range(self, i, j):\n return self.sum(j) - self.sum(i)\n\n # \u548c\u304cw\u4ee5\u4e0a\u3068\u306a\u308b\u6700\u5c0f\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u6c42\u3081\u308b\n def lowerbound(self, w):\n if w <= 0:\n return 0\n x, k = 0, self.maxbit\n while k:\n if x+k <= self.n and self.bit[x+k] < w:\n w -= self.bit[x+k]\n x += k\n k //= 2\n return x\n\n # v\u306b\u4e00\u756a\u8fd1\u3044v\u4ee5\u4e0a\u306e\u5024\u3092\u6c42\u3081\u308b\n def greater(self, v):\n if v > self.maxmember:\n return None\n p = self.sum(bl(self.member_list, v))\n if p == self.allsum:\n return None\n return self.member_list[self.lowerbound(p+1)]\n\n # v\u306b\u4e00\u756a\u8fd1\u3044v\u4ee5\u4e0b\u306e\u5024\u3092\u6c42\u3081\u308b\n def smaller(self, v):\n if v < self.minmember:\n return None\n b = bl(self.member_list, v)\n if b == self.n:\n b -= 1\n elif self.member_list[b] != v:\n b -= 1\n p = self.sum(b+1)\n if p == 0:\n return None\n return self.member_list[self.lowerbound(p)]\n\n r, c, n = list(map(int, input().split()))\n xyzw = [list(map(int, input().split())) for _ in [0]*n]\n outer = []\n for x, y, z, w in xyzw:\n if x in [0, r] or y in [0, c]:\n if z in [0, r] or w in [0, c]:\n if y == 0:\n p = x\n elif x == r:\n p = r+y\n elif y == c:\n p = 2*r+c-x\n else:\n p = 2*r+2*c-y\n if w == 0:\n q = z\n elif z == r:\n q = r+w\n elif w == c:\n q = 2*r+c-z\n else:\n q = 2*r+2*c-w\n if p > q:\n p, q = q, p\n outer.append((p, q))\n\n member = [i for i, j in outer]+[j for i, j in outer]+[-1]+[2*r+2*c+1]\n bit = BIT(member)\n bit.add(-1, 1)\n bit.add(2*r+2*c+1, 1)\n\n outer.sort(key=lambda x: x[0]-x[1])\n for a, b in outer:\n if bit.greater(a) < b:\n print(\"NO\")\n return\n bit.add(a, 1)\n bit.add(b, 1)\n print(\"YES\")\n\n\nmain()\n", "import sys\ninput = sys.stdin.readline\nimport math\n\n\"\"\"\n\u5185\u90e8\u306e\u70b9\u304c\u7d61\u3080\u3082\u306e\u306f\u3001\u66f2\u7dda\u3067\u7d50\u3093\u3067\u30db\u30e2\u30c8\u30d4\u30fc\u3067\u5909\u5f62\u3059\u308c\u3070\u3001\u7121\u8996\u3067\u304d\u308b\n\u5883\u754c\u306e2\u70b9\u3092\u7d50\u3076\u3082\u306e\u305f\u3061\u3060\u3051\u304c\u554f\u984c\n\"\"\"\n\nR,C,N = map(int,input().split())\npts = [] # \u89d2\u5ea6\u3001\u756a\u53f7\nis_inner = lambda x,y: 0 < x < R and 0 < y < C\nfor i in range(N):\n x1,y1,x2,y2 = map(int,input().split())\n if is_inner(x1,y1) or is_inner(x2,y2):\n continue\n pts.append((math.atan2(y1 - C/2, x1 - R/2),i))\n pts.append((math.atan2(y2 - C/2, x2 - R/2),i))\npts.sort()\n\narr = []\nfor _, i in pts:\n if arr and arr[-1] == i:\n arr.pop()\n continue\n arr.append(i)\n\nanswer = 'NO' if arr else 'YES'\nprint(answer)", "r, c, n = map(int, input().split())\ndots = []\nnum = 0\nfor i in range(n):\n\tx1, y1, x2, y2 = map(int, input().split())\n\tif (0 < x1 < r and 0 < y1 < c) or (0 < x2 < r and 0 < y2 < c):\n\t\tcontinue\n\telse:\n\t\tnum += 1\n\t\td1 = (x1, y1)\n\t\td2 = (x2, y2)\n\t\tif x1 == 0:\n\t\t\tdots.append((y1, i))\n\t\telif y1 == c:\n\t\t\tdots.append((c + x1, i))\n\t\telif x1 == r:\n\t\t\tdots.append((2 * c + r - y1, i))\n\t\telse:\n\t\t\tdots.append((2 * (r + c) - x1, i))\n\n\t\tif x2 == 0:\n\t\t\tdots.append((y2, i))\n\t\telif y2 == c:\n\t\t\tdots.append((c + x2, i))\n\t\telif x2 == r:\n\t\t\tdots.append((2 * c + r - y2, i))\n\t\telse:\n\t\t\tdots.append((2 * (r + c) - x2, i))\n\n#print(dots)\nif num <= 1:\n\tprint(\"YES\")\nelse:\n\tdots.sort(key=lambda x: x[0])\n\tstack = []\n\tfor i in range(num * 2):\n\t\tif stack == []:\n\t\t\tstack.append(dots[i][1])\n\t\telse:\n\t\t\tif stack[-1] == dots[i][1]:\n\t\t\t\tstack.pop()\n\t\t\telse:\n\t\t\t\tstack.append(dots[i][1])\n\tif stack:\n\t\tprint(\"NO\")\n\telse:\n\t\tprint(\"YES\")", "#!usr/bin/env python3\nfrom collections import defaultdict,deque\nfrom heapq import heappush, heappop\nimport sys\nimport math\nimport bisect\nimport random\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef I(): return int(sys.stdin.readline())\ndef LS():return [list(x) for x in sys.stdin.readline().split()]\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == \"\\n\":\n return res[:-1]\n return res\ndef IR(n):\n return [I() for i in range(n)]\ndef LIR(n):\n return [LI() for i in range(n)]\ndef SR(n):\n return [S() for i in range(n)]\ndef LSR(n):\n return [LS() for i in range(n)]\n\nsys.setrecursionlimit(1000000)\nmod = 1000000007\n\ndef solve():\n def check(x,y):\n return (x == 0)|(x == w)|(y == 0)|(y == h)\n\n w,h,n = LI()\n px0 = []\n pxw = []\n py0 = []\n pyh = []\n for i in range(1,n+1):\n x,y,s,t = LI()\n if check(x,y)&check(s,t):\n if x == 0:\n px0.append((y,i))\n elif x == w:\n pxw.append((-y,i))\n elif y == 0:\n py0.append((-x,i))\n else:\n pyh.append((x,i))\n if s == 0:\n px0.append((t,i))\n elif s == w:\n pxw.append((-t,i))\n elif t == 0:\n py0.append((-s,i))\n else:\n pyh.append((s,i))\n px0.sort()\n pxw.sort()\n py0.sort()\n pyh.sort()\n p = px0+pyh+pxw+py0\n q = deque()\n for x, i in p:\n if q:\n qi = q.pop()\n if qi != i:\n q.append(qi)\n q.append(i)\n else:\n q.append(i)\n if q:\n print(\"NO\")\n else:\n print(\"YES\")\n return\n\n#Solve\ndef __starting_point():\n solve()\n\n__starting_point()", "from collections import deque\nimport sys\ninput = sys.stdin.readline\n\n\nclass BIT():\n \"\"\"\u533a\u9593\u52a0\u7b97\u3001\u4e00\u70b9\u53d6\u5f97\u30af\u30a8\u30ea\u3092\u305d\u308c\u305e\u308cO(logN)\u3067\u7b54\u3048\u308b\n add: \u533a\u9593[l, r)\u306bval\u3092\u52a0\u3048\u308b\n get_val: i\u756a\u76ee\u306e\u5024\u3092\u6c42\u3081\u308b\n i, l, r\u306f0-indexed\n \"\"\"\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def _add(self, i, val):\n while i > 0:\n self.bit[i] += val\n i -= i & -i\n\n def get_val(self, i):\n \"\"\"i\u756a\u76ee\u306e\u5024\u3092\u6c42\u3081\u308b\"\"\"\n i = i + 1\n s = 0\n while i <= self.n:\n s += self.bit[i]\n i += i & -i\n return s\n\n def add(self, l, r, val):\n \"\"\"\u533a\u9593[l, r)\u306bval\u3092\u52a0\u3048\u308b\"\"\"\n self._add(r, val)\n self._add(l, -val)\n\n\nr, c, n = map(int, input().split())\ninfo = [list(map(int, input().split())) for i in range(n)]\n\ndef solve(x1, y1):\n if y1 == 0:\n return x1\n if x1 == r:\n return r + y1\n if y1 == c:\n return r + c + (r-x1)\n if x1 == 0:\n return r + c + r + (c-y1)\n\nli = []\nfor i in range(n):\n x1, y1, x2, y2 = info[i]\n if (x1 % r == 0 or y1 % c == 0) and (x2 % r == 0 or y2 % c == 0):\n pos1, pos2 = solve(x1, y1), solve(x2, y2)\n li.append((pos1, i))\n li.append((pos2, i))\n\nli = sorted(li)\nq = deque([])\nfor i in range(len(li)):\n _, j = li[i]\n if q and q[-1] == j:\n q.pop()\n else:\n q.append(j)\nif q:\n print(\"NO\")\nelse:\n print(\"YES\")", "#!/usr/bin/env python3\n\n\ndef add(bound, r, c, x, y, i):\n if x == 0:\n bound.append((0, y, i))\n elif y == c:\n bound.append((1, x, i))\n elif x == r:\n bound.append((2, c - y, i))\n else:\n bound.append((3, r - x, i))\n\n\ndef solve(bound):\n\n if not bound:\n return True\n\n bound.sort()\n st = [0] * len(bound)\n p = -1\n\n for _, _, i in bound:\n if 0 <= p and st[p] == i:\n p -= 1\n else:\n p += 1\n st[p] = i\n\n return p == -1\n\n\ndef main():\n r, c, n = input().split()\n r = int(r)\n c = int(c)\n n = int(n)\n bound = []\n for i in range(n):\n x1, y1, x2, y2 = input().split()\n x1 = int(x1)\n y1 = int(y1)\n x2 = int(x2)\n y2 = int(y2)\n if (x1 % r == 0 or y1 % c == 0) and (x2 % r == 0 or y2 % c == 0):\n add(bound, r, c, x1, y1, i)\n add(bound, r, c, x2, y2, i)\n\n\n print(('YES' if solve(bound) else 'NO'))\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "import random\nimport sys\ninput = sys.stdin.readline\n\n\nclass BIT():\n \"\"\"\u533a\u9593\u52a0\u7b97\u3001\u4e00\u70b9\u53d6\u5f97\u30af\u30a8\u30ea\u3092\u305d\u308c\u305e\u308cO(logN)\u3067\u7b54\u3048\u308b\n add: \u533a\u9593[l, r)\u306bval\u3092\u52a0\u3048\u308b\n get_val: i\u756a\u76ee\u306e\u5024\u3092\u6c42\u3081\u308b\n i, l, r\u306f0-indexed\n \"\"\"\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def _add(self, i, val):\n while i > 0:\n self.bit[i] += val\n i -= i & -i\n\n def get_val(self, i):\n \"\"\"i\u756a\u76ee\u306e\u5024\u3092\u6c42\u3081\u308b\"\"\"\n i = i + 1\n s = 0\n while i <= self.n:\n s += self.bit[i]\n i += i & -i\n return s\n\n def add(self, l, r, val):\n \"\"\"\u533a\u9593[l, r)\u306bval\u3092\u52a0\u3048\u308b\"\"\"\n self._add(r, val)\n self._add(l, -val)\n\n\nr, c, n = map(int, input().split())\ninfo = [list(map(int, input().split())) for i in range(n)]\n\ndef solve(x1, y1):\n if y1 == 0:\n return x1\n if x1 == r:\n return r + y1\n if y1 == c:\n return r + c + (r-x1)\n if x1 == 0:\n return r + c + r + (c-y1)\n\ndef compress(array):\n set_ = set([])\n for i in range(len(array)):\n a, b = array[i]\n set_.add(a)\n set_.add(b)\n memo = {value : index for index, value in enumerate(sorted(list(set_)))}\n max_ = 0\n for i in range(len(array)):\n array[i][0] = memo[array[i][0]]\n array[i][1] = memo[array[i][1]]\n max_ = max(max_, *array[i])\n return max_, array\n\nquery = []\nfor i in range(n):\n x1, y1, x2, y2 = info[i]\n if (x1 % r == 0 or y1 % c == 0) and (x2 % r == 0 or y2 % c == 0):\n pos1, pos2 = solve(x1, y1), solve(x2, y2)\n if pos1 > pos2:\n pos1, pos2 = pos2, pos1\n query.append([pos1, pos2 + 1])\n\nm, query = compress(query)\nbit = BIT(m) \nfor i in range(len(query)):\n begin, end = query[i]\n if bit.get_val(begin) != bit.get_val(end - 1):\n print(\"NO\")\n return\n tmp = random.randrange(0, 10**18)\n bit.add(begin, end, tmp)\nprint(\"YES\")", "def ri(): return int(input())\ndef rli(): return list(map(int, input().split()))\ndef rls(): return list(input())\ndef pli(a): return \"\".join(list(map(str, a)))\n\n\nR, C, N = rli()\nlis = []\nidx = 0\ni = 0\nfor j in range(N):\n x1, y1, x2, y2 = rli()\n if((x1 % R == 0 or y1 % C == 0) and (x2 % R == 0 or y2 % C == 0)):\n i += 1\n for _ in range(2):\n if(y1 == 0):\n lis.append([x1, i])\n elif(x1 == R):\n lis.append([R+y1, i])\n elif(y1 == C):\n lis.append([2*R+C-x1, i])\n elif(x1 == 0):\n lis.append([2*R+2*C-y1, i])\n x1 = x2\n y1 = y2\nlis.sort()\nstack = []\nexist = [False for _ in range(2*i)]\nans = True\nfor k in range(2*i):\n if(exist[lis[k][1]]):\n if(lis[k][1] != stack.pop()):\n ans = False\n break\n exist[lis[k][1]] = False\n else:\n stack.append(lis[k][1])\n exist[lis[k][1]] = True\nif(ans):\n print(\"YES\")\nelse:\n print(\"NO\")\n", "\ndef hantei(x,y):\n\n if y == 0:\n return \"l\"\n elif x == R:\n return \"d\"\n elif y == C:\n return \"r\"\n elif x == 0:\n return \"u\"\n\n return \"n\"\n\nR,C,N = list(map(int,input().split()))\n\nu = []\nl = []\nd = []\nr = []\n\nfor i in range(N):\n\n X1,Y1,X2,Y2 = list(map(int,input().split()))\n\n if hantei(X1,Y1) != \"n\" and hantei(X2,Y2) != \"n\":\n\n\n if hantei(X1,Y1) == \"l\":\n l.append([X1,Y1,i])\n elif hantei(X1,Y1) == \"d\":\n d.append([X1,Y1,i])\n elif hantei(X1,Y1) == \"r\":\n r.append([X1,Y1,i])\n elif hantei(X1,Y1) == \"u\":\n u.append([X1,Y1,i])\n\n X1 = X2\n Y1 = Y2\n \n if hantei(X1,Y1) == \"l\":\n l.append([X1,Y1,i])\n elif hantei(X1,Y1) == \"d\":\n d.append([X1,Y1,i])\n elif hantei(X1,Y1) == \"r\":\n r.append([X1,Y1,i])\n elif hantei(X1,Y1) == \"u\":\n u.append([X1,Y1,i])\n\nl.sort()\nd.sort()\nr.sort()\nr.reverse()\nu.sort()\nu.reverse()\n\nps = []\nfor i in l:\n ps.append(i[2])\nfor i in d:\n ps.append(i[2])\nfor i in r:\n ps.append(i[2])\nfor i in u:\n ps.append(i[2])\n\nq = []\n\nfor i in ps:\n if len(q) > 0 and q[-1] == i:\n del q[-1]\n else:\n q.append(i)\n\nif len(q) == 0:\n print (\"YES\")\nelse:\n print (\"NO\")\n\n", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\ndef main():\n h, w, n = MI()\n points = []\n cnt = 0\n # 2\u70b9\u3068\u3082\u5468\u4e0a\u306b\u3042\u308b\u7d44\u306e\u307f\u6b8b\u3059\n # \u539f\u70b9\uff08\u5de6\u4e0a\uff09\u304b\u3089\u53cd\u6642\u8a08\u56de\u308a\u306b\u79fb\u52d5\u3057\u305f\u8ddd\u96e2\u3068\u70b9\u306e\u901a\u3057\u756a\u53f7\u3092\u8a18\u9332\n for _ in range(n):\n i0, j0, i1, j1 = MI()\n if (0 < i0 < h and 0 < j0 < w) or (0 < i1 < h and 0 < j1 < w): continue\n for i, j in [(i0, j0), (i1, j1)]:\n if j == 0 or i == h:\n d = i + j\n else:\n d = 2 * (h + w) - i - j\n points.append([d, cnt])\n cnt += 1\n points.sort()\n first = [True] * cnt\n visited = []\n # ABAB\u306e\u3088\u3046\u306b\uff12\u3064\u306e\u533a\u9593\u304c\u305a\u308c\u3066\u91cd\u306a\u3063\u3066\u3044\u305f\u3089NO\n # ABBA\u306e\u3088\u3046\u306b\u5b8c\u5168\u306b\u542b\u307e\u308c\u308b\u306e\u306f\u30bb\u30fc\u30d5\n for d, pi in points:\n if first[pi]:\n visited.append(pi)\n first[pi] = False\n else:\n last_pi = visited.pop()\n if pi != last_pi:\n print(\"NO\")\n return\n print(\"YES\")\n\nmain()\n", "r,c,n = map(int,input().split())\na = [list(map(int, input().split())) for _ in range(n)]\niru = []\nfor i in range(n):\n if ((a[i][0] == 0 or a[i][0] == r or a[i][1] == 0 or a[i][1] == c) and (a[i][2] == 0 or a[i][2] == r or a[i][3] == 0 or a[i][3] == c)):\n b = a[i]\n b1 = [b[0],b[1]]\n b2 = [b[2],b[3]]\n if b1[0] == 0:\n b1 = b1[1]\n elif b1[1] == c:\n b1 = b1[0] + b1[1]\n elif b1[0] == r:\n b1 = c +r+c -b1[1]\n else:\n b1 = c*2 + r*2 - b1[0]\n \n if b2[0] == 0:\n b2 = b2[1]\n elif b2[1] == c:\n b2 = b2[0] + b2[1]\n elif b2[0] == r:\n b2 = c*2 +r -b2[1]\n else:\n b2 = c*2 + r*2 - b2[0]\n if b1 > b2:\n tmp = b1 +0\n b1 = b2 +0\n b2 = tmp + 0\n iru.append([b1,b2])\niru = sorted(iru)\nato = 0\nstack = [r+r+c+c]\nflag = 'YES'\nfor a,b in iru:\n while a >= stack[-1]:\n stack.pop()\n \n if b > stack[-1]:\n flag = 'NO'\n break\n else:\n stack.append(b)\n \nprint(flag)", "import cmath\n\n\nr, c, n = map(int, input().split())\nlis = []\n\n\nfor i in range(n):\n x1, y1, x2, y2 = map(int, input().split())\n if (0 < x1 < r and 0 < y1 < c) or (0 < x2 < r and 0 < y2 < c):\n continue\n else:\n lis.append((i, x1 - r / 2 + (y1 - c / 2) * 1j))\n lis.append((i, x2 - r / 2 + (y2 - c / 2) * 1j))\n\n\nlis.sort(key=lambda x: cmath.phase(x[1]))\nstack = []\n\n\nfor i in lis:\n if stack == [] or stack[-1] != i[0]:\n stack.append(i[0])\n else:\n stack.pop()\n\n \nif stack == []:\n print(\"YES\")\nelse:\n print(\"NO\")", "r, c, n = list(map(int, input().split()))\n\np = []\nfor i in range(n):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if x1 == 0 or x1 == r or y1 == 0 or y1 == c:\n if x2 == 0 or x2 == r or y2 == 0 or y2 == c:\n if y1 == 0:\n p.append([x1, i])\n elif x1 == r:\n p.append([r + y1, i])\n elif y1 == c:\n p.append([2 * r + c - x1, i])\n else:\n p.append([2 * r + 2 * c - y1, i])\n\n if y2 == 0:\n p.append([x2, i])\n elif x2 == r:\n p.append([r + y2, i])\n elif y2 == c:\n p.append([2 * r + c - x2, i])\n else:\n p.append([2 * r + 2 * c - y2, i])\n\np.sort()\n\nt = []\n\nold = -1\nfor i in range(0, len(p)):\n temp = p[i][1]\n\n if temp == old:\n t.pop()\n if len(t) == 0:\n old = -1\n else:\n old = t[-1]\n else:\n t.append(temp)\n old = temp\nif len(t) > 0:\n print(\"NO\")\nelse:\n print(\"YES\")\n", "R, C, N = map(int, input().split())\n\npts = [tuple(map(int, input().split())) for _ in range(N)]\n\ndef on_boundary(x1, y1):\n return (x1 == 0 or x1 == R or y1 == 0 or y1 == C)\n\ndef perim_until(x, y):\n if x == 0:\n return y\n if y == C:\n return C + x\n if x == R:\n return R + C + (C - y)\n if y == 0:\n return R + C + C + (R - x)\n return -1\n\nperimpts = []\nfor i, pt in enumerate(pts):\n x1, y1, x2, y2 = pt\n if on_boundary(x1, y1) and on_boundary(x2, y2):\n per1, per2 = perim_until(x1, y1), perim_until(x2, y2)\n perimpts.append((per1, i))\n perimpts.append((per2, i))\n\nperimpts.sort()\ndef solve():\n stack = []\n seen = [False for _ in range(N)]\n for ppt in perimpts:\n _, ind = ppt\n if seen[ind]:\n if stack[-1] != ind:\n print(\"NO\")\n return\n stack.pop()\n else:\n seen[ind] = True\n stack.append(ind)\n print(\"YES\")\n \nsolve()", "def f(r,c):\n if c==0: return r\n elif c==C: return R+C+(R-r)\n elif r==0: return R*2+C+(C-c)\n elif r==R: return R+c\n else: return -1\n\nimport sys\ninput = sys.stdin.readline\nR,C,N=map(int, input().split())\nQ=[]\nl=1\nfor i in range(N):\n r0,c0,r1,c1=map(int, input().split())\n if f(r0,c0) != -1 and f(r1,c1) != -1:\n s,t=f(r0,c0),f(r1,c1)\n if s>t: s,t=t,s\n Q.append((s,l))\n Q.append((t,-l))\n l+=1\nQ.sort(key=lambda x:x[0])\nflg=True\nR=[]\nfor _, q in Q:\n if q>0:\n R.append(q)\n elif q<0:\n if not R: flg=False; break\n p=R.pop()\n if -p!=q: flg=False; break\nprint(\"YES\" if flg else \"NO\")", "R,C,N=list(map(int,input().split()))\npoints=[list(map(int,input().split())) for i in range(N)]\ndef circ(x,y):\n if y==0:\n return x\n elif x==R:\n return y+R\n elif y==C:\n return R+C+R-x\n elif x==0:\n return R+C+R+C-y\n else:\n return -1\n\nL=[]\nfor i in range(N):\n x1,y1,x2,y2=points[i]\n if circ(x1,y1)==-1 or circ(x2,y2)==-1:\n continue\n L.append((circ(x1,y1),i))\n L.append((circ(x2,y2),i))\n#board=[[circ(x,y) for y in range(C+1)] for x in range(R+1)]\nR=[s[1] for s in sorted(L)]\nX=[]\nfor i in R:\n if len(X)==0:\n X.append(i)\n else:\n if X[-1]==i:\n X.pop()\n else:\n X.append(i)\nif len(X)==0:\n print(\"YES\")\nelse:\n print(\"NO\")\n", "R, C, N = list(map(int, input().split()))\n\npoints = []\n\ndef dist(x, y):\n if x == 0:\n return R * 2 + C + (C - y)\n if x == R:\n return R + y\n if y == 0:\n return x\n if y == C:\n return R + C + (R - x)\n\nfor i in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if ((x1 == 0 or x1 == R) or (y1 == 0 or y1 == C)) and ((x2 == 0 or x2 == R) or (y2 == 0 or y2 == C)):\n points.append((i + 1, dist(x1, y1)))\n points.append((i + 1, dist(x2, y2)))\npoints.sort(key=lambda p: p[1])\nl = []\nfor point in points:\n if len(l) == 0:\n l.append(point[0])\n continue\n if point[0] == l[-1]:\n l.pop()\n else:\n l.append(point[0])\nif len(l) == 0:\n print(\"YES\")\nelse:\n print(\"NO\")\n", "w, h, n = list(map(int, input().split()))\n\npos = []\nfor i in range(n):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if (x1 in [0, w] or y1 in [0, h]) and (x2 in [0, w] or y2 in [0, h]):\n pos.append((x1, y1, i))\n pos.append((x2, y2, i))\n\npos.sort(key=lambda v: v[0]) # top \u2192\nedge = [v[-1] for v in pos if v[1] == 0 and v[0] != 0]\n\npos.sort(key=lambda v: v[1]) # left \u2193\nedge += [v[-1] for v in pos if v[0] == w and v[1] != 0]\n\npos.sort(key=lambda v: v[0], reverse=True) # bottom \u2190\nedge += [v[-1] for v in pos if v[1] == h and v[0] != w]\n\npos.sort(key=lambda v: v[1], reverse=True) # right \u2191\nedge += [v[-1] for v in pos if v[0] == 0 and v[1] != h]\n\n# for i in range(len(edge) - 1):\n# if edge[i] == edge[i + 1]:\n# break\n# for j in range(len(edge) // 2):\n# if edge[(i + j + 1) % n] != edge[(i - j + n) % n]:\n# print(\"NO\")\n# break\n# else:\n# print(\"YES\")\n\n# print(edge)\nhist = [None] * n\nstep = 0\nfor v in edge:\n if hist[v] is None:\n hist[v] = step + 1\n step += 1\n else:\n if hist[v] != step:\n print(\"NO\")\n break\n step -= 1\nelse:\n print(\"YES\")\n\n", "def inpl(): return [int(i) for i in input().split()]\n\nR, C, N = inpl()\nloopx = {0: [], R: []}\nloopy = {0: [], C: []}\nfor i in range(N):\n x1, y1, x2, y2 = inpl() \n if (x1 in (0,R) or y1 in (0,C))\\\n and (x2 in (0,R) or y2 in (0,C)):\n if x1 in (0,R):\n loopx[x1].append((y1,i))\n elif y1 in (0,C):\n loopy[y1].append((x1,i))\n if x2 in (0,R):\n loopx[x2].append((y2,i))\n elif y2 in (0,C):\n loopy[y2].append((x2,i))\nloop = [j for i, j in sorted(loopy[0])] +\\\n[j for i, j in sorted(loopx[R])] +\\\n[j for i, j in sorted(loopy[C])][::-1] +\\\n[j for i, j in sorted(loopx[0])][::-1]\nstack = []\nfor i in loop:\n if not stack:\n stack.append(i)\n continue\n if stack[-1] == i:\n stack.pop()\n else:\n stack.append(i)\nif not stack:\n print('YES')\nelse:\n print('NO')", "R, C, n = list(map(int, input().split()))\nx1 = []\ny1 = []\nx2 = []\ny2 = []\nfor i in range(n): \n xx1, yy1, xx2, yy2 = list(map(int, input().split()))\n x1.append(xx1)\n y1.append(yy1)\n x2.append(xx2)\n y2.append(yy2)\n\nt = []\nb = []\nl = []\nr = []\n\ndef add(x, y, i):\n if x == 0:\n t.append((i, y))\n elif x == R:\n b.append((i, y))\n elif y == 0:\n l.append((i, x))\n elif y == C:\n r.append((i, x))\n\n\nfor i in range(n):\n add(x1[i], y1[i], i)\n add(x2[i], y2[i], i)\n\nt = sorted(t, key=lambda x : x[1]) \nr = sorted(r, key=lambda x : x[1])\nb = sorted(b, key=lambda x : x[1], reverse=True)\nl = sorted(l, key=lambda x : x[1], reverse=True)\n\nlis = []\nlis.extend(t)\nlis.extend(r)\nlis.extend(b)\nlis.extend(l)\n\nlis = [x[0] for x in lis]\n\ncnt = {}\nfor i in lis:\n if not i in cnt:\n cnt[i] = 0\n cnt[i] += 1\n\nlis = [x for x in lis if cnt[x] == 2]\n\nstk = []\nfor i in lis:\n if len(stk) == 0 or stk[-1] != i:\n stk.append(i)\n else:\n stk.pop()\n\nif len(stk) == 0:\n print(\"YES\")\nelse:\n print(\"NO\")\n", "import sys\ninput = sys.stdin.readline\n\nR, C, N = map(int, input().split())\nright = []\ntop = []\nleft = []\nbottom = []\nfor i in range(N):\n x1, y1, x2, y2 = map(int, input().split())\n # if both points are on the edge\n if (x1 in (0, R) or y1 in (0, C)) and (x2 in (0, R) or y2 in (0, C)):\n if x1 == 0:\n top.append((y1, i))\n elif x1 == R:\n bottom.append((y1, i))\n elif y1 == 0:\n left.append((x1, i))\n elif y1 == C:\n right.append((x1, i))\n\n if x2 == 0:\n top.append((y2, i))\n elif x2 == R:\n bottom.append((y2, i))\n elif y2 == 0:\n left.append((x2, i))\n elif y2 == C:\n right.append((x2, i))\nleft.sort(key=lambda p: p[0])\nbottom.sort(key=lambda p: p[0])\nright.sort(key=lambda p: -p[0])\ntop.sort(key=lambda p: -p[0])\npoints = left + bottom + right + top\nstack = []\nfor x, i in points:\n if not stack or stack[-1] != i:\n stack.append(i)\n else:\n stack.pop()\nprint('NO' if stack else 'YES')", "def main():\n from bisect import bisect_left as bl\n\n class BIT():\n def __init__(self, member):\n self.member_list = sorted(member)\n self.member_dict = {v: i+1 for i, v in enumerate(self.member_list)}\n self.n = len(member)\n self.maxmember = self.member_list[-1]\n self.minmember = self.member_list[0]\n self.maxbit = 2**(len(bin(self.n))-3)\n self.bit = [0]*(self.n+1)\n self.allsum = 0\n\n # \u8981\u7d20i\u306bv\u3092\u8ffd\u52a0\u3059\u308b\n def add(self, i, v):\n x = self.member_dict[i]\n self.allsum += v\n while x < self.n + 1:\n self.bit[x] += v\n x += x & (-x)\n\n # \u4f4d\u7f6e0\u304b\u3089i\u307e\u3067\u306e\u548c(sum(bit[:i]))\u3092\u8a08\u7b97\u3059\u308b\n def sum(self, i):\n ret = 0\n x = i\n while x > 0:\n ret += self.bit[x]\n x -= x & (-x)\n return ret\n\n # \u4f4d\u7f6ei\u304b\u3089j\u307e\u3067\u306e\u548c(sum(bit[i:j]))\u3092\u8a08\u7b97\u3059\u308b\n def sum_range(self, i, j):\n return self.sum(j) - self.sum(i)\n\n # \u548c\u304cw\u4ee5\u4e0a\u3068\u306a\u308b\u6700\u5c0f\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u6c42\u3081\u308b\n def lowerbound(self, w):\n if w <= 0:\n return 0\n x, k = 0, self.maxbit\n while k:\n if x+k <= self.n and self.bit[x+k] < w:\n w -= self.bit[x+k]\n x += k\n k //= 2\n return x\n\n # v\u306b\u4e00\u756a\u8fd1\u3044v\u4ee5\u4e0a\u306e\u5024\u3092\u6c42\u3081\u308b\n def greater(self, v):\n if v > self.maxmember:\n return None\n p = self.sum(bl(self.member_list, v))\n if p == self.allsum:\n return None\n return self.member_list[self.lowerbound(p+1)]\n\n # v\u306b\u4e00\u756a\u8fd1\u3044v\u4ee5\u4e0b\u306e\u5024\u3092\u6c42\u3081\u308b\n def smaller(self, v):\n if v < self.minmember:\n return None\n b = bl(self.member_list, v)\n if b == self.n:\n b -= 1\n elif self.member_list[b] != v:\n b -= 1\n p = self.sum(b+1)\n if p == 0:\n return None\n return self.member_list[self.lowerbound(p)]\n\n r, c, n = list(map(int, input().split()))\n xyzw = [list(map(int, input().split())) for _ in [0]*n]\n outer = []\n for x, y, z, w in xyzw:\n if x in [0, r] or y in [0, c]:\n if z in [0, r] or w in [0, c]:\n if y == 0:\n p = x\n elif x == r:\n p = r+y\n elif y == c:\n p = 2*r+c-x\n else:\n p = 2*r+2*c-y\n if w == 0:\n q = z\n elif z == r:\n q = r+w\n elif w == c:\n q = 2*r+c-z\n else:\n q = 2*r+2*c-w\n if p > q:\n p, q = q, p\n outer.append((p, q))\n\n member = [i for i, j in outer]+[j for i, j in outer]+[-1]+[2*r+2*c+1]\n bit = BIT(member)\n bit.add(-1, 1)\n bit.add(2*r+2*c+1, 1)\n\n outer.sort(key=lambda x: x[0]-x[1])\n for a, b in outer:\n if bit.greater(a) < b:\n print(\"NO\")\n return\n bit.add(a, 1)\n bit.add(b, 1)\n print(\"YES\")\n\n\nmain()\n", "R, C, N = map(int, input().split())\nedge = []\n\n\ndef F(x, y):\n if x == 0:\n return y\n if y == C:\n return C + x\n if x == R:\n return R + C * 2 - y\n if y == 0:\n return 2 * R + 2 * C - x\n return -1\n\n\nfor i in range(1, N + 1):\n x1, y1, x2, y2 = map(int, input().split())\n d1 = F(x1, y1)\n d2 = F(x2, y2)\n if d1 < 0:\n continue\n if d2 < 0:\n continue\n edge.append((d1, i))\n edge.append((d2, i))\n\nedge.sort()\nstack = []\nused = [False] * (N + 1)\n\nans = \"YES\"\nfor _, x in edge:\n if not used[x]:\n used[x] = True\n stack.append(x)\n else:\n y = stack.pop()\n if x != y:\n ans = \"NO\"\n break\n\nprint(ans)", "R, C, N = list(map(int, input().split()))\ndef calc(x, y):\n if x == 0 or y == C:\n return x + y\n return 2*R + 2*C - x - y\nA = {}\nfor i in range(N):\n x1, y1, x2, y2 = list(map(int, input().split()))\n if not ((x1 in [0, R] or y1 in [0, C]) and (x2 in [0, R] or y2 in [0, C])):\n continue\n A[calc(x1, y1)] = i\n A[calc(x2, y2)] = i\n\nst = []\nfor i, a in sorted(A.items()):\n if st and st[-1] == a:\n st.pop()\n elif a is not None:\n st.append(a)\nprint(('YES' if not st else 'NO'))\n"] | {"inputs": ["4 2 3\n0 1 3 1\n1 1 4 1\n2 0 2 2\n", "2 2 4\n0 0 2 2\n2 0 0 1\n0 2 1 2\n1 1 2 1\n", "5 5 7\n0 0 2 4\n2 3 4 5\n3 5 5 2\n5 5 5 4\n0 3 5 1\n2 2 4 4\n0 5 4 1\n", "1 1 2\n0 0 1 1\n1 0 0 1\n"], "outputs": ["YES\n", "NO\n", "YES\n", "NO\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 81,236 | |
f0fc08fff231b208311a3a4db6ecaa3e | UNKNOWN | You are given a string S consisting of a,b and c. Find the number of strings that can be possibly obtained by repeatedly performing the following operation zero or more times, modulo 998244353:
- Choose an integer i such that 1\leq i\leq |S|-1 and the i-th and (i+1)-th characters in S are different. Replace each of the i-th and (i+1)-th characters in S with the character that differs from both of them (among a, b and c).
-----Constraints-----
- 2 \leq |S| \leq 2 × 10^5
- S consists of a, b and c.
-----Input-----
Input is given from Standard Input in the following format:
S
-----Output-----
Print the number of strings that can be possibly obtained by repeatedly performing the operation, modulo 998244353.
-----Sample Input-----
abc
-----Sample Output-----
3
abc, aaa and ccc can be obtained. | ["#!/usr/bin/env python3\n\n\nM = 998244353\n\ndef powmod(a, x, m = M):\n y = 1\n while 0 < x:\n if x % 2 == 1:\n y *= a\n y %= m\n x //= 2\n a = a ** 2\n a %= m\n\n return y\n\n\ndef solve(s):\n n = len(s)\n\n nb = nc = 0\n ch = s[0]\n if ch == 'b':\n nb += 1\n elif ch == 'c':\n nc += 1\n sf = True\n tf = True\n left = ch\n for ch in s[1:]:\n if ch == 'b':\n nb += 1\n elif ch == 'c':\n nc += 1\n if ch == left:\n sf = False\n else:\n tf = False\n left = ch\n\n\n if tf:\n return 1\n if n == 3:\n if (nb + nc * 2) % 3:\n return 7 if sf else 6\n else:\n return 3\n if n % 3:\n return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M\n else:\n if (nb + nc * 2) % 3:\n return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M\n else:\n return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M\n\ndef main():\n s = input()\n\n print((solve(s)))\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "import itertools\n\nS = input()\nN = len(S)\nif all(S[0] == c for c in S):\n print((1))\n return\nif N == 2:\n print((1 if S[0]==S[1] else 2))\n return\n\nif N == 3:\n def another(a,b):\n s = set('abc')\n s -= set([a,b])\n return list(s)[0]\n ptn = set()\n stack = [S]\n while stack:\n a = stack.pop()\n ptn.add(a)\n if a[0] != a[1]:\n b = another(a[0],a[1])*2 + a[2]\n if not b in ptn:\n stack.append(b)\n if a[1] != a[2]:\n c = a[0] + another(a[1],a[2])*2\n if not c in ptn:\n stack.append(c)\n print((len(ptn)))\n return\n\n#N >= 4\nMOD = 998244353\ndp = [[[0 for u in range(2)] for l in range(3)] for s in range(3)]\n#dp[sum%3][last][exist'xx'?]\nfor ptn in itertools.product(list(range(3)),repeat=4):\n seq = (ptn[0]==ptn[1] or ptn[1]==ptn[2] or ptn[2]==ptn[3])\n dp[sum(ptn)%3][ptn[3]][seq] += 1\n\nfor n in range(4,N):\n dp2 = [[[0 for u in range(2)] for l in range(3)] for s in range(3)]\n for s in range(3):\n for l in range(3):\n for u in range(2):\n for l2 in range(3):\n s2 = (s+l2)%3\n u2 = u or l==l2\n dp2[s2][l2][u2] += dp[s][l][u]\n dp2[s2][l2][u2] %= MOD\n dp = dp2\n\nsm = 0\nfor c in S:\n sm += ord(c) - ord('a')\nseq = False\nfor c1,c2 in zip(S,S[1:]):\n if c1 == c2:\n seq = True\n break\nans = sum([dp[sm%3][i][1] for i in range(3)])\nif not seq: ans += 1\nprint((ans % MOD))\n", "def solve(s):\n if all(a == b for a, b in zip(s, s[1:])):\n return 1\n if len(s) == 2:\n return 2\n elif len(s) == 3:\n if s[0] == s[1] or s[1] == s[2]:\n return 6\n elif s[0] == s[2]:\n return 7\n else:\n return 3\n # dp[has succession=0][mod 3][last char], dp[has succession=1][mod 3]\n dp = [[[0] * 3 for _ in range(3)], [0] * 3]\n dp[0][0][0] = 1\n dp[0][1][1] = 1\n dp[0][2][2] = 1\n MOD = 998244353\n for _ in range(len(s) - 1):\n ndp = [[[0] * 3 for _ in range(3)], [0] * 3]\n dp0, dp1 = dp\n ndp0, ndp1 = ndp\n sdp1 = sum(dp1)\n ndp0[0][0] = (dp0[0][1] + dp0[0][2]) % MOD\n ndp0[1][0] = (dp0[1][1] + dp0[1][2]) % MOD\n ndp0[2][0] = (dp0[2][1] + dp0[2][2]) % MOD\n ndp0[0][1] = (dp0[2][0] + dp0[2][2]) % MOD\n ndp0[1][1] = (dp0[0][0] + dp0[0][2]) % MOD\n ndp0[2][1] = (dp0[1][0] + dp0[1][2]) % MOD\n ndp0[0][2] = (dp0[1][0] + dp0[1][1]) % MOD\n ndp0[1][2] = (dp0[2][0] + dp0[2][1]) % MOD\n ndp0[2][2] = (dp0[0][0] + dp0[0][1]) % MOD\n ndp1[0] = (dp0[0][0] + dp0[1][2] + dp0[2][1] + sdp1) % MOD\n ndp1[1] = (dp0[1][0] + dp0[2][2] + dp0[0][1] + sdp1) % MOD\n ndp1[2] = (dp0[2][0] + dp0[0][2] + dp0[1][1] + sdp1) % MOD\n dp = ndp\n return (dp[1][sum(map(ord, s)) % 3] + all(a != b for a, b in zip(s, s[1:]))) % MOD\n\n\ns = input()\nprint((solve(s)))\n", "def solve(s):\n if len(s) == 2:\n return 1 if s[0] == s[1] else 2\n elif len(s) == 3:\n if s[0] == s[1] == s[2]:\n return 1\n elif s[0] == s[1] or s[1] == s[2]:\n return 6\n elif s[0] == s[2]:\n return 7\n else:\n return 3\n if all(a == b for a, b in zip(s, s[1:])):\n return 1\n dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]\n dp[0][0][0] = 1\n dp[0][1][1] = 1\n dp[0][2][2] = 1\n MOD = 998244353\n for _ in range(len(s) - 1):\n ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]\n ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD\n ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD\n ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD\n ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD\n ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD\n ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD\n ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD\n ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD\n ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD\n ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD\n ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD\n ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD\n ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD\n ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD\n ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD\n ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD\n ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD\n ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD\n dp = ndp\n return (sum(dp[1][x][sum(map(ord, s)) % 3] for x in range(3)) + all(a != b for a, b in zip(s, s[1:]))) % MOD\n\n\ns = input()\nprint((solve(s)))\n", "def main():\n md = 998244353\n s = input()\n n = len(s)\n al = True # all\u3059\u3079\u3066\u540c\u3058\u6587\u5b57\n an = 1 # any\u9023\u7d9a\u304c\u5b58\u5728\u3059\u308b\u30680\n for c0, c1 in zip(s, s[1:]):\n if c0 == c1:\n an = 0\n else:\n al = False\n if an == 0 and not al: break\n if al:\n print((1))\n return\n if n == 2:\n print((2))\n return\n if n == 3:\n if s[0] == s[-1]:\n print((7))\n elif s[0] == s[1] or s[1] == s[2]:\n print((6))\n else:\n print((3))\n return\n #print(n)\n #print(an)\n ord0=ord(\"a\")\n r = sum(ord(c) - ord0 for c in s) % 3\n if n%3==0:\n d=pow(2,n//3-1,md)\n if r==0:\n an-=d*2\n else:\n an+=d\n print(((pow(3, n - 1, md) - pow(2, n - 1, md) + an) % md))\n\nmain()\n", "def solve(s):\n if all(a == b for a, b in zip(s, s[1:])):\n return 1\n if len(s) == 2:\n return 2\n elif len(s) == 3:\n if s[0] == s[1] or s[1] == s[2]:\n return 6\n elif s[0] == s[2]:\n return 7\n else:\n return 3\n # dp[has succession=0][mod 3][last char], dp[has succession=1][mod 3]\n dp = [[[0] * 3 for _ in range(3)], [0] * 3]\n dp[0][0][0] = 1\n dp[0][1][1] = 1\n dp[0][2][2] = 1\n MOD = 998244353\n for _ in range(len(s) - 1):\n ndp = [[[0] * 3 for _ in range(3)], [0] * 3]\n dp0, dp1 = dp\n ndp0, ndp1 = ndp\n sdp1 = sum(dp1)\n ndp0[0][0] = (dp0[0][1] + dp0[0][2]) % MOD\n ndp0[1][0] = (dp0[1][1] + dp0[1][2]) % MOD\n ndp0[2][0] = (dp0[2][1] + dp0[2][2]) % MOD\n ndp0[0][1] = (dp0[2][0] + dp0[2][2]) % MOD\n ndp0[1][1] = (dp0[0][0] + dp0[0][2]) % MOD\n ndp0[2][1] = (dp0[1][0] + dp0[1][2]) % MOD\n ndp0[0][2] = (dp0[1][0] + dp0[1][1]) % MOD\n ndp0[1][2] = (dp0[2][0] + dp0[2][1]) % MOD\n ndp0[2][2] = (dp0[0][0] + dp0[0][1]) % MOD\n ndp1[0] = (dp0[0][0] + dp0[1][2] + dp0[2][1] + sdp1) % MOD\n ndp1[1] = (dp0[1][0] + dp0[2][2] + dp0[0][1] + sdp1) % MOD\n ndp1[2] = (dp0[2][0] + dp0[0][2] + dp0[1][1] + sdp1) % MOD\n dp = ndp\n return (dp[1][sum(map(ord, s)) % 3] + all(a != b for a, b in zip(s, s[1:]))) % MOD\n\n\ns = input()\nprint((solve(s)))\n", "import sys\ninput = sys.stdin.readline\n\nimport numpy as np\n\nMOD = 998244353\n\nS = input().rstrip()\n\narr = np.array(list(S.replace('a','0').replace('b','1').replace('c','2')),dtype=np.int32)\n\nif (arr == arr[0]).all():\n print(1)\n return\n\ndef solve_naive(S):\n se = set([S])\n q = [S]\n while q:\n S = q.pop()\n for i in range(len(S)-1):\n x,y = S[i:i+2]\n if x == y:\n continue\n for t in 'abc':\n if t != x and t != y:\n T = S[:i] + t+t + S[i+2:]\n if T not in se:\n q.append(T)\n se.add(T)\n return len(se)\n\nLS = len(S)\nif LS < 6:\n answer = solve_naive(S)\n print(answer)\n return\n\n# \u9069\u5f53\u306a\u5fc5\u8981\u6761\u4ef6\u306e\u3082\u3068\u5168\u90e8\u4f5c\u308c\u308b\n# mod 3\u4e0d\u5909\u91cf\nanswer = pow(3,LS-1,MOD)\n# \u540c\u4e00\u5024\u306e\u9023\u7d9a\u304c\u5b58\u5728\u3057\u306a\u3044\u3082\u306e\u3092\u9593\u5f15\u304f\nif LS%3 == 0:\n x,y = (3+MOD)//2,0\n for _ in range(LS//3):\n x,y = 4*x+4*y,2*x+6*y\n x %= MOD\n y %= MOD\n if arr.sum()%3 == 0:\n answer -= x\n else:\n answer -= y\nelse:\n answer -= pow(2,LS-1,MOD)\n# \u521d\u624b\u306b\u5b8c\u6210\u3057\u3066\u3044\u308b\u3084\u3064\u306f\u4f7f\u3063\u3066\u826f\u3044\nif (arr[:-1] != arr[1:]).all():\n answer += 1\n\nanswer %= MOD\nprint(answer)", "def main():\n a = input().strip()\n l = len(a)\n if l < 6:\n s = set()\n s.add(a)\n q = [a]\n oa = ord('a')\n while q:\n a = q.pop()\n for i in range(l - 1):\n if a[i] != a[i+1]:\n t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i+1]) - oa))\n na = a[:i] + t * 2 + a[i+2:]\n if na not in s:\n s.add(na)\n q.append(na)\n print(len(s))\n return\n t = a[0] * l\n if t == a:\n print(1)\n return\n x = 0\n for c in a:\n if c == 'b':\n x += 1\n elif c == 'c':\n x += 2\n ans = 0\n if all(a[i] != a[i+1] for i in range(l - 1)):\n ans += 1\n mod = 998244353\n dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)\n for i in range(l - 1):\n s = (dp[-1] + dp[-2] + dp[-3]) % mod\n dp = ((dp[3]+dp[6])%mod,(dp[4]+dp[7])%mod,(dp[5]+dp[8])%mod,(dp[2]+dp[8])%mod,(dp[0]+dp[6])%mod,(dp[1]+dp[7])%mod,(dp[1]+dp[4])%mod,(dp[2]+dp[5])%mod,(dp[0]+dp[3])%mod,(dp[0]+dp[5]+dp[7]+s)%mod,(dp[1]+dp[3]+dp[8]+s)%mod,(dp[2]+dp[4]+dp[6]+s)%mod)\n print((ans + dp[9+x%3]) % mod)\nmain()\n", "M=998244353\ns=input()\nn=len(s)-1\nv=sum(map(ord,s))\nr=pow(3,n,M)-pow(2,n,M)+pow(2,n//3,M)*(n%3==2)*(1-3*(v%3==0))+all(s[i]!=s[i+1]for i in range(n))-(v==294)\nif all(s[0]==k for k in s):r=1\nprint(r%M)", "from collections import defaultdict\nimport sys\nS=input()\nN=len(S)\nif N==3:\n if S[0]==S[1]:\n if S[1]==S[2]:\n print((1))\n else:\n print((6))\n else:\n if S[0]==S[2]:\n print((7))\n elif S[1]==S[2]:\n print((6))\n else:\n print((3))\n return\na=S[0]\nt=1\nfor i in range(N):\n if S[i]!=a:\n t=0\n break\nif t==1:\n print((1))\n return\n\nmod=998244353\nM=0\nfor s in S:\n if s=='b':\n M+=1\n elif s=='c':\n M+=2\n M%=3\ndp=[]\nfor i in range(2):\n for k in range(3):\n for l in range(3):\n dp.append((i,k,l))\ndd=[[[0]*3 for i in range(3)] for i in range(2)]\nfor i in range(3):\n dd[0][i][i]=1\nfor k in range(2,N+1):\n nd=[[[0]*3 for i in range(3)] for i in range(2)]\n for p in dp:\n con,moji,m=p\n n=dd[con][moji][m]\n #print(con,moji,m)\n if con==0:\n for k in range(3):\n if moji==k:\n nd[1][k][ (m + k) % 3] += n\n nd[1] [k ][(m + k) % 3] %=mod\n else:\n nd[0][k][(m+k)%3]+=n\n nd[0][ k] [(m+k) % 3] %=mod\n else:\n for k in range(3):\n nd[1][k][(m + k) % 3] += n\n nd[1][k][(m + k) % 3] %=mod\n #print(nd)\n dd=nd\nflag=1\nfor i in range(N-1):\n if S[i]==S[i+1]:\n flag=0\nans=flag\nfor k in range(3):\n ans+=dd[1][k][M]\n ans%=mod\nprint(ans)\n\n\n\n\n", "s = input()\nn = len(s)\nflg = 0\nfor i in range(1,n):\n if s[i-1] != s[i]:\n flg += 1\nif flg == 0:\n print(1)\n return\npar = (s.count(\"a\")+s.count(\"b\")*2+2)%3\ndp = [[0 for i in range(9)] for j in range(n)]\nmod = 998244353\ndp[0][0] = 1\ndp[0][4] = 1\ndp[0][8] = 1\nfor i in range(1,n):\n dp[i][0] = dp[i-1][5]+dp[i-1][8]\n dp[i][1] = dp[i-1][3]+dp[i-1][6]\n dp[i][2] = dp[i-1][4]+dp[i-1][7]\n dp[i][3] = dp[i-1][1]+dp[i-1][7]\n dp[i][4] = dp[i-1][2]+dp[i-1][8]\n dp[i][5] = dp[i-1][0]+dp[i-1][6]\n dp[i][6] = dp[i-1][0]+dp[i-1][3]\n dp[i][7] = dp[i-1][1]+dp[i-1][4]\n dp[i][8] = dp[i-1][2]+dp[i-1][5]\n for j in range(9):\n dp[i][j] %= mod\nans = pow(3,n-1,mod)-dp[-1][par]-dp[-1][par+3]-dp[-1][par+6]\nif flg == n-1:\n ans += 1\nif n == 3 and flg == n-1 and par == 2:\n ans -= 1\nprint(ans%mod)", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\ndef solve():\n s = input()\n n = len(s)\n if all(s[0] == k for k in s):\n return 1\n \n somesame = 0\n for j in range(n-1):\n if s[j] == s[j+1]:\n somesame = 1\n break\n\n x = [(ord(i)-1)%3 for i in s]\n v = sum(x)%3\n\n if n==2: return 2\n if n==3:\n if v==0: return 3\n if somesame==0:\n return 7\n else:\n return 6\n \n dp = [[1,0,0],[0,1,0],[0,0,1]]\n for _ in range(n-1):\n ndp = [[0]*3 for i in range(3)]\n for i in range(3):\n for j in range(3):\n for k in range(3):\n if k == j: continue\n ndp[(i+k)%3][k] += dp[i][j]\n ndp[(i+k)%3][k] %= MOD\n dp = ndp \n #for c in dp:\n # print(3**(_+1) - sum(c), end = \" \")\n #print(dp)\n \n c = pow(3,n-1,MOD) \n c -= sum(dp[v])\n if somesame==0:\n c += 1\n return c%MOD\n \n\n \nMOD = 998244353 \nprint(solve())\n\n\n\n\"\"\"\ndef check(n):\n from itertools import product\n res = 0\n for a in product(range(3),repeat=n):\n for j in range(n-1):\n if a[j] == a[j+1]: break\n else:\n continue\n #print(a)\n if sum(a)%3==0:\n res += 1\n print(res)\n\n\n\ndef check2(a):\n n = len(a)\n s = set()\n s.add(tuple(a))\n from random import randrange\n for _ in range(2000):\n co = a[:]\n for k in range(1000):\n i = randrange(0,n-1)\n if co[i] != co[i+1]:\n co[i] = co[i+1] = 2*(co[i]+co[i+1])%3\n s.add(tuple(co))\n if all(co[0] == k for k in co): break\n print(a)\n print(len(s),s) \n\n\n \ncheck(5)\n#check2([0,1,2,0,1,2])\n\n\n\"\"\"", "s = list(input())\n\nn = len(s)\n\na = [0] * n\n\nMOD = 998244353\n\nfor i in range(n):\n a[i] = ord(s[i]) - ord('a')\n\nif max(a) == min(a):\n print((1))\n return\nelif n == 3:\n def solver(m):\n x = m // 100\n y = ( m % 100 ) // 10\n z = m % 10\n if x != y:\n c = (3 - x - y) % 3\n temp = c * 110 + z\n if temp not in ans:\n ans.add(temp)\n solver(temp)\n if y != z:\n c = (3 - y - z) % 3\n temp = x * 100 + c * 11\n if temp not in ans:\n ans.add(temp)\n solver(temp)\n\n t = a[0] * 100 + a[1] * 10 + a[2]\n ans = set()\n ans.add(t)\n solver(t)\n print((len(ans)))\n return\nelif n == 2:\n print((2))\n return\n\ndp = [[0,0,0] for _ in range(3)]\n\ndp[0][0] = 1\ndp[1][1] = 1\ndp[2][2] = 1\n\nfor i in range(n-1):\n T = [[0,0,0] for _ in range(3)]\n T[0][0] = (dp[1][0] + dp[2][0]) % MOD\n T[0][1] = (dp[1][1] + dp[2][1]) % MOD\n T[0][2] = (dp[1][2] + dp[2][2]) % MOD\n T[1][0] = (dp[0][2] + dp[2][2]) % MOD\n T[1][1] = (dp[0][0] + dp[2][0]) % MOD\n T[1][2] = (dp[0][1] + dp[2][1]) % MOD\n T[2][0] = (dp[0][1] + dp[1][1]) % MOD\n T[2][1] = (dp[0][2] + dp[1][2]) % MOD\n T[2][2] = (dp[0][0] + dp[1][0]) % MOD\n dp, T = T, dp\n\nm = sum(a) % 3\n\nans = 3 ** (n-1) - (dp[0][m] + dp[1][m] + dp[2][m])\n\ncheck = 1\nfor i in range(n-1):\n if a[i] == a[i+1]:\n check = 0\n break\n\nans += check\n\n#print(dp, 2 ** (n-1))\n\nprint((ans % MOD))\n", "def solve(s):\n if all(a == b for a, b in zip(s, s[1:])):\n return 1\n if len(s) == 2:\n return 2\n elif len(s) == 3:\n if s[0] == s[1] or s[1] == s[2]:\n return 6\n elif s[0] == s[2]:\n return 7\n else:\n return 3\n # dp[has succession][mod 3][last char]\n dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]\n dp[0][0][0] = 1\n dp[0][1][1] = 1\n dp[0][2][2] = 1\n MOD = 998244353\n for _ in range(len(s) - 1):\n ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]\n dp0, dp1 = dp\n ndp0, ndp1 = ndp\n sdp10, sdp11, sdp12 = sum(dp1[0]), sum(dp1[1]), sum(dp1[2])\n ndp0[0][0] = (dp0[0][1] + dp0[0][2]) % MOD\n ndp0[1][0] = (dp0[1][1] + dp0[1][2]) % MOD\n ndp0[2][0] = (dp0[2][1] + dp0[2][2]) % MOD\n ndp0[0][1] = (dp0[2][0] + dp0[2][2]) % MOD\n ndp0[1][1] = (dp0[0][0] + dp0[0][2]) % MOD\n ndp0[2][1] = (dp0[1][0] + dp0[1][2]) % MOD\n ndp0[0][2] = (dp0[1][0] + dp0[1][1]) % MOD\n ndp0[1][2] = (dp0[2][0] + dp0[2][1]) % MOD\n ndp0[2][2] = (dp0[0][0] + dp0[0][1]) % MOD\n ndp1[0][0] = (dp0[0][0] + sdp10) % MOD\n ndp1[1][0] = (dp0[1][0] + sdp11) % MOD\n ndp1[2][0] = (dp0[2][0] + sdp12) % MOD\n ndp1[0][1] = (dp0[2][1] + sdp12) % MOD\n ndp1[1][1] = (dp0[0][1] + sdp10) % MOD\n ndp1[2][1] = (dp0[1][1] + sdp11) % MOD\n ndp1[0][2] = (dp0[1][2] + sdp11) % MOD\n ndp1[1][2] = (dp0[2][2] + sdp12) % MOD\n ndp1[2][2] = (dp0[0][2] + sdp10) % MOD\n dp = ndp\n return (sum(dp[1][sum(map(ord, s)) % 3]) + all(a != b for a, b in zip(s, s[1:]))) % MOD\n\n\ns = input()\nprint((solve(s)))\n", "def solve(s):\n if all(a == b for a, b in zip(s, s[1:])):\n return 1\n if len(s) == 2:\n return 2\n elif len(s) == 3:\n if s[0] == s[1] or s[1] == s[2]:\n return 6\n elif s[0] == s[2]:\n return 7\n else:\n return 3\n # dp[has succession=0][mod 3][last char], dp[has succession=1][mod 3]\n dp = [[[0] * 3 for _ in range(3)], [0] * 3]\n dp[0][0][0] = 1\n dp[0][1][1] = 1\n dp[0][2][2] = 1\n MOD = 998244353\n for _ in range(len(s) - 1):\n ndp = [[[0] * 3 for _ in range(3)], [0] * 3]\n dp0, dp1 = dp\n ndp0, ndp1 = ndp\n sdp1 = sum(dp1)\n ndp0[0][0] = (dp0[0][1] + dp0[0][2]) % MOD\n ndp0[1][0] = (dp0[1][1] + dp0[1][2]) % MOD\n ndp0[2][0] = (dp0[2][1] + dp0[2][2]) % MOD\n ndp0[0][1] = (dp0[2][0] + dp0[2][2]) % MOD\n ndp0[1][1] = (dp0[0][0] + dp0[0][2]) % MOD\n ndp0[2][1] = (dp0[1][0] + dp0[1][2]) % MOD\n ndp0[0][2] = (dp0[1][0] + dp0[1][1]) % MOD\n ndp0[1][2] = (dp0[2][0] + dp0[2][1]) % MOD\n ndp0[2][2] = (dp0[0][0] + dp0[0][1]) % MOD\n ndp1[0] = (dp0[0][0] + dp0[1][2] + dp0[2][1] + sdp1) % MOD\n ndp1[1] = (dp0[1][0] + dp0[2][2] + dp0[0][1] + sdp1) % MOD\n ndp1[2] = (dp0[2][0] + dp0[0][2] + dp0[1][1] + sdp1) % MOD\n dp = ndp\n return (dp[1][sum(map(ord, s)) % 3] + all(a != b for a, b in zip(s, s[1:]))) % MOD\n\n\ns = input()\nprint((solve(s)))\n", "M=998244353;s=input();n=len(s)-1;v=sum(map(ord,s));print((pow(3,n,M)-pow(2,n,M)+pow(2,n//3,M)*(n%3==2)*(1-3*(v%3==0))+all(s[i]!=s[i+1]for i in range(n))-(v==294)-1)*any(s[0]!=k for k in s)%M+1)", "def main():\n md = 998244353\n s = input()\n n = len(s)\n if s.count(s[0]) == n:\n print((1))\n return\n if n == 2:\n print((2))\n return\n if n == 3:\n if s[0] == s[-1]:\n print((7))\n elif s[0] == s[1] or s[1] == s[2]:\n print((6))\n else:\n print((3))\n return\n ord0 = ord(\"a\")\n a = [ord(c) - ord0 for c in s]\n r = sum(a) % 3\n dp = [[[[0] * 3 for _ in range(2)] for _ in range(3)] for _ in range(n)]\n for m in range(3):\n dp[0][m][0][m] = 1\n # print(a)\n # print(dp)\n for i in range(n - 1):\n for j in range(3):\n for k in range(2):\n for m in range(3):\n pre = dp[i][j][k][m] # i\u3051\u305f j\u4f59\u308a k\u9023\u7d9a\u6709\u7121 m\u524d\u306e\u4f4d\n for nm in range(3):\n nj = (j + nm) % 3\n if nm == m:\n dp[i + 1][nj][1][nm] = (dp[i + 1][nj][1][nm] + pre) % md\n else:\n dp[i + 1][nj][k][nm] = (dp[i + 1][nj][k][nm] + pre) % md\n d = 1\n for c0, c1 in zip(s, s[1:]):\n if c0 == c1:\n d = 0\n break\n print(((sum(dp[n - 1][r][1]) + d) % md))\n\nmain()\n", "from collections import Counter\nimport sys\nsys.setrecursionlimit(10**6)\n\nMOD = 998244353\n\nABC = \"abc\".index\n*S, = map(ABC, input())\nN = len(S)\n\ndef bruteforce(S):\n used = set()\n def dfs(s):\n key = tuple(s)\n if key in used:\n return\n used.add(key)\n for i in range(len(s)-1):\n if s[i] != s[i+1]:\n a = s[i]; b = s[i+1]\n s[i] = s[i+1] = 3 - a - b\n dfs(s)\n s[i] = a; s[i+1] = b\n dfs(S)\n return len(used)\n\nif len(S) <= 3:\n print(bruteforce(S))\nelse:\n c = Counter(S)\n if c[0] == N or c[1] == N or c[2] == N:\n print(1)\n else:\n P = [[[0,0] for i in range(3)] for j in range(3)]\n Q = [[[0,0] for i in range(3)] for j in range(3)]\n P[0][0][0] = P[1][1][0] = P[2][2][0] = 1\n for i in range(N-1):\n for p in range(3):\n for q in range(3):\n for r in range(2):\n Q[p][q][r] = 0\n for p in range(3):\n for q in range(3):\n for r in range(2):\n for k in range(3):\n Q[k][(q+k)%3][r | (p == k)] += P[p][q][r] % MOD\n P, Q = Q, P\n ans = 0\n r = sum(S) % 3\n for i in range(3):\n ans += P[i][r][1]\n if all(S[i] != S[i+1] for i in range(N-1)):\n ans += 1\n print(ans % MOD)"] | {"inputs": ["abc\n", "abbac\n", "babacabac\n", "ababacbcacbacacbcbbcbbacbaccacbacbacba\n"], "outputs": ["3\n", "65\n", "6310\n", "148010497\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 24,024 | |
fbd7f83cfed30e89370bb59cbf7aff04 | UNKNOWN | We have a graph with N vertices and M edges, and there are two people on the graph: Takahashi and Aoki.
The i-th edge connects Vertex U_i and Vertex V_i.
The time it takes to traverse this edge is D_i minutes, regardless of direction and who traverses the edge (Takahashi or Aoki).
Takahashi departs Vertex S and Aoki departs Vertex T at the same time. Takahashi travels to Vertex T and Aoki travels to Vertex S, both in the shortest time possible.
Find the number of the pairs of ways for Takahashi and Aoki to choose their shortest paths such that they never meet (at a vertex or on an edge) during the travel, modulo 10^9 + 7.
-----Constraints-----
- 1 \leq N \leq 100 000
- 1 \leq M \leq 200 000
- 1 \leq S, T \leq N
- S \neq T
- 1 \leq U_i, V_i \leq N (1 \leq i \leq M)
- 1 \leq D_i \leq 10^9 (1 \leq i \leq M)
- If i \neq j, then (U_i, V_i) \neq (U_j, V_j) and (U_i, V_i) \neq (V_j, U_j).
- U_i \neq V_i (1 \leq i \leq M)
- D_i are integers.
- The given graph is connected.
-----Input-----
Input is given from Standard Input in the following format:
N M
S T
U_1 V_1 D_1
U_2 V_2 D_2
:
U_M V_M D_M
-----Output-----
Print the answer.
-----Sample Input-----
4 4
1 3
1 2 1
2 3 1
3 4 1
4 1 1
-----Sample Output-----
2
There are two ways to choose shortest paths that satisfies the condition:
- Takahashi chooses the path 1 \rightarrow 2 \rightarrow 3, and Aoki chooses the path 3 \rightarrow 4 \rightarrow 1.
- Takahashi chooses the path 1 \rightarrow 4 \rightarrow 3, and Aoki chooses the path 3 \rightarrow 2 \rightarrow 1. | ["# ARC090E\n\ndef hoge():\n M = 10**9 + 7\n import sys\n input = lambda : sys.stdin.readline().rstrip()\n\n n, m = map(int, input().split())\n s, t = map(int, input().split())\n s -= 1\n t -= 1\n from collections import defaultdict\n ns = defaultdict(set)\n for i in range(m):\n u, v, d = map(int, input().split())\n ns[u-1].add((v-1, d))\n ns[v-1].add((u-1, d))\n \n def _dijkstra(N, s, Edge):\n import heapq\n geta = 10**15\n inf = geta\n dist = [inf] * N\n dist[s] = 0\n Q = [(0, s)]\n dp = [0]*N\n dp[s] = 1\n while Q:\n dn, vn = heapq.heappop(Q)\n if dn > dist[vn]:\n continue\n for vf, df in Edge[vn]:\n if dist[vn] + df < dist[vf]:\n dist[vf] = dist[vn] + df\n dp[vf] = dp[vn]\n heapq.heappush(Q, (dn + df,vf))\n elif dist[vn] + df == dist[vf]:\n dp[vf] = (dp[vf] + dp[vn]) % M\n return dist, dp\n\n def dijkstra(start):\n import heapq\n vals = [None] * n\n nums = [None] * n\n nums[start] = 1\n h = [(0, start)] # (\u8ddd\u96e2, \u30ce\u30fc\u30c9\u756a\u53f7)\n vals[start] = 0\n while h:\n val, u = heapq.heappop(h)\n for v, d in ns[u]:\n if vals[v] is None or vals[v]>val+d:\n vals[v] = val+d\n nums[v] = nums[u]\n heapq.heappush(h, (vals[v], v))\n elif vals[v] is not None and vals[v]==val+d:\n nums[v] = (nums[v] + nums[u]) % M\n return vals, nums\n \n vals1, nums1 = dijkstra(s)\n vals2, nums2 = dijkstra(t)\n \n T = vals1[t]\n\n c1 = 0 # \u9802\u70b9\u3067\u885d\u7a81\u3059\u308b\u30da\u30a2\u306e\u6570\n c2 = 0 # \u30a8\u30c3\u30b8(\u7aef\u70b9\u9664\u304f)\u3067\u885d\u7a81\u3059\u308b\u30da\u30a2\u306e\u6570\n \n for u in range(n):\n if 2*vals1[u]==T and 2*vals2[u]==T:\n c1 = (c1 + pow((nums1[u] * nums2[u]), 2, M)) % M\n for v,d in ns[u]:\n if (vals1[u]+d+vals2[v]==T) and (2*vals1[u] < T < 2*(vals1[u] + d)):\n c2 = (c2 + (nums1[u] * nums2[v])**2) % M\n print((nums1[t]*nums2[s] - (c1+c2)) % M)\nhoge()", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 10**9+7\ndd = [(-1,0),(0,1),(1,0),(0,-1)]\nddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\ndef main():\n n,m = LI()\n s,t = LI()\n e = collections.defaultdict(list)\n for _ in range(m):\n u,v,d = LI()\n e[u].append((v,d))\n e[v].append((u,d))\n\n def search(s,t):\n d = collections.defaultdict(lambda: inf)\n dc = collections.defaultdict(int)\n d[s] = 0\n dc[s] = 1\n q = []\n heapq.heappush(q, (0, s))\n v = collections.defaultdict(bool)\n while len(q):\n k, u = heapq.heappop(q)\n if v[u]:\n continue\n v[u] = True\n\n dc[u] %= mod\n if u == t:\n return (d,dc)\n\n uc = dc[u]\n\n for uv, ud in e[u]:\n if v[uv]:\n continue\n vd = k + ud\n if d[uv] < vd:\n continue\n if d[uv] > vd:\n d[uv] = vd\n dc[uv] = uc\n heapq.heappush(q, (vd, uv))\n elif d[uv] == vd:\n dc[uv] += uc\n\n return (d,dc)\n\n d1,dc1 = search(s,t)\n d2,dc2 = search(t,s)\n rd = d1[t]\n kk = rd / 2.0\n\n r = dc1[t] ** 2 % mod\n for k in list(d1.keys()):\n t = d1[k]\n c = dc1[k]\n if t > kk:\n continue\n if t == kk:\n if d2[k] == t:\n r -= pow(c,2,mod) * pow(dc2[k],2,mod) % mod\n continue\n\n for uv, ud in e[k]:\n if d2[uv] >= kk or t + ud + d2[uv] != rd:\n continue\n r -= pow(c,2,mod) * pow(dc2[uv],2,mod) % mod\n\n return r % mod\n\n\n\n\nprint(main())\n", "from heapq import heappush as k,heappop as l\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)]\n while p:\n d,v=l(p)\n if d>a[v]:continue\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;k(p,(d+w,u))\n return a\ndef g(a,s):\n w=[0]*N;w[s]=1;b=[0]*N;b[s]=1;p=[(0,s)]\n while p:\n d,v=l(p)\n for u,d in G[v]:\n if a[v]+d==a[u]:\n w[u]=(w[u]+w[v])%m\n if 1-b[u]:k(p,(a[u],u));b[u]=1\n return w\nm=10**9+7\nN,M=map(int,input().split());N+=1\nS,T=map(int,input().split())\nG=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=map(int,input().split());G[U]+=[(V,D)];G[V]+=[(U,D)]\nP=f(S);Q=f(T);X=g(P,S);Y=g(Q,T);s=P[T]\nprint((X[T]**2-(1-s%2)*sum((X[i]*Y[i])**2for i in range(N)if P[i]==Q[i]==s//2)-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%m)", "import sys\ninput = sys.stdin.readline\nN, M = map(int, input().split())\nS, T = map(int, input().split())\nmod = 10 ** 9 + 7\ne = [[] for _ in range(N + 1)]\nfor _ in range(M):\n u, v, c = map(int, input().split())\n e[u].append((v, c))\n e[v].append((u, c))\n\nimport heapq\nhpush = heapq.heappush\nhpop = heapq.heappop\nclass dijkstra:\n def __init__(self, n, e):\n self.e = e\n self.n = n\n def path(self, s):\n d = [float(\"inf\")] * (self.n + 1)\n vis = [0] * (self.n + 1)\n d[s] = 0\n h = [s]\n while len(h):\n v = hpop(h)\n v1 = v % (10 ** 6)\n v0 = v // (10 ** 6)\n if vis[v1]: continue\n vis[v1] = 1\n for p in self.e[v1]:\n d[p[0]] = min(d[p[0]], d[v1] + p[1])\n if vis[p[0]]: continue\n hpush(h, d[p[0]] * (10 ** 6) + p[0])\n return d\n\ndij = dijkstra(N, e)\nps = dij.path(S)\npt = dij.path(T)\ndps = [0] * (N + 1)\ndpt = [0] * (N + 1)\ndps[S] = 1\nh = []\nfor x in range(1, N + 1): hpush(h, (ps[x], x))\nwhile len(h):\n _, x = hpop(h)\n for y, c in e[x]:\n if ps[y] > ps[x] and ps[y] - ps[x] == c:\n dps[y] += dps[x]\n dps[y] %= mod\n\ndpt[T] = 1\nh = []\nfor x in range(1, N + 1): hpush(h, (pt[x], x))\nwhile len(h):\n _, x = hpop(h)\n for y, c in e[x]:\n if pt[y] > pt[x] and pt[y] - pt[x] == c:\n dpt[y] += dpt[x]\n dpt[y] %= mod\n\nres = dps[T] * dpt[S] % mod\nfor x in range(1, N + 1):\n if ps[x] == pt[x]:\n if ps[x] + pt[x] > ps[T]: continue\n res -= dps[x] ** 2 * dpt[x] ** 2 % mod\n res %= mod\n\nfor x in range(1, N + 1):\n for y, c in e[x]:\n if ps[y] - ps[x] == c and ps[y] * 2 > ps[T] and ps[x] * 2 < ps[T]:\n if ps[x] + pt[y] + c > ps[T]: continue\n res -= dps[x] ** 2 * dpt[y] ** 2 % mod\n res %= mod\nprint(res)", "from heapq import heappop,heappush\ndef main0(n,m,s,t,abc):\n mod=10**9+7\n g=[set() for _ in range(n)]\n for i,(a,b,c) in enumerate(abc):\n a,b=a-1,b-1\n g[a].add((b,c,i))\n g[b].add((a,c,i))\n s,t=s-1,t-1\n todo=[[0,s]]\n inf=float('inf')\n froms=[inf]*n\n froms[s]=0\n while todo:\n c,v=heappop(todo)\n if froms[v]<c:continue\n for nv,nc,_ in g[v]:\n if froms[nv]>c+nc:\n froms[nv]=c+nc\n heappush(todo,[nc+c,nv])\n mincost=froms[t]\n mideary=[0]*m\n midvary=[0]*n\n vary=[0]*n\n vary[t]=1\n todo=[[0,t]]\n fromt=[inf]*n\n fromt[t]=0\n fromt[s]=mincost\n while todo:\n c,v=heappop(todo)\n for nv,nc,i in g[v]:\n if mincost==froms[nv]+c+nc:\n if c<mincost/2 and c+nc>mincost/2:\n mideary[i]+=vary[v]\n mideary[i]%=mod\n elif mincost%2==0 and c+nc==mincost//2:\n midvary[nv]+=vary[v]\n midvary[nv]%=mod\n vary[nv]+=vary[v]\n vary[nv]%=mod\n if fromt[nv]>c+nc:\n fromt[nv]=c+nc\n heappush(todo,[c+nc,nv])\n\n mideary1=[0]*m\n midvary1=[0]*n\n vary=[0]*n\n vary[s]=1\n todo=[[0,s]]\n nfroms=[inf]*n\n nfroms[s]=0\n nfroms[t]=mincost\n while todo:\n c,v=heappop(todo)\n for nv,nc,i in g[v]:\n if mincost==fromt[nv]+c+nc:\n if c<mincost/2 and c+nc>mincost/2:\n mideary1[i]+=vary[v]\n mideary1[i]%=mod\n elif mincost%2==0 and c+nc==mincost//2:\n midvary1[nv]+=vary[v]\n midvary1[nv]%=mod\n vary[nv]+=vary[v]\n vary[nv]%=mod\n if nfroms[nv]>c+nc:\n nfroms[nv]=c+nc\n heappush(todo,[c+nc,nv])\n for i in range(n):\n midvary[i]*=midvary1[i]\n midvary[i]%=mod\n for i in range(m):\n mideary[i]*=mideary1[i]\n mideary[i]%=mod\n summid=sum(mideary)+sum(midvary)\n summid%=mod\n ret=0\n for x in mideary:\n if x!=0:\n ret+=x*(summid-x)\n ret%=mod\n for x in midvary:\n if x!=0:\n ret+=x*(summid-x)\n ret%=mod\n #print(mincost,mideary,midvary)\n return ret\nimport sys\ninput=sys.stdin.readline\ndef __starting_point():\n n,m=list(map(int,input().split()))\n s,t=list(map(int,input().split()))\n abc=[list(map(int,input().split())) for _ in range(m)]\n print((main0(n,m,s,t,abc)))\n\n__starting_point()", "from collections import defaultdict, deque\nfrom heapq import heappop, heappush\ndef inpl(): return list(map(int, input().split()))\n\nN, M = inpl()\nS, T = inpl()\nG = [[] for _ in range(N+1)]\nMOD = 10**9 + 7\nfor _ in range(M):\n u, v, d = inpl()\n G[u].append((v, d))\n G[v].append((u, d))\n\ncost = [10**18]*(N+1)\nappear = [0]*(N+1)\n\nQ = [(0, S)]\ncost[S] = 0\nappear[S] = 1\n\nwhile Q:\n c, p = heappop(Q)\n if cost[p] < c:\n continue\n for q, d in G[p]:\n if cost[p] + d == cost[q]:\n appear[q] = (appear[q] + appear[p])%MOD\n elif cost[p] + d < cost[q]:\n cost[q] = cost[p] + d\n appear[q] = appear[p] % MOD\n heappush(Q, (cost[q], q))\n\nend = cost[T]*1\nans = pow(appear[T], 2, MOD)\n\nQ = [(0, T)]\ncost2 = [10**18]*(N+1)\ncost2[T] = 0\nappear2 = [0]*(N+1)\nappear2[T] = 1\nwhile Q:\n c, p = heappop(Q)\n if cost2[p] < c:\n continue\n for q, d in G[p]:\n if cost[p] - d != cost[q]:\n continue\n if cost2[p] + d == cost2[q]:\n appear2[q] = (appear2[q] + appear2[p])%MOD\n elif cost2[p] + d < cost2[q]:\n cost2[q] = cost2[p] + d\n appear2[q] = appear2[p] % MOD\n heappush(Q, (cost2[q], q))\n\nQ = deque([S])\nsearched = [False]*(N+1)\nsearched[S] = True\n\nwhile Q:\n p = Q.pop()\n if 2*cost2[p] == end:\n ans = (ans - (appear[p]*appear2[p])**2)%MOD\n\n for q, d in G[p]:\n if cost2[p] - d != cost2[q]:\n continue\n if 2*cost2[q] < end < 2*cost2[p]:\n ans = (ans - (appear[p]*appear2[q])**2)%MOD\n if not searched[q]:\n Q.append(q)\n searched[q] = True\nprint(ans)", "import sys\ninput = sys.stdin.readline\nimport heapq as hq\nn,m = map(int,input().split())\ns,t = map(int,input().split())\nabd = [list(map(int,input().split())) for i in range(m)]\nmod = 10**9+7\ngraph = [[] for i in range(n+1)]\n#\u96a3\u63a5\u30ea\u30b9\u30c8\nfor a,b,d in abd:\n graph[a].append((b,d))\n graph[b].append((a,d))\ndists = [[10**18,0] for i in range(n+1)]\ndistt = [[10**18,0] for i in range(n+1)]\n#S,T\u304b\u3089dijkstra\n#distX[i]: [X\u304b\u3089i\u3078\u306e\u6700\u77ed\u7d4c\u8def\u9577\u3001\u305d\u306e\u30d1\u30b9\u306e\u672c\u6570]\nfor start,dist in (s,dists),(t,distt):\n dist[start] = [0,1]\n q = [(0,start)]\n hq.heapify(q)\n while q:\n dx,x = hq.heappop(q)\n k = dist[x][1]\n for y,d in graph[x]:\n if dist[y][0] > dx+d:\n dist[y][0] = dx+d\n dist[y][1] = k\n hq.heappush(q,(dist[y][0],y))\n elif dist[y][0] == dx+d:\n dist[y][1] = (dist[y][1]+k)%mod\ndst = dists[t][0]\n#dst: S-T\u9593\u306e\u8ddd\u96e2\n#ansls\u306b\u300c2\u4eba\u304c\u51fa\u4f1a\u3044\u3046\u308b\u8fba/\u9802\u70b9\u3092\u901a\u308b\u30d1\u30b9\u306e\u672c\u6570\u300d\u3092\u683c\u7d0d\nans = dists[t][1]**2%mod\nfor v in range(1,n+1):\n if dists[v][0]+distt[v][0] != dst:\n continue\n if dists[v][0]*2 == distt[v][0]*2 == dst:\n ans = (ans-(dists[v][1]*distt[v][1])**2)%mod\n else:\n for u,d in graph[v]:\n if dists[u][0]*2 < dst and distt[v][0]*2 < dst:\n if dists[u][0]+distt[v][0]+d == dst:\n ans = (ans-(dists[u][1]*distt[v][1])**2)%mod\n#\u7b54\u3048: ansls\u306e\u8981\u7d20\u3092ai\u3068\u3059\u308b\u3068\n#(\u03a3ai)^2-\u03a3(ai^2)\u306b\u306a\u308b\u306f\u305a\u2026\n\nprint(ans%mod)", "from heapq import heappop, heappush\nimport sys\n\nMOD, INF = 1000000007, float('inf')\n\n\ndef count_routes(visited, s, links):\n counts = [0] * n\n counts[s] = 1\n for dv, v in sorted((d, v) for v, d in enumerate(visited) if d != INF):\n for u, du in list(links[v].items()):\n if dv + du == visited[u]:\n counts[u] += counts[v]\n counts[u] %= MOD\n return counts\n\n\ndef solve(s, t, links):\n q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]\n visited_fwd, visited_bwd = [INF] * n, [INF] * n\n collision_nodes, collision_links = set(), set()\n limit = 0\n while q:\n cost, cost_a, v, a, is_bwd = heappop(q)\n if is_bwd:\n visited_self = visited_bwd\n visited_opp = visited_fwd\n else:\n visited_self = visited_fwd\n visited_opp = visited_bwd\n\n relax_flag = False\n cost_preceding = visited_self[v]\n if cost_preceding == INF:\n visited_self[v] = cost\n relax_flag = True\n elif cost > cost_preceding:\n continue\n\n cost_opp = visited_opp[v]\n if cost_opp != INF:\n limit = cost + cost_opp\n if cost == cost_opp:\n collision_nodes.add(v)\n else:\n collision_links.add((v, a) if is_bwd else (a, v))\n break\n\n if relax_flag:\n for u, du in list(links[v].items()):\n nc = cost + du\n if visited_self[u] < nc:\n continue\n heappush(q, (nc, cost, u, v, is_bwd))\n\n collision_time = limit / 2\n while q:\n cost, cost_a, v, a, is_bwd = heappop(q)\n if cost > limit:\n break\n visited_self = visited_bwd if is_bwd else visited_fwd\n if visited_self[v] == INF:\n visited_self[v] = cost\n if is_bwd:\n continue\n if cost_a == collision_time:\n collision_nodes.add(a)\n elif cost == collision_time:\n collision_nodes.add(v)\n else:\n collision_links.add((v, a) if is_bwd else (a, v))\n\n counts_fwd = count_routes(visited_fwd, s, links)\n counts_bwd = count_routes(visited_bwd, t, links)\n shortest_count = 0\n collision_count = 0\n\n for v in collision_nodes:\n if visited_fwd[v] == visited_bwd[v]:\n r = counts_fwd[v] * counts_bwd[v]\n shortest_count += r\n shortest_count %= MOD\n collision_count += r * r\n collision_count %= MOD\n\n for u, v in collision_links:\n if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:\n r = counts_fwd[u] * counts_bwd[v]\n shortest_count += r\n shortest_count %= MOD\n collision_count += r * r\n collision_count %= MOD\n\n return (shortest_count ** 2 - collision_count) % MOD\n\n\nn, m = list(map(int, input().split()))\ns, t = list(map(int, input().split()))\ns -= 1\nt -= 1\nlinks = [{} for _ in range(n)]\nfor uvd in sys.stdin.readlines():\n u, v, d = list(map(int, uvd.split()))\n # for _ in range(m):\n # u, v, d = map(int, input().split())\n u -= 1\n v -= 1\n links[u][v] = d\n links[v][u] = d\nprint((solve(s, t, links)))\n", "from heapq import*\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)];c=[0]*N;c[s]=1\n while p:\n d,v=heappop(p)\n if d<=a[v]:\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u));c[u]=0\n c[u]+=c[v]*(a[u]==d+w)\n return a,c\nn=lambda:map(int,input().split());N,M=n();N+=1;S,T=n();G=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=n();G[U]+=[(V,D)];G[V]+=(U,D),\nP,X=f(S);Q,Y=f(T);s=P[T];print((X[T]**2--~s%2*sum((x*y)**2for x,y,p,q in zip(X,Y,P,Q)if p==q==s//2)-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%(10**9+7))", "import sys\nreadline = sys.stdin.readline\n\nfrom heapq import heappop as hpp, heappush as hp\ndef dijkstra(N, s, Edge):\n inf = geta\n dist = [inf] * N\n dist[s] = 0\n Q = [(0, s)]\n dp = [0]*N\n dp[s] = 1\n while Q:\n dn, vn = hpp(Q)\n if dn > dist[vn]:\n continue\n for df, vf in Edge[vn]:\n if dist[vn] + df < dist[vf]:\n dist[vf] = dist[vn] + df\n dp[vf] = dp[vn]\n hp(Q, (dn + df,vf))\n elif dist[vn] + df == dist[vf]:\n dp[vf] = (dp[vf] + dp[vn]) % MOD\n return dist, dp\n\nMOD = 10**9+7\nN, M = map(int, readline().split())\nS, T = map(int, readline().split())\nS -= 1\nT -= 1\n\ngeta = 10**15\nEdge = [[] for _ in range(N)]\nfor _ in range(M):\n u, v, d = map(int, readline().split())\n u -= 1\n v -= 1\n Edge[u].append((d, v))\n Edge[v].append((d, u))\n \n\ndists, dps = dijkstra(N, S, Edge)\ndistt, dpt = dijkstra(N, T, Edge)\nst = dists[T]\n\nonpath = [i for i in range(N) if dists[i] + distt[i] == st]\n\nans = dps[T]**2%MOD\nfor i in onpath:\n if 2*dists[i] == 2*distt[i] == st:\n ans = (ans - pow(dps[i]*dpt[i], 2, MOD))%MOD\n \n for cost, vf in Edge[i]:\n if dists[i] + cost + distt[vf] == st:\n if 2*dists[i] < st < 2*dists[vf]:\n ans = (ans - pow(dps[i]*dpt[vf], 2, MOD))%MOD\nprint(ans)", "import heapq\nimport sys\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nMOD = 10**9+7\nclass DijkstraList():\n\t#\u96a3\u63a5\u30ea\u30b9\u30c8\u7248\n\t#\u540c\u4e00\u9802\u70b9\u306e\u8907\u6570\u56de\u63a2\u7d22\u3092\u9632\u3050\u305f\u3081\u8a2a\u554f\u3057\u305f\u9802\u70b9\u6570\u3092\u5909\u6570cnt\u3067\u6301\u3064\n\tdef __init__(self, adj, start):\n\t\tself.list = adj\n\t\tself.start = start\n\t\tself.size = len(adj)\n\n\tdef solve(self):\n\t\tself.dist = [float(\"inf\") for _ in range(self.size)]\n\t\tself.dist[self.start] = 0\n\t\tself.dp = [0 for _ in range(self.size)]\n\t\tself.dp[self.start] = 1\n\t\t#self.prev = [-1 for _ in range(self.size)]\n\t\tself.q = []\n\t\tself.cnt = 0\n\n\t\theapq.heappush(self.q, (0, self.start))\n\n\t\twhile self.q and self.cnt < self.size:\n\t\t\tu_dist, u = heapq.heappop(self.q)\n\t\t\tif self.dist[u] < u_dist:\n\t\t\t\tcontinue\n\t\t\tfor v, w in self.list[u]:\n\t\t\t\tif self.dist[v] > u_dist + w:\n\t\t\t\t\tself.dist[v] = u_dist + w\n\t\t\t\t\tself.dp[v] = self.dp[u]\n\t\t\t\t\t#self.prev[v] = u\n\t\t\t\t\theapq.heappush(self.q, (self.dist[v], v))\n\t\t\t\telif self.dist[v] == u_dist + w:\n\t\t\t\t\tself.dp[v] += self.dp[u]\n\t\t\t\t\tself.dp[v] %= MOD\n\n\t\t\tself.cnt += 1\n\t\t#print(self.dp)\n\t\treturn\n\n\tdef distance(self, goal):\n\t\treturn self.dist[goal]\n\n\tdef get_dp(self, x):\n\t\treturn self.dp[x]\n\nn, m = map(int, input().split())\ns, t = map(int, input().split())\ns, t = s-1, t-1\nadj = [[] for _ in range(n)]\nfor _ in range(m):\n\tu, v, d = map(int, input().split())\n\tadj[u-1].append([v-1, d])\n\tadj[v-1].append([u-1, d])\nS, T = DijkstraList(adj, s), DijkstraList(adj, t)\nS.solve()\nT.solve()\nans = pow(S.get_dp(t), 2, MOD)\ngoal = S.distance(t)\n#print(ans, goal)\n\nfor i in range(n):\n\tSI, TI = S.distance(i), T.distance(i)\n\tif SI + TI != goal:\n\t\tcontinue\n\tif SI*2 == goal:\n\t\tans -= S.get_dp(i) * T.get_dp(i) * S.get_dp(i) * T.get_dp(i)\n\t\tans %= MOD\n\n\telse:\n\t\tfor j, d in adj[i]:\n\t\t\tif i>j:\n\t\t\t\tcontinue\n\t\t\tSJ, TJ = S.distance(j), T.distance(j)\n\t\t\tif SJ + TJ != goal or abs(SI - SJ) != d:\n\t\t\t\tcontinue\n\t\t\tif SI*2 < goal < SJ*2:\n\t\t\t\t#print(i, j, SI, SJ)\n\t\t\t\tans -= S.get_dp(i) * T.get_dp(j) * S.get_dp(i) * T.get_dp(j)\n\t\t\t\tans %= MOD\n\t\t\telif SJ*2 < goal < SI*2:\n\t\t\t\t#print(i, j, SI, SJ)\n\t\t\t\tans -= S.get_dp(j) * T.get_dp(i) * S.get_dp(j) * T.get_dp(i)\n\t\t\t\tans %= MOD\n\nprint(ans)", "mod=10**9+7\n\nclass Dijkstra():\n \"\"\" \u30c0\u30a4\u30af\u30b9\u30c8\u30e9\u6cd5\n \u91cd\u307f\u4ed8\u304d\u30b0\u30e9\u30d5\u306b\u304a\u3051\u308b\u5358\u4e00\u59cb\u70b9\u6700\u77ed\u8def\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\n\n * \u4f7f\u7528\u6761\u4ef6\n - \u8ca0\u306e\u30b3\u30b9\u30c8\u304c\u306a\u3044\u3053\u3068\n - \u6709\u5411\u30b0\u30e9\u30d5\u3001\u7121\u5411\u30b0\u30e9\u30d5\u3068\u3082\u306bOK\n\n * \u8a08\u7b97\u91cf\u306fO(E*log(V))\n\n * \u30d9\u30eb\u30de\u30f3\u30d5\u30a9\u30fc\u30c9\u6cd5\u3088\u308a\u9ad8\u901f\u306a\u306e\u3067\u3001\u8ca0\u306e\u30b3\u30b9\u30c8\u304c\u306a\u3044\u306a\u3089\u3070\u3053\u3061\u3089\u3092\u4f7f\u3046\u3068\u3088\u3044\n \"\"\"\n class Edge():\n \"\"\" \u91cd\u307f\u4ed8\u304d\u6709\u5411\u8fba \"\"\"\n def __init__(self, _to, _cost):\n self.to = _to\n self.cost = _cost\n\n def __init__(self, V):\n \"\"\" \u91cd\u307f\u4ed8\u304d\u6709\u5411\u8fba\n \u7121\u5411\u8fba\u3092\u8868\u73fe\u3057\u305f\u3044\u3068\u304d\u306f\u3001_from\u3068_to\u3092\u9006\u306b\u3057\u305f\u6709\u5411\u8fba\u3092\u52a0\u3048\u308c\u3070\u3088\u3044\n\n Args:\n V(int): \u9802\u70b9\u306e\u6570\n \"\"\"\n self.G = [[] for i in range(V)] # \u96a3\u63a5\u30ea\u30b9\u30c8G[u][i] := \u9802\u70b9u\u306ei\u500b\u76ee\u306e\u96a3\u63a5\u8fba\n self._E = 0 # \u8fba\u306e\u6570\n self._V = V # \u9802\u70b9\u306e\u6570\n\n @property\n def E(self):\n \"\"\" \u8fba\u6570\n \u7121\u5411\u30b0\u30e9\u30d5\u306e\u3068\u304d\u306f\u3001\u8fba\u6570\u306f\u6709\u5411\u30b0\u30e9\u30d5\u306e\u500d\u306b\u306a\u308b\n \"\"\"\n return self._E\n\n @property\n def V(self):\n \"\"\" \u9802\u70b9\u6570 \"\"\"\n return self._V\n\n def add(self, _from, _to, _cost):\n \"\"\" 2\u9802\u70b9\u3068\u3001\u8fba\u306e\u30b3\u30b9\u30c8\u3092\u8ffd\u52a0\u3059\u308b \"\"\"\n self.G[_from].append(self.Edge(_to, _cost))\n self._E += 1\n\n def edge(self,_from):\n return self.G[_from]\n\n def shortest_path(self, s):\n \"\"\" \u59cb\u70b9s\u304b\u3089\u9802\u70b9i\u307e\u3067\u306e\u6700\u77ed\u8def\u3092\u683c\u7d0d\u3057\u305f\u30ea\u30b9\u30c8\u3092\u8fd4\u3059\n Args:\n s(int): \u59cb\u70b9s\n Returns:\n d(list): d[i] := \u59cb\u70b9s\u304b\u3089\u9802\u70b9i\u307e\u3067\u306e\u6700\u77ed\u30b3\u30b9\u30c8\u3092\u683c\u7d0d\u3057\u305f\u30ea\u30b9\u30c8\u3002\n \u5230\u9054\u4e0d\u53ef\u306e\u5834\u5408\u3001\u5024\u306ffloat(\"inf\")\n \"\"\"\n import heapq\n que = [] # \u30d7\u30e9\u30a4\u30aa\u30ea\u30c6\u30a3\u30ad\u30e5\u30fc\uff08\u30d2\u30fc\u30d7\u6728\uff09\n d = [10**15] * self.V\n d[s] = 0\n cnt=[0]*self.V\n cnt[s]=1\n heapq.heappush(que, (0, s)) # \u59cb\u70b9\u306e(\u6700\u77ed\u8ddd\u96e2, \u9802\u70b9\u756a\u53f7)\u3092\u30d2\u30fc\u30d7\u306b\u8ffd\u52a0\u3059\u308b\n\n while len(que) != 0:\n cost, v = heapq.heappop(que)\n # \u30ad\u30e5\u30fc\u306b\u683c\u7d0d\u3055\u308c\u3066\u3044\u308b\u6700\u77ed\u7d4c\u8def\u306e\u5019\u88dc\u304cd\u306e\u8ddd\u96e2\u3088\u308a\u3082\u5927\u304d\u3051\u308c\u3070\u3001\u4ed6\u306e\u7d4c\u8def\u3067\u6700\u77ed\u7d4c\u8def\u304c\u5b58\u5728\u3059\u308b\u306e\u3067\u3001\u51e6\u7406\u3092\u30b9\u30ad\u30c3\u30d7\n if d[v] < cost: continue\n\n for i in range(len(self.G[v])):\n # \u9802\u70b9v\u306b\u96a3\u63a5\u3059\u308b\u5404\u9802\u70b9\u306b\u95a2\u3057\u3066\u3001\u9802\u70b9v\u3092\u7d4c\u7531\u3057\u305f\u5834\u5408\u306e\u8ddd\u96e2\u3092\u8a08\u7b97\u3057\u3001\u4eca\u307e\u3067\u306e\u8ddd\u96e2(d)\u3088\u308a\u3082\u5c0f\u3055\u3051\u308c\u3070\u66f4\u65b0\u3059\u308b\n e = self.G[v][i] # v\u306ei\u500b\u76ee\u306e\u96a3\u63a5\u8fbae\n if d[e.to] > d[v] + e.cost:\n d[e.to] = d[v] + e.cost # d\u306e\u66f4\u65b0\n heapq.heappush(que, (d[e.to], e.to)) # \u30ad\u30e5\u30fc\u306b\u65b0\u305f\u306a\u6700\u77ed\u7d4c\u8def\u306e\u5019\u88dc(\u6700\u77ed\u8ddd\u96e2, \u9802\u70b9\u756a\u53f7)\u306e\u60c5\u5831\u3092push\n cnt[e.to]=cnt[v]%mod\n elif d[e.to]==d[v]+e.cost:\n cnt[e.to]+=cnt[v]\n cnt[e.to]%=mod\n return d,cnt\n\nimport sys\n\ninput=sys.stdin.readline\nsys.setrecursionlimit(1000000)\n\nN,M=list(map(int,input().split()))\nS,T=list(map(int,input().split()))\nmati=Dijkstra(N)\nfor i in range(M):\n u,v,d=list(map(int,input().split()))\n mati.add(u-1,v-1,d)\n mati.add(v-1,u-1,d)\n\nspath,Sways=mati.shortest_path(S-1)\ntpath,Tways=mati.shortest_path(T-1)\n\nans=Sways[T-1]*Tways[S-1]\nans%=mod\nfor u in range(N):\n for e in mati.edge(u):\n v=e.to\n d=e.cost\n ans-=(Tways[v]*Sways[u])**2*(spath[u]+d+tpath[v]==spath[T-1] and spath[u]+d!=tpath[v] and spath[u]!=tpath[v]+d and (tpath[v]+d>=spath[u]>=tpath[v] or tpath[v]+d>=spath[u]+d>=tpath[v]))\n ans%=mod\n\nfor i in range(N):\n ans-=(Tways[i]*Sways[i])**2*(spath[i]+tpath[i]==spath[T-1] and spath[i]==tpath[i])\n ans%=mod\n\nprint((ans%mod))\n", "from heapq import heappush,heappop\ndef dijkstra(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)]\n while p:\n d,v=heappop(p)\n if d>a[v]:continue\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u))\n return a\ndef cnt(dist,s):\n w=[0]*N;w[s]=1;b=[0]*N;b[s]=1;p=[(0,s)]\n while p:\n d,v=heappop(p)\n for u,d in G[v]:\n if dist[v]+d==dist[u]:\n w[u]=(w[u]+w[v])%m\n if not b[u]:heappush(p,(dist[u],u));b[u]=1\n return w\nm=10**9+7\nN,M=map(int,input().split())\nS,T=map(int,input().split())\nS-=1;T-=1\nG=[[]for _ in[0]*N]\nfor _ in[0]*M:\n U,V,D=map(int,input().split())\n U-=1;V-=1\n G[U]+=[(V,D)]\n G[V]+=[(U,D)]\ndS=dijkstra(S)\ndT=dijkstra(T)\nwS=cnt(dS,S)\nwT=cnt(dT,T)\ns=dS[T]\na=wS[T]**2%m\nif s%2==0:\n for i in range(N):\n if dS[i]==dT[i]==s//2:\n a=(a-(wS[i]*wT[i])**2)%m\nfor i in range(N):\n for j,d in G[i]:\n if dS[i]+d+dT[j]==s:\n if dS[i]<dT[i]and dT[j]<dS[j]:\n a=(a-(wS[i]*wT[j])**2)%m\nprint(a)", "def main():\n import sys\n sys.setrecursionlimit(100000)\n input = sys.stdin.readline\n from heapq import heappop, heappush\n mod = 10**9+7\n INF = 1<<60\n N, M = list(map(int, input().split()))\n S, T = list(map(int, input().split()))\n E = [[] for _ in range(N+1)]\n edges = []\n # for _ in range(M):\n # u, v, d = map(int, input().split())\n # E[u].append((v, d))\n # E[v].append((u, d))\n # edges.append((u, v, d))\n for u, v, d in zip(*[iter(map(int, sys.stdin.read().split()))]*3):\n E[u].append((v, d))\n E[v].append((u, d))\n edges.append((u, v, d))\n\n def dijksrtra(start):\n Dist = [INF] * (N+1)\n Dist[start] = 0\n q = [0<<17 | start]\n mask = (1<<17)-1\n while q:\n dist_v = heappop(q)\n v = dist_v & mask\n dist = dist_v >> 17\n if Dist[v] != dist:\n continue\n for u, d in E[v]:\n new_dist = dist + d\n if Dist[u] > new_dist:\n Dist[u] = new_dist\n heappush(q, new_dist<<17 | u)\n return Dist\n\n Dist_S = dijksrtra(S)\n Dist_T = dijksrtra(T)\n dist_st = Dist_S[T]\n\n DAG_edges = [] # S -> T\n DAG = [[] for _ in range(N+1)]\n DAG_rev = [[] for _ in range(N+1)]\n for u, v, d in edges:\n if Dist_S[u] + Dist_T[v] + d == dist_st:\n DAG_edges.append((u, v))\n DAG[u].append(v)\n DAG_rev[v].append(u)\n elif Dist_T[u] + Dist_S[v] + d == dist_st:\n DAG_edges.append((v, u))\n DAG[v].append(u)\n DAG_rev[u].append(v)\n\n\n # \u30c8\u30dd\u30ed\u30b8\u30ab\u30eb\u30bd\u30fc\u30c8\n V = []\n rem = [0] * (N+1)\n for _, v in DAG_edges:\n rem[v] += 1\n q = [S]\n while q:\n v = q.pop()\n V.append(v)\n for u in DAG[v]:\n rem[u] -= 1\n if rem[u] == 0:\n q.append(u)\n\n\n # n_paths_S = [-1] * (N+1)\n # n_paths_T = [-1] * (N+1)\n n_paths_S = [0] * (N+1)\n n_paths_T = [0] * (N+1)\n n_paths_S[S] = 1\n n_paths_T[T] = 1\n # def calc_n_paths_S(v):\n # if n_paths_S[v] != -1:\n # return n_paths_S[v]\n # res = 0\n # for u in DAG_rev[v]:\n # res = (res + calc_n_paths_S(u)) % mod\n # n_paths_S[v] = res\n # return res\n # def calc_n_paths_T(v):\n # if n_paths_T[v] != -1:\n # return n_paths_T[v]\n # res = 0\n # for u in DAG[v]:\n # res = (res + calc_n_paths_T(u)) % mod\n # n_paths_T[v] = res\n # return res\n\n # ans = calc_n_paths_S(T) # \u5168\u7d4c\u8def\u6570\n # calc_n_paths_T(S)\n\n for v in V:\n n = n_paths_S[v]\n for u in DAG[v]:\n n_paths_S[u] += n\n for v in V[::-1]:\n n = n_paths_T[v]\n for u in DAG_rev[v]:\n n_paths_T[u] += n\n ans = n_paths_S[T]\n ans = ans * ans % mod\n\n for v, u in DAG_edges: # \u8fba\u3067\u3059\u308c\u9055\u3046\u5834\u5408\n if Dist_S[v]*2 < dist_st and dist_st < Dist_S[u]*2:\n ans = (ans - (n_paths_S[v]*n_paths_T[u])**2) % mod\n\n # \u9802\u70b9\u3067\u3059\u308c\u9055\u3046\u5834\u5408\n for v, (dist, ns, nt) in enumerate(zip(Dist_S, n_paths_S, n_paths_T)):\n if dist*2 == dist_st:\n ans = (ans - (ns*nt)**2) % mod\n\n print(ans)\n\nmain()\n", "import sys\ninput = sys.stdin.readline\n\nINF = 10**18\nmod = 10**9+7\n# AOJ GRL_1_A Single Sourse Shortest Path\nimport heapq as hp\n\nN, M = map(int, input().split())\ns, t = map(int, input().split())\ns -= 1; t -= 1\ngraph = [[] for _ in range(N)]\nfor _ in range(M):\n n, m, d = map(int, input().split())\n graph[n-1].append((d, m-1)) \n graph[m-1].append((d, n-1)) #\u7121\u5411\u30b0\u30e9\u30d5\u306a\u3089\u3053\u308c\u4f7f\u3046\n\ndef dijkstra(s):\n D = [INF for _ in range(N)] # \u9802\u70b9i\u3078\u306e\u6700\u77ed\u8ddd\u96e2\u304cD[i]\n B = [0]*N\n D[s] = 0\n B[s] = 1\n q = [] # \u3057\u307e\u3063\u3066\u3044\u304f\u512a\u5148\u5ea6\u4ed8\u304d\u30ad\u30e5\u30fc\n hp.heappush(q, (0, s))\n\n while q:\n nd, np = hp.heappop(q)\n if D[np] < nd:\n continue\n for d, p in graph[np]:\n if D[p] > D[np] + d:\n D[p] = D[np] + d\n B[p] = B[np]\n hp.heappush(q, (D[p], p))\n elif D[p] == D[np] + d:\n B[p] = (B[p] + B[np])%mod\n return D, B\n\nsD, sB = dijkstra(s)\ntD, tB = dijkstra(t)\n\ndistance = sD[t]\n\nans = 0\nfor n in range(N):\n for d, m in graph[n]:\n if sD[n] + d + tD[m] == distance and 2*sD[n] < distance < 2*(sD[n]+d):\n ans = (ans + (sB[n]*tB[m])**2)%mod\n if sD[n] + tD[n] == distance and 2*sD[n] == distance:\n ans = (ans + (sB[n]*tB[n])**2) % mod\nans = (sB[t]*tB[s] - ans) % mod\nprint(ans)", "import sys\nreadline = sys.stdin.readline\n\nfrom heapq import heappop as hpp, heappush as hp\ndef dijkstra(N, s, Edge):\n inf = geta\n dist = [inf] * N\n dist[s] = 0\n Q = [(0, s)]\n dp = [0]*N\n dp[s] = 1\n while Q:\n dn, vn = hpp(Q)\n if dn > dist[vn]:\n continue\n for df, vf in Edge[vn]:\n if dist[vn] + df < dist[vf]:\n dist[vf] = dist[vn] + df\n dp[vf] = dp[vn]\n hp(Q, (dn + df,vf))\n elif dist[vn] + df == dist[vf]:\n dp[vf] = (dp[vf] + dp[vn]) % MOD\n return dist, dp\n\nMOD = 10**9+7\nN, M = map(int, readline().split())\nS, T = map(int, readline().split())\nS -= 1\nT -= 1\n\ngeta = 10**15\nEdge = [[] for _ in range(N)]\nfor _ in range(M):\n u, v, d = map(int, readline().split())\n u -= 1\n v -= 1\n Edge[u].append((d, v))\n Edge[v].append((d, u))\n \n\ndists, dps = dijkstra(N, S, Edge)\ndistt, dpt = dijkstra(N, T, Edge)\nst = dists[T]\n\nonpath = [i for i in range(N) if dists[i] + distt[i] == st]\n\nans = dps[T]**2%MOD\nfor i in onpath:\n if 2*dists[i] == 2*distt[i] == st:\n ans = (ans - pow(dps[i]*dpt[i], 2, MOD))%MOD\n \n for cost,vf in Edge[i]:\n if dists[i]+cost+distt[vf] == st:\n if 2*dists[i] < st < 2*dists[vf]:\n ans = (ans - pow(dps[i]*dpt[vf], 2, MOD))%MOD\nprint(ans)", "from heapq import*\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)];c=[0]*N;c[s]=1\n while p:\n d,v=heappop(p)\n if d<=a[v]:\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u));c[u]=0\n c[u]+=c[v]*(a[u]==d+w)\n return a,c\nn=lambda:map(int,input().split());N,M=n();N+=1;S,T=n();G=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=n();G[U]+=[(V,D)];G[V]+=[(U,D)]\nP,X=f(S);Q,Y=f(T);s=P[T];print((X[T]**2--~s%2*sum((x*y)**2for x,y,p,q in zip(X,Y,P,Q)if p==q==s//2)-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%(10**9+7))", "import sys\ninput = sys.stdin.readline\nimport heapq as hq\nn,m = map(int,input().split())\ns,t = map(int,input().split())\nabd = [list(map(int,input().split())) for i in range(m)]\nmod = 10**9+7\ngraph = [[] for i in range(n+1)]\nfor a,b,d in abd:\n graph[a].append((b,d))\n graph[b].append((a,d))\ndists = [[10**18,0] for i in range(n+1)]\ndistt = [[10**18,0] for i in range(n+1)]\nfor start,dist in (s,dists),(t,distt):\n dist[start] = [0,1]\n q = [(0,start)]\n hq.heapify(q)\n while q:\n dx,x = hq.heappop(q)\n k = dist[x][1]\n for y,d in graph[x]:\n if dist[y][0] > dx+d:\n dist[y][0] = dx+d\n dist[y][1] = k\n hq.heappush(q,(dist[y][0],y))\n elif dist[y][0] == dx+d:\n dist[y][1] = (dist[y][1]+k)%mod\ndst = dists[t][0]\nansls = []\nfor u,v,d in abd:\n for a,b in (u,v),(v,u):\n if dists[a][0] < distt[a][0]:\n if dists[a][0]*2 < dst and distt[b][0]*2 < dst:\n if dists[a][0]+distt[b][0]+d == dst:\n ansls.append(dists[a][1]*distt[b][1]%mod)\nfor v in range(1,n+1):\n if dists[v][0]*2 == distt[v][0]*2 == dst:\n ansls.append(dists[v][1]*distt[v][1]%mod)\nsm = sum(ansls)%mod\nans = sm**2%mod\nfor i in ansls:\n ans = (ans-i**2)%mod\nprint(ans)", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\nfrom heapq import heapify, heappush as hpush, heappop as hpop\ndef dijkstra(n, E, i0=0):\n kk = 18\n mm = (1 << kk) - 1\n h = [i0]\n D = [-1] * n\n done = [0] * n\n D[i0] = 0\n while h:\n x = hpop(h)\n d, i = x >> kk, x & mm\n if done[i]: continue\n done[i] = 1\n for j, w in E[i]:\n nd = d + w\n if D[j] < 0 or D[j] > nd:\n if done[j] == 0:\n hpush(h, (nd << kk) + j)\n D[j] = nd\n return D\ndef dijkstra2(n, DD, i0=0):\n L = [0] * n\n L[i0] = 1\n AA = [i for i in V]\n AA.sort(key = lambda x: DD[x])\n for a in AA:\n for b, c in E[a]:\n if DD[b] + c == DD[a]:\n L[a] += L[b]\n if L[a] >= P: L[a] -= P\n return L\n\nP = 10 ** 9 + 7\nN, M = list(map(int, input().split()))\nS, T = [int(a) - 1 for a in input().split()]\nE = [[] for _ in range(N)]\nfor _ in range(M):\n a, b, c = list(map(int, input().split()))\n E[a-1].append((b-1, c))\n E[b-1].append((a-1, c))\n\nD1 = dijkstra(N, E, S)\nD2 = dijkstra(N, E, T)\nmad = D1[T]\nV = set([i for i in range(N) if D1[i] + D2[i] == mad])\nX = dijkstra2(N, D1, S)\nY = dijkstra2(N, D2, T)\nans = X[T] ** 2 % P\nfor i in V:\n if D1[i] == D2[i]:\n ans = (ans - (X[i] * Y[i] % P) ** 2) % P\nfor a in V:\n for b, c in E[a]:\n if D1[a] + c == D1[b]:\n if D1[a] * 2 < mad < D1[b] * 2:\n ans = (ans - (X[a] * Y[b] % P) ** 2) % P\nprint(ans)\n", "from heapq import*\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)];c=[0]*N;c[s]=1\n while p:\n d,v=heappop(p)\n if d<=a[v]:\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u));c[u]=0\n c[u]+=c[v]*(a[u]==d+w)\n return a,c\nn=lambda:map(int,input().split());N,M=n();N+=1;S,T=n();G=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=n();G[U]+=(V,D),;G[V]+=(U,D),\nP,X=f(S);Q,Y=f(T);s=P[T];print((X[T]**2-sum(-~s%2*x*x*y*y*(p==q==s//2)+(p<q)*x*x*sum((p+d+Q[j]==s)*(Q[j]<P[j])*Y[j]**2for j,d in g)for g,p,q,x,y in zip(G,P,Q,X,Y)))%(10**9+7))", "import heapq\nimport sys\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nMOD = 10**9+7\nclass DijkstraList():\n\t#\u96a3\u63a5\u30ea\u30b9\u30c8\u7248\n\t#\u540c\u4e00\u9802\u70b9\u306e\u8907\u6570\u56de\u63a2\u7d22\u3092\u9632\u3050\u305f\u3081\u8a2a\u554f\u3057\u305f\u9802\u70b9\u6570\u3092\u5909\u6570cnt\u3067\u6301\u3064\n\tdef __init__(self, adj, start):\n\t\tself.list = adj\n\t\tself.start = start\n\t\tself.size = len(adj)\n\n\tdef solve(self):\n\t\tself.dist = [float(\"inf\") for _ in range(self.size)]\n\t\tself.dist[self.start] = 0\n\t\tself.dp = [0 for _ in range(self.size)]\n\t\tself.dp[self.start] = 1\n\t\t#self.prev = [-1 for _ in range(self.size)]\n\t\tself.q = []\n\t\tself.cnt = 0\n\n\t\theapq.heappush(self.q, (0, self.start))\n\n\t\twhile self.q and self.cnt < self.size:\n\t\t\tu_dist, u = heapq.heappop(self.q)\n\t\t\tif self.dist[u] < u_dist:\n\t\t\t\tcontinue\n\t\t\tfor v, w in self.list[u]:\n\t\t\t\tif self.dist[v] > u_dist + w:\n\t\t\t\t\tself.dist[v] = u_dist + w\n\t\t\t\t\tself.dp[v] = self.dp[u]\n\t\t\t\t\t#self.prev[v] = u\n\t\t\t\t\theapq.heappush(self.q, (self.dist[v], v))\n\t\t\t\telif self.dist[v] == u_dist + w:\n\t\t\t\t\tself.dp[v] += self.dp[u]\n\t\t\t\t\tself.dp[v] %= MOD\n\n\t\t\tself.cnt += 1\n\t\t#print(self.dp)\n\t\treturn\n\n\tdef distance(self, goal):\n\t\treturn self.dist[goal]\n\n\tdef get_dp(self, x):\n\t\treturn self.dp[x]\n\nn, m = map(int, input().split())\ns, t = map(int, input().split())\ns, t = s-1, t-1\nadj = [[] for _ in range(n)]\nfor _ in range(m):\n\tu, v, d = map(int, input().split())\n\tadj[u-1].append([v-1, d])\n\tadj[v-1].append([u-1, d])\nS, T = DijkstraList(adj, s), DijkstraList(adj, t)\nS.solve()\nT.solve()\nans = pow(S.get_dp(t), 2, MOD)\ngoal = S.distance(t)\n#print(ans, goal)\n\nfor i in range(n):\n\tSI, TI = S.distance(i), T.distance(i)\n\tif SI + TI != goal:\n\t\tcontinue\n\tif SI*2 == goal:\n\t\tans -= S.get_dp(i) * T.get_dp(i) * S.get_dp(i) * T.get_dp(i)\n\t\tans %= MOD\n\n\telse:\n\t\tfor j, d in adj[i]:\n\t\t\tif i>j:\n\t\t\t\tcontinue\n\t\t\tSJ, TJ = S.distance(j), T.distance(j)\n\t\t\tif SJ + TJ != goal or abs(SI - SJ) != d:\n\t\t\t\tcontinue\n\t\t\tif SI*2 < goal < SJ*2:\n\t\t\t\t#print(i, j, SI, SJ)\n\t\t\t\tans -= S.get_dp(i) * T.get_dp(j) * S.get_dp(i) * T.get_dp(j)\n\t\t\t\tans %= MOD\n\t\t\telif SJ*2 < goal < SI*2:\n\t\t\t\t#print(i, j, SI, SJ)\n\t\t\t\tans -= S.get_dp(j) * T.get_dp(i) * S.get_dp(j) * T.get_dp(i)\n\t\t\t\tans %= MOD\n\nprint(ans)", "import sys\ndef MI(): return list(map(int,sys.stdin.readline().rstrip().split()))\n\nN,M = MI()\nS,T = MI()\nedges = [[] for _ in range(N+1)]\nedges2 = []\nfor _ in range(M):\n U,V,D = MI()\n edges[U].append((V,D))\n edges[V].append((U,D))\n edges2.append((U,V,D))\n edges2.append((V,U,D))\n\nmod = 10**9+7\n\nfrom heapq import heappop,heappush\n\ndistS = [(10**18,0)]*(N+1) # (\u6700\u77ed\u8ddd\u96e2,\u7d4c\u8def\u6570)\ndistS[S] = (0,1)\nqS = []\nheappush(qS,(0,S))\nvS = [False]*(N+1)\nwhile qS:\n d,i = heappop(qS)\n if vS[i]:\n continue\n vS[i] = True\n for j,d in edges[i]:\n if vS[j]:\n continue\n if distS[j][0] > distS[i][0] + d:\n distS[j] = (distS[i][0] + d,distS[i][1])\n heappush(qS,(distS[i][0] + d,j))\n elif distS[j][0] == distS[i][0] + d:\n distS[j] = (distS[j][0],distS[j][1]+distS[i][1])\n heappush(qS,(distS[i][0] + d,j))\n\ndistT = [(10**18,0)]*(N+1)\ndistT[T] = (0,1)\nqT = []\nheappush(qT,(0,T))\nvT = [False]*(N+1)\nwhile qT:\n d,i = heappop(qT)\n if vT[i]:\n continue\n vT[i] = True\n for j,d in edges[i]:\n if vT[j]:\n continue\n if distT[j][0] > distT[i][0] + d:\n distT[j] = (distT[i][0] + d,distT[i][1])\n heappush(qT,(distT[i][0] + d,j))\n elif distT[j][0] == distT[i][0] + d:\n distT[j] = (distT[j][0],distT[j][1]+distT[i][1])\n heappush(qT,(distT[i][0] + d,j))\n\na,b = distS[T] # S\u304b\u3089T\u307e\u3067\u306e\u6700\u77ed\u8ddd\u96e2,\u7d4c\u8def\u6570\nans = b**2 % mod\n\n# \u9802\u70b9\u3067\u51fa\u304f\u308f\u3059\u5834\u5408\nif a % 2 == 0:\n for i in range(1,N+1):\n if distS[i][0] == distT[i][0] == a//2:\n ans -= (distS[i][1]*distT[i][1])**2\n ans %= mod\n\n# \u8fba\u4e0a\u3067\u51fa\u304f\u308f\u3059\u5834\u5408\nfor i in range(2*M):\n U,V,D = edges2[i]\n if distS[U][0] < (a+1)//2 and distT[V][0] < (a+1)//2 and a == distS[U][0] + D + distT[V][0]:\n ans -= (distS[U][1]*distT[V][1])**2\n ans %= mod\n\nprint(ans)\n", "from heapq import heappush,heappop\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)]\n while p:\n d,v=heappop(p)\n if d>a[v]:continue\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u))\n return a\ndef g(a,s):\n w=[0]*N;w[s]=1;b=[0]*N;b[s]=1;p=[(0,s)]\n while p:\n d,v=heappop(p)\n for u,d in G[v]:\n if a[v]+d==a[u]:\n w[u]=(w[u]+w[v])%m\n if not b[u]:heappush(p,(a[u],u));b[u]=1\n return w\nm=10**9+7\nN,M=map(int,input().split());N+=1\nS,T=map(int,input().split())\nG=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=map(int,input().split());G[U]+=[(V,D)];G[V]+=[(U,D)]\ndS=f(S)\ndT=f(T)\nwS=g(dS,S)\nwT=g(dT,T)\ns=dS[T]\na=(wS[T]**2-(1-s%2)*sum((wS[i]*wT[i])**2for i in range(N)if dS[i]==dT[i]==s//2))%m\nfor i in range(N):\n for j,d in G[i]:\n if(dS[i]+d+dT[j]==s)*(dS[i]<dT[i])*(dT[j]<dS[j]):a=(a-(wS[i]*wT[j])**2)%m\nprint(a)", "\n\"\"\"\n\n\u4e21\u65b9\u304b\u3089\u8ddd\u96e2L\u306e\u70b9\u306e\u6570\u304c\u308f\u304b\u308c\u3070\u3088\u3044\nST\u304b\u3089\u30c0\u30a4\u30af\u30b9\u30c8\u30e9\n\n\u9802\u70b9\u304c\u306a\u308b\u5834\u5408\u2192\u8abf\u3079\u308b\n\u8fba\u306e\u9593\u3067\u306a\u308b\u5834\u5408\n\u4e21\u65b9\u8fd1\u3044\u307b\u3046\u304c\u7570\u306a\u308b & \u305d\u306e\u548c+\u8fba\u306e\u9577\u3055\u304c2L\n\n\u3076\u3064\u304b\u308b\u3082\u306e\u3092\u5f15\u304d\u305f\u3044\n\u305d\u306e\u9802\u70b9\u307e\u3067\u306e\u7d4c\u8def\u6570\u3082\u6c42\u3081\u3066\u304a\u304f\n\n\"\"\"\n\nfrom sys import stdin\n\nimport heapq\ndef Dijkstra(lis,start):\n\n ret = [float(\"inf\")] * len(lis)\n rnum = [0] * len(lis)\n rnum[start] = 1\n \n ret[start] = 0\n end_flag = [False] * len(lis)\n end_num = 0\n \n q = [[0,start]]\n\n while len(q) > 0:\n\n ncost,now = heapq.heappop(q)\n\n if end_flag[now]:\n continue\n\n end_flag[now] = True\n end_num += 1\n\n if end_num == len(lis):\n break\n\n for nex,ecost in lis[now]:\n\n if ret[nex] > ncost + ecost:\n ret[nex] = ncost + ecost\n heapq.heappush(q , [ret[nex] , nex])\n rnum[nex] = 0\n if ret[nex] == ncost + ecost:\n rnum[nex] = (rnum[nex] + rnum[now]) % mod\n #print (now,rnum)\n return ret,rnum\n\nN,M = list(map(int,stdin.readline().split()))\nS,T = list(map(int,stdin.readline().split()))\nS -= 1\nT -= 1\nmod = 10**9+7\n\nlis = [ [] for i in range(N) ]\nfor i in range(M):\n u,v,d = list(map(int,stdin.readline().split()))\n u -= 1\n v -= 1\n lis[u].append((v,d))\n lis[v].append((u,d))\n\nDS,rootS = Dijkstra(lis,S)\nDT,rootT = Dijkstra(lis,T)\n\nans = (rootS[T] ** 2) % mod\nL = DS[T]\n\n#print (DS,rootS)\n\nfor v in range(N):\n \n if L % 2 == 0 and DS[v] == DT[v] == L//2:\n ans -= (rootS[v] * rootT[v]) ** 2\n continue\n\n for nex,ecost in lis[v]:\n if nex < v:\n if DS[v]+DT[nex]+ecost == L and DS[v]*2<L and DT[nex]*2<L:\n ans -= (rootS[v] * rootT[nex]) ** 2\n elif DS[nex]+DT[v]+ecost == L and DS[nex]*2<L and DT[v]*2<L:\n ans -= (rootS[nex] * rootT[v]) ** 2\n ans %= mod\n \nprint((ans % mod))\n", "def main():\n from sys import stdin\n input = stdin.readline\n\n n, m = list(map(int, input().split()))\n s, t = [int(x)-1 for x in input().split()]\n g = [[] for _ in [0]*n]\n for i in range(m):\n a, b, c = list(map(int, input().split()))\n g[a-1].append((b-1, c))\n g[b-1].append((a-1, c))\n\n import heapq\n inf = 10**16\n short = inf\n mod = 10**9+7\n\n dist_s = [inf]*n\n dp_s = ([0]*n)+[1]\n h = [(0, s, -1)]\n heapq.heapify(h)\n while h:\n d, i, a = heapq.heappop(h)\n if d > short:\n break\n elif i == t:\n short = d\n d2 = dist_s[i]\n if d2 == inf:\n dist_s[i] = d\n dp_s[i] = dp_s[a]\n for j, k in g[i]:\n if dist_s[j] == inf:\n heapq.heappush(h, (d+k, j, i))\n elif d2 == d:\n dp_s[i] = (dp_s[i]+dp_s[a]) % mod\n\n dist_t = [inf]*n\n dp_t = ([0]*n)+[1]\n h = [(0, t, -1)]\n heapq.heapify(h)\n while h:\n d, i, a = heapq.heappop(h)\n if d > short:\n break\n d2 = dist_t[i]\n if d2 == inf:\n dist_t[i] = d\n dp_t[i] = dp_t[a]\n for j, k in g[i]:\n if dist_t[j] == inf:\n heapq.heappush(h, (d+k, j, i))\n elif d2 == d:\n dp_t[i] = (dp_t[i]+dp_t[a]) % mod\n\n ans = dp_s[t]**2 % mod\n\n for i, (p, q) in enumerate(zip(dist_s, dist_t)):\n if p+q == short:\n d = p*2\n if d == short and q*2 == short:\n ans = (ans-(dp_s[i]*dp_t[i])**2) % mod\n elif d < short:\n for j, k in g[i]:\n if d+2*k > short:\n if d+2*k+2*dist_t[j] == 2*short:\n ans = (ans-(dp_s[i]*dp_t[j])**2) % mod\n\n print(ans)\n\n\nmain()\n", "from heapq import heappush, heappop\nimport sys\ninput = sys.stdin.readline\nINF = 10**18\nmod = 10**9+7\ndef dijkstra(start, n, graph):\n route_cnt = [start] * n\n route_cnt[start] = 1\n que = [(0, start)]\n dist = [INF] * n\n dist[start] = 0\n while que:\n min_dist, u = heappop(que)\n if min_dist > dist[u]:\n continue\n for c, v in graph[u]:\n if dist[u] + c < dist[v]:\n dist[v] = dist[u] + c\n route_cnt[v] = route_cnt[u]\n heappush(que, (dist[u] + c , v))\n elif dist[u] + c == dist[v]:\n route_cnt[v] = (route_cnt[v] + route_cnt[u]) % mod\n return route_cnt, dist\nN, M = list(map(int, input().split()))\nS, T = list(map(int, input().split()))\nG = [[] for _ in range(N)]\nedges = []\nfor _ in range(M):\n u, v, d = list(map(int, input().split()))\n G[u-1].append((d, v-1))\n G[v-1].append((d, u-1))\n edges.append((v-1, u-1, d))\nnum_s, dist_s = dijkstra(S-1, N, G)\nnum_t, dist_t = dijkstra(T-1, N, G)\nans = num_s[T-1]**2%mod\nl = dist_s[T-1]\nfor u, v, d in edges:\n if dist_s[v]<dist_s[u]:\n u, v = v, u\n if dist_s[u]*2<l<dist_s[v]*2 and dist_s[u]+dist_t[v]+d == l:\n ans-=(num_s[u]**2%mod)*(num_t[v]**2%mod)\n ans%=mod\nfor v in range(N):\n if dist_s[v] == dist_t[v] == l/2:\n ans-=(num_t[v]**2%mod)*(num_s[v]**2%mod)\n ans%=mod\nprint((ans%mod))\n\n\n\n\n\n", "from heapq import heappush,heappop\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)]\n while p:\n d,v=heappop(p)\n if d>a[v]:continue\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u))\n return a\ndef g(a,s):\n w=[0]*N;w[s]=1;b=[0]*N;b[s]=1;p=[(0,s)]\n while p:\n d,v=heappop(p)\n for u,d in G[v]:\n if a[v]+d==a[u]:\n w[u]=(w[u]+w[v])%m\n if not b[u]:heappush(p,(a[u],u));b[u]=1\n return w\nm=10**9+7\nN,M=map(int,input().split())\nS,T=map(int,input().split())\nS-=1;T-=1\nG=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=map(int,input().split());U-=1;V-=1;G[U]+=[(V,D)];G[V]+=[(U,D)]\ndS=f(S)\ndT=f(T)\nwS=g(dS,S)\nwT=g(dT,T)\ns=dS[T]\na=(wS[T]**2-(1-s%2)*sum((wS[i]*wT[i])**2for i in range(N)if dS[i]==dT[i]==s//2))%m\nfor i in range(N):\n for j,d in G[i]:\n if dS[i]+d+dT[j]==s:\n if(dS[i]<dT[i])*(dT[j]<dS[j]):a=(a-(wS[i]*wT[j])**2)%m\nprint(a)", "from heapq import heapify, heappush, heappop\ndef conv(c, p, pp):\n return (c*N + p)*N + pp\ndef rev(X):\n pp = X % N\n X //= N\n p = X % N\n c = X // N\n return (c, p, pp)\n\nMOD = 10**9 + 7\nN, M = list(map(int,input().split()))\ns, t = list(map(int,input().split()))\ns -= 1; t -= 1;\nI = [[] for _ in range(N)]\nedges = []\nfor _ in range(M):\n u, v, c = list(map(int,input().split()))\n u -= 1; v -= 1;\n I[u].append((v, c))\n I[v].append((u, c))\n edges.append(conv(c,u,v))\n \nfin_i = [0 for _ in range(N)]\nml_i = [0 for _ in range(N)]\nfin_r = [0 for _ in range(N)]\nml_r = [0 for _ in range(N)]\n\n \ndef dijkstra(s, fin, ml):\n task = [conv(0, s, s)]\n fin[s] = 1\n ml[s] = 0\n vis = set()\n while task:\n while True:\n if not task:\n return\n #print(task)\n c, p, pp = rev(heappop(task))\n #print(c, p, pp, task)\n if p in vis and c == ml[p]:\n #print(p, pp, 1, vis)\n fin[p] += fin[pp]\n fin[p] %= MOD\n elif p not in vis:\n #print(p)\n break\n if p != s:\n #print(p, pp, 2)\n fin[p] += fin[pp]\n fin[p] %= MOD\n ml[p] = c\n vis.add(p)\n #print(p, I[p])\n for q, c_n in I[p]:\n if q not in vis:\n heappush(task, conv(c+c_n, q, p))\n return\n\ndijkstra(s, fin_i, ml_i)\ndijkstra(t, fin_r, ml_r)\n#print(ml_i)\n#print(fin_i)\n#print(ml_r)\n#print(fin_r)\nL = ml_i[t]\n\nans = 0\nfor X in edges:\n c, u, v = rev(X)\n if ml_i[u] + c + ml_r[v] == L and ml_i[u]*2 < L < ml_i[v]*2:\n #print(u, v, fin_i[u], fin_r[v])\n ans += (fin_i[u] * fin_r[v]) ** 2\n u, v = v, u\n if ml_i[u] + c + ml_r[v] == L and ml_i[u]*2 < L < ml_i[v]*2:\n #print(u, v, fin_i[u], fin_r[v])\n ans += (fin_i[u] * fin_r[v]) ** 2\n ans %= MOD\nfor p in range(N):\n if 2*ml_i[p] == L:\n #print(p, fin_i[p] * fin_r[p])\n ans += (fin_i[p] * fin_r[p]) ** 2\n ans %= MOD\n \nprint(((fin_i[t]**2 - ans) %MOD))\n", "from heapq import heappop, heappush\nimport sys\n\nMOD, INF = 1000000007, float('inf')\n\n\ndef solve(s, t, links):\n q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]\n visited_fwd, visited_bwd = [INF] * n, [INF] * n\n patterns_fwd, patterns_bwd = [0] * (n + 1), [0] * (n + 1)\n patterns_fwd[-1] = patterns_bwd[-1] = 1\n collision_nodes, collision_links = set(), set()\n limit = 0\n while q:\n cost, cost_a, v, a, is_bwd = heappop(q)\n if is_bwd:\n visited_self = visited_bwd\n visited_opp = visited_fwd\n patterns_self = patterns_bwd\n else:\n visited_self = visited_fwd\n visited_opp = visited_bwd\n patterns_self = patterns_fwd\n\n relax_flag = False\n cost_preceding = visited_self[v]\n if cost_preceding == INF:\n visited_self[v] = cost\n relax_flag = True\n elif cost > cost_preceding:\n continue\n\n patterns_self[v] += patterns_self[a]\n\n cost_opp = visited_opp[v]\n if cost_opp != INF:\n limit = cost + cost_opp\n if cost == cost_opp:\n collision_nodes.add(v)\n else:\n collision_links.add((v, a) if is_bwd else (a, v))\n break\n\n if relax_flag:\n for u, du in list(links[v].items()):\n nc = cost + du\n if visited_self[u] < nc:\n continue\n heappush(q, (nc, cost, u, v, is_bwd))\n\n collision_time = limit / 2\n while q:\n cost, cost_a, v, a, is_bwd = heappop(q)\n if cost > limit:\n break\n visited_self = visited_bwd if is_bwd else visited_fwd\n if visited_self[v] == INF:\n visited_self[v] = cost\n if is_bwd:\n if cost == collision_time:\n patterns_bwd[v] += patterns_bwd[a]\n continue\n if cost_a == collision_time:\n collision_nodes.add(a)\n elif cost == collision_time:\n collision_nodes.add(v)\n patterns_fwd[v] += patterns_fwd[a]\n else:\n collision_links.add((a, v))\n\n shortest_count = 0\n collision_count = 0\n\n for v in collision_nodes:\n if visited_fwd[v] == visited_bwd[v]:\n r = patterns_fwd[v] * patterns_bwd[v]\n shortest_count += r\n shortest_count %= MOD\n collision_count += r * r\n collision_count %= MOD\n\n for u, v in collision_links:\n if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:\n r = patterns_fwd[u] * patterns_bwd[v]\n shortest_count += r\n shortest_count %= MOD\n collision_count += r * r\n collision_count %= MOD\n\n return (shortest_count ** 2 - collision_count) % MOD\n\n\nn, m = list(map(int, input().split()))\ns, t = list(map(int, input().split()))\ns -= 1\nt -= 1\nlinks = [{} for _ in range(n)]\nfor uvd in sys.stdin.readlines():\n u, v, d = list(map(int, uvd.split()))\n # for _ in range(m):\n # u, v, d = map(int, input().split())\n u -= 1\n v -= 1\n links[u][v] = d\n links[v][u] = d\nprint((solve(s, t, links)))\n", "from heapq import heappush, heappop\nfrom collections import deque\nN, M = list(map(int, input().split()))\nS, T = list(map(int, input().split()))\nS -= 1; T -= 1\nG = [[] for i in range(N)]\nfor i in range(M):\n u, v, d = list(map(int, input().split()))\n G[u-1].append((v-1, d))\n G[v-1].append((u-1, d))\n\nINF = 10**18\nMOD = 10**9 + 7\n\ndist = [INF]*N\ndist[S] = 0\nque = [(0, S)]\nwhile que:\n cost, v = heappop(que)\n if dist[v] < cost:\n continue\n for w, c in G[v]:\n if cost + c < dist[w]:\n dist[w] = cost + c\n heappush(que, (cost + c, w))\n\nque = deque()\nmi = [0]*N\nque.append(T)\nmi[T] = 1\nH = [[] for i in range(N)]\nRH = [[] for i in range(N)]\n\nD = dist[T]\n\nV = []\nE = []\nwhile que:\n v = que.popleft()\n d = dist[v]\n if d*2 == D:\n V.append(v)\n for w, c in G[v]:\n if d == dist[w] + c:\n if dist[w]*2 < D < d*2:\n E.append((w, v))\n H[v].append(w)\n RH[w].append(v)\n if mi[w] == 0:\n mi[w] = 1\n que.append(w)\n\ndef bfs(G, RG, s):\n *deg, = list(map(len, RG))\n que = deque([s])\n res = [0]*N\n res[s] = 1\n while que:\n v = que.popleft()\n for w in G[v]:\n deg[w] -= 1\n res[w] += res[v]\n if deg[w] == 0:\n que.append(w)\n res[w] %= MOD\n return res\nCT = bfs(H, RH, T)\nCS = bfs(RH, H, S)\n\nans = CS[T] * CT[S] % MOD\nfor v in V:\n ans -= (CS[v] * CT[v]) ** 2\n ans %= MOD\nfor v, w in E:\n ans -= (CS[v] * CT[w]) ** 2\n ans %= MOD\nprint(ans)\n", "from heapq import *\ndef dijkstra(g,start):\n n = len(g)\n INF = 1<<61\n dist = [INF]*(n) #start\u304b\u3089\u306e\u6700\u77ed\u8ddd\u96e2\n num = [0]*n\n dist[start] = 0\n num[start] = 1\n q = [(0,start)] #(\u305d\u3053\u307e\u3067\u306e\u8ddd\u96e2\u3001\u70b9)\n while q:\n dv,v = heappop(q)\n if dist[v] < dv: continue\n for to, cost in g[v]:\n if dv + cost < dist[to]:\n dist[to] = dv + cost\n num[to] = num[v]\n heappush(q, (dist[to], to))\n elif dv + cost == dist[to]:\n num[to] += num[v]\n num[to] %= MOD\n return dist,num\n\n# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn,m = list(map(int,readline().split()))\ns,t = list(map(int,readline().split()))\ns -= 1\nt -= 1\n\ng = [[] for _ in range(n)]\nedges = []\nfor _ in range(m):\n a,b,c = list(map(int,readline().split()))\n g[a-1].append((b-1,c))\n g[b-1].append((a-1,c))\n edges.append((a-1,b-1,c))\n\nMOD = 10**9+7\ndist,num = dijkstra(g,s)\ndt,nt = dijkstra(g,t)\n\n#print(dist,dt)\n#print(num,nt)\n\nans = num[t]**2\n#print(ans,\"original\")\n\nD = dist[t]\nfor i in range(n):\n if dist[i]*2 == D and dist[i] + dt[i] == dist[t]:\n ans -= ((num[i]*nt[i]%MOD)**2)%MOD\n\n#print(ans,\"remove-pt\")\n\nfor a,b,c in edges:\n da = dist[a]\n db = dist[b]\n if da > db:\n a,b = b,a\n da,db = db,da\n if da*2 < D and db*2 > D and dist[a] + dt[b] + c == dist[t]:\n ans -= ((num[a]*nt[b]%MOD)**2)%MOD\n\nprint((ans%MOD))\n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 10**9+7\ndd = [(-1,0),(0,1),(1,0),(0,-1)]\nddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\ndef main():\n n,m = LI()\n s,t = LI()\n e = collections.defaultdict(list)\n for _ in range(m):\n u,v,d = LI()\n e[u].append((v,d))\n e[v].append((u,d))\n\n def search(s,t):\n d = collections.defaultdict(lambda: inf)\n dc = collections.defaultdict(int)\n d[s] = 0\n dc[s] = 1\n q = []\n heapq.heappush(q, (0, s))\n v = collections.defaultdict(bool)\n while len(q):\n k, u = heapq.heappop(q)\n if v[u]:\n continue\n v[u] = True\n\n if u == t:\n return (d,dc)\n\n uc = dc[u]\n\n for uv, ud in e[u]:\n if v[uv]:\n continue\n vd = k + ud\n if d[uv] < vd:\n continue\n if d[uv] > vd:\n d[uv] = vd\n dc[uv] = uc\n heapq.heappush(q, (vd, uv))\n elif d[uv] == vd:\n dc[uv] += uc\n\n return (d,dc)\n\n d1,dc1 = search(s,t)\n d2,dc2 = search(t,s)\n rd = d1[t]\n kk = rd / 2.0\n\n r = dc1[t] ** 2 % mod\n for k in list(d1.keys()):\n t = d1[k]\n c = dc1[k]\n if t > kk:\n continue\n if t == kk:\n if d2[k] == t:\n r -= (c**2 * dc2[k]**2) % mod\n continue\n\n for uv, ud in e[k]:\n if d2[uv] >= kk or t + ud + d2[uv] != rd:\n continue\n r -= (c**2 * dc2[uv]**2) % mod\n\n return r % mod\n\n\n\n\nprint(main())\n", "from heapq import*\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)];c=[0]*N;c[s]=1\n while p:\n d,v=heappop(p)\n if d<=a[v]:\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u));c[u]=0\n c[u]+=c[v]*(a[u]==d+w)\n return a,c\nn=lambda:map(int,input().split());N,M=n();N+=1;S,T=n();G=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=n();G[U]+=(V,D),;G[V]+=(U,D),\nP,X=f(S);Q,Y=f(T);s=P[T];print((X[T]**2--~s%2*sum(x*x*y*y*(p==q==s//2)for x,y,p,q in zip(X,Y,P,Q))-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%(10**9+7))", "import heapq as h\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)];c=[0]*N;c[s]=1\n while p:\n d,v=h.heappop(p)\n if d<=a[v]:\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;h.heappush(p,(d+w,u));c[u]=0\n if a[u]==d+w:c[u]+=c[v]\n return a,c\nn=lambda:map(int,input().split());N,M=n();N+=1;S,T=n();G=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=n();G[U]+=[(V,D)];G[V]+=[(U,D)]\nP,X=f(S);Q,Y=f(T);s=P[T];print((X[T]**2-(1-s%2)*sum((X[i]*Y[i])**2for i in range(N)if P[i]==Q[i]==s//2)-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%(10**9+7))", "from heapq import heappush as k,heappop as l\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)]\n c=[0]*N;c[s]=1\n while p:\n d,v=l(p)\n if d>a[v]:continue\n for u,w in G[v]:\n if a[u]==d+w:\n c[u]+=c[v]\n if a[u]>d+w:\n a[u]=d+w;k(p,(d+w,u))\n c[u]=c[v]\n return a,c\nm=10**9+7\nN,M=map(int,input().split());N+=1\nS,T=map(int,input().split())\nG=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=map(int,input().split());G[U]+=[(V,D)];G[V]+=[(U,D)]\nP,X=f(S);Q,Y=f(T);s=P[T]\nprint((X[T]**2-(1-s%2)*sum((X[i]*Y[i])**2for i in range(N)if P[i]==Q[i]==s//2)-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%m)", "import heapq\nMOD = 10 ** 9 + 7\n\nN, M = list(map(int, input().split()))\nS, T = [int(x) - 1 for x in input().split()]\n\nadjList = [[] for i in range(N)]\nfor i in range(M):\n U, V, D = list(map(int, input().split()))\n adjList[U - 1].append((V - 1, D))\n adjList[V - 1].append((U - 1, D))\n\n# \u9802\u70b9S\u304b\u3089\u5404\u9802\u70b9\u3078\u306e\u6700\u77ed\u8def\u306e\u500b\u6570\nnumRouteS = [0 for i in range(N)]\nnumRouteS[S] = 1\n\ncost = [float('inf')] * N\ncost[S] = 0\nprev = [None] * N\n\npq = []\nheapq.heappush(pq, (0, S))\n\nvs = []\nwhile pq:\n c, vNow = heapq.heappop(pq)\n if c > cost[vNow]: continue\n if c > cost[T]: break\n vs += [vNow]\n\n for v2, wt in adjList[vNow]:\n c2 = cost[vNow] + wt\n if c2 <= cost[v2]:\n if c2 == cost[v2]:\n prev[v2] += [vNow]\n numRouteS[v2] = (numRouteS[v2] + numRouteS[vNow]) % MOD\n else:\n cost[v2] = c2\n prev[v2] = [vNow]\n numRouteS[v2] = numRouteS[vNow]\n heapq.heappush(pq, (c2, v2))\n\n# \u9802\u70b9T\u304b\u3089\u5404\u9802\u70b9\u3078\u306e\u6700\u77ed\u8def\u306e\u500b\u6570\nnumRouteT = [0] * N\nnumRouteT[T] = 1\nfor v in reversed(vs[1:]):\n for v0 in prev[v]:\n numRouteT[v0] = (numRouteT[v0] + numRouteT[v]) % MOD\n\n# \u4e8c\u4eba\u306e\u6700\u77ed\u8def\u306e\u9078\u3073\u65b9\u306e\u7d44\u304b\u3089\u3001\u9014\u4e2d\u3067\u51fa\u4f1a\u3046\u3082\u306e\u3092\u5f15\u304f\ncST = cost[T]\nans = (numRouteS[T] ** 2) % MOD\n\nfor v, c in enumerate(cost):\n if c * 2 == cST:\n x = (numRouteS[v] ** 2) % MOD\n y = (numRouteT[v] ** 2) % MOD\n ans = (ans - x * y) % MOD\n\nfor v, c in enumerate(cost):\n if c * 2 < cST:\n for v2, wt in adjList[v]:\n if (cost[v2] * 2 > cST) and c + wt == cost[v2]:\n x = (numRouteS[v] ** 2) % MOD\n y = (numRouteT[v2] ** 2) % MOD\n ans = (ans - x * y) % MOD\n\nprint(ans)\n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 10**9+7\ndd = [(-1,0),(0,1),(1,0),(0,-1)]\nddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\ndef main():\n n,m = LI()\n s,t = LI()\n e = collections.defaultdict(list)\n for _ in range(m):\n u,v,d = LI()\n e[u].append((v,d))\n e[v].append((u,d))\n\n def search(s,t):\n d = collections.defaultdict(lambda: inf)\n dc = collections.defaultdict(int)\n d[s] = 0\n dc[s] = 1\n q = []\n heapq.heappush(q, (0, s))\n v = collections.defaultdict(bool)\n while len(q):\n k, u = heapq.heappop(q)\n if v[u]:\n continue\n v[u] = True\n\n dc[u] %= mod\n if u == t:\n return (d,dc)\n\n uc = dc[u]\n\n for uv, ud in e[u]:\n if v[uv]:\n continue\n vd = k + ud\n if d[uv] < vd:\n continue\n if d[uv] > vd:\n d[uv] = vd\n dc[uv] = uc\n heapq.heappush(q, (vd, uv))\n elif d[uv] == vd:\n dc[uv] += uc\n\n return (d,dc)\n\n d1,dc1 = search(s,t)\n d2,dc2 = search(t,s)\n rd = d1[t]\n kk = rd / 2.0\n\n r = dc1[t] ** 2 % mod\n for k in list(d1.keys()):\n t = d1[k]\n c = dc1[k]\n if t > kk:\n continue\n if t == kk:\n if d2[k] == t:\n r -= pow(c,2,mod) * pow(dc2[k],2,mod) % mod\n continue\n\n for uv, ud in e[k]:\n if d2[uv] >= kk or t + ud + d2[uv] != rd:\n continue\n r -= pow(c,2,mod) * pow(dc2[uv],2,mod) % mod\n\n return r % mod\n\n\n\n\nprint(main())\n", "from heapq import heappop, heappush\nMOD = 10 ** 9 + 7\n\nN, M = list(map(int, input().split()))\nS, T = [int(x) - 1 for x in input().split()]\n\nadjList = [[] for i in range(N)]\nfor i in range(M):\n U, V, D = list(map(int, input().split()))\n adjList[U - 1].append((V - 1, D))\n adjList[V - 1].append((U - 1, D))\n\n# \u9802\u70b9S\u304b\u3089\u5404\u9802\u70b9\u3078\u306e\u6700\u77ed\u8def\u306e\u500b\u6570\nnumRouteS = [0] * N\nnumRouteS[S] = 1\n\ncost = [float('inf')] * N\ncost[S] = 0\nprev = [None] * N\nvs = []\n\npq = []\nheappush(pq, (0, S))\nwhile pq:\n c, vNow = heappop(pq)\n if c > cost[vNow]: continue\n if c > cost[T]: break\n vs += [vNow]\n\n for v2, wt in adjList[vNow]:\n c2 = c + wt\n if c2 < cost[v2]:\n cost[v2] = c2\n prev[v2] = [vNow]\n numRouteS[v2] = numRouteS[vNow]\n heappush(pq, (c2, v2))\n elif c2 == cost[v2]:\n prev[v2] += [vNow]\n numRouteS[v2] = (numRouteS[v2] + numRouteS[vNow]) % MOD\n\n# \u9802\u70b9T\u304b\u3089\u5404\u9802\u70b9\u3078\u306e\u6700\u77ed\u8def\u306e\u500b\u6570\nnumRouteT = [0] * N\nnumRouteT[T] = 1\ncST = cost[T]\nfor iV, v in enumerate(reversed(vs)):\n if cost[v] * 2 < cST:\n iVLim = len(vs) - iV\n break\n for v0 in prev[v]:\n numRouteT[v0] = (numRouteT[v0] + numRouteT[v]) % MOD\n\n# \u4e8c\u4eba\u306e\u6700\u77ed\u8def\u306e\u9078\u3073\u65b9\u306e\u7d44\u304b\u3089\u3001\u9014\u4e2d\u3067\u51fa\u4f1a\u3046\u3082\u306e\u3092\u5f15\u304f\nans = (numRouteS[T] ** 2) % MOD\n\nfor v in vs[:iVLim]:\n x = (numRouteS[v] ** 2) % MOD\n for v2, wt in adjList[v]:\n if (cost[v2] * 2 > cST) and cost[v] + wt == cost[v2]:\n y = (numRouteT[v2] ** 2) % MOD\n ans = (ans - x * y) % MOD\n\nfor v in vs[iVLim:]:\n if cost[v] * 2 > cST: break\n x = (numRouteS[v] ** 2) % MOD\n y = (numRouteT[v] ** 2) % MOD\n ans = (ans - x * y) % MOD\n\nprint(ans)\n", "from heapq import*\ndef f(s):\n a=[1<<50]*N;a[s]=0;p=[(0,s)];c=[0]*N;c[s]=1\n while p:\n d,v=heappop(p)\n if d<=a[v]:\n for u,w in G[v]:\n if a[u]>d+w:a[u]=d+w;heappush(p,(d+w,u));c[u]=0\n if a[u]==d+w:c[u]+=c[v]\n return a,c\nn=lambda:map(int,input().split());N,M=n();N+=1;S,T=n();G=[[]for _ in[0]*N]\nfor _ in[0]*M:U,V,D=n();G[U]+=[(V,D)];G[V]+=[(U,D)]\nP,X=f(S);Q,Y=f(T);s=P[T];print((X[T]**2--~s%2*sum((X[i]*Y[i])**2for i in range(N)if P[i]==Q[i]==s//2)-sum((P[i]+d+Q[j]==s)*(P[i]<Q[i])*(Q[j]<P[j])*(X[i]*Y[j])**2for i in range(N)for j,d in G[i]))%(10**9+7))", "from heapq import heappush, heappop\nimport sys\ninput = sys.stdin.readline\n\nINF = float('inf')\nMOD = 10**9 + 7\n\ndef Dijkstra(adjList, vSt):\n numV = len(adjList)\n numUsed = 0\n costs = [INF] * numV\n costs[vSt] = 0\n nums = [0] * numV\n nums[vSt] = 1\n PQ = []\n heappush(PQ, (0, vSt))\n while PQ:\n cNow, vNow = heappop(PQ)\n if cNow > costs[vNow]: continue\n numUsed += 1\n if numUsed == numV: break\n for v2, wt in adjList[vNow]:\n c2 = cNow + wt\n if c2 < costs[v2]:\n costs[v2] = c2\n nums[v2] = nums[vNow]\n heappush(PQ, (c2, v2))\n elif c2 == costs[v2]:\n nums[v2] = (nums[v2]+nums[vNow]) % MOD\n return (costs, nums)\n\ndef solve():\n N, M = list(map(int, input().split()))\n S, T = list(map(int, input().split()))\n S, T = S-1, T-1\n edges = [tuple(map(int, input().split())) for _ in range(M)]\n adjL = [[] for _ in range(N)]\n for u, v, d in edges:\n adjL[u-1].append((v-1, d))\n adjL[v-1].append((u-1, d))\n\n costSs, numSs = Dijkstra(adjL, S)\n costTs, numTs = Dijkstra(adjL, T)\n minCost = costSs[T]\n\n ans = (numSs[T]**2) % MOD\n for v in range(N):\n if costSs[v] == costTs[v] == minCost/2:\n k = (numSs[v]*numTs[v]) % MOD\n ans -= (k**2) % MOD\n ans %= MOD\n for u, v, d in edges:\n u, v = u-1, v-1\n if costSs[u] > costSs[v]:\n u, v = v, u\n if costSs[u] < minCost/2 and costTs[v] < minCost/2 and costSs[u]+d+costTs[v] == minCost:\n k = (numSs[u]*numTs[v]) % MOD\n ans -= (k**2) % MOD\n ans %= MOD\n\n print(ans)\n\nsolve()\n", "from heapq import heappush, heappop\nimport sys\ninput = sys.stdin.readline\n\ndef dijkstra(G, s):\n INF = 10**18\n dist = [INF] * len(G)\n dist[s] = 0\n pq = [(0, s)]\n while pq:\n d, v = heappop(pq)\n if d > dist[v]:\n continue\n for u, weight in G[v]:\n nd = d + weight\n if dist[u] > nd:\n dist[u] = nd\n heappush(pq, (nd, u))\n return dist\n\ndef count_ways(G, dist, s):\n ways = [0] * len(G)\n ways[s] = 1\n visited = [False] * len(G)\n visited[s] = True\n pq = [(0, s)]\n while pq:\n d, v = heappop(pq)\n for u, d in G[v]:\n if dist[v] + d == dist[u]:\n ways[u] = (ways[u] + ways[v]) % mod\n if not visited[u]:\n heappush(pq, (dist[u], u))\n visited[u] = True\n return ways\n\nmod = 10**9 + 7\nN, M = list(map(int, input().split()))\nS, T = list(map(int, input().split()))\nS -= 1; T -= 1\nG = [[] for _ in range(N)]\nfor _ in range(M):\n U, V, D = list(map(int, input().split()))\n U -= 1; V -= 1\n G[U].append((V, D))\n G[V].append((U, D))\ndistS = dijkstra(G, S)\ndistT = dijkstra(G, T)\nwayS = count_ways(G, distS, S)\nwayT = count_ways(G, distT, T)\nshortest = distS[T]\ncnt = wayS[T]**2 % mod\nif shortest % 2 == 0:\n for i in range(N):\n if distS[i] == distT[i] == shortest // 2:\n cnt = (cnt - (wayS[i] * wayT[i])**2) % mod\nfor i in range(N):\n for j, d in G[i]:\n if distS[i] + d + distT[j] == shortest:\n if distS[i] < distT[i] and distT[j] < distS[j]:\n cnt = (cnt - (wayS[i] * wayT[j])**2) % mod\nprint(cnt)\n", "from heapq import heapify,heappop,heappush\nimport sys\ninput=sys.stdin.readline\nN,M=list(map(int,input().split()))\nS,T=list(map(int,input().split()))\nGraph=[set() for i in range(N)]\nEdge=[]\nmod=10**9+7\ninf=float(\"inf\")\nfor i in range(M):\n a,b,c=list(map(int,input().split()))\n Graph[a-1].add((c,b-1))\n Graph[b-1].add((c,a-1))\n Edge.append((a-1,b-1,c))\n Edge.append((b-1,a-1,c))\ndef dijkstra(s,n,links):\n Visited=[False]*n\n cost=[inf]*n\n P=[0]*n\n P[s]=1\n cost[s]=0\n heap=[(0,s)]\n heapify(heap)\n while heap:\n hc,hp=heappop(heap)\n if Visited[hp]:\n continue\n Visited[hp]=True\n for c,p in links[hp]:\n if Visited[p]:\n continue\n if c+hc<cost[p]:\n cost[p]=c+hc\n P[p]=P[hp]\n heappush(heap,(cost[p],p))\n elif c+hc==cost[p]:\n P[p]=(P[p]+P[hp])%mod\n return cost,P\n\ndef dp(s,n,links,d):\n Visited=[False]*n\n cost=[inf]*n\n P=[0]*n\n P[s]=1\n cost[s]=0\n heap=[(0,s)]\n heapify(heap)\n while heap:\n hc,hp=heappop(heap)\n if 2*hc>d:\n break\n if Visited[hp]:\n continue\n Visited[hp]=True\n for c,p in links[hp]:\n if Visited[p]:\n continue\n if c+hc<cost[p]:\n cost[p]=c+hc\n P[p]=P[hp]\n heappush(heap,(cost[p],p))\n elif c+hc==cost[p]:\n P[p]=(P[p]+P[hp])%mod\n return cost,P\n\ncost_S,P_S=dijkstra(S-1,N,Graph)\nD=cost_S[T-1]\ncost_T,P_T=dp(T-1,N,Graph,D)\nPat=P_S[T-1]\nans=(Pat**2)%mod\nfor a,b,c in Edge:\n if cost_S[a]+cost_T[b]+c==D:\n if 2*cost_S[a]<D and 2*cost_T[b]<D:\n ans-=((P_S[a]*P_T[b])**2)%mod\nfor i in range(N):\n if 2*cost_S[i]==2*cost_T[i]==D:\n ans-=((P_S[i]*P_T[i])**2)%mod\nprint((ans%mod))\n\n\n\n \n \n \n \n \n", "from collections import defaultdict, deque, Counter\nfrom heapq import heappush, heappop, heapify\nimport math\nfrom bisect import bisect_left, bisect_right\nimport random\nfrom itertools import permutations, accumulate, combinations\nimport sys\nimport string\nfrom copy import deepcopy\n\nINF = 10 ** 20\n\n\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef I(): return int(sys.stdin.readline())\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\ndef IR(n): return [I() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\ndef LSR(n): return [LS() for i in range(n)]\ndef SRL(n): return [list(S()) for i in range(n)]\ndef MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]\nmod = 10 ** 9 + 7\n\ndef dijkstra(s):\n hq=[(0,s)]\n dist=[INF]*n\n dp=[0]*n\n dp[s]=1\n dist[s]=0\n checked=[0]*n\n while hq:\n min_dist,u=heappop(hq)\n if checked[u]:\n continue\n checked[u]=1\n for v,c in G[u]:\n if dist[u]+c<dist[v]:\n dist[v]=dist[u]+c\n dp[v]=dp[u]\n heappush(hq,(dist[v],v))\n elif dist[u]+c==dist[v]:\n dp[v]+=dp[u]\n dp[v]%=mod\n return dp, dist\n\nn, m = LI()\ns, t = LI()\nG = [[] for _ in range(n)]\nfor _ in range(m):\n a,b, d = LI()\n G[a - 1] += [(b - 1, d)]\n G[b - 1] += [(a - 1, d)]\n\ndp1,dist1=dijkstra(s-1)\ndp2,dist2=dijkstra(t-1)\ntotal=dist1[t-1]\nans=dp1[t-1]*dp2[s-1]%mod\nfor i in range(n):\n if dist1[i]==dist2[i]==total/2:\n ans-=pow(dp1[i]*dp2[i]%mod,2,mod)\n\nfor j in range(n):\n for k, ci in G[j]:\n if dist1[j]+dist2[k]+ci==total and dist1[j]<total/2 and dist2[k]<total/2:\n ans-=pow(dp1[j]*dp2[k]%mod,2,mod)\n\nprint((ans%mod))\n\n\n\n\n\n\n"] | {"inputs": ["4 4\n1 3\n1 2 1\n2 3 1\n3 4 1\n4 1 1\n", "3 3\n1 3\n1 2 1\n2 3 1\n3 1 2\n", "3 3\n1 3\n1 2 1\n2 3 1\n3 1 2\n", "8 13\n4 2\n7 3 9\n6 2 3\n1 6 4\n7 6 9\n3 8 9\n1 2 2\n2 8 12\n8 6 9\n2 5 5\n4 2 18\n5 3 7\n5 1 515371567\n4 8 6\n"], "outputs": ["2\n", "2\n", "2\n", "6\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 76,817 | |
47bdae14a31a5a98514dde3f998dfb72 | UNKNOWN | You are given a permutation of 1,2,...,N: p_1,p_2,...,p_N. Determine if the state where p_i=i for every i can be reached by performing the following operation any number of times:
- Choose three elements p_{i-1},p_{i},p_{i+1} (2\leq i\leq N-1) such that p_{i-1}>p_{i}>p_{i+1} and reverse the order of these three.
-----Constraints-----
- 3 \leq N \leq 3 × 10^5
- p_1,p_2,...,p_N is a permutation of 1,2,...,N.
-----Input-----
Input is given from Standard Input in the following format:
N
p_1
:
p_N
-----Output-----
If the state where p_i=i for every i can be reached by performing the operation, print Yes; otherwise, print No.
-----Sample Input-----
5
5
2
1
4
3
-----Sample Output-----
Yes
The state where p_i=i for every i can be reached as follows:
- Reverse the order of p_1,p_2,p_3. The sequence p becomes 1,2,5,4,3.
- Reverse the order of p_3,p_4,p_5. The sequence p becomes 1,2,3,4,5. | ["import sys\n\n\ndef solve(ppp):\n section_start = -1\n moved_left_max = 0\n moved_right_max = 0\n prev = True\n\n for i, p in enumerate(ppp, start=1):\n if i == p:\n if prev:\n moved_left_max = 0\n moved_right_max = 0\n section_start = -1\n prev = True\n else:\n if not prev:\n if moved_left_max > i - 1:\n return False\n\n moved_left_max = 0\n moved_right_max = 0\n section_start = i\n\n if section_start == -1:\n section_start = i\n\n if i > p:\n if section_start > p:\n return False\n if moved_right_max > p:\n return False\n moved_right_max = p\n else:\n if moved_left_max > p:\n return False\n moved_left_max = p\n\n prev = False\n return True\n\n\nn, *ppp = list(map(int, sys.stdin))\nprint(('Yes' if solve(ppp) else 'No'))\n", "def Split(a):\n no = []\n for i, x in a:\n if no and (i == x) == (no[-1][0] == no[-1][1]):\n yield no\n no = []\n no.append((i, x))\n yield no\n\nfor sq in Split((i + 1, int(input())) for i in range(int(input()))):\n tb = [0, 0]\n for np, goal in sq:\n if goal != np:\n if goal < tb[np < goal] or goal > sq[-1][0] or goal < sq[0][0]:\n print(\"No\")\n return\n tb[np < goal] = goal\nprint(\"Yes\")", "def Split(a):\n no = []\n for i, x in a:\n if no:\n is_ok = i == x\n la_ok = no[-1][0] == no[-1][1]\n if is_ok == la_ok:\n yield no\n no = []\n no.append((i, x))\n yield no\n\nn = int(input())\np = list(enumerate((int(input()) for i in range(n)), 1))\nfor sq in Split(p):\n tl = tr = 0\n for np, goal in sq:\n if goal > np:\n if goal < tr or goal > sq[-1][0]:\n print(\"No\")\n return\n tr = goal\n elif goal < np:\n if goal < tl or goal < sq[0][0]:\n print(\"No\")\n return\n tl = goal\nprint(\"Yes\")"] | {"inputs": ["5\n5\n2\n1\n4\n3\n", "4\n3\n2\n4\n1\n", "7\n3\n2\n1\n6\n5\n4\n7\n", "6\n5\n3\n4\n1\n2\n6\n"], "outputs": ["Yes\n", "No\n", "Yes\n", "No\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 2,342 | |
26a5d8674c23dcd4ded3f1f9ae606182 | UNKNOWN | There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done.
Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
-----Constraints-----
- 1 ≤ N,M ≤ 2 × 10^5
- 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
- All input values are integers.
-----Input-----
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
-----Output-----
Print the minimum required number of additional chairs.
-----Sample Input-----
4 4
0 3
2 3
1 3
3 4
-----Sample Output-----
0
The four people can sit in chairs at the coordinates 3, 2, 1 and 4, respectively, and no more chair is needed. | ["import sys\n\ninput=sys.stdin.readline\n\nN,M=list(map(int,input().split()))\n\n# N: \u51e6\u7406\u3059\u308b\u533a\u9593\u306e\u9577\u3055\nINF = 2**31-1\n\nLV = (M+2-1).bit_length()\nN0 = 2**LV\ndata = [0]*(2*N0)\nlazy = [0]*(2*N0)\n\ndef gindex(l, r):\n L = (l + N0) >> 1; R = (r + N0) >> 1\n lc = 0 if l & 1 else (L & -L).bit_length()\n rc = 0 if r & 1 else (R & -R).bit_length()\n for i in range(LV):\n if rc <= i:\n yield R\n if L < R and lc <= i:\n yield L\n L >>= 1; R >>= 1\n\n# \u9045\u5ef6\u4f1d\u642c\u51e6\u7406\ndef propagates(*ids):\n for i in reversed(ids):\n v = lazy[i-1]\n if not v:\n continue\n lazy[2*i-1] += v; lazy[2*i] += v\n data[2*i-1] += v; data[2*i] += v\n lazy[i-1] = 0\n\n# \u533a\u9593[l, r)\u306bx\u3092\u52a0\u7b97\ndef update(l, r, x):\n *ids, = gindex(l, r)\n propagates(*ids)\n\n L = N0 + l; R = N0 + r\n while L < R:\n if R & 1:\n R -= 1\n lazy[R-1] += x; data[R-1] += x\n if L & 1:\n lazy[L-1] += x; data[L-1] += x\n L += 1\n L >>= 1; R >>= 1\n for i in ids:\n data[i-1] = min(data[2*i-1], data[2*i])\n\n# \u533a\u9593[l, r)\u5185\u306e\u6700\u5c0f\u5024\u3092\u6c42\u3081\u308b\ndef query(l, r):\n propagates(*gindex(l, r))\n L = N0 + l; R = N0 + r\n\n s = INF\n while L < R:\n if R & 1:\n R -= 1\n s = min(s, data[R-1])\n if L & 1:\n s = min(s, data[L-1])\n L += 1\n L >>= 1; R >>= 1\n return s\n\nfor i in range(1,M+1):\n update(0,i+1,1)\n\nadd=M-N\nhito=[]\nfor i in range(N):\n L,R=list(map(int,input().split()))\n hito.append((L,R))\nhito.sort()\n#test=[query(i,i+1) for i in range(M+2)]\n#print(test)\nfor l,r in hito:\n update(0,r+1,-1)\n #test=[query(i,i+1) for i in range(M+2)]\n #print(test)\n m=query(l+1,M+2)+l\n add=min(m,add)\n\nprint((max(-add,0)))\n", "from operator import itemgetter\nfrom heapq import heappush, heappop\nN, M = list(map(int, input().split()))\nLR = [list(map(int, input().split())) for _ in range(N)]\nLR.sort(key=itemgetter(1))\nA = []\nans_left = 0\nidx = 1\nfor _, r in LR:\n if r==M+1 or idx==M+1:\n break\n ans_left += 1\n idx = max(idx+1, r+1)\n\nidx_LR = 0\nq = []\nfor i in range(M+1-ans_left, M+1):\n while idx_LR<N and LR[idx_LR][1]<=i:\n l, _ = LR[idx_LR]\n heappush(q, l)\n idx_LR += 1\n heappop(q)\nwhile idx_LR<N:\n l, _ = LR[idx_LR]\n q.append(l)\n idx_LR += 1\n\nq.sort(reverse=True)\nans_right = 0\nidx = M\nfor l in q:\n if l==0 or idx==0 or ans_right+ans_left==M:\n break\n ans_right += 1\n idx = min(l-1, idx-1)\nans = N - ans_left - ans_right\nprint(ans)\n"] | {"inputs": ["4 4\n0 3\n2 3\n1 3\n3 4\n", "7 6\n0 7\n1 5\n3 6\n2 7\n1 6\n2 6\n3 7\n", "3 1\n1 2\n1 2\n1 2\n", "6 6\n1 6\n1 6\n1 5\n1 5\n2 6\n2 6\n"], "outputs": ["0\n", "2\n", "2\n", "2\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 2,818 | |
f3ac98fe997ed51f5a1923f10968557a | UNKNOWN | There is a tree with N vertices numbered 1 through N.
The i-th edge connects Vertex x_i and y_i.
Each vertex is painted white or black.
The initial color of Vertex i is represented by a letter c_i.
c_i = W represents the vertex is white; c_i = B represents the vertex is black.
A cat will walk along this tree.
More specifically, she performs one of the following in one second repeatedly:
- Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
- Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex.
At least how many seconds does it takes for the cat to achieve her objective?
-----Constraints-----
- 1 ≤ N ≤ 10^5
- 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
- The given graph is a tree.
- c_i = W or c_i = B.
-----Input-----
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
-----Output-----
Print the minimum number of seconds required to achieve the objective.
-----Sample Input-----
5
1 2
2 3
2 4
4 5
WBBWW
-----Sample Output-----
5
The objective can be achieved in five seconds, for example, as follows:
- Start at Vertex 1. Change the color of Vertex 1 to black.
- Move to Vertex 2, then change the color of Vertex 2 to white.
- Change the color of Vertex 2 to black.
- Move to Vertex 4, then change the color of Vertex 4 to black.
- Move to Vertex 5, then change the color of Vertex 5 to black. | ["import sys\nfrom collections import deque\n\ninput=sys.stdin.readline\n\nN=int(input())\nedge=[[] for i in range(N)]\nfor i in range(N-1):\n x,y=list(map(int,input().split()))\n edge[x-1].append(y-1)\n edge[y-1].append(x-1)\n\nc=input()[:N]\n\ndeg=[len(edge[i]) for i in range(N)]\nleaf=set([])\nfor i in range(N):\n if deg[i]==1 and c[i]==\"B\":\n leaf.add(i)\n\nban=set([])\nwhile leaf:\n v=leaf.pop()\n ban.add(v)\n deg[v]=0\n for nv in edge[v]:\n deg[nv]-=1\n if deg[nv]==1 and c[nv]==\"B\":\n leaf.add(nv)\n\nfor i in range(N):\n edge[i]=[nv for nv in edge[i] if nv not in ban]\n\nroot=-1\nfor i in range(N):\n if i not in ban:\n root=i\n\nparent=[-2]*N\ndeq=deque([(root,-1)])\nnode=[]\nwhile deq:\n v,pv=deq.popleft()\n parent[v]=pv\n node.append(v)\n for nv in edge[v]:\n if nv!=pv:\n deq.append((nv,v))\n\nnode=node[::-1]\n\nfor i in range(N):\n edge[i]=[nv for nv in edge[i] if nv!=parent[i]]\n\ncheck=True\nfor i in range(N):\n check&=(deg[i]<=0)\nif check:\n print((int(c[root]==\"W\")))\n return\n\ncond=[0]*N\nfor v in range(N):\n if (deg[v]%2==1 and c[v]==\"B\") or (deg[v]%2==0 and c[v]==\"W\"):\n cond[v]+=1\n else:\n cond[v]-=1\n\nlower=[0]*N\nfor v in node:\n res=0\n for nv in edge[v]:\n res=max(res,lower[nv])\n res+=1+cond[v]\n lower[v]=res\n\nupper=[0]*N\nnode=node[::-1]\nfor v in node:\n n=len(edge[v])\n if n>1:\n left=[0]*n\n right=[0]*n\n for i in range(n-1):\n nv=edge[v][i]\n left[i]=max(left[i-1],lower[nv]+2+cond[v])\n nv=edge[v][-1]\n upper[nv]=left[n-2]+cond[nv]\n right[n-1]=lower[nv]+2+cond[v]\n for i in range(n-2,0,-1):\n nv=edge[v][i]\n upper[nv]=max(left[i-1],right[i+1])+cond[nv]\n right[i]=max(right[i+1],lower[nv]+2+cond[v])\n if edge[v][0]!=pv:\n nv=edge[v][0]\n upper[nv]=right[1]+cond[nv]\n if v!=root:\n for nv in edge[v]:\n upper[nv]=max(upper[nv],upper[v]+1+cond[nv])\n\nbase=sum(deg[i] for i in range(N))+sum(cond[i]==1 for i in range(N))\n#print(deg)\n#print(base)\n#print(lower)\n#print(upper)\n#print(base)\nprint((base-max(max(upper),max(lower))))\n", "\n\"\"\"\n\nhttps://atcoder.jp/contests/arc097/tasks/arc097_d\n\n\u59cb\u70b9\u3068\u7d42\u70b9\u95a2\u4fc2\u3042\u308b\uff1f\n\u2192\u9006\u306b\u3057\u3066\u3082\u554f\u984c\u306f\u306a\u3044\n\n\u9ed2\u3044\u8449\u306f\u5b8c\u5168\u306b\u7121\u8996\u3067\u304d\u308b(\u843d\u3068\u305b\u308b)\n\u3088\u3063\u3066\u3001\u8449\u306f\u3059\u3079\u3066\u767d\n\u8449\u4ee5\u5916\u306f\u767d\u9ed2\u3069\u3063\u3061\u3082\u3042\u308a\u5f97\u308b\n\n\u3059\u3079\u3066\u306e\u8449\u3092\u3081\u3050\u308b\u6700\u77ed\u7d4c\u8def\uff1f\n\u3042\u308b\u8449\u304b\u3089\u30b9\u30bf\u30fc\u30c8\u3059\u308b\u306e\u306f\u81ea\u660e\u3063\u307d\u3044\uff1f\n\u3042\u308b\u767d\u304b\u3089\u30b9\u30bf\u30fc\u30c8\u3059\u308b\u306e\u306f\u305d\u3046\n\n\u2192\u81ea\u5206\u3092\u5857\u3063\u3066\u304b\u3089dfs\u3059\u308b\n\u2192\u5168\u65b9\u4f4d\u6728dp?\n\n\u884c\u304d\u306e\u307f\u3067\u5e30\u3089\u306a\u3044\u5834\u6240\u304c1\u3064\u5b58\u5728\u3059\u308b\u306f\u305a\n\u2192\u59cb\u70b9\u3068\u7d42\u70b9\u306e\u30d1\u30b9\u3068\u305d\u3053\u304b\u3089\u751f\u3048\u308b\u6728\u3063\u3066\u611f\u3058\u306e\u30a4\u30e1\u30fc\u30b8\n\n\u8db3\u8e0f\u307f(\u505c\u6b62)\u306e\u56de\u6570\u3092\u6975\u529b\u5c11\u306a\u304f\u3057\u305f\u3044\n\u2192\u59cb\u70b9\u3067\u3082\u7d42\u70b9\u3067\u3082\u306a\u3044\u5834\u5408\u3001 e\u672c\u306e\u8fba\u304c\u3064\u306a\u304c\u3063\u3066\u305f\u3089e\u56de\u8a2a\u554f\u306f\u78ba\u5b9a\n\u3000e^color\u304c\u9ed2\u3067\u306a\u3044\u5834\u5408\u306f+1\n\u2192\u3064\u307e\u308a\u3001\u5404\u9802\u70b9\u3067\u6d88\u8cbb\u3059\u308b\u56de\u6570\u306f\u59cb\u70b9\u30fb\u7d42\u70b9\u3067\u306a\u3044\u9650\u308a\u5e38\u306b\u4e00\u5b9a\uff1f\n\n\u7d42\u70b9\u306f\u307e\u305a\u8449\u2192\u59cb\u70b9\u3082\u8449\u3067\u304a\uff4b\n\u59cb\u70b9\u306f\u8db3\u8e0f\u307f\u306a\u306e\u30671\u79d2\u3064\u304b\u3046\u3000\u7d42\u70b9\u30821\u79d2\u4f7f\u3046\n\u30d1\u30b9\u4e0a\u306e\u70b9\u306f\u3001e-1\u56de\u8a2a\u554f(\u3053\u3053\u304c\u6839\u672c\u7684\u306b\u9055\u3046\uff01)\n\n\u3064\u307e\u308a\u3001\u3042\u308b\u30d1\u30b9\u304c\u3042\u3063\u3066\u3000\u305d\u306e\u9577\u3055\u304cL(\u4e21\u7aef\u9664\u304f)\u306e\u6642\u3001\u6700\u5927\u3067L\u6e1b\u308b\n\u305f\u3060\u3057\u3001\u30d1\u30b9\u4e0a\u306b\u3042\u3063\u3066\u3082\u56de\u6570\u304c\u6e1b\u3089\u306a\u3044\u70b9\u3082\u3042\u308b\n\nB=0 W=1\u3068\u3059\u308b\u304b\n(color^E) == 1 \u306e\u70b9\u306f\u3001E-1\u56de\u8a2a\u554f\u306b\u306a\u308b\u3068\u8db3\u8e0f\u307f\u304c\u3044\u3089\u306a\u3044\u304b\u30892\u6e1b\u308b\n\u3064\u307e\u308a\u3001\u305d\u306e\u3088\u3046\u306a\u70b9\u304c\u6700\u5927\u6570\u3042\u308b\u30d1\u30b9\u3092\u6c42\u3081\u308c\u3070\u3044\u3044\n\n\"\"\"\n\nimport sys\nsys.setrecursionlimit(200000)\nfrom collections import deque\n\nMM = 0\n\ndef dfs(v,p):\n nonlocal MM\n\n if v != p and linknum[v] == 1:\n return 0\n\n cl = []\n for nex in lis[v]:\n if nex != p and exist[nex]:\n tmp = dfs(nex,v)\n cl.append(tmp)\n cl.sort()\n cl.reverse()\n\n if len(cl) == 1:\n MM = max(MM , cl[0])\n else:\n if (linknum[v]+c[v])%2 == 1:\n MM = max(MM , cl[0] + cl[1] + 2)\n else:\n MM = max(MM , cl[0] + cl[1])\n\n \n if (linknum[v]+c[v]) % 2 == 1:\n return cl[0]+ 2\n else:\n return cl[0]\n\nN = int(input())\n\nlis = [ [] for i in range(N) ]\nlinknum = [0] * N\nfor i in range(N-1):\n u,v = list(map(int,input().split()))\n u -= 1\n v -= 1\n\n lis[u].append(v)\n lis[v].append(u)\n linknum[u] += 1\n linknum[v] += 1\n\nctmp = input()\nc = []\n\nfor i in ctmp:\n if i == \"B\":\n c.append(0)\n else:\n c.append(1)\n\nexist = [True] * N\n\nq = deque([])\nfor i in range(N):\n if linknum[i] <= 1 and c[i] == 0:\n q.append(i)\n\nwhile len(q) > 0:\n now = q.popleft()\n exist[now] = False\n linknum[now] = 0\n \n for nex in lis[now]:\n linknum[nex] -= 1\n\n if linknum[nex] == 1 and c[nex] == 0:\n q.append(nex)\n\n#print (exist)\nstart = None\nfor i in range(N):\n if exist[i]:\n start = i\n break\nelse:\n print((0))\n return\n\nif linknum[start] == 0:\n print((1))\n return\n\nans = 0\n#print (linknum)\nfor i in range(N):\n if exist[i]:\n\n if (linknum[i] + c[i]) % 2 == 0:\n ans += linknum[i]\n else:\n ans += linknum[i] + 1\n\nMM = 0\npick = dfs(start,start)\nprint((ans - MM))\n", "from collections import deque\n\n\ndef first_cut(links, colors):\n tmp_links = links.copy()\n for v, neighbors in list(tmp_links.items()):\n while len(neighbors) == 1 and colors[v]:\n del links[v]\n par = neighbors.pop()\n links[par].remove(v)\n v = par\n neighbors = links[par]\n return links\n\n\ndef diameter(links, flags):\n def dfs(s):\n fs = flags[s]\n d, v = 0, 0\n q = deque(sorted((fs + flags[v], v, s) for v in links[s]))\n while q:\n d, v, a = q.popleft()\n for u in links[v]:\n if u == a:\n continue\n fu = flags[u]\n if fu:\n q.append((d + 1, u, v))\n else:\n q.appendleft((d, u, v))\n return d, v\n\n s = next(iter(links))\n _, t = dfs(s)\n d, _ = dfs(t)\n return d\n\n\ndef solve(links, colors):\n if all(colors):\n return 0\n\n links = first_cut(links, colors)\n k = len(links)\n\n if k == 1:\n return 1\n\n flags = {v: colors[v] ^ (len(link) % 2 == 0) for v, link in list(links.items())}\n euler_tour = 2 * (k - 1) + sum(flags.values())\n return euler_tour - 2 * diameter(links, flags)\n\n\nn = int(input())\nlinks = {i: set() for i in range(n)}\nfor _ in range(n - 1):\n x, y = list(map(int, input().split()))\n x -= 1\n y -= 1\n links[x].add(y)\n links[y].add(x)\ncolors = [c == 'B' for c in input()]\n\nprint((solve(links, colors)))\n"] | {"inputs": ["5\n1 2\n2 3\n2 4\n4 5\nWBBWW\n", "6\n3 1\n4 5\n2 6\n6 1\n3 4\nWWBWBB\n", "1\nB\n", "20\n2 19\n5 13\n6 4\n15 6\n12 19\n13 19\n3 11\n8 3\n3 20\n16 13\n7 14\n3 17\n7 8\n10 20\n11 9\n8 18\n8 2\n10 1\n6 13\nWBWBWBBWWWBBWWBBBBBW\n"], "outputs": ["5\n", "7\n", "0\n", "21\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 8,398 | |
2efa0036be83bb3de44a257fe6294fc2 | UNKNOWN | There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
- Each a_i is a non-negative integer.
- For each edge (i, j), a_i \neq a_j holds.
- For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
-----Constraints-----
- 2 ≤ N ≤ 200 000
- 1 ≤ p_i ≤ N
- p_i \neq i
- The graph is weakly connected.
-----Input-----
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
-----Output-----
If the assignment is possible, print POSSIBLE; otherwise, print IMPOSSIBLE.
-----Sample Input-----
4
2 3 4 1
-----Sample Output-----
POSSIBLE
The assignment is possible: {a_i} = {0, 1, 0, 1} or {a_i} = {1, 0, 1, 0}. | ["import sys\nsys.setrecursionlimit(10**6)\nn = int(input())\np = list(map(int, input().split()))\nc = [[] for _ in range(n)]\nis_leaf = [True for _ in range(n)]\nfor i in range(n):\n\tp[i] -= 1\n\tc[p[i]].append(i)\n\tis_leaf[p[i]] = False\n\nif sum(is_leaf) == 0:\n\tif n%2 == 0:\n\t\tprint(\"POSSIBLE\")\n\telse:\n\t\tprint(\"IMPOSSIBLE\")\n\treturn\n\nfor i in range(n):\n\tif is_leaf[i]:\n\t\tcur = i\n\t\tbreak\n\nvisited_set = {cur}\nvisited_list = [cur]\nwhile p[cur] not in visited_set:\n\tvisited_list.append(p[cur])\n\tvisited_set.add(p[cur])\n\tcur = p[cur]\n\nroot = p[cur]\n\ngrundy = [-1 for _ in range(n)]\ng_set = [set() for _ in range(n)]\n\ndef dfs(x):\n\tres = 0\n\tfor v in c[x]:\n\t\tdfs(v)\n\t\tg_set[x].add(grundy[v])\n\twhile res in g_set[x]:\n\t\tres += 1\n\tgrundy[x] = res\n\treturn res\n\nloop = [False for _ in range(n)]\nloop[root] = True\nind = len(visited_list)-1\nwhile visited_list[ind] != root:\n\tloop[visited_list[ind]] = True\n\tind -= 1\n#print(loop)\n\nfor i in range(n):\n\tif loop[i]:\n\t\tfor x in c[i]:\n\t\t\tif not loop[x]:\n\t\t\t\tdfs(x)\n\t\t\t\tg_set[i].add(grundy[x])\n\ncand = []\nnum = 0\nwhile num in g_set[root]:\n\tnum += 1\ncand.append(num)\nnum += 1\nwhile num in g_set[root]:\n\tnum += 1\ncand.append(num)\n\nfor x in cand:\n\tcur = root\n\tgrundy[root] = x\n\twhile True:\n\t\tnum = 0\n\t\twhile num in g_set[p[cur]] or num == grundy[cur]:\n\t\t\tnum += 1\n\t\tgrundy[p[cur]] = num\n\t\tif p[cur] == root:\n\t\t\tbreak\n\t\tcur = p[cur]\n\tif grundy[root] == x:\n\t\t#print(grundy)\n\t\tprint(\"POSSIBLE\")\n\t\treturn\n\nprint(\"IMPOSSIBLE\")", "mod = 1000000007\neps = 10**-9\n\n\ndef main():\n import sys\n from collections import deque\n input = sys.stdin.readline\n\n N = int(input())\n P = list(map(int, input().split()))\n adj = [[] for _ in range(N+1)]\n adj_directed = [[] for _ in range(N+1)]\n adj_rev = [[] for _ in range(N+1)]\n out = [0] * (N + 1)\n for i, p in enumerate(P):\n adj_directed[p].append(i+1)\n adj[p].append(i+1)\n adj[i+1].append(p)\n adj_rev[i+1].append(p)\n out[p] += 1\n\n que = deque()\n que.append(1)\n seen = [-1] * (N+1)\n seen[1] = 0\n par = [-1] * (N+1)\n back_from = -1\n back_to = -1\n while que:\n v = que.popleft()\n for u in adj[v]:\n if seen[u] == -1:\n seen[u] = seen[v] + 1\n que.append(u)\n par[u] = v\n else:\n if par[v] != u:\n if P[v-1] == u:\n back_from = u\n back_to = v\n out[u] -= 1\n\n G = [-1] * (N+1)\n for v in range(1, N+1):\n if out[v] == 0:\n que.append(v)\n while que:\n v = que.popleft()\n M = set()\n for u in adj_directed[v]:\n if v == back_from and u == back_to:\n continue\n M.add(G[u])\n for i in range(N+1):\n if i not in M:\n G[v] = i\n break\n for u in adj_rev[v]:\n if v == back_to and u == back_from:\n continue\n out[u] -= 1\n if out[u] == 0:\n que.append(u)\n\n if G[back_from] != G[back_to]:\n print(\"POSSIBLE\")\n return\n\n cycle = set()\n v = back_from\n while v > 0:\n cycle.add(v)\n v = par[v]\n v = back_to\n while v > 0:\n cycle.add(v)\n v = par[v]\n\n v = back_from\n seen = {v}\n while True:\n M = set()\n for u in adj_directed[v]:\n M.add(G[u])\n for i in range(N+1):\n if i not in M:\n if G[v] == i:\n print(\"POSSIBLE\")\n return\n G[v] = i\n break\n fin = 1\n for u in adj_rev[v]:\n if u in cycle and u not in seen:\n v = u\n seen.add(u)\n fin = 0\n break\n if fin:\n break\n print(\"IMPOSSIBLE\")\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import sys\nsys.setrecursionlimit(10**6)\nn = int(input())\np = list(map(int, input().split()))\nc = [[] for _ in range(n)]\nis_leaf = [True for _ in range(n)]\nfor i in range(n):\n\tp[i] -= 1\n\tc[p[i]].append(i)\n\tis_leaf[p[i]] = False\n\nif sum(is_leaf) == 0:\n\tif n%2 == 0:\n\t\tprint(\"POSSIBLE\")\n\telse:\n\t\tprint(\"IMPOSSIBLE\")\n\treturn\n\nfor i in range(n):\n\tif is_leaf[i]:\n\t\tcur = i\n\t\tbreak\n\nvisited_set = {cur}\nvisited_list = [cur]\nwhile p[cur] not in visited_set:\n\tvisited_list.append(p[cur])\n\tvisited_set.add(p[cur])\n\tcur = p[cur]\n\nroot = p[cur]\n\ngrundy = [-1 for _ in range(n)]\ng_set = [set() for _ in range(n)]\n\ndef dfs(x):\n\tres = 0\n\tfor v in c[x]:\n\t\tdfs(v)\n\t\tg_set[x].add(grundy[v])\n\twhile res in g_set[x]:\n\t\tres += 1\n\tgrundy[x] = res\n\treturn res\n\nloop = [False for _ in range(n)]\nloop[root] = True\nind = len(visited_list)-1\nwhile visited_list[ind] != root:\n\tloop[visited_list[ind]] = True\n\tind -= 1\n#print(loop)\n\nfor i in range(n):\n\tif loop[i]:\n\t\tfor x in c[i]:\n\t\t\tif not loop[x]:\n\t\t\t\tdfs(x)\n\t\t\t\tg_set[i].add(grundy[x])\n\ncand = []\nnum = 0\nwhile num in g_set[root]:\n\tnum += 1\ncand.append(num)\nnum += 1\nwhile num in g_set[root]:\n\tnum += 1\ncand.append(num)\n\nfor x in cand:\n\tcur = root\n\tgrundy[root] = x\n\twhile True:\n\t\tnum = 0\n\t\twhile num in g_set[p[cur]] or num == grundy[cur]:\n\t\t\tnum += 1\n\t\tgrundy[p[cur]] = num\n\t\tif p[cur] == root:\n\t\t\tbreak\n\t\tcur = p[cur]\n\tif grundy[root] == x:\n\t\t#print(grundy)\n\t\tprint(\"POSSIBLE\")\n\t\treturn\n\nprint(\"IMPOSSIBLE\")", "import sys\nfrom itertools import chain\nreadline = sys.stdin.readline\n\n#\u975e\u518d\u5e30\ndef scc(Edge):\n N = len(Edge)\n Edgeinv = [[] for _ in range(N)]\n for vn in range(N):\n for vf in Edge[vn]:\n Edgeinv[vf].append(vn)\n \n used = [False]*N\n dim = [len(Edge[i]) for i in range(N)]\n order = []\n for st in range(N):\n if not used[st]:\n stack = [st, 0]\n while stack:\n vn, i = stack[-2], stack[-1] \n if not i and used[vn]:\n stack.pop()\n stack.pop()\n else:\n used[vn] = True\n if i < dim[vn]:\n stack[-1] += 1\n stack.append(Edge[vn][i])\n stack.append(0)\n else:\n stack.pop()\n order.append(stack.pop())\n res = [None]*N\n used = [False]*N\n cnt = -1\n for st in order[::-1]:\n if not used[st]:\n cnt += 1\n stack = [st]\n res[st] = cnt\n used[st] = True\n while stack:\n vn = stack.pop()\n for vf in Edgeinv[vn]:\n if not used[vf]:\n used[vf] = True\n res[vf] = cnt\n stack.append(vf)\n M = cnt+1\n components = [[] for _ in range(M)]\n for i in range(N):\n components[res[i]].append(i)\n tEdge = [[] for _ in range(M)]\n teset = set()\n for vn in range(N):\n tn = res[vn]\n for vf in Edge[vn]:\n tf = res[vf]\n if tn != tf and tn*M + tf not in teset:\n teset.add(tn*M + tf)\n tEdge[tn].append(tf)\n return res, components, tEdge\n\nN = int(readline())\nP = list([int(x)-1 for x in readline().split()])\n\nEdge = [[] for _ in range(N)]\nfor i in range(N):\n Edge[P[i]].append(i)\n\nR, Com, _ = scc(Edge)\n\nLord = list(chain(*Com[::-1]))\nval = [None]*N\nfor vn in Lord:\n if not R[vn]:\n break\n lvn = len(Edge[vn]) + 1\n res = [0]*lvn\n for vf in Edge[vn]:\n if val[vf] < lvn:\n res[val[vf]] += 1\n \n for k in range(lvn):\n if not res[k]:\n val[vn] = k\n break\n\nst = Lord[-1]\nlst = len(Edge[st]) + 2\nres = [0]*lst\nfor vf in Edge[st]:\n if val[vf] is None:\n continue\n if val[vf] < lst:\n res[val[vf]] += 1\nmc = []\nfor k in range(lst):\n if not res[k]:\n mc.append(k)\n\nvn = st\nLs = []\nwhile vn is not None:\n for vf in Edge[vn]:\n if R[vf]:\n continue\n if vf == st:\n vn = None\n else:\n Ls.append(vf)\n vn = vf\n\nLs.reverse()\n\nans = False\nfor idx in range(2):\n vc = val[:]\n vc[st] = mc[idx]\n for vn in Ls:\n lvn = len(Edge[vn])+1\n res = [0]*lvn\n for vf in Edge[vn]:\n if vc[vf] < lvn:\n res[vc[vf]] += 1\n \n for k in range(lvn):\n if not res[k]:\n vc[vn] = k\n break\n \n for vn in range(N):\n res = [False]*vc[vn]\n for vf in Edge[vn]:\n if vc[vn] == vc[vf]:\n break\n if vc[vf] < vc[vn]:\n res[vc[vf]] = True\n else:\n if not all(res):\n break\n continue\n break\n else:\n ans = True\n if ans:\n break\nprint(('POSSIBLE' if ans else 'IMPOSSIBLE'))\n", "# \u7d50\u5c40\u306f\u6728+1\u8fba\nfrom collections import defaultdict\nimport heapq as hq\n\nN = int(input())\nP = list(map(lambda x:int(x)-1,input().split()))\nD = [0]*N\nfor p in P:\n D[p] += 1\n\nchild_L = defaultdict(list)\n\nS = [p for p in range(N) if D[p] == 0]\nL = [None]*N\n\nwhile S:\n n = S.pop()\n\n q = child_L[n]\n del child_L[n]\n\n hq.heapify(q)\n i = 0\n while q:\n t = hq.heappop(q)\n if i < t:\n break\n else:\n i += (i==t)\n \n L[n] = i\n m = P[n]\n child_L[m].append(i)\n D[m] -= 1\n if D[m] == 0:\n S.append(m)\n\n# cycle check\ntry:\n start = D.index(1)\nexcept ValueError:\n print('POSSIBLE')\n return\n\ndef helper(n):\n q = child_L[n]\n del child_L[n]\n \n hq.heapify(q)\n i = 0\n while q:\n t = hq.heappop(q)\n if i < t:\n break\n else:\n i += (i==t)\n\n j = i+1\n while q:\n t = hq.heappop(q)\n if j < t:\n break\n else:\n j += (j==t)\n\n return (i,j)\n\n\ns1,s2 = helper(start)\nG = []\nn = P[start]\nwhile n != start:\n G.append(helper(n))\n n = P[n]\n\n\ndel N,P,D,child_L,S,L\n\n\n# \u53ef\u80fd\u306a\u521d\u671f\u5024\u3092\u305d\u308c\u305e\u308c\u30b7\u30df\u30e5\u30ec\u30fc\u30c8\n# 1\nn = s1\nfor g in G:\n if g[0] == n:\n n = g[1]\n else:\n n = g[0]\nif n != s1:\n print('POSSIBLE')\n return\n\n# 2\nn = s2\nfor g in G:\n if g[0] == n:\n n = g[1]\n else:\n n = g[0]\nif n == s1:\n print('POSSIBLE')\n return\n\nprint('IMPOSSIBLE')", "import sys\nsys.setrecursionlimit(10**6)\nn = int(input())\np = list(map(int, input().split()))\nc = [[] for _ in range(n)]\nis_leaf = [True for _ in range(n)]\nfor i in range(n):\n\tp[i] -= 1\n\tc[p[i]].append(i)\n\tis_leaf[p[i]] = False\n\nif sum(is_leaf) == 0:\n\tif n%2 == 0:\n\t\tprint(\"POSSIBLE\")\n\telse:\n\t\tprint(\"IMPOSSIBLE\")\n\treturn\n\nfor i in range(n):\n\tif is_leaf[i]:\n\t\tcur = i\n\t\tbreak\n\nvisited_set = {cur}\nvisited_list = [cur]\nwhile p[cur] not in visited_set:\n\tvisited_list.append(p[cur])\n\tvisited_set.add(p[cur])\n\tcur = p[cur]\n\nroot = p[cur]\n\ngrundy = [-1 for _ in range(n)]\ng_set = [set() for _ in range(n)]\n\ndef dfs(x):\n\tres = 0\n\tfor v in c[x]:\n\t\tdfs(v)\n\t\tg_set[x].add(grundy[v])\n\twhile res in g_set[x]:\n\t\tres += 1\n\tgrundy[x] = res\n\treturn res\n\nloop = [False for _ in range(n)]\nloop[root] = True\nind = len(visited_list)-1\nwhile visited_list[ind] != root:\n\tloop[visited_list[ind]] = True\n\tind -= 1\n#print(loop)\n\nfor i in range(n):\n\tif loop[i]:\n\t\tfor x in c[i]:\n\t\t\tif not loop[x]:\n\t\t\t\tdfs(x)\n\t\t\t\tg_set[i].add(grundy[x])\n\ncand = []\nnum = 0\nwhile num in g_set[root]:\n\tnum += 1\ncand.append(num)\nnum += 1\nwhile num in g_set[root]:\n\tnum += 1\ncand.append(num)\n\nfor x in cand:\n\tcur = root\n\tgrundy[root] = x\n\twhile True:\n\t\tnum = 0\n\t\twhile num in g_set[p[cur]] or num == grundy[cur]:\n\t\t\tnum += 1\n\t\tgrundy[p[cur]] = num\n\t\tif p[cur] == root:\n\t\t\tbreak\n\t\tcur = p[cur]\n\tif grundy[root] == x:\n\t\t#print(grundy)\n\t\tprint(\"POSSIBLE\")\n\t\treturn\n\nprint(\"IMPOSSIBLE\")", "from collections import deque\n\nN=int(input())\nIN=[[] for i in range(N)]\nOUT=[-1 for i in range(N)]\np=list(map(int,input().split()))\nfor i in range(N):\n IN[p[i]-1].append(i)\n OUT[i]=p[i]-1\n\ndeg=[len(IN[i]) for i in range(N)]\n\ndeq=deque([v for v in range(N) if deg[v]==0])\nres=[]\nwhile deq:\n v=deq.popleft()\n res.append(v)\n deg[OUT[v]]-=1\n if deg[OUT[v]]==0:\n deq.append(OUT[v])\n\nif len(res)==N:\n print(\"POSSIBLE\")\n return\n\nstart=-1\nfor i in range(N):\n if deg[i]>0:\n start=i\n break\n\ncycle=[start]\nwhile True:\n nv=OUT[cycle[-1]]\n if nv!=start:\n cycle.append(nv)\n else:\n break\n\n\ndp=[-1]*N\nfor v in res:\n mex=[False]*(len(IN[v])+1)\n for pv in IN[v]:\n if dp[pv]<=len(IN[v]):\n mex[dp[pv]]=True\n for i in range(len(mex)):\n if not mex[i]:\n dp[v]=i\n break\n\nm0=-1\nm1=-1\nmex=[False]*(len(IN[start])+2)\nfor pv in IN[start]:\n if dp[pv]!=-1 and dp[pv]<=len(IN[v])+1:\n mex[dp[pv]]=True\nfor i in range(len(mex)):\n if not mex[i]:\n if m0==-1:\n m0=i\n else:\n m1=i\n break\n\n#m0\ndp[start]=m0\nfor i in range(1,len(cycle)):\n v=cycle[i]\n temp=-1\n mex=[False]*(len(IN[v])+1)\n for pv in IN[v]:\n if dp[pv]<=len(IN[v]):\n mex[dp[pv]]=True\n for i in range(len(mex)):\n if not mex[i]:\n dp[v]=i\n break\nmex=[False]*(len(IN[start])+2)\nfor pv in IN[start]:\n if dp[pv]!=-1 and dp[pv]<=len(IN[v])+1:\n mex[dp[pv]]=True\ncheck=-1\nfor i in range(len(mex)):\n if not mex[i]:\n check=i\n break\nif check==m0:\n print(\"POSSIBLE\")\n return\n\nfor v in cycle:\n dp[v]=-1\n\n#m1\ndp[start]=m1\nfor i in range(1,len(cycle)):\n v=cycle[i]\n temp=-1\n mex=[False]*(len(IN[v])+1)\n for pv in IN[v]:\n if dp[pv]<=len(IN[v]):\n mex[dp[pv]]=True\n for i in range(len(mex)):\n if not mex[i]:\n dp[v]=i\n break\nmex=[False]*(len(IN[start])+2)\nfor pv in IN[start]:\n if dp[pv]!=-1 and dp[pv]<=len(IN[start])+1:\n mex[dp[pv]]=True\ncheck=-1\nfor i in range(len(mex)):\n if not mex[i]:\n check=i\n break\nif check==m1:\n print(\"POSSIBLE\")\n return\n\nprint(\"IMPOSSIBLE\")\n"] | {"inputs": ["4\n2 3 4 1\n", "3\n2 3 1\n", "4\n2 3 1 1\n", "6\n4 5 6 5 6 4\n"], "outputs": ["POSSIBLE\n", "IMPOSSIBLE\n", "POSSIBLE\n", "IMPOSSIBLE\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 14,912 | |
68fabb9bfc0e04cf1280e01c623badde | UNKNOWN | In the State of Takahashi in AtCoderian Federation, there are N cities, numbered 1, 2, ..., N.
M bidirectional roads connect these cities.
The i-th road connects City A_i and City B_i.
Every road connects two distinct cities.
Also, for any two cities, there is at most one road that directly connects them.
One day, it was decided that the State of Takahashi would be divided into two states, Taka and Hashi.
After the division, each city in Takahashi would belong to either Taka or Hashi.
It is acceptable for all the cities to belong Taka, or for all the cities to belong Hashi.
Here, the following condition should be satisfied:
- Any two cities in the same state, Taka or Hashi, are directly connected by a road.
Find the minimum possible number of roads whose endpoint cities belong to the same state.
If it is impossible to divide the cities into Taka and Hashi so that the condition is satisfied, print -1.
-----Constraints-----
- 2 \leq N \leq 700
- 0 \leq M \leq N(N-1)/2
- 1 \leq A_i \leq N
- 1 \leq B_i \leq N
- A_i \neq B_i
- If i \neq j, at least one of the following holds: A_i \neq A_j and B_i \neq B_j.
- If i \neq j, at least one of the following holds: A_i \neq B_j and B_i \neq A_j.
-----Input-----
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
-----Output-----
Print the answer.
-----Sample Input-----
5 5
1 2
1 3
3 4
3 5
4 5
-----Sample Output-----
4
For example, if the cities 1, 2 belong to Taka and the cities 3, 4, 5 belong to Hashi, the condition is satisfied.
Here, the number of roads whose endpoint cities belong to the same state, is 4. | ["from collections import deque\n\nN, M = list(map(int, input().split()))\nadj = [[1 for _ in range(N + 1)] for _ in range(N + 1)]\nfor _ in range(M):\n a, b = list(map(int, input().split()))\n adj[a][b] = 0\n adj[b][a] = 0\nadj_inv = [[] for _ in range(N + 1)]\nfor i in range(1, N+1):\n for j in range(i+1, N+1):\n if adj[i][j] == 1:\n adj_inv[i].append(j)\n adj_inv[j].append(i)\n\nseen = [0] * (N+1)\nnum = []\nfor i in range(1, N+1):\n if seen[i] == 0:\n plus = 0\n minus = 0\n que = deque()\n que.append(i)\n seen[i] = 1\n plus += 1\n while que:\n v = que.pop()\n u_list = adj_inv[v]\n for u in u_list:\n if seen[u] == 0:\n que.append(u)\n seen[u] = -seen[v]\n if seen[u] == 1:\n plus += 1\n else:\n minus += 1\n else:\n if seen[u] == seen[v]:\n print((-1))\n return\n num.append((min(plus, minus), max(plus, minus)))\n\nmin_sum = 0\nadd = []\nfor i in range(len(num)):\n min_sum += num[i][0]\n add.append(num[i][1] - num[i][0])\n\ndp = [[0 for _ in range((N // 2) + 1)] for _ in range(len(add) + 1)]\ndp[0][min_sum] = 1\nfor i in range(len(add)):\n for j in range(min_sum, (N // 2) + 1):\n if dp[i][j] == 1:\n if j + add[i] <= (N // 2):\n dp[i+1][j+add[i]] = 1\n dp[i+1][j] = 1\n\ndp_last = dp[-1]\nfor i in range(len(dp_last)-1, -1, -1):\n if dp_last[i] == 1:\n N1 = i\n break\n\nprint(((N1 * (N1 - 1)) // 2 + ((N - N1) * (N - N1 - 1)) // 2))\n", "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nclass Graph:\n def __init__(self, nvert, edges):\n self.adj = [[False] * nvert for i in range(nvert)]\n for e in edges:\n u, v = e\n self.adj[u][v] = True\n self.adj[v][u] = True\n\n def __str__(self):\n return str(self.adj)\n\n # \u7bc0\u70b9\u6570\n def nvertices(self):\n return len(self.adj)\n\n # \u88dc\u30b0\u30e9\u30d5\n def complement(self):\n nv = len(self.adj)\n g = Graph(nv, [])\n for u in range(nv):\n for v in range(nv):\n if u == v: continue\n g.adj[u][v] = not self.adj[u][v]\n g.adj[v][u] = not self.adj[v][u]\n return g\n\n # \u9023\u7d50\u6210\u5206\u3067\u3042\u308b\u30b0\u30e9\u30d5\u306e\u30ea\u30b9\u30c8\n def connectedcomps(self):\n self.visited = [False] * self.nvertices()\n ccs = []\n for v in range(self.nvertices()):\n if not self.visited[v]:\n vs = []\n self.__connectedcomp(v, vs)\n cc = self.inducedsubgraph(vs)\n ccs.append(cc)\n self.visited = None\n return ccs\n\n # v\u3092\u542b\u3080\u9023\u7d50\u6210\u5206 (\u7bc0\u70b9\u306e\u30ea\u30b9\u30c8)\n def __connectedcomp(self, v, vs):\n if self.visited[v]: return\n self.visited[v] = True\n vs.append(v)\n for u in range(self.nvertices()):\n if self.adj[v][u]:\n self.__connectedcomp(u, vs)\n\n # \u8a98\u5c0e\u90e8\u5206\u30b0\u30e9\u30d5\n def inducedsubgraph(self, vs):\n n = len(vs)\n # [3, 1, 4] -> {3:0, 1:1, 4:2}\n m = {}\n for i in range(n):\n m[vs[i]] = i\n\n sg = Graph(n, [])\n for v in vs:\n for u in range(self.nvertices()):\n if self.adj[v][u]:\n sg.adj[m[v]][m[u]] = True\n sg.adj[m[u]][m[v]] = True\n return sg\n\n # 2\u90e8\u30b0\u30e9\u30d5\u306a\u3089\u30702\u30b0\u30eb\u30fc\u30d7\u306e\u5404\u7bc0\u70b9\u6570\u306e\u7d44\u30022\u90e8\u30b0\u30e9\u30d5\u3067\u306a\u3051\u308c\u3070False\n # \u7d44\u3092\u8fd4\u3059\u3068\u304d\u306f(\u5927,\u5c0f)\u306e\u9806\n def isbipartite(self):\n self.color = [None] * self.nvertices()\n self.color[0] = 0\n if not self.__isbipartite(0):\n return False\n m = sum(1 for c in self.color if c == 0)\n n = sum(1 for c in self.color if c == 1)\n assert m + n == self.nvertices()\n return (max(m, n), min(m, n))\n\n def __isbipartite(self, v):\n for u in range(self.nvertices()):\n if self.adj[v][u]:\n if self.color[u] == None:\n self.color[u] = 1 - self.color[v]\n if not self.__isbipartite(u):\n return False\n elif self.color[u] != 1 - self.color[v]:\n return False\n return True\n\n\n# \u5165\u529b\nN, M = [int(w) for w in input().split()]\nedges = []\nfor i in range(M):\n a, b = [int(w) for w in input().split()]\n edges.append((a - 1, b - 1))\n\n# \u5165\u529b\u3055\u308c\u305f\u30b0\u30e9\u30d5\u306e\u88dc\u30b0\u30e9\u30d5 g \u304c2\u90e8\u30b0\u30e9\u30d5\ng = Graph(N, edges).complement()\nccs = g.connectedcomps()\nbs = [cc.isbipartite() for cc in ccs]\nif not all(bs):\n print(-1)\n return\n\n# (\u9023\u7d50\u6210\u5206\u304c\u8907\u6570\u3042\u308b\u5834\u5408),\n# 2\u30b0\u30eb\u30fc\u30d7\u306e\u7bc0\u70b9\u6570\u306e\u5dee\u304c\u6700\u5c0f\u3068\u306a\u308b\u3088\u3046\u306a\u5206\u3051\u65b9\u3092\u6c42\u3081\u308b\ndiffs = [t[0] - t[1] for t in bs]\nsums = {0}\nfor d in diffs:\n newsums = set()\n for s in sums:\n newsums.add(s + d)\n sums.update(newsums)\n\nhalfdiff = sum(diffs)/2\nnearlyhalfdiff = min((abs(s - halfdiff), s) for s in sums)[1]\n\n# \u7bc0\u70b9\u6570\u306e\u5dee\u3092\u6700\u5c0f\u306b\u3059\u308b\u3068\uff0c\u305d\u306e\u5dee\u306fdiff\u306b\u306a\u308b\ndiff = abs(sum(diffs) - 2 * nearlyhalfdiff)\n\n# \u30b0\u30eb\u30fc\u30d7\u306e\u7bc0\u70b9\u6570 (x, y)\nx = (N - diff) // 2\ny = N - x\n\n# \u5b8c\u5168\u30b0\u30e9\u30d5\u306e\u8fba\u6570\nx = x * (x - 1) // 2\ny = y * (y - 1) // 2\n\nprint(x + y)", "N,M = map(int,input().split())\n\nE = [[False]*N for _ in range(N)]\n\nfor n in range(N):\n E[n][n] = True\n\nfor _ in range(M):\n a,b = map(int,input().split())\n a,b = a-1,b-1\n E[a][b] = True\n E[b][a] = True\n\n\nunvisited = set(range(N))\ncolor = [None]*N\ncomponents = []\n\nwhile unvisited:\n v0 = next(iter(unvisited))\n count = [0,0]\n\n stack = [(v0,False)]\n while stack:\n v,c = stack.pop()\n if color[v] is None:\n color[v] = c\n unvisited.discard(v)\n count[c] += 1\n for u,f in enumerate(E[v]):\n if not f:\n stack.append((u, not c))\n\n elif color[v] != c:\n print(-1)\n return\n\n components.append(count)\n\n# DP\nL = N//2+1\ndp = [False]*L\n\n\ndp[0] = True\n\nfor a,b in components:\n ndp = [False]*L\n for i,f in enumerate(dp):\n if f:\n if i+a < L:\n ndp[i+a] = True\n if i+b < L:\n ndp[i+b] = True\n dp = ndp\n\nfor i,f in zip(reversed(range(L)), reversed(dp)):\n if f:\n break\nj = N - i\n\nprint(i*(i-1)//2 + j*(j-1)//2)", "import queue\nN,M=list(map(int,input().split()))\nG=[[1 for i in range(N)] for i in range(N)]\nH=[[] for i in range(N)]\nfor i in range(N):\n G[i][i]-=1\nfor i in range(M):\n a,b=list(map(int,input().split()))\n G[a-1][b-1]-=1\n G[b-1][a-1]-=1\nfor i in range(N):\n for j in range(N):\n if G[i][j]==1:\n H[i].append(j)\nA=[[[],[]]]\nk=0\nq=queue.Queue()\nreached=[0 for i in range(N)]\ndist=[-1 for i in range(N)]\nfor i in range(N):\n if reached[i]==1:\n continue\n q.put(i)\n reached[i]=1\n dist[i]=0\n while(not(q.empty())):\n r=q.get()\n A[k][dist[r]].append(r)\n for p in H[r]:\n if reached[p]==0:\n q.put(p)\n dist[p]=(dist[r]+1)%2\n reached[p]=1\n k+=1\n A.append([[],[]])\nfor i in range(k):\n for j in range(2):\n for x in A[i][j]:\n for y in A[i][j]:\n if x==y:\n continue\n if G[x][y]==1:\n print((-1))\n return\nB=[]\nfor i in range(k):\n B.append((len(A[i][0]),len(A[i][1])))\ndp=[[0 for i in range(N+1)] for i in range(k+1)]\ndp[0][0]=1\nfor i in range(1,k+1):\n for j in range(N+1):\n if dp[i-1][j]==0:\n continue\n dp[i][j+B[i-1][0]]=1\n dp[i][j+B[i-1][1]]=1\ndelta=N\nfor i in range(N+1):\n if dp[k][i]==1:\n tmp=abs(N-2*i)\n if tmp<delta:\n delta=tmp\nX=(N+delta)//2\nY=(N-delta)//2\nprint(((X*(X-1)+Y*(Y-1))//2))\n", "N,M=list(map(int,input().split()))\nROAD=[None]*M\n\nfor i in range(M):\n ROAD[i]=tuple(sorted(list(map(int,input().split()))))\n \nimport itertools\n\nNOROAD=list(itertools.combinations(list(range(1,N+1)),2))\n\nNOROAD=set(NOROAD) - set(ROAD)\n\nGroup=[[i,[]] for i in range(N+1)]\n\ndef find(x):\n while Group[x][0] != x:\n x=Group[x][0]\n return x\n\n\nfor i in NOROAD:\n a,b=i\n #print(a,b)\n Group[a][1]+=[b]\n Group[b][1]+=[a]\n\n if find(a) != find(b):\n Group[find(a)][0]=min(find(a),find(b))\n Group[find(b)][0]=min(find(a),find(b))\n Group[a][0]=min(find(a),find(b))\n Group[b][0]=min(find(a),find(b))\n\nGroupSORT=[[i,j[1]] for i,j in enumerate(Group)]\nGroupSORT.sort(key=lambda x:len(x[1]))\nNUMBERING=[[find(i),\"none\"] for i in range(N+1)]\nCHECK=[0 for i in range(N+1)]\n\nfor i in range(N):\n if CHECK[find(GroupSORT[i][0])]==0:\n \n NUMBERING[GroupSORT[i][0]][1]=0\n CHECK[find(GroupSORT[i][0])]=1\n\nCONDITION=1\n#print(NUMBERING)\n\n\nrepeat_condition=1\nwhile repeat_condition==1:\n\n repeat_condition=0\n\n for i in range(1,N+1):\n if NUMBERING[i][1]==0:\n for j in Group[i][1]:\n if NUMBERING[j][1]==0:\n CONDITION=0\n break\n elif NUMBERING[j][1]==\"none\":\n NUMBERING[j][1]=1\n repeat_condition=1\n\n if NUMBERING[i][1]==1:\n for j in Group[i][1]:\n if NUMBERING[j][1]==1:\n CONDITION=0\n break\n elif NUMBERING[j][1]==\"none\":\n NUMBERING[j][1]=0\n repeat_condition=1\n\n\nimport sys\nif CONDITION==0:\n print((-1))\n return\n\nNUMBERS=set()\nfor i in range(1,len(NUMBERING)):\n NUMBERS=NUMBERS|{NUMBERING[i][0]}\n\ncount=[]\nfor i in NUMBERS:\n count+=[(i,NUMBERING.count([i,0]),NUMBERING.count([i,1]))]\n\nDP=[set() for i in range(len(count))]\nDP[0]={count[0][1],count[0][2]}\n\nfor i in range(1,len(count)):\n for k in DP[i-1]:\n DP[i]=DP[i]|{k+count[i][1],k+count[i][2]}\n\nDIVIDE=list(DP[len(count)-1])\n#print(DIVIDE)\nfor i in range(len(DIVIDE)):\n DIVIDE[i]=abs(DIVIDE[i]-N/2)\n\nx=int(min(DIVIDE)+N/2)\n\nprint((x*(x-1)//2+(N-x)*(N-x-1)//2))\n", "# import math\n# n,k = list(map(int,input().split()))\n# print(math.ceil((n-1)/(k-1)))\n\nn,m = list(map(int,input().split()))\nroad = {}\nwhole = []\nfor i in range(1,n+1):\n whole.append(i)\n road[i] = set()\nwhole = set(whole)\n\nfor i in range(m):\n a,b = list(map(int, input().split()))\n road[a].add(b)\n road[b].add(a)\n\ntaka = []\nhashi = []\nused = set()\nno = 0\nfor x in road:\n l = set()\n r = set()\n l1 = []\n r1 = []\n if x in used:\n continue\n else:\n l.add(x)\n l1.append(x)\n used.add(x)\n for y in whole - road[x]:\n if y not in used:\n r.add(y)\n r1.append(y)\n used.add(y)\n while l1 != [] or r1 != []:\n while r1 != []:\n t = r1.pop()\n for y in whole-road[t]-used-l:\n l.add(y)\n l1.append(y)\n used.add(y)\n while l1 != []:\n t = l1.pop()\n for y in whole-road[t]-used-r:\n r.add(y)\n r1.append(y)\n used.add(y)\n r = list(r)\n l = list(l)\n\n for i in range(len(l)):\n for j in range(i+1,len(l)):\n if l[j] not in road[l[i]]:\n no = 1\n break\n if no == 1:break\n if no == 1:break\n for i in range(len(r)):\n for j in range(i+1,len(r)):\n if r[j] not in road[r[i]]:\n no = 1\n break\n if no == 1:break\n if no == 1:break\n\n taka.append(len(l))\n hashi.append(len(r))\n\nif no == 1:print((-1))\nelse:\n res = [abs(taka[i]-hashi[i]) for i in range(len(taka))]\n res.sort(reverse=-1)\n delta = 0\n for x in res:\n if delta>0:delta-=x\n else:delta+=x\n left = (n+delta)/2\n right = (n-delta)/2\n result = int((left*(left-1)+right*(right-1))/2)\n print(result)\n\n\n", "import sys\nsys.setrecursionlimit(10**7)\nn,m = map(int,input().split())\nG = [[1]*n for i in range(n)]\nfor i in range(m):\n a,b = map(int,input().split())\n a -=1;b-=1\n G[a][b] = G[b][a] = 0\ncolors = [-1 for i in range(n)]\npossible = True\nni = []\ndef dfs(x,y):\n colors[x] = y\n k[y] += 1\n for l in range(n):\n if l == x or G[x][l] == 0:\n continue\n if colors[l] == -1:\n dfs(l,1-y)\n elif colors[l] != 1-y:\n nonlocal possible\n possible = False\nfor i in range(n):\n k = [0,0]\n if colors[i] != -1:\n continue\n dfs(i,0)\n ni.append([k[0],k[1]])\nif possible == False:\n print(-1)\n return\ndp =[0]*701\ndp[0] = 1\nfor i in ni:\n for j in range(700,-1,-1):\n if dp[j]:\n dp[j] = 0\n dp[j+i[0]] = 1\n dp[j+i[1]] = 1\nans = float(\"inf\")\nfor i in range(0,701):\n if dp[i]:\n tmp = (n-i)*(n-i-1)//2 + i*(i-1)//2\n ans = min(tmp,ans)\nprint(ans)", "# \u554f\u984c\u306e\u8da3\u65e8\uff1a\u3067\u304d\u308b\u3060\u3051\u8fba\u304c\u5c11\u306a\u304f\u306a\u308b\u3088\u3046\u306b2\u3064\u306e\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u5206\u3051\u305f\u3044\n# \u307e\u305a\u30012\u3064\u306e\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u5206\u3051\u3089\u308c\u308b\u306e\u304b\u3092\u8abf\u3079\u308b\u5fc5\u8981\u304c\u3042\u308b\u3002\n# \u3053\u308c\u304c\u4e0d\u53ef\u80fd\u3067\u3042\u308c\u3070-1\u3092\u51fa\u529b\u3057\u3066\u5373\u5ea7\u306b\u7d42\u4e86\u3002\n# \u5206\u3051\u3089\u308c\u308b\u5834\u5408\u306f\u3001\u3067\u304d\u308b\u3060\u3051\u8857\u306e\u6570\u3092\u5747\u7b49\u306b\u3057\u305f\u3044\u3002\n\n# \u4ee5\u4e0b\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u3092\u8003\u3048\u308b\u3002\n# \u307e\u305a\u304a\u4e92\u3044\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306e\u7d44A,B\u3092\u9078\u3076\u3002\n# \u3059\u308b\u3068\u3001A\u306b\u3057\u304b\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u8857\u3001B\u306b\u3057\u304b\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u8857\u3001\n# \u4e21\u65b9\u306b\u7e4b\u304c\u3063\u3066\u3044\u308b\u8857\u306e3\u30b0\u30eb\u30fc\u30d7\u306b\u5206\u304b\u308c\u308b\u3002\n# \u6700\u521d\u306e2\u30b0\u30eb\u30fc\u30d7\u306b\u3064\u3044\u3066\u306f\u30b0\u30eb\u30fc\u30d7\u306e\u30b5\u30a4\u30ba\u3092\u4fdd\u5b58\u3057\u3066\u304a\u304f\u3002\n# \u6700\u5f8c\u306e\u30b0\u30eb\u30fc\u30d7\u304c\u7a7a\u3067\u306a\u3044\u5834\u5408\u306f\u3001\u3053\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u5bfe\u3057\u3066\u307e\u305f\u540c\u69d8\u306e\u51e6\u7406\u3092\u884c\u3046\u3002\n# \u8857\u304c\u306a\u304f\u306a\u308b\u304b\u3001\u4e21\u65b9\u306b\u7e4b\u304c\u3063\u3066\u3044\u308b\u8857\u306e\u30b0\u30eb\u30fc\u30d7\u304c\n# \u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u306a\u3063\u305f\u6642\u70b9\u3067\u7d42\u4e86\u3002\n\n# \u4e0a\u8a18\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u306b\u3088\u308a\u3001\u30b0\u30eb\u30fc\u30d7\u306e\u30b5\u30a4\u30ba\u306e\u5217\u3068\u6700\u5f8c\u306b\u6b8b\u3063\u305f\u8857\u306e\u6570\u304c\u6c42\u3081\u3089\u308c\u308b\u3002\n# \u3053\u308c\u3092\u3082\u3068\u306b\u3001\u52d5\u7684\u8a08\u753b\u6cd5\u3067\u8003\u3048\u3089\u308c\u308b\u8857\u306e\u632f\u308a\u5206\u3051\u65b9\u3092\u5168\u3066\u6d17\u3044\u51fa\u3059\u3002\n# \u6700\u3082\u5747\u7b49\u306b\u8fd1\u304f\u632f\u308a\u5206\u3051\u305f\u5834\u5408\u306b\u3064\u3044\u3066\u3001\u5b8c\u5168\u30b0\u30e9\u30d5\u306e\u8fba\u6570\u3092\u8a08\u7b97\u3057\u3066\n# \u51fa\u529b\u3059\u308c\u3070\u554f\u984c\u304c\u89e3\u3051\u308b\u3002\n\ndef main():\n from sys import stdin\n input = stdin.readline\n n, m = list(map(int, input().split()))\n ab = [list(map(int, input().split())) for _ in [0]*m]\n\n rest = n # \u6b8b\u308a\u306e\u8fba\n g = [set() for _ in [0]*n]\n [g[a-1].add(b-1) for a, b in ab]\n [g[b-1].add(a-1) for a, b in ab]\n s = set([i for i in range(n)])\n\n a_list, b_list = [], []\n while True:\n if m == rest*(rest-1)//2:\n break\n a = [-1, 10**10]\n for i in s:\n length = len(g[i])\n if length < a[1]:\n a = [i, length]\n a = a[0]\n b = [-1, 10**10]\n for i in s-g[a]-{a}:\n length = len(g[i])\n if length < b[1]:\n b = [i, length]\n b = b[0]\n a_set, b_set = {a}, {b}\n s.remove(a)\n s.remove(b)\n rest -= 2\n remain = set() # \u6700\u5f8c\u306e\u30b0\u30eb\u30fc\u30d7\n for i in s:\n flag_a = True\n for j in a_set:\n if j not in g[i]:\n flag_a = False\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n flag_b = True\n for j in b_set:\n if j not in g[i]:\n flag_b = False\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n if flag_a+flag_b == 0:\n print((-1))\n return\n elif flag_a*flag_b == 0:\n q = {i}\n flag = flag_a # True\u2192A\u3001False\u2192B\n while q:\n qq = set()\n while q:\n i = q.pop()\n if flag:\n a_set.add(i)\n else:\n b_set.add(i)\n for j in remain:\n if j not in g[i]:\n qq.add(j)\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n for j in q:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n for i in qq:\n remain.remove(i)\n flag ^= True\n q = qq\n else:\n remain.add(i)\n for i in (a_set | b_set)-{a}-{b}:\n s.remove(i)\n rest -= 1\n\n a_list.append(len(a_set))\n b_list.append(len(b_set))\n\n k = len(a_list)\n dp = [False]*(n+1)\n dp[0] = True\n\n for i in range(k):\n a, b = a_list[i], b_list[i]\n dp2 = [False]*(n+1)\n for j in range(n-max(a, b)+1):\n dp2[j+a] |= dp[j]\n dp2[j+b] |= dp[j]\n dp = dp2\n\n ans = 10**10\n for j in range(rest+1):\n for i in range(n-j+1):\n if dp[i]:\n p = i+j\n q = n-p\n ans = min(ans, p*(p-1)//2+q*(q-1)//2)\n\n print(ans)\n\n\nmain()\n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 998244353\ndd = [(0,-1),(1,0),(0,1),(-1,0)]\nddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\ndef main():\n n,m = LI()\n a = [LI_() for _ in range(m)]\n ss = [set() for _ in range(n)]\n for b,c in a:\n ss[b].add(c)\n ss[c].add(b)\n ts = [set(list(range(n))) - set([_]) for _ in range(n)]\n for i in range(n):\n ts[i] -= ss[i]\n\n d = []\n u = set()\n for i in range(n):\n if i in u:\n continue\n ab = set([i])\n nb = set([i])\n ac = set()\n nc = set()\n f = True\n while f:\n f = False\n k = set()\n nc = set()\n for j in nb:\n nc |= ts[j]\n nc -= ac\n ac |= nc\n nb = set()\n for j in nc:\n nb |= ts[j]\n nb -= ab\n ab |= nb\n if nb:\n f = True\n if ab & ac:\n return -1\n d.append((len(ab),len(ac)))\n u |= ab\n u |= ac\n r = set([0])\n for b,c in d:\n t = set()\n for k in r:\n t.add(k+b)\n t.add(k+c)\n r = t\n rr = inf\n for t in r:\n nt = n - t\n if t == 0 or nt == 0:\n continue\n tr = t * (t-1) // 2\n tr += nt * (nt-1) // 2\n if rr > tr:\n rr = tr\n return rr\n\n\nprint(main())\n\n", "from collections import deque\nN, M = map(int, input().split())\nG0 = [set([i]) for i in range(N)]\n\nA = set(range(N))\n\nfor i in range(M):\n a, b = map(int, input().split())\n G0[a-1].add(b-1)\n G0[b-1].add(a-1)\n\nG = [A - g for g in G0]\n\nb = 1\nc = [-1]*N\nfor i in range(N):\n if c[i] != -1:\n continue\n p = 0; s = 0\n que = deque([i])\n c[i] = 0\n while que:\n v = que.popleft()\n s += 1\n if c[v] == 0:\n p += 1\n for w in G[v]:\n if c[w] == -1:\n c[w] = c[v]^1\n que.append(w)\n elif c[w] == c[v]:\n print(-1)\n return\n b = (b << p) | (b << (s-p))\n\nans = 10**18\nfor i in range(N+1):\n if (b >> i) & 1:\n ans = min(ans, i*(i-1)//2 + (N-i)*(N-i-1)//2)\nprint(ans)", "from collections import Counter\nimport numpy as np\n\nclass DisjointSet:\n def __init__(self, size):\n self.parent = list(range(size))\n self.rank = [0]*size\n \n def find(self, x):\n stack = []\n parent = self.parent\n while parent[x] != x:\n stack.append(x)\n x = parent[x]\n for y in stack:\n parent[y] = x\n return x\n\n def union(self, x, y):\n xr, yr = self.find(x), self.find(y)\n \n if self.rank[xr] > self.rank[yr]:\n self.parent[yr] = xr\n elif self.rank[xr] < self.rank[yr]:\n self.parent[xr] = yr\n elif xr != yr:\n self.parent[yr] = xr\n self.rank[xr] += 1\n\ndef check_bipartiteness(n_vertices, edges):\n ds = DisjointSet(2*n_vertices)\n\n for a,b in edges:\n ds.union(a, b+n_vertices)\n ds.union(b, a+n_vertices)\n \n next_color = 0\n color = [-1]*(2*n_vertices)\n for v in range(n_vertices):\n ra = ds.find(v)\n rb = ds.find(v+n_vertices)\n if ra == rb:\n return None\n if color[ra] < 0:\n color[ra] = next_color\n color[rb] = next_color+1\n next_color += 2\n color[v] = color[ra]\n color[v+n_vertices] = color[rb]\n return color[:n_vertices]\n\n\n\nn,m = list(map(int,input().split()))\n\nmat = [[True]*t for t in range(n)]\n\nfor _ in range(m):\n a,b = list(map(int,input().split()))\n if a < b:\n a,b = b,a\n mat[a-1][b-1] = False\n\nedges = ((a,b) for a in range(n) for b in range(a) if mat[a][b])\n\ncolors = check_bipartiteness(n, edges)\nif colors is None:\n print((-1))\n return\n\ncnt = Counter(colors)\ndp = np.zeros(n,dtype=bool)\ndp[0] = True\n\nfor i in range(n):\n a,b = cnt[i*2],cnt[i*2+1]\n if a == 0 and b == 0:\n break\n d = abs(a-b)\n if d == 0:\n continue\n ndp = np.zeros(n,dtype=bool)\n ndp[d:] = dp[:-d]\n ndp[:-d] |= dp[d:]\n ndp[:d] |= dp[d-1::-1]\n dp = ndp\nx = list(dp).index(True)\n\na = (n-x)//2\nb = n-a\n\nprint((a*(a-1)//2 + b*(b-1)//2))\n", "import sys\ninput = sys.stdin.readline\n\nN, M = map(int, input().split())\ngraph1 = [[False]*N for _ in range(N)]\nfor _ in range(M):\n a, b = map(int, input().split())\n graph1[a-1][b-1] = True\n graph1[b-1][a-1] = True\n\ngraph = [[] for _ in range(N)]\nfor i in range(N):\n for j in range(N):\n if i!=j and not graph1[i][j]:\n graph[i].append(j)\n\n\nchecked = [-1]*N\nColor = [None]*N\n\ndef bfs(start):\n q = [start]\n checked[start] = start\n Color[start] = 0\n color = 0\n Cs = [1, 0]\n while q:\n qq = []\n color ^= 1\n for p in q:\n for np in graph[p]:\n if checked[np] == -1:\n checked[np] = start\n Color[np] = color\n qq.append(np)\n Cs[color] += 1\n elif checked[np] == start and color != Color[np]:\n return [-1, -1]\n q = qq\n return Cs\n\ndef main():\n Dif = []\n for i in range(N):\n if checked[i] == -1:\n a, b = bfs(i)\n if a == -1:\n print(-1)\n return\n Dif.append(abs(a-b))\n dp = [False]*(N+1)\n dp[0] = True\n for d in Dif:\n for j in reversed(range(d, N+1)):\n dp[j] = dp[j] or dp[j-d]\n\n min_dif = 10**15\n S = sum(Dif)\n for j in range(N+1):\n if dp[j]:\n min_dif = min(min_dif, abs(S-j*2))\n \n t1 = (N+min_dif)//2\n t2 = (N-min_dif)//2\n print(t1*(t1-1)//2 + t2*(t2-1)//2)\n\ndef __starting_point():\n main()\n__starting_point()", "import sys\ninput = sys.stdin.readline\nfrom itertools import combinations\nn,m = map(int,input().split())\nab = [list(map(int,input().split())) for i in range(m)]\ng2d = [[1 for i in range(n+1)] for j in range(n+1)]\nfor i in range(1,n+1):\n g2d[i][i] = 0\nfor a,b in ab:\n g2d[a][b] = 0\n g2d[b][a] = 0\ngraph = [[] for i in range(n+1)]\nfor i in range(1,n+1):\n for j in range(1,n+1):\n if g2d[i][j]:\n graph[i].append(j)\n graph[j].append(i)\nvis = [-1]*(n+1)\noddeven = []\nfor i in range(1,n+1):\n if vis[i] == -1:\n stack = [i]\n vis[i] = 0\n odd = 0\n even = 1\n while stack:\n x = stack.pop()\n for y in graph[x]:\n if vis[y] == -1:\n vis[y] = vis[x]+1\n if vis[y]%2:\n odd += 1\n else:\n even += 1\n stack.append(y)\n elif (vis[y]-vis[x])%2 == 0:\n print(-1)\n return\n oddeven.append(abs(odd-even))\nt = len(oddeven)\ns = sum(oddeven)\ndp = 1<<s\nfor x in oddeven:\n dp = (dp<<abs(x)) | (dp>>abs(x))\nfor i in range(s+1):\n if (dp&1<<(s-i))|(dp&1<<(s+i)):\n ex = i\n break\nA,B = (n+ex)//2,(n-ex)//2\nprint(A*(A-1)//2+B*(B-1)//2)", "# \u554f\u984c\u306e\u8da3\u65e8\uff1a\u3067\u304d\u308b\u3060\u3051\u8fba\u304c\u5c11\u306a\u304f\u306a\u308b\u3088\u3046\u306b2\u3064\u306e\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u5206\u3051\u305f\u3044\n# \u307e\u305a\u30012\u3064\u306e\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u5206\u3051\u3089\u308c\u308b\u306e\u304b\u3092\u8abf\u3079\u308b\u5fc5\u8981\u304c\u3042\u308b\u3002\n# \u3053\u308c\u304c\u4e0d\u53ef\u80fd\u3067\u3042\u308c\u3070-1\u3092\u51fa\u529b\u3057\u3066\u5373\u5ea7\u306b\u7d42\u4e86\u3002\n# \u5206\u3051\u3089\u308c\u308b\u5834\u5408\u306f\u3001\u3067\u304d\u308b\u3060\u3051\u8857\u306e\u6570\u3092\u5747\u7b49\u306b\u3057\u305f\u3044\u3002\n\n# \u4ee5\u4e0b\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u3092\u8003\u3048\u308b\u3002\n# \u307e\u305a\u304a\u4e92\u3044\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306e\u7d44A,B\u3092\u9078\u3076\u3002\n# \u3059\u308b\u3068\u3001A\u306b\u3057\u304b\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u8857\u3001B\u306b\u3057\u304b\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u8857\u3001\n# \u4e21\u65b9\u306b\u7e4b\u304c\u3063\u3066\u3044\u308b\u8857\u306e3\u30b0\u30eb\u30fc\u30d7\u306b\u5206\u304b\u308c\u308b\u3002\n# \u6700\u521d\u306e2\u30b0\u30eb\u30fc\u30d7\u306b\u3064\u3044\u3066\u306f\u30b0\u30eb\u30fc\u30d7\u306e\u30b5\u30a4\u30ba\u3092\u4fdd\u5b58\u3057\u3066\u304a\u304f\u3002\n# \u6700\u5f8c\u306e\u30b0\u30eb\u30fc\u30d7\u304c\u7a7a\u3067\u306a\u3044\u5834\u5408\u306f\u3001\u3053\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u5bfe\u3057\u3066\u307e\u305f\u540c\u69d8\u306e\u51e6\u7406\u3092\u884c\u3046\u3002\n# \u8857\u304c\u306a\u304f\u306a\u308b\u304b\u3001\u4e21\u65b9\u306b\u7e4b\u304c\u3063\u3066\u3044\u308b\u8857\u306e\u30b0\u30eb\u30fc\u30d7\u304c\n# \u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u306a\u3063\u305f\u6642\u70b9\u3067\u7d42\u4e86\u3002\n\n# \u4e0a\u8a18\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u306b\u3088\u308a\u3001\u30b0\u30eb\u30fc\u30d7\u306e\u30b5\u30a4\u30ba\u306e\u5217\u3068\u6700\u5f8c\u306b\u6b8b\u3063\u305f\u8857\u306e\u6570\u304c\u6c42\u3081\u3089\u308c\u308b\u3002\n# \u3053\u308c\u3092\u3082\u3068\u306b\u3001\u52d5\u7684\u8a08\u753b\u6cd5\u3067\u8003\u3048\u3089\u308c\u308b\u8857\u306e\u632f\u308a\u5206\u3051\u65b9\u3092\u5168\u3066\u6d17\u3044\u51fa\u3059\u3002\n# \u6700\u3082\u5747\u7b49\u306b\u8fd1\u304f\u632f\u308a\u5206\u3051\u305f\u5834\u5408\u306b\u3064\u3044\u3066\u3001\u5b8c\u5168\u30b0\u30e9\u30d5\u306e\u8fba\u6570\u3092\u8a08\u7b97\u3057\u3066\n# \u51fa\u529b\u3059\u308c\u3070\u554f\u984c\u304c\u89e3\u3051\u308b\u3002\n\ndef main():\n from sys import stdin\n input = stdin.readline\n n, m = map(int, input().split())\n ab = [list(map(int, input().split())) for _ in [0]*m]\n\n rest = n # \u6b8b\u308a\u306e\u8fba\n g = [set() for _ in [0]*n]\n [g[a-1].add(b-1) for a, b in ab]\n [g[b-1].add(a-1) for a, b in ab]\n s = set([i for i in range(n)])\n\n a_list, b_list = [], []\n while True:\n if m == rest*(rest-1)//2:\n break\n a = [-1, 10**10]\n for i in s:\n length = len(g[i])\n if length < a[1]:\n a = [i, length]\n a = a[0]\n b = [-1, 10**10]\n for i in s-g[a]-{a}:\n length = len(g[i])\n if length < b[1]:\n b = [i, length]\n b = b[0]\n a_set, b_set = {a}, {b}\n s.remove(a)\n s.remove(b)\n rest -= 2\n remain = set() # \u6700\u5f8c\u306e\u30b0\u30eb\u30fc\u30d7\n for i in s:\n flag_a = True\n for j in a_set:\n if j not in g[i]:\n flag_a = False\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n flag_b = True\n for j in b_set:\n if j not in g[i]:\n flag_b = False\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n if flag_a+flag_b == 0:\n print(-1)\n return\n elif flag_a*flag_b == 0:\n q = {i}\n flag = flag_a # True\u2192A\u3001False\u2192B\n while q:\n qq = set()\n while q:\n i = q.pop()\n if flag:\n a_set.add(i)\n else:\n b_set.add(i)\n for j in remain:\n if j not in g[i]:\n qq.add(j)\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n for j in q:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n for i in qq:\n remain.remove(i)\n flag ^= True\n q = qq\n else:\n remain.add(i)\n for i in (a_set | b_set)-{a}-{b}:\n s.remove(i)\n rest -= 1\n\n a_list.append(len(a_set))\n b_list.append(len(b_set))\n\n k = len(a_list)\n dp = [False]*(n+1)\n dp[0] = True\n\n for i in range(k):\n a, b = a_list[i], b_list[i]\n dp2 = [False]*(n+1)\n for j in range(n-max(a, b)+1):\n dp2[j+a] |= dp[j]\n dp2[j+b] |= dp[j]\n dp = dp2\n\n ans = 10**10\n for j in range(rest+1):\n for i in range(n-j+1):\n if dp[i]:\n p = i+j\n q = n-p\n ans = min(ans, p*(p-1)//2+q*(q-1)//2)\n print(ans)\n\n\nmain()", "import sys\nn, m = list(map(int, input().split()))\nN = 2000\nG = [[0] * N for i in range(N)]\ndp = [[0] * N for i in range(N)]\ncol = [0] * N\ncnt = [0] * 2\nvisit = [0] * N\nfor i in range(m):\n a, b = list(map(int, input().split()))\n a, b = a - 1, b - 1\n G[a][b], G[b][a] = 1, 1\n\n\ndef dfs(u, c):\n visit[u] = 1\n col[u] = c\n cnt[c] += 1\n\n for v in range(n):\n if v == u or G[u][v] == 1:\n continue\n\n if visit[v] == 1 and col[v] == c:\n return False\n\n if not visit[v] and not dfs(v, c ^ 1):\n return False\n\n return True\n\n\nnum = 0\ndp[0][0] = 1\nfor i in range(n):\n if not visit[i]:\n num += 1\n\n cnt[0], cnt[1] = 0, 0\n\n if not dfs(i, 0):\n print((-1))\n return\n\n for j in range(n):\n for k in range(2):\n if j >= cnt[k]:\n dp[num][j] |= dp[num - 1][j - cnt[k]]\n\nans = m\nfor i in range(n):\n if dp[num][i]:\n ans = min(ans, i * (i - 1) // 2 + (n - i) * (n - i - 1) // 2)\n\nprint(ans)\n\n\n", "import queue\nN,M=list(map(int,input().split()))\nG=[[1 for i in range(N)] for i in range(N)]\nH=[[] for i in range(N)]\nfor i in range(N):\n G[i][i]-=1\nfor i in range(M):\n a,b=list(map(int,input().split()))\n G[a-1][b-1]-=1\n G[b-1][a-1]-=1\nfor i in range(N):\n for j in range(N):\n if G[i][j]==1:\n H[i].append(j)\nA=[[[],[]]]\nk=0\nq=queue.Queue()\nreached=[0 for i in range(N)]\ndist=[-1 for i in range(N)]\nfor i in range(N):\n if reached[i]==1:\n continue\n q.put(i)\n reached[i]=1\n dist[i]=0\n while(not(q.empty())):\n r=q.get()\n A[k][dist[r]].append(r)\n for p in H[r]:\n if reached[p]==0:\n q.put(p)\n dist[p]=(dist[r]+1)%2\n reached[p]=1\n k+=1\n A.append([[],[]])\nfor i in range(k):\n for j in range(2):\n for x in A[i][j]:\n for y in A[i][j]:\n if x==y:\n continue\n if G[x][y]==1:\n print((-1))\n return\nB=[]\nfor i in range(k):\n B.append((len(A[i][0]),len(A[i][1])))\ndp=[[0 for i in range(N+1)] for i in range(k+1)]\ndp[0][0]=1\nfor i in range(1,k+1):\n for j in range(N+1):\n if dp[i-1][j]==0:\n continue\n dp[i][j+B[i-1][0]]=1\n dp[i][j+B[i-1][1]]=1\ndelta=N\nfor i in range(N+1):\n if dp[k][i]==1:\n tmp=abs(N-2*i)\n if tmp<delta:\n delta=tmp\nX=(N+delta)//2\nY=(N-delta)//2\nprint(((X*(X-1)+Y*(Y-1))//2))\n", "import sys\nimport math\n\ninput = sys.stdin.readline\nN, M = list(map(int, input().split()))\nAB = [list(map(int, input().split())) for _ in range(M)]\nconnected = [set() for _ in range(N)]\nfor a, b in AB:\n a -= 1\n b -= 1\n connected[a].add(b)\n connected[b].add(a)\nfor i in range(N):\n connected[i].add(i)\n\nwhole_set = set(range(N))\nunconnected = [whole_set-connected[i] for i in range(N)]\nassign = [-1] * N\nass_q = []\ng = 0\nfor i in range(N):\n if len(unconnected[i]) != 0:\n assign[i] = g\n for j in unconnected[i]:\n assign[j] = (assign[i] + 1) % 2 + g\n ass_q.append(j)\n break\nwhile len(ass_q) > 0:\n i = ass_q.pop()\n for j in unconnected[i]:\n if assign[j] == -1:\n assign[j] = (assign[i] + 1) % 2 + g\n ass_q.append(j)\n elif assign[j] == assign[i]:\n print((-1))\n return\n if len(ass_q) == 0:\n g += 2\n for i in range(N):\n if len(unconnected[i]) > 0 and assign[i] == -1:\n assign[i] = g\n for j in unconnected[i]:\n assign[j] = (assign[i] + 1) % 2 + g\n ass_q.append(j)\n break\n\n\ngroups = [(assign.count(g_), assign.count(g_+1)) for g_ in range(0, g, 2)]\nans = math.inf\nnot_assign = assign.count(-1)\nfor b in range(pow(2, len(groups))):\n taka, hashi = 0, 0\n for i in range(len(groups)):\n taka += groups[i][(b>>i)&1]\n hashi += groups[i][((~b)>>i)&1]\n for _ in range(not_assign):\n if taka < hashi:\n taka += 1\n else:\n hashi += 1\n ans = min(ans, (taka*(taka-1))//2 + (hashi*(hashi-1))//2)\nprint(ans)\n", "# E\nfrom collections import deque\nimport numpy as np\n\nN, M = map(int, input().split())\nG = dict()\nfor i in range(1, N+1):\n G[i] = dict()\n for j in range(1, N+1):\n if i != j:\n G[i][j] = 1\n \nfor _ in range(M):\n a, b = map(int, input().split())\n _ = G[a].pop(b)\n _ = G[b].pop(a)\n \nres_con = []\n\ndone_list = [1] + [0]*N\n\n\n\ncore = 1\n\nwhile core != 0:\n \n # BFS\n queue = deque([core]) \n res_flag = True\n \n size_a = 1\n size_b = 0\n\n done_list[core] = 1\n while len(queue) > 0:\n a = queue.popleft()\n for b in G[a].keys():\n if done_list[b] == done_list[a]:\n res_flag = False\n break\n elif done_list[b] == 0:\n done_list[b] = -1*done_list[a]\n if done_list[a] == 1:\n size_b += 1\n else:\n size_a += 1\n queue.append(b)\n \n res_con.append([size_a, size_b])\n \n \n if res_flag == False:\n break\n \n \n core = 0\n for i in range(1, N+1):\n if done_list[i] == 0:\n core = i\n break\n \n# summarize\nif res_flag == False:\n res = 0\nelse:\n res_can_s = np.array([0])\n for rr in res_con:\n a = rr[0]\n b = rr[1]\n res_can_s = np.unique(np.concatenate([res_can_s + a, res_can_s + b]))\n res = ((res_can_s*(res_can_s - 1) // 2) + ((N - res_can_s)*(N - res_can_s - 1) // 2)).min()\n\nif res_flag == False:\n print(-1)\nelse:\n print(res)", "import sys\nreadline = sys.stdin.readline\n\npopcntsum = ((1<<1024) - 1)\nFa = [0] + [popcntsum//((1<<(1<<(i-1)))+1) for i in range(1,11)]\nFb = [0] + [Fa[i]<<(1<<(i-1)) for i in range(1,11)]\nfila1 = Fa[1]\nfilb1 = Fb[1]\nfila2 = Fa[2]\nfilb2 = Fb[2]\nfila3 = Fa[3]\nfilb3 = Fb[3]\nfila4 = Fa[4]\nfilb4 = Fb[4]\nfila5 = Fa[5]\nfilb5 = Fb[5]\nfila6 = Fa[6]\nfilb6 = Fb[6]\nfila7 = Fa[7]\nfilb7 = Fb[7]\nfila8 = Fa[8]\nfilb8 = Fb[8]\nfila9 = Fa[9]\nfilb9 = Fb[9]\nfila10 = Fa[10]\nfilb10 = Fb[10]\ndef popcount(x):\n x = (x&fila1) + ((x&filb1)>>1)\n x = (x&fila2) + ((x&filb2)>>2)\n x = (x&fila3) + ((x&filb3)>>4)\n x = (x&fila4) + ((x&filb4)>>8)\n x = (x&fila5) + ((x&filb5)>>16)\n x = (x&fila6) + ((x&filb6)>>32)\n x = (x&fila7) + ((x&filb7)>>64)\n x = (x&fila8) + ((x&filb8)>>128)\n x = (x&fila9) + ((x&filb9)>>256)\n x = (x&fila10) + ((x&filb10)>>512)\n return x\n\n\ndef check(S):\n if S == 0:\n return []\n if S < 0:\n return None\n G1 = [G[i]&S for i in range(N)]\n M = popcount(S)\n if M**2 == sum(G1[i] for i in range(N) if S&(1<<i)):\n return [(0, 1)]*M\n st = 0\n A = 0\n for i in range(N):\n if (1<<i) & S:\n st = i\n A = 1<<i\n break\n B = 0\n for i in range(N):\n if not (1<<i) & S:\n continue\n if not (G[st] & (1<<i)):\n B = 1<<i\n break\n T = (((1<<N)-1)^S)|A|B\n na = 1\n nb = popcount(B)\n T2 = None\n while T2 != T:\n T2 = T\n for i in range(N):\n if (1<<i) & T:\n continue\n fa = (na == popcount(G1[i]&A))\n fb = (nb == popcount(G1[i]&B))\n if fa and fb:\n continue\n if fa:\n A |= 1<<i\n T |= 1<<i\n na += 1\n continue\n if fb:\n B |= 1<<i\n T |= 1<<i\n nb += 1\n continue\n return None\n S2 = ((1<<N)-1) ^ T\n \n if na > nb:\n na, nb = nb, na\n ss = check(S2)\n if ss is None:\n return None\n return ss + [(na, nb)] \n\n\nN, M = map(int, readline().split())\nG = [1<<i for i in range(N)]\nfor _ in range(M):\n a, b = map(int, readline().split())\n a -= 1\n b -= 1\n G[a] |= 1<<b\n G[b] |= 1<<a\nss = check((1<<N)-1)\nif ss is None:\n print(-1)\nelse:\n SA, SB = list(map(list, zip(*ss)))\n res = 1\n for sa, sb in zip(SA, SB):\n res = (res<<sa)|(res<<sb)\n ans = 10**9+7\n for i in range(N+1):\n if not (1<<i)&res:\n continue\n ans = min(ans, (i-1)*i//2 + (N-i-1)*(N-i)//2)\n print(ans)", "import sys\ninput = lambda : sys.stdin.readline().rstrip()\nsys.setrecursionlimit(max(1000, 10**9))\nwrite = lambda x: sys.stdout.write(x+\"\\n\")\n\n\nn,m = list(map(int, input().split()))\nmt = [[True]*n for _ in range(n)]\nfor i in range(m):\n a,b = map(int, input().split())\n a -= 1\n b -= 1\n mt[a][b] = False\n mt[b][a] = False\nfor i in range(n):\n mt[i][i] = False\nns = [[] for _ in range(n)]\nfor i in range(n):\n for j in range(n):\n if mt[i][j]:\n ns[i].append(j)\n \n# \u4e8c\u90e8\u30b0\u30e9\u30d5\u5224\u5b9a bipertite\ndef is_bip(ns):\n cs = [None]*n\n vs = []\n for start in range(n):\n if cs[start] is not None:\n continue\n v0 = v1 = 0\n q = [start]\n cs[start] = 1\n v1 += 1\n while q:\n u = q.pop()\n c = cs[u]\n cc = int(not c)\n for v in ns[u]:\n if cs[v] is None:\n cs[v] = cc\n if cc==0:\n v0 += 1\n else:\n v1 += 1\n q.append(v)\n elif cs[v]==c:\n# print(cs)\n return False, None\n vs.append((v0,v1))\n return True, vs\nres, vs = is_bip(ns)\nif not res:\n ans = -1\nelse:\n dp = 1\n for v0,v1 in vs:\n dp = (dp<<v0) | (dp<<v1)\n# for i in range(n,-1,-1):\n# if i-v0>=0:\n# dp[i] |= dp[i-v0]\n# if i-v1>=0:\n# dp[i] |= dp[i-v1]\n# print(dp)\n ans = float(\"inf\")\n for i in range(1,n+1):\n if dp>>i&1:\n ans = min(ans, i*(i-1)//2+(n-i)*(n-i-1)//2)\nprint(ans)", "\"\"\"\nE\u554f\u984c\n\u7e4b\u304c\u3063\u3066\u3044\u308b\u90fd\u5e02\u540c\u58eb\u306f\u540c\u3058\u5dde\u306b\u3042\u3063\u3066\u3082\u9055\u3046\u5dde\u306b\u3042\u3063\u3066\u3082\u3088\u3044\u2192\u8003\u3048\u306b\u304f\u3044\n\u2192\u300c\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306f\u5fc5\u305a\u9055\u3046\u5dde\u306b\u3042\u308b\u300d\u306e\u307b\u3046\u304c\u8003\u3048\u3084\u3059\u3044\n\u2192\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306b\u3059\u3079\u3066\u8fba\u3092\u5f35\u3063\u3066\u4e8c\u90e8\u30b0\u30e9\u30d5\u304c\u69cb\u6210\u3067\u304d\u308b\u304b\u3069\u3046\u304b\u3067\u5224\u5b9a\u3067\u304d\u305d\u3046\uff1f\n\uff08\u5fc5\u8981\u6761\u4ef6\u3067\u306f\u3042\u308b\u3051\u3069\u5341\u5206\u6761\u4ef6\u3067\u3042\u308b\u304b\u3069\u3046\u304b\u306f\u308f\u304b\u3089\u306a\u3044\uff09\n\u2192\u3053\u306e\u6761\u4ef6\u3060\u3068\u540c\u3058\u5dde\u306b\u3042\u308b\u306a\u3089\u5fc5\u305a\u4efb\u610f\u306e\u4e8c\u90fd\u5e02\u9593\u306f\u7e4b\u304c\u3063\u3066\u3044\u308b\u306e\u3067\u5341\u5206\u6761\u4ef6\u3082\u6e80\u305f\u3057\u3066\u305d\u3046\uff01\n\uff08\u2235\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306b\u8fba\u3092\u5f35\u3063\u305f\u6642\u540c\u3058\u5dde\u5185\u306b\u8fba\u3092\u6301\u305f\u306a\u3044\u305f\u3081\uff09\n\n\uff08\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306b\u8fba\u3092\u5f35\u3063\u305f\uff09\u30b0\u30e9\u30d5\u304c\u9023\u7d50\u21d2\u90fd\u5e02\u306e\u9078\u3073\u65b9\u306f\u9ad8\u30051\u901a\u308a\n\u9023\u7d50\u3067\u306a\u3044\u306a\u3089\u8907\u6570\u306e\u9078\u3073\u65b9\u304c\u5b58\u5728\u3059\u308b\n\u2192\u6700\u5c0f\u3068\u306a\u308b\u3088\u3046\u306a\u9078\u3073\u65b9\u306f\u3069\u306e\u3088\u3046\u306b\u6c7a\u3081\u308c\u3070\u3088\u3044\u304b\uff1f\n\u2192\u305d\u308c\u305e\u308c\u306e\u9023\u7d50\u6210\u5206\u3054\u3068\u306b\u3001\u7247\u65b9\u306bai\u90fd\u5e02\u3001\u3082\u3046\u7247\u65b9\u306bbi\u90fd\u5e02\u632f\u308a\u5206\u3051\u3089\u308c\u308b\u3068\u3059\u308b\u3068\nL = [[a1, b1], [a2, b2], ... , [ak, bk]]\n\u3068\u3067\u304d\u3066\u3001(sum(A)+sum(B) == n)\ns = \u03a3[i = 1 to k](ai\u304bbi\u306e\u3069\u3061\u3089\u304b\u3092\u9078\u3093\u3067\u8db3\u3059)\u3000\u3068\u3057\u305f\u3068\u304d\u306b\n\u3082\u3063\u3068\u3082s\u304cn//2\u306b\u8fd1\u304f\u306a\u308b\u3088\u3046\u306bs\u3092\u9078\u3079\u3070\u3088\u304f\u3001\u3053\u308c\u306fdp\u3067O(nk)\u3067\u3067\u304d\u308b\n\"\"\"\nimport sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10**7)\nimport numpy as np\n\nn, m = map(int, input().split())\nG = [{i for i in range(n) if i != j} for j in range(n)]\nfor _ in range(m):\n a, b = map(int, input().split())\n a -= 1\n b -= 1\n G[a].remove(b)\n G[b].remove(a)\n\nseen = [-1]*n\nL = []\ndef is_bipartite(v, color):\n seen[v] = color\n L[-1][color] += 1\n for i in G[v]:\n if seen[i] != -1:\n if seen[i] == color:\n return False\n else:\n if not is_bipartite(i, color^1):\n return False\n return True\n\nfor i in range(n):\n if seen[i] == -1:\n L.append([0, 0])\n if not is_bipartite(i, 0):\n print(-1)\n break\nelse:\n dp = np.zeros((len(L)+1, n+1), dtype=bool)\n dp[0, 0] = True\n for i, ab in enumerate(L):\n a, b = ab\n dp[i+1, a:] |= dp[i, :n+1-a]\n dp[i+1, b:] |= dp[i, :n+1-b]\n temp = n//2\n dp = dp[-1].tolist()\n while not dp[temp]:\n temp += 1\n r = n - temp\n print(temp*(temp-1)//2 + r*(r-1)//2)", "from collections import deque\n\nN, M = list(map(int, input().split()))\nadjL = [set(range(N)) for _ in range(N)]\nfor v in range(N):\n adjL[v].remove(v)\nfor _ in range(M):\n A, B = list(map(int, input().split()))\n A, B = A-1, B-1\n adjL[A].remove(B)\n adjL[B].remove(A)\n\ndef getSizes(adjList):\n def bfs(vSt):\n colors[vSt] = 1\n nums[1] += 1\n Q = deque([vSt])\n while Q:\n vNow = Q.popleft()\n color = colors[vNow]\n for v2 in adjList[vNow]:\n if colors[v2] == color:\n return False\n elif colors[v2] == 0:\n colors[v2] = -color\n nums[-color] += 1\n Q.append(v2)\n return True\n\n numV = len(adjList)\n colors = [0] * numV\n anss = []\n for vSt in range(numV):\n if colors[vSt] != 0: continue\n nums = {-1: 0, 1: 0}\n if not bfs(vSt):\n return []\n anss.append((nums[-1], nums[1]))\n return anss\n\nsizes = getSizes(adjL)\n\nif not sizes:\n print((-1))\nelse:\n bitset = 1<<N\n for A, B in sizes:\n bitset = (bitset>>A) | (bitset>>B)\n\n minDiff = N\n iMinDiff = -1\n for i in reversed(list(range(N+1))):\n if bitset & 1:\n diff = abs(i-N/2)\n if diff < minDiff:\n minDiff = diff\n iMinDiff = i\n bitset >>= 1\n\n print((iMinDiff*(iMinDiff-1)//2 + (N-iMinDiff)*(N-iMinDiff-1)//2))\n", "from collections import deque\n\n\nn, m = map(int, input().split())\ninfo = [list(map(int, input().split())) for i in range(m)]\n\nmatrix = [[0]*n for i in range(n)]\nfor i in range(m):\n a, b = info[i]\n a -= 1\n b -= 1\n matrix[a][b] = 1\n matrix[b][a] = 1\n\ngraph = [[] for i in range(n)]\nfor i in range(n):\n for j in range(i+1, n):\n if matrix[i][j] == 0:\n graph[i].append(j)\n graph[j].append(i)\n\n\ndef coloring(graph):\n n = len(graph)\n visited = [-1] * n\n ans = []\n for i in range(n):\n if visited[i] >= 0:\n continue\n visited[i] = 0\n q = deque([i]) \n num = [1, 0]\n while q:\n _from = q.pop()\n for to in graph[_from]:\n if visited[to] == visited[_from]:\n return [[-1, -1]]\n if visited[to] >= 0:\n continue\n visited[to] = visited[_from] ^ 1\n num[visited[to]] += 1\n q.append(to)\n ans.append(num)\n return ans\n\nnum = coloring(graph)\nif num[0][0] == -1:\n print(-1)\n return\n\ndp = [[False]*(n+1) for _ in range(len(num) + 1)]\ndp[0][0] = True\n\nfor i in range(len(num)):\n a, b = num[i]\n for j in range(n+1):\n if j-a >= 0:\n dp[i+1][j] = dp[i][j-a] or dp[i+1][j]\n if j-b >= 0:\n dp[i+1][j] = dp[i][j-b] or dp[i+1][j]\n\nans = 10**20\nfor i, boolian in enumerate(dp[len(num)]):\n if boolian:\n tmp_ans = i * (i-1) // 2 + (n-i) * (n-i-1) // 2 \n ans = min(tmp_ans, ans)\nprint(ans)", "from typing import List\n\n\nclass UnionFind:\n def __init__(self, n: int) -> None:\n '\u6728\u306e\u521d\u671f\u5316\u3092\u3059\u308b'\n self.p = [-1] * n\n self.rank = [1]*n\n self.size = [1] * n\n\n def find(self, x: int) -> int:\n 'x \u306e\u89aa\u3092\u8fd4\u3059'\n if self.p[x] == -1:\n return x\n else:\n self.p[x] = self.find(self.p[x])\n return self.p[x]\n\n def unite(self, x: int, y: int) -> bool:\n 'rank\u306e\u4f4e\u3044\u89aa\u3092\u9ad8\u3044\u65b9\u306e\u306e\u89aa\u306b\u3059\u308b'\n if not self.same(x, y):\n x = self.find(x)\n y = self.find(y)\n if self.rank[x] > self.rank[y]:\n x, y = y, x\n elif self.rank[x] == self.rank[y]:\n self.rank[y] += 1\n self.p[x] = y\n self.size[y] += self.size[x]\n return True\n else:\n return False\n\n def same(self, x: int, y: int) -> bool:\n return self.find(x) == self.find(y)\n\n\nn, m = list(map(int, input().split()))\npath = [[1]*n for _ in range(n)]\nfor j in range(n):\n path[j][j] = 0\nfor i in range(m):\n a, b = list(map(int, input().split()))\n a -= 1\n b -= 1\n path[a][b] = 0\n path[b][a] = 0\n\nuf = UnionFind(2*n)\n\nfor i in range(n):\n for j in range(n):\n if path[i][j] == 1:\n uf.unite(i, j+n)\n uf.unite(i+n, j)\n\nfor i in range(n):\n if uf.same(i, i+n):\n print((-1))\n return\n\ndeltas: List[int] = []\n\nview = [1]*n\n\nfor i in range(n):\n if view[i] == 0:\n continue\n delta = 0\n for j in range(n):\n if uf.same(i, j):\n view[j] = 0\n delta += 1\n elif uf.same(i, j+n):\n view[j] = 0\n delta -= 1\n delta = abs(delta)\n deltas.append(delta)\ndp = [0]*(n+10)\ndp[0] = 1\nfor delta in deltas:\n dpnxt = [0]*(n+10)\n for i in range(n+1):\n if i+delta <= n:\n dpnxt[i+delta] += dp[i]\n dpnxt[abs(i-delta)] += dp[i]\n dp = dpnxt.copy()\n\nfor i in range(n+1):\n if dp[i]:\n print(((n+i)//2*((n+i-1)//2)//2 + (n-i)//2*((n-i-1)//2)//2))\n return\n", "from collections import deque\nN, M = map(int, input().split())\nG0 = [set([i]) for i in range(N)]\n\nA = set(range(N))\n\nfor i in range(M):\n a, b = map(int, input().split())\n G0[a-1].add(b-1)\n G0[b-1].add(a-1)\n\nG = [A - g for g in G0]\n\nb = 1 << (N//2)\nc = [-1]*N\nfor i in range(N):\n if c[i] != -1:\n continue\n p = 0; s = 0\n que = deque([i])\n c[i] = 0\n while que:\n v = que.popleft()\n s += 1\n if c[v] == 0:\n p += 1\n for w in G[v]:\n if c[w] == -1:\n c[w] = c[v]^1\n que.append(w)\n elif c[w] == c[v]:\n print(-1)\n return\n b = (b >> p) | (b >> (s-p))\n\np = N//2 - ((b & -b).bit_length()-1)\nq = N - p\nprint(p*(p-1)//2 + q*(q-1)//2)", "import sys\nN,M=map(int,input().split())\ndata=[[0]*(N+1) for i in range(N+1)]\nfor i in range(M):\n A,B=map(int,input().split())\n data[A][B]=1\n data[B][A]=1\nfor i in range(1,N+1):\n data[i][i]=1\nlst=[-1]*(N+1)\nddd=[]\nfor i in range(1,N+1):\n if lst[i]!=-1:\n continue\n else:\n lst[i]=0\n que=[i]\n count=[1,0]\n while que:\n h=[]\n for u in que:\n for j in range(1,N+1):\n if data[u][j]==1:\n continue\n else:\n if lst[j]==-1:\n lst[j]=lst[u]^1\n count[lst[j]]+=1\n h.append(j)\n elif lst[j]^lst[u]==0:\n print(-1)\n return\n que=h\n ddd.append(count)\ndp=[0]*(N+1)\ndp[0]=1\nfor u in ddd:\n v=u[0]\n h=[0]*(N+1)\n for i in range(v,N+1):\n if dp[i-v]==1:\n h[i]=1\n v=u[1]\n for i in range(v,N+1):\n if dp[i-v]==1:\n h[i]=1\n dp=h\nans=0\nfor i in range(N+1):\n if dp[i]==1:\n if abs(N-2*ans)>abs(N-2*i):\n ans=i\nqqq=N-ans\nif qqq==0 or ans==0:\n print(N*(N-1)//2)\nelse:\n print(ans*(ans-1)//2+qqq*(qqq-1)//2)", "\ndef main(n,m,ab):\n g=[set(j for j in range(n) if j!=i) for i in range(n)]\n for i,(a,b) in enumerate(ab):\n a,b=a-1,b-1\n g[a].discard(b)\n g[b].discard(a)\n xy=[]\n mi=set(range(n))\n seen=[-1]*n\n while mi:\n v=mi.pop()\n todo=[[v,-1]]\n seen[v]=0\n xyi=[0,0]\n xyi[0]+=1\n while todo:\n v,p=todo.pop()\n for nv in g[v]:\n if nv==p:continue\n if seen[nv]==-1:\n seen[nv]=(seen[v]+1)%2\n xyi[seen[nv]]+=1\n mi.discard(nv)\n todo.append([nv,v])\n elif seen[nv]!=(seen[v]+1)%2:return -1\n xy.append(xyi)\n abl=[0]*(n+1)\n abl[0]=1\n for x,y in xy:\n for i in range(n,-1,-1):\n if abl[i]>0:\n abl[i]=0\n abl[i+x]=1\n abl[i+y]=1\n ans=m\n for i,x in enumerate(abl):\n if x==0:continue\n j=n-i\n ans=min(ans,(i*(i-1))//2+(j*(j-1))//2)\n return ans\n\nn,m=map(int,input().split())\nab=[list(map(int,input().split())) for _ in range(m)]\nprint(main(n,m,ab))", "N,M=map(int,input().split())\nedge=[set([]) for i in range(N)]\nfor i in range(M):\n a,b=map(int,input().split())\n edge[a-1].add(b-1)\n edge[b-1].add(a-1)\n\ncedge=[[] for i in range(N)]\nfor i in range(N):\n for j in range(N):\n if j not in edge[i] and j!=i:\n cedge[i].append(j)\n\nans=[]\ndef is_bipartgraph():\n color=[0]*N\n used=[False]*N\n for i in range(N):\n if not used[i]:\n stack=[(i,1)]\n black=0\n white=0\n while stack:\n v,c=stack.pop()\n if not used[v]:\n color[v]=c\n black+=(c==1)\n white+=(c==-1)\n used[v]=True\n for nv in cedge[v]:\n if color[nv]==color[v]:\n return False\n elif color[nv]==0:\n stack.append((nv,-c))\n ans.append([black,white])\n return True\n\nif is_bipartgraph():\n dp=[[False for i in range(0,N+1)] for j in range(len(ans))]\n a,b=ans[0]\n dp[0][a],dp[0][b]=True,True\n for i in range(1,len(ans)):\n a,b=ans[i]\n for j in range(0,N+1):\n test=False\n if j>=a:\n test=test|dp[i-1][j-a]\n if j>=b:\n test=test|dp[i-1][j-b]\n dp[i][j]=test\n ans=0\n for i in range(0,N+1):\n if dp[-1][i] and abs(ans-N/2)>abs(i-N/2):\n ans=i\n ans2=N-ans\n print(ans*(ans-1)//2+ans2*(ans2-1)//2)\nelse:\n print(-1)", "def main():\n n, m = list(map(int, input().split()))\n ab = [list(map(int, input().split())) for _ in [0]*m]\n\n n_hozon = n\n g = [set() for _ in [0]*n]\n [g[a-1].add(b-1) for a, b in ab]\n [g[b-1].add(a-1) for a, b in ab]\n s = set([i for i in range(n)])\n\n # \u984c\u610f\uff1a\u3067\u304d\u308b\u3060\u3051\u8fba\u304c\u5c11\u306a\u304f\u306a\u308b\u3088\u3046\u306b2\u3064\u306e\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u5206\u3051\u305f\u3044\n # \u307e\u305a\u30012\u3064\u306e\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\u5206\u3051\u3089\u308c\u308b\u306e\u304b\u3092\u8abf\u3079\u308b\u5fc5\u8981\u304c\u3042\u308b\u3002\n # \u3053\u308c\u304c\u4e0d\u53ef\u80fd\u3067\u3042\u308c\u3070-1\u3092\u51fa\u529b\u3057\u3066\u5373\u5ea7\u306b\u7d42\u4e86\u3002\n\n # \u5206\u3051\u3089\u308c\u308b\u306e\u3067\u3042\u308c\u3070\u3001\u3067\u304d\u308b\u3060\u3051\u8857\u306e\u6570\u3092\u5747\u7b49\u306b\u3057\u305f\u3044\u3002\n # \u4ee5\u4e0b\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u3092\u8003\u3048\u308b\u3002\n # \u307e\u305a\u304a\u4e92\u3044\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u90fd\u5e02\u306e\u7d44A,B\u3092\u9078\u3076\u3002\n # \u3059\u308b\u3068\u3001A\u306b\u3057\u304b\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u8857\u3001B\u306b\u3057\u304b\u7e4b\u304c\u3063\u3066\u3044\u306a\u3044\u8857\u3001\n # \u4e21\u65b9\u306b\u7e4b\u304c\u3063\u3066\u3044\u308b\u8857\u306e3\u30b0\u30eb\u30fc\u30d7\u306b\u5206\u304b\u308c\u308b\u3002\n # \u3053\u306e\u3046\u3061\u3001\u6700\u5f8c\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u3064\u3044\u3066\u3001\n # \u6700\u521d\u306b\u623b\u3063\u3066\u540c\u69d8\u306e\u51e6\u7406\u3092\u884c\u3046\u3002\n # \u8857\u304c\u306a\u304f\u306a\u308b\u304b\u3001\u4e21\u65b9\u306b\u7e4b\u304c\u3063\u3066\u3044\u308b\u8857\u306e\u30b0\u30eb\u30fc\u30d7\u304c\u5b8c\u5168\u30b0\u30e9\u30d5\u306b\n # \u306a\u3063\u305f\u6642\u70b9\u3067\u7d42\u4e86\u3002\n\n # \u4e0a\u8a18\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u306b\u3088\u308a\u3001(A,B)\u306e\u5217\u3068\u6700\u5f8c\u306b\u6b8b\u3063\u305f\u8857\u306e\u6570\u304c\u6c42\u3081\u3089\u308c\u308b\u3002\n # \u3053\u308c\u3092\u3082\u3068\u306b\u3001\u52d5\u7684\u8a08\u753b\u6cd5\u3067\u8003\u3048\u3089\u308c\u308b\u8857\u306e\u632f\u308a\u5206\u3051\u65b9\u3092\u5168\u3066\u6d17\u3044\u51fa\u3059\u3002\n # \u6700\u3082\u5747\u7b49\u306b\u8fd1\u304f\u632f\u308a\u5206\u3051\u305f\u5834\u5408\u306b\u3064\u3044\u3066\u3001\u5b8c\u5168\u30b0\u30e9\u30d5\u306e\u8fba\u6570\u3092\u8a08\u7b97\u3057\u3066\n # \u51fa\u529b\u3059\u308c\u3070\u554f\u984c\u304c\u89e3\u3051\u308b\u3002\n a_list, b_list = [], []\n while True:\n #print(n, m)\n # print(s)\n # print(g)\n # \u5b8c\u5168\u30b0\u30e9\u30d5\u304b\u3069\u3046\u304b\n #print(n, m, g, s)\n if m == n*(n-1)//2:\n break\n a = [-1, 10**10]\n for i in s:\n l = len(g[i])\n if l < a[1]:\n a = [i, l]\n a = a[0]\n b = [-1, 10**10]\n for i in s-g[a]-{a}:\n l = len(g[i])\n if l < b[1]:\n b = [i, l]\n b = b[0]\n #print(a, b)\n a_set, b_set = {a}, {b}\n s.remove(a)\n s.remove(b)\n n -= 2\n remain = set()\n for i in s:\n flag_a = True\n for j in a_set:\n if j not in g[i]:\n flag_a = False\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n flag_b = True\n for j in b_set:\n if j not in g[i]:\n flag_b = False\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n #print(i, flag_a, flag_b)\n if flag_a == flag_b == False:\n print((-1))\n return\n elif flag_a == False or flag_b == False:\n # print(remain)\n q = {i}\n flag = flag_a # True\u2192A\u306b\u5165\u308c\u308b\n while q:\n #print(q, \"q\")\n qq = set()\n while q:\n i = q.pop()\n if flag:\n a_set.add(i)\n else:\n b_set.add(i)\n for j in remain:\n if j not in g[i]:\n qq.add(j)\n else:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n for j in q:\n g[i].remove(j)\n g[j].remove(i)\n m -= 1\n for i in qq:\n remain.remove(i)\n flag ^= True\n q = qq\n else:\n remain.add(i)\n # print(g)\n for i in (a_set | b_set)-{a}-{b}:\n s.remove(i)\n n -= 1\n\n a_list.append(len(a_set))\n b_list.append(len(b_set))\n\n m = n\n n = n_hozon\n k = len(a_list)\n\n if k == 1:\n dp = [False]*(n+1)\n a = a_list[0]\n b = b_list[0]\n ans = 10**10\n for i in range(m+1):\n ans = min(ans, (a+i)*(a+i-1)//2+(n-a-i)*(n-a-i-1)//2)\n print(ans)\n return\n\n dp = [False]*(n+1)\n dp[0] = True\n\n for i in range(k):\n a, b = a_list[i], b_list[i]\n maxab = max(a, b)\n dp2 = [False]*(n+1)\n for j in range(n-maxab+1):\n dp2[j+a] |= dp[j]\n dp2[j+b] |= dp[j]\n dp = dp2\n\n dp2 = [False]*(n+1)\n for j in range(m+1):\n for i in range(n-j+1):\n dp2[i+j] |= dp[i]\n ans = 10**10\n\n for i in range(n+1):\n if dp2[i] is False:\n continue\n j = n-i\n ans = min(ans, i*(i-1)//2+j*(j-1)//2)\n print(ans)\n\n\nmain()\n", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn,m = list(map(int,readline().split()))\n\n# \u88dc\u30b0\u30e9\u30d5\ng = [[1]*n for _ in range(n)]\nfor i in range(n): g[i][i] = 0\n\nfor _ in range(m):\n a,b = list(map(int,readline().split()))\n g[a-1][b-1] = g[b-1][a-1] = 0\n\nused = [-1]*n\ndp = 1\nok = 1\nfor i in range(n):\n if used[i]==-1:\n used[i] = 0\n st = [i]\n a = b = 0\n while st:\n v = st.pop()\n c = used[v]\n if c: a += 1\n else: b += 1\n for k in range(n):\n if g[v][k] == 1:\n if used[k] == -1:\n used[k] = 1-c\n st.append(k)\n elif used[k] == c:\n ok = 0\n break\n \n dp = (dp<<a)|(dp<<b)\n #print(a,b)\n if not ok:\n dp = 0\n break\n\n#print(bin(dp)[2:][::-1])\n\nans = -1\nfor i in range(n//2+1):\n if dp>>i&1:\n ans = i*(i-1)//2 + (n-i)*(n-i-1)//2\n\nprint(ans)\n", "import sys\nreader = (s.rstrip() for s in sys.stdin)\ninput = reader.__next__\n\nn,m = map(int, input().split())\nG = [[1]*n for i in range(n)]\nfor i in range(n):\n G[i][i] = 0\nfor i in range(m):\n a,b = map(int, input().split())\n a,b = a-1,b-1\n G[a][b] = 0\n G[b][a] = 0\n\nfrom collections import deque\n\nused = [0]*n\ntmp = []\n\ndef bfs(start):\n if used[start]:\n return True\n d = {-1:0, 1:0}\n que = deque()\n que.append((start, 1))\n while que:\n cur, flag = que.popleft()\n if used[cur] == flag:\n continue\n elif used[cur]:\n return False\n used[cur] = flag\n d[flag] += 1\n for to in range(n):\n if G[cur][to] and used[to] == 0:\n que.append((to, -flag))\n tmp.append(list(d.values()))\n return True\n\nif not all(bfs(i) for i in range(n)):\n print(-1)\nelse:\n s = set([0])\n target = (n+1)//2\n for l in tmp:\n t = set()\n for a in l:\n for b in s:\n if a+b <= target:\n t.add(a+b)\n s = t\n k = max(s)\n l = n-k\n ans = k*(k-1)//2 + l*(l-1)//2\n print(ans)", "def dfs(links, fixed, s):\n q = [(s, 0)]\n cnt = [0, 0]\n while q:\n v, c = q.pop()\n if fixed[v] > -1:\n if fixed[v] != c:\n return False\n continue\n fixed[v] = c\n cnt[c] += 1\n for u in links[v]:\n q.append((u, c ^ 1))\n return (max(cnt), min(cnt))\n\n\ndef is_bipartite(n, links):\n fixed = [-1] * n\n l, r = 0, 0\n can = []\n for i in range(n):\n if fixed[i] > -1:\n continue\n cnt = dfs(links, fixed, i)\n if cnt == False:\n return -1\n can.append(cnt)\n\n can.sort(reverse=True)\n for cnt in can:\n j = 0 if cnt[0] > cnt[1] else 1\n if l > r:\n j ^= 1\n l += cnt[j]\n r += cnt[j ^ 1]\n return (l * (l - 1) + r * (r - 1)) // 2\n\n\nn, m = list(map(int, input().split()))\nlinks = [set(range(n)) - {i} for i in range(n)]\nfor _ in range(m):\n a, b = list(map(int, input().split()))\n a -= 1\n b -= 1\n links[a].remove(b)\n links[b].remove(a)\nprint((is_bipartite(n, links)))\n", "N,M=list(map(int,input().split()))\nedge=[set([]) for i in range(N)]\nfor i in range(M):\n a,b=list(map(int,input().split()))\n edge[a-1].add(b-1)\n edge[b-1].add(a-1)\n\ncedge=[[] for i in range(N)]\nfor i in range(N):\n for j in range(N):\n if j not in edge[i] and j!=i:\n cedge[i].append(j)\n\nans=[]\ndef is_bipartgraph():\n color=[0]*N\n used=[False]*N\n for i in range(N):\n if not used[i]:\n stack=[(i,1)]\n black=0\n white=0\n while stack:\n v,c=stack.pop()\n color[v]=c\n black+=(not used[v])*(c==1)\n white+=(not used[v])*(c==-1)\n used[v]=True\n for nv in cedge[v]:\n if color[nv]==color[v]:\n return False\n elif color[nv]==0:\n stack.append((nv,-c))\n ans.append([black,white])\n return True\n\nif is_bipartgraph():\n dp=[[False for i in range(0,N+1)] for j in range(len(ans))]\n a,b=ans[0]\n dp[0][a],dp[0][b]=True,True\n for i in range(1,len(ans)):\n a,b=ans[i]\n for j in range(0,N+1):\n test=False\n if j>=a:\n test=test|dp[i-1][j-a]\n if j>=b:\n test=test|dp[i-1][j-b]\n dp[i][j]=test\n ans=0\n for i in range(0,N+1):\n if dp[-1][i] and abs(ans-N/2)>abs(i-N/2):\n ans=i\n ans2=N-ans\n print((ans*(ans-1)//2+ans2*(ans2-1)//2))\nelse:\n print((-1))\n", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef MI1(): return map(int1, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\nclass UnionFind:\n def __init__(self, n):\n self.state = [-1] * n\n self.size_table = [1] * n\n # cnt\u306f\u30b0\u30eb\u30fc\u30d7\u6570\n # self.cnt = n\n\n def root(self, u):\n v = self.state[u]\n if v < 0: return u\n self.state[u] = res = self.root(v)\n return res\n\n def merge(self, u, v):\n ru = self.root(u)\n rv = self.root(v)\n if ru == rv: return\n du = self.state[ru]\n dv = self.state[rv]\n if du > dv: ru, rv = rv, ru\n if du == dv: self.state[ru] -= 1\n self.state[rv] = ru\n # self.cnt -= 1\n self.size_table[ru] += self.size_table[rv]\n return\n\n # \u30b0\u30eb\u30fc\u30d7\u306e\u8981\u7d20\u6570\n def size(self, u):\n return self.size_table[self.root(u)]\n\ndef ng():\n for u in range(n):\n for v in range(n):\n if v == u: continue\n if to[u][v]: continue\n if uf.root(u)==uf.root(v):return True\n return False\n\nn,m=MI()\nto=[[False]*n for _ in range(n)]\nfor _ in range(m):\n u,v=MI1()\n to[u][v]=to[v][u]=True\n\nuf=UnionFind(n)\nuncon=[-1]*n\nfor u in range(n):\n pv=-1\n for v in range(n):\n if v==u:continue\n if to[u][v]:continue\n if pv==-1:pv=v\n else:uf.merge(pv,v)\n uncon[u]=pv\n\n#print(uf.state)\n#print(uf.size_table)\n#print(uncon)\n\nif ng():\n print(-1)\n return\n\nfin=[False]*n\nfree=0\nss=[]\nfor u in range(n):\n if uncon[u]==-1:\n free+=1\n continue\n r0=uf.root(u)\n if fin[r0]:continue\n r1=uf.root(uncon[u])\n fin[r0]=fin[r1]=True\n ss.append(abs(uf.size_table[r0]-uf.size_table[r1]))\ncur=1<<1000\nfor s in ss:cur=cur<<s|cur>>s\ncur>>=1000\nd=(cur&-cur).bit_length()-1\nd=max(0,d-free)\ns0=(n-d)//2\ns1=n-s0\nprint(s0*(s0-1)//2+s1*(s1-1)//2)\n", "n,m,*A=map(int,open(0).read().split())\ng=[[1]*n for _ in [0]*n]\nfor a,b in zip(A[::2],A[1::2]):\n g[a-1][b-1]=g[b-1][a-1]=0\nU=[1]*n\nD=1\ndef dfs(v):\n nonlocal D\n R[U[v]]+=1\n for k in range(n):\n if g[v][k]*(k-v):\n D *= U[k]!=U[v]\n if U[k]>0:\n U[k]=~U[v]\n dfs(k)\nfor i in range(n):\n if U[i]>0:\n R=[0,0];U[i]=0\n dfs(i);\n D=(D<<R[0])|(D<<R[1])\na=-1\nfor i in range(n//2+1):\n if D>>i&1:a=(i*(i-1)+(n-i)*(n-i-1))//2\nprint(a)", "import sys\ninput = sys.stdin.readline\n\n\ndef is_bipartite(graph, s):\n \"\"\"\u4e8c\u90e8\u30b0\u30e9\u30d5\u5224\u5b9a\u3059\u308b\"\"\"\n n = len(graph)\n col = [-1] * n\n col[s] = 0\n stack = [s]\n used[s] = True\n while stack:\n v = stack.pop()\n for nxt_v in graph[v]:\n used[nxt_v] = True\n if col[nxt_v] == -1:\n col[nxt_v] = col[v] ^ 1\n stack.append(nxt_v)\n elif col[nxt_v] ^ col[v] == 0:\n return False\n return True\n\ndef color_bipartite(graph, s):\n \"\"\"\u4e8c\u90e8\u30b0\u30e9\u30d5\u3092\u5f69\u8272\u3059\u308b\"\"\"\n n = len(graph)\n col = [-1] * n\n col[s] = 0\n stack = [s]\n while stack:\n v = stack.pop()\n for nxt_v in graph[v]:\n if col[nxt_v] == -1:\n col[nxt_v] = col[v] ^ 1\n stack.append(nxt_v)\n return col\n\n\nn, m = map(int, input().split())\ninfo = [list(map(int, input().split())) for i in range(m)]\n\ngraph = [set() for i in range(n)]\nfor a, b in info:\n a -= 1\n b -= 1\n graph[a].add(b)\n graph[b].add(a)\n\ncomp_graph = [[] for i in range(n)]\nfor a in range(n):\n for b in range(n):\n if b in graph[a] or a == b:\n continue\n comp_graph[a].append(b)\n \n\ncnt0 = []\ncnt1 = []\nused = [False] * n\nfor i in range(n):\n if used[i]:\n continue\n used[i] = True\n if not is_bipartite(comp_graph, i):\n print(-1)\n return\n col = color_bipartite(comp_graph, i)\n cnt0.append(col.count(0))\n cnt1.append(col.count(1))\n\ndp = [[False] * (n + 1) for i in range(len(cnt0) + 1)]\ndp[0][0] = True\nfor i in range(len(cnt0)):\n wei0 = cnt0[i]\n wei1 = cnt1[i]\n for w in range(n + 1):\n if w + wei0 < n + 1:\n dp[i + 1][w + wei0] = (dp[i][w] or dp[i + 1][w + wei0])\n if w + wei1 < n + 1:\n dp[i + 1][w + wei1] = (dp[i][w] or dp[i + 1][w + wei1])\n\nans = 10 ** 18\nfor num in range(n + 1):\n if dp[-1][num]:\n c0 = num\n c1 = n - num\n res = c0 * (c0 - 1) // 2 + c1 * (c1 - 1) // 2\n ans = min(ans, res)\nprint(ans)", "import sys\ninput = sys.stdin.readline\nN, M = map(int, input().split())\ne = [set([x for x in range(1, N + 1) if i != x]) for i in range(N + 1)]\nfor _ in range(M):\n u, v = map(int, input().split())\n e[u].discard(v)\n e[v].discard(u)\n\ncl = [0] * (N + 1)\ndp = [0] * (N + 1)\ndp[0] = 1\nfor x in range(1, N + 1):\n if cl[x]: continue\n s = [x]\n qs = []\n cl[x] = 1\n while len(s):\n p = s.pop()\n qs.append(p)\n for q in e[p]:\n if cl[q]:\n if cl[q] % 2 == cl[p] % 2:\n print(-1)\n return\n continue\n cl[q] = cl[p] % 2 + 1\n s.append(q)\n predp = dp[: ]\n for i in range(N, -1, -1):\n if dp[i] == 0: continue\n u = 0\n v = 0\n for q in qs:\n u += cl[q] % 2\n v += cl[q] % 2 == 0\n dp[i] -= predp[i]\n dp[i + u] += 1\n dp[i + v] += 1\n #print(dp)\nres = N * (N - 1) // 2\nfor i in range(1, N + 1):\n if dp[i] == 0: continue\n u = i * (i - 1) // 2\n v = (N - i) * (N - i - 1) // 2\n res = min(res, u + v)\nprint(res)", "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return list(map(int, input().split()))\ndef LI(): return list(map(int, input().split()))\nmod=10**9+7\n\n\n\"\"\"\nA,B\u306e2\u3064\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u5206\u3051\u308b\uff0e\u5404\u30b0\u30eb\u30fc\u30d7\u5185\u306e\u5168\u3066\u306e\u70b9\u3078\u6700\u77ed\u8ddd\u96e2\u304c1\u3068\u306a\u308b.\n\u9006\u306b\uff0c\u6700\u77ed\u8ddd\u96e2\u304c1\u51fa\u306a\u3051\u308c\u3070\u7570\u306a\u308b\u30b0\u30eb\u30fc\u30d7\u306b\u914d\u5c5e\u3055\u308c\u308b.\n\u5168\u70b9\u9593\u8ddd\u96e2\u306f\u308f\u30fc\u30b7\u30e3\u30eb\u30d5\u30ed\u30a4\u30c8\u3067\u6c42\u3081\u308b\uff0e\n\u3053\u308c\u306f2-SAT\u304b\u306a\uff0ca,b\u306e\u8ddd\u96e2\u304c1\u3067\u306f\u306a\u3044\u2192a,b\u306f\u9055\u3046\u30b0\u30eb\u30fc\u30d7\u306b\u5165\u308b\u2192(a\u2228b)\u2227(not_a \u2228 not_b)\n\u3053\u308c\u3092\u2227\u3067\u3064\u306a\u3052\u3066\u3044\u3051\u3070\u826f\u3044\uff0e\n\n\u3069\u3061\u3089\u306b\u5165\u3063\u3066\u3082\u826f\u3044\u70b9(\u5168\u3066\u306e\u70b9\u3068\u306e\u8ddd\u96e2\u304c1)\uff0c\u3068\u3044\u3046\u306e\u304c\u3042\u308b\uff0c\u3053\u308c\u306fA,B\u306e\u500b\u6570\u306e\u30d0\u30e9\u30f3\u30b9\u3092\u898b\u3066\uff0c\u5c11\u306a\u3044\u65b9\u306b\u5165\u308c\u3066\u3044\u304f\uff0e\n\u3053\u308c\u306f2SAT\u3060\u306801\u306e\u3069\u3061\u3089\u3067\u3082\u826f\u3044\u5024\u306b\u306a\u3063\u3066\u3057\u307e\u3046\u306e\u3067\u8a08\u7b97\u304b\u3089\u4e88\u3081\u907f\u3051\u3066\u304a\u304f.\n\n\n\u3053\u308c\u4ee5\u5916\u306b\u3082\u6c17\u3092\u3064\u3051\u308b\u30d1\u30bf\u30fc\u30f3\u304c\u3042\u3063\u3066\uff0c\na\u3068b,a\u3068c\nd\u3068e,d\u3068f\n\u304c\u540c\u3058\u5834\u6240\u306b\u306a\u3089\u306a\u3044\u3068\u3044\u3046\u6761\u4ef6\u306e\u3068\u304d\uff0c\naef-bcd\n\u306e\u304a\u3088\u3046\u306b\u5206\u3051\u305f\u3044\u304c\nad-bcef\n\u306e\u3088\u3046\u306b\u3082\u5206\u3051\u3089\u308c\u3066\u3057\u307e\u3046\uff0e\n\nuf\u3068\u304b\u3067\u4e0a\u624b\u3044\u611f\u3058\u306b\u7ba1\u7406\u3067\u304d\u308b\u304b\u306a?\n\"\"\"\n\nfrom collections import defaultdict\nclass UnionFind:\n def __init__(self, N: int):\n \"\"\"\n N:\u8981\u7d20\u6570\n root:\u5404\u8981\u7d20\u306e\u89aa\u8981\u7d20\u306e\u756a\u53f7\u3092\u683c\u7d0d\u3059\u308b\u30ea\u30b9\u30c8.\n \u305f\u3060\u3057, root[x] < 0 \u306a\u3089\u305d\u306e\u9802\u70b9\u304c\u6839\u3067-root[x]\u304c\u6728\u306e\u8981\u7d20\u6570.\n rank:\u30e9\u30f3\u30af\n \"\"\"\n self.N = N\n self.root = [-1] * N\n self.rank = [0] * N\n\n def __repr__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\n def find(self, x: int):\n \"\"\"\u9802\u70b9x\u306e\u6839\u3092\u898b\u3064\u3051\u308b\"\"\"\n if self.root[x] < 0:\n return x\n else:\n while self.root[x] >= 0:\n x = self.root[x]\n return x\n\n def union(self, x: int, y: int):\n \"\"\"x,y\u304c\u5c5e\u3059\u308b\u6728\u3092union\"\"\"\n # \u6839\u3092\u6bd4\u8f03\u3059\u308b\n # \u3059\u3067\u306b\u540c\u3058\u6728\u306b\u5c5e\u3057\u3066\u3044\u305f\u5834\u5408\u306f\u4f55\u3082\u3057\u306a\u3044.\n # \u9055\u3046\u6728\u306b\u5c5e\u3057\u3066\u3044\u305f\u5834\u5408\u306frank\u3092\u898b\u3066\u304f\u3063\u3064\u3051\u308b\u65b9\u3092\u6c7a\u3081\u308b.\n # rank\u304c\u540c\u3058\u6642\u306frank\u30921\u5897\u3084\u3059\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n elif self.rank[x] > self.rank[y]:\n self.root[x] += self.root[y]\n self.root[y] = x\n else:\n self.root[y] += self.root[x]\n self.root[x] = y\n if self.rank[x] == self.rank[y]:\n self.rank[y] += 1\n\n def same(self, x: int, y: int):\n \"\"\"x\u3068y\u304c\u540c\u3058\u30b0\u30eb\u30fc\u30d7\u306b\u5c5e\u3059\u308b\u304b\u3069\u3046\u304b\"\"\"\n return self.find(x) == self.find(y)\n\n def count(self, x):\n \"\"\"\u9802\u70b9x\u304c\u5c5e\u3059\u308b\u6728\u306e\u30b5\u30a4\u30ba\u3092\u8fd4\u3059\"\"\"\n return - self.root[self.find(x)]\n\n def members(self, x):\n \"\"\"x\u304c\u5c5e\u3059\u308b\u6728\u306e\u8981\u7d20\u3092\u5217\u6319\"\"\"\n _root = self.find(x)\n return [i for i in range(self.N) if self.find == _root]\n\n def roots(self):\n \"\"\"\u68ee\u306e\u6839\u3092\u5217\u6319\"\"\"\n return [i for i, x in enumerate(self.root) if x < 0]\n\n def group_count(self):\n \"\"\"\u9023\u7d50\u6210\u5206\u306e\u6570\"\"\"\n return len(self.roots())\n\n def all_group_members(self):\n \"\"\"{\u30eb\u30fc\u30c8\u8981\u7d20: [\u305d\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u542b\u307e\u308c\u308b\u8981\u7d20\u306e\u30ea\u30b9\u30c8], ...}\u306e\u30c7\u30d5\u30a9\u30eb\u30c8\u30c7\u30a3\u30af\u30c8\u3092\u8fd4\u3059\"\"\"\n dd = defaultdict(list)\n for i in range(N):\n root=self.find(i)\n dd[root].append(i)\n return dd\n\n\nclass Scc_graph:\n\n def __init__(self, N):\n self.N = N\n self.edges = []\n\n def csr(self):\n start = [0]*(self.N+1)\n elist = [0]*len(self.edges)\n for v, w in self.edges:\n start[v+1] += 1\n for i in range(1, self.N+1):\n start[i] += start[i-1]\n counter = start.copy()\n for v, w in self.edges:\n elist[counter[v]] = w\n counter[v] += 1\n self.start = start\n self.elist = elist\n\n def add_edge(self, v, w):\n self.edges.append((v, w))\n\n def scc_ids(self):\n self.csr()\n N = self.N\n now_ord = group_num = 0\n visited = []\n low = [0]*N\n order = [-1]*N\n ids = [0]*N\n parent = [-1]*N\n stack = []\n for i in range(N):\n if order[i] == -1:\n stack.append(~i)\n stack.append(i)\n while stack:\n v = stack.pop()\n if v >= 0:\n if order[v] == -1:\n low[v] = order[v] = now_ord\n now_ord += 1\n visited.append(v)\n for i in range(self.start[v], self.start[v+1]):\n to = self.elist[i]\n if order[to] == -1:\n stack.append(~to)\n stack.append(to)\n parent[to] = v\n else:\n low[v] = min(low[v], order[to])\n else:\n v = ~v\n if low[v] == order[v]:\n while True:\n u = visited.pop()\n order[u] = N\n ids[u] = group_num\n if u == v:\n break\n group_num += 1\n if parent[v] != -1:\n low[parent[v]] = min(low[parent[v]], low[v])\n for i, x in enumerate(ids):\n ids[i] = group_num-1-x\n\n return group_num, ids\n\n def scc(self):\n group_num, ids = self.scc_ids()\n groups = [[] for _ in range(group_num)]\n for i, x in enumerate(ids):\n groups[x].append(i)\n return groups\n\n\nclass Two_sat:\n def __init__(self, N):\n self.N = N\n self.answer = []\n self.scc = Scc_graph(2*N)\n\n \"\"\"\n A[i]=a,A[j]=b\n (a\u2228b)\u3092\u8ffd\u52a0\u3057\u305f\u3044\u3068\u304d\uff0c(f,g)=(1,1)\n \u5426\u5b9a\u3057\u305f\u3082\u306e\u3092\u5165\u308c\u305f\u3044\u6642f\u3084g\u30920\u306b\u5909\u66f4\u3059\u308b\n \"\"\"\n def add_clause(self, i, f, j, g):\n # assert 0 <= i < self.N\n # assert 0 <= j < self.N\n self.scc.add_edge(2*i+(f == 0), 2*j+(g == 1))\n self.scc.add_edge(2*j+(g == 0), 2*i+(f == 1))\n\n def satisfiable(self):\n _, ids = self.scc.scc_ids()\n self.answer.clear()\n for i in range(self.N):\n if ids[2 * i] == ids[2 * i + 1]:\n self.answer.clear()\n return False\n self.answer.append(ids[2*i] < ids[2*i+1])\n return True\n\n# def warshall_floyd(d):\n# #d[i][j]: i\u304b\u3089j\u3078\u306e\u6700\u77ed\u8ddd\u96e2\n# N=len(d)\n# for k in range(N):\n# for i in range(N):\n# for j in range(N):\n# d[i][j] = min(d[i][j],d[i][k] + d[k][j])\n# return d\n#################################################\n\n\nN,M=MI()\ninf = N+5\nd=[[inf]*N for _ in range(N)]\nfor i in range(N):\n d[i][i]=0\n\nfor _ in range(M):\n a,b=MI()\n a-=1\n b-=1\n d[a][b]=1\n d[b][a]=1\n\n# \u8ddd\u96e2\u304c1\u304b\u5426\u304b\u3060\u3051\u308f\u304b\u308c\u3070\u826f\u3044\u306e\u3067\uff0c\u3053\u308c\u3044\u3089\u306a\u3044\n# d=warshall_floyd(d)\n\n# for i in range(N):\n# print(d[i])\n\ndef calc(x):\n return (x*(x-1))//2\n\nuf=UnionFind(N)\nfor i in range(N):\n for j in range(i+1,N):\n if d[i][j]>1:\n uf.union(i,j)\n # print(i,j)\n\nroots=uf.roots()\nNr=len(roots)\nG=[[]for _ in range(Nr)]\n\nfrom collections import defaultdict\ndd = defaultdict(int)\ncnt=0\nfor v in roots:\n dd[v]=cnt\n cnt+=1\n \n# print(roots,Nr)\n\nfor i in range(N):\n r=uf.find(i)\n rnum=dd[r]\n \n # print(i,r,rnum)\n G[rnum].append(i)\n\n\n\nallOK=0#A,B\u3069\u3061\u3089\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u5165\u308c\u3066\u3082\u554f\u984c\u306a\u3044\u3082\u306e\n\n\"\"\"\n\u3068\u308a\u3042\u3048\u305a\uff0c\u9023\u7d50\u6210\u5206\u6bce\u306b2SAT\u3059\u308b\uff0e\na\u500b,b\u500b(a<=b)\n\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u5206\u3051\u3089\u308c\u308b\u3068\u3057\u3066\uff0c\u3053\u308c\u3092A,B\u306e\u30b0\u30eb\u30fc\u30d7\u306b\u3069\u3046\u3075\u308a\u5206\u3051\u308b\u304b.\n= (a,b)2\u3064\u306e\u6570\u5b57\u306e\u7d44\u307f\u304c\u5927\u91cf\u306b\u3042\u3063\u3066\uff0c\u305d\u308c\u3089\u3092\u632f\u308a\u5206\u3051\u3066\u5dee\u304c\u5c0f\u3055\u304f\u306a\u308b\u3088\u3046\u306b\u9811\u5f35\u308c\u3070\u826f\u3044\u306f\u305a\n\n\u4e21\u65b9\u306ba\u3092\u52a0\u7b97\u3057\u3066\uff0c\u5dee\u5206(b-a)\u3092\u8a18\u61b6\u3057\u3066\u304a\u304d\uff0c\u3042\u3068\u3067\u3069\u3063\u3061\u306b\u632f\u308a\u5206\u3051\u308b\u304b\u8003\u3048\u308b\n\"\"\"\nD=[]#A,B\u30b0\u30eb\u30fc\u30d7\u306e\u5dee\nS1=0\nS2=0\n\n\n\nfor g in G:\n Ng=len(g)\n if Ng==1:\n allOK+=1\n continue\n \n g.sort()\n ts=Two_sat(Ng)\n \n # print(g)\n \n for i in range(Ng):\n for j in range(i+1,Ng):\n a=g[i]\n b=g[j]\n if d[a][b]!=1:\n ts.add_clause(i,0,j,0)\n ts.add_clause(i,1,j,1)\n \n if not ts.satisfiable():\n print((-1))\n return\n \n a=sum(ts.answer)\n b=Ng-a\n \n S1+=min(a,b)\n S2+=min(a,b)\n \n if a!=b:\n D.append(abs(a-b))\n \n \n# \u3042\u3068\u306fD\u3092\u3069\u3046\u5272\u308a\u632f\u308b\u304b\uff0e\n# \u3053\u308c\u306f\uff0cD\u5185\u306e\u6570\u5b57\u3092+/-\u306e\u3069\u3061\u3089\u304b\u7b26\u53f7\u3092\u9078\u3093\u3067\u8db3\u3057\u3066\u3044\u304d\uff0c\u305d\u306e\u7d50\u679c\u30920\u306b\u8fd1\u3065\u3051\u305f\u3044\u3068\u3044\u3046\u554f\u984c\u306b\u5e30\u7740\uff0e\u6570\u5b57\u304c\u5c0f\u3055\u3044\u306e\u3067dp\u3067\u3067\u304d\u308b.\nNd=len(D)\n\ngeta=1000\ndp=[[0]*(geta*2+1) for _ in range(Nd+1)]\ndp[0][geta]=1\nfor i,num in enumerate(D):\n for j in range(geta*2+1):\n if dp[i][j]:\n dp[i+1][j-num]=1\n dp[i+1][j+num]=1\n \ndiff=geta\nfor j in range(geta+1):\n if dp[-1][j]:\n diff=min(diff,\n abs(j-geta))\n \n# print(D)\n# print(diff)\n\nSd=sum(D)\ns11=(Sd-diff)//2\ns12=Sd-s11\n\n\n# S1<=S2\nS1+=s11\nS2+=s12\n\nds=S2-S1\nif ds>allOK:\n ans=calc(S2)+calc(S1+allOK)\nelse:\n aa=N//2\n bb=N-aa\n ans=calc(aa)+calc(bb)\n \n \n# \nprint(ans)\n \n\n\n\n\n\n\n\n", "import sys\nN, M = list(map(int,input().split()))\n\nI = [[0 for _ in range(N)] for _ in range(N)]\nfor _ in range(M):\n a, b = list(map(int,input().split()))\n a -= 1\n b -= 1\n I[a][b] = 1\n I[b][a] = 1\nfor a in range(N):\n I[a][a] = 1\n# 0\u3092\u8fba\u3068\u3059\u308b\u30b0\u30e9\u30d5\u304c\u4e8c\u90e8\u30b0\u30e9\u30d5\u304b\u5426\u304b\u5224\u5b9a\n#print(*I, sep=\"\\n\") \n \n# \u5404\u9023\u7d50\u6210\u5206\u306e\u9802\u70b9\u6570\nR = []\nB = []\n\nvis = set()\n\ndef dfs(s, c):# 0\u3092\u8fba\u3068\u3059\u308b\u30b0\u30e9\u30d5\u304c\u4e8c\u90e8\u30b0\u30e9\u30d5\u304b\u5426\u304b\u3092\u3001\u59cb\u70b9s, \u521d\u671f\u8272c\u306eBFS\u3067\u5224\u5b9a\n adj = I[s]\n tmp = True\n r_ct = 0\n b_ct = 0\n clr[s] = c\n for p in range(N):\n if adj[p] == 1: # \u96a3\u63a5\u3057\u3066\u306a\u3044\n continue\n if p in vis: \n if clr[p] != 1-c:\n #print(s, p)\n return False\n continue\n else:\n vis.add(p)\n if not dfs(p, 1-c):\n return False\n return True\n \n \n \n# \u4e8c\u90e8\u30b0\u30e9\u30d5\u304b\u3044\u306a\u304b\u3068\u3001\u5404\u9023\u7d50\u6210\u5206\u306e\u8272\u3054\u3068\u306e\u6570\u3092\u5224\u5b9a\nvis = set()\nans = 0\nused_edge = 0\nfor s in range(N):\n if s in vis: continue\n R.append(0)\n B.append(0)\n clr = {}\n vis.add(s)\n if not dfs(s, 0):\n print((-1)); return;\n #print(clr)\n for p in clr:\n if clr[p] == 0:\n R[-1] += 1\n else:\n B[-1] += 1\n for p in clr:\n for q in clr:\n if p != q and I[p][q] == 1: \n used_edge += 1\n if clr[p] == clr[q]:\n ans += 1\n #print(ans)\n \n#print(R)\n#print(B)\n \n# \u6700\u5927\u5024 : a_i*b_j\u306e\u975e\u5bfe\u89d2\u548c\u306e\u534a\u5206\u3067\u3001a_i\u306e\u548c\u304cN/2\u306b\u6700\u3082\u8fd1\u3044\u5834\u5408\nDP = 1\nfor i in range(len(R)):\n DP = (DP << R[i]) | (DP << B[i])\n\ni = 0\nex = []\nwhile DP > 0:\n if DP % 2 == 1:\n ex.append(i)\n i += 1\n DP >>= 1\n#print(ex) \nex.sort(key = lambda x: abs(2*x-N))\n#print(ex[0])\ntmp = ex[0] * (N - ex[0])\nfor i in range(len(R)):\n tmp -= R[i]*B[i]\n#print(used_edge)\n#print(tmp)\n#print(2*M - used_edge)\nans //= 2\nans += (2*M - used_edge)//2 - tmp\n \nprint(ans)\n \n \n\n \n \n", "import sys\ninput = sys.stdin.readline\n\nN, M = map(int, input().split())\nG = [set() for _ in range(N)]\nfor _ in range(M):\n A, B = map(int, input().split())\n A -= 1\n B -= 1\n G[A].add(B)\n G[B].add(A)\n\nG_comp = [[] for _ in range(N)]\nfor i in range(N):\n for j in range(N):\n if i != j and j not in G[i]:\n G_comp[i].append(j)\n\ncolor = [-1] * N\nA = []\ndp = set([0])\nfor i in range(N):\n if color[i] != -1:\n continue\n cnt = [1, 0]\n color[i] = 0\n stack = [i]\n while stack:\n v = stack.pop()\n for u in G_comp[v]:\n if color[u] == -1:\n color[u] = 1 - color[v]\n stack.append(u)\n cnt[color[u]] += 1\n if color[u] == color[v]:\n print(-1)\n return\n ndp = set()\n for a in dp:\n ndp.add(a + cnt[0])\n ndp.add(a + cnt[1])\n dp = ndp\nans = float('inf')\nfor a in dp:\n ans = min(ans, a * (a - 1) // 2 + (N - a) * (N - a - 1) // 2)\nprint(ans)"] | {"inputs": ["5 5\n1 2\n1 3\n3 4\n3 5\n4 5\n", "5 1\n1 2\n", "4 3\n1 2\n1 3\n2 3\n", "10 39\n7 2\n7 1\n5 6\n5 8\n9 10\n2 8\n8 7\n3 10\n10 1\n8 10\n2 3\n7 4\n3 9\n4 10\n3 4\n6 1\n6 7\n9 5\n9 7\n6 9\n9 4\n4 6\n7 5\n8 3\n2 5\n9 2\n10 7\n8 6\n8 9\n7 3\n5 3\n4 5\n6 3\n2 10\n5 10\n4 2\n6 2\n8 4\n10 6\n"], "outputs": ["4\n", "-1\n", "3\n", "21\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 91,057 | |
b98ed11c0258d494327c9032603b50a0 | UNKNOWN | Haiku is a short form of Japanese poetry. A Haiku consists of three phrases with 5, 7 and 5 syllables, in this order.
Iroha is looking for X,Y,Z-Haiku (defined below) in integer sequences.
Consider all integer sequences of length N whose elements are between 1 and 10, inclusive. Out of those 10^N sequences, how many contain an X,Y,Z-Haiku?
Here, an integer sequence a_0, a_1, ..., a_{N-1} is said to contain an X,Y,Z-Haiku if and only if there exist four indices x, y, z, w (0 ≦ x < y < z < w ≦ N) such that all of the following are satisfied:
- a_x + a_{x+1} + ... + a_{y-1} = X
- a_y + a_{y+1} + ... + a_{z-1} = Y
- a_z + a_{z+1} + ... + a_{w-1} = Z
Since the answer can be extremely large, print the number modulo 10^9+7.
-----Constraints-----
- 3 ≦ N ≦ 40
- 1 ≦ X ≦ 5
- 1 ≦ Y ≦ 7
- 1 ≦ Z ≦ 5
-----Input-----
The input is given from Standard Input in the following format:
N X Y Z
-----Output-----
Print the number of the sequences that contain an X,Y,Z-Haiku, modulo 10^9+7.
-----Sample Input-----
3 5 7 5
-----Sample Output-----
1
Here, the only sequence that contains a 5,7,5-Haiku is [5, 7, 5]. | ["# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nn,X,Y,Z = list(map(int,read().split()))\n\nN = 1<<(X+Y+Z)\nNX = 1<<X\nNY = 1<<(X+Y)\nNZ = 1<<(X+Y+Z)\n\nMX = (1<<X) - 1\nMY = (1<<(Y+X)) - (1<<X)\nMZ = (1<<(X+Y+Z)) - (1<<(Y+X))\n\nMMX = MX<<1\nMMY = MY<<1\nMMZ = MZ<<1\n\ndp = [0]*N\ndp[1] = 1\n\nMOD = 10**9+7\n\nfor _ in range(n):\n ndp = [0]*N\n #cnt = 0\n #bad = 0\n for mask in range(N):\n if dp[mask]==0: continue\n mx = mask&MX\n my = mask&MY\n mz = mask&MZ\n \n for j in range(1,11):\n nmx = mx << j\n nmx &= MMX\n\n nmy = my << j\n nmy &= MMY\n\n nmz = mz << j\n nmz &= MMZ\n\n nmask = nmx|nmy|nmz|1\n if not nmask&(1<<(X+Y+Z)):\n ndp[nmask] += dp[mask]\n ndp[nmask] %= MOD\n\n dp = ndp\n #print(sum(dp),\"sum\")\n\nans = (pow(10,n,MOD)-sum(dp))\nprint((ans%MOD))\n\n\n", "import sys\ninput = sys.stdin.readline\nimport numpy as np\n\nN,X,Y,Z = map(int,input().split())\n\nMOD = 10 ** 9 + 7\n\n# \u30c0\u30e1\u306a\u3084\u3064\u3092\u6570\u3048\u308b\nL = max(10,X + Y + Z)\ndp = np.zeros(1 << L+1, dtype = np.int64) # \u53f3\u304b\u3089\u898b\u3066\u90e8\u5206\u548c\u3068\u3057\u3066\u8e0f\u3080\u5834\u6240\nrng = np.arange(1 << L+1, dtype=np.int64)\nx575 = (1 << Z) + (1 << (Y+Z)) + (1 << (X+Y+Z))\nbad = ((x575 & rng) == x575)\ndp[1] = 1\n\nfor n in range(N):\n prev = dp\n dp = np.zeros_like(prev)\n for i in range(1, 11):\n dp[1::1<<i] += prev.reshape(1<<i, 1<<(L+1-i)).sum(axis = 0)\n dp[bad] = 0\n dp %= MOD\n\nanswer = pow(10,N,MOD) - dp.sum()\nanswer %= MOD\nprint(answer)", "mod = 1000000007\neps = 10**-9\n\n\ndef main():\n import sys\n input = sys.stdin.readline\n\n N, x, y, z = list(map(int, input().split()))\n s = x + y + z\n m = max(x, y, z)\n mask_x = (1 << (x + 1)) - 1\n mask_y = (1 << y) - 1\n mask_z = (1 << z) - 1\n\n dp = [0] * (1 << s)\n dp[1] = 1\n for _ in range(N):\n dp_new = [0] * (1 << s)\n for state in range(1 << s):\n if dp[state] == 0:\n continue\n state_x = state & mask_x\n state_y = (state >> (x + 1)) & mask_y\n state_z = (state >> (x + y + 1)) & mask_z\n for w in range(1, m+1):\n if z - w - 1 >= 0:\n if (state_z >> (z - w - 1)) & 1:\n continue\n if w == z and (state_y >> (y - 1)) & 1:\n continue\n state_new = ((state_x << w) & mask_x) | (((state_y << w) & mask_y) << (x + 1))\\\n | (((state_z << w) & mask_z) << (x + y + 1)) | 1\n if ((state_x >> x) & 1) and w <= y:\n state_new |= (1 << (w + x))\n if ((state_y >> (y - 1)) & 1) and w <= z:\n state_new |= (1 << (w + x + y))\n dp_new[state_new] = (dp_new[state_new] + dp[state])%mod\n dp_new[1] = (dp_new[1] + (dp[state] * (10 - m))%mod)%mod\n dp = dp_new\n ans = pow(10, N, mod)\n for a in dp:\n ans = (ans - a)%mod\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()"] | {"inputs": ["3 5 7 5\n", "4 5 7 5\n", "37 4 2 3\n", "40 5 7 5\n"], "outputs": ["1\n", "34\n", "863912418\n", "562805100\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 3,322 | |
180aa4ebc316dd6f979d6b8ed5f63c15 | UNKNOWN | We have a permutation of the integers from 1 through N, p_1, p_2, .., p_N.
We also have M pairs of two integers between 1 and N (inclusive), represented as (x_1,y_1), (x_2,y_2), .., (x_M,y_M).
AtCoDeer the deer is going to perform the following operation on p as many times as desired so that the number of i (1 ≤ i ≤ N) such that p_i = i is maximized:
- Choose j such that 1 ≤ j ≤ M, and swap p_{x_j} and p_{y_j}.
Find the maximum possible number of i such that p_i = i after operations.
-----Constraints-----
- 2 ≤ N ≤ 10^5
- 1 ≤ M ≤ 10^5
- p is a permutation of integers from 1 through N.
- 1 ≤ x_j,y_j ≤ N
- x_j ≠ y_j
- If i ≠ j, \{x_i,y_i\} ≠ \{x_j,y_j\}.
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
N M
p_1 p_2 .. p_N
x_1 y_1
x_2 y_2
:
x_M y_M
-----Output-----
Print the maximum possible number of i such that p_i = i after operations.
-----Sample Input-----
5 2
5 3 1 4 2
1 3
5 4
-----Sample Output-----
2
If we perform the operation by choosing j=1, p becomes 1 3 5 4 2, which is optimal, so the answer is 2. | ["import sys\nreadline = sys.stdin.readline\n\nclass UnionFind(object):\n def __init__(self, n):\n self._par = list(range(n))\n self.size = [1]*n\n\n def root(self, v):\n if self._par[v] == v:\n return v\n self._par[v] = self.root(self._par[v])\n return self._par[v]\n \n def unite(self, u, v):\n u, v = self.root(u), self.root(v)\n if u==v:\n return False\n if self.size[u] > self.size[v]:\n u, v = v, u\n self.size[v] += self.size[u]\n self._par[u] = v\n\n def is_connected(self, u, v):\n return self.root(u)==self.root(v)\n\nn, m = map(int, readline().split())\nP = list(map(lambda x:int(x)-1, readline().split()))\nuf = UnionFind(n)\nfor _ in range(m):\n x, y = map(lambda x:int(x)-1, readline().split())\n uf.unite(x,y)\n\nans = 0\nfor i in range(n):\n if uf.is_connected(i, P[i]):\n ans += 1\nprint(ans)", "#ARC097D Equals\ndef f(x):\n while q[x]>=0:\n x=q[x]\n return x\nN, M = map(int, input().split())\np = list(map(int, input().split()))\nq = [-1]*N\nfor _ in range(M):\n x, y = map(lambda x:f(int(x)-1), input().split())\n if x == y: continue\n elif x < y: x,y=y,x\n q[x] += q[y]\n q[y] = x\n#\u65b9\u91dd:\u5404\u6728\u306b\u5206\u5272\u3001\u5404\u6728\u5185\u306e\u4e00\u81f4\u306e\u6700\u5927\u6570\u3092\u8db3\u305b\u3070\u3088\u3044\u3002\ntree = [[] for n in range(N)]\nfor n in range(N):\n tree[f(n)].append(n)\n #print(f(n))\nans = 0\nfor n in range(N):\n ans += len(set(tree[n])&{p[i]-1 for i in tree[n]})\nprint(ans)", "class UnionFind:\n def __init__(self,n):\n self.tree = [-1 for i in range(n)]\n return\n \n def union(self,x,y):\n xroot = self.root(x)\n yroot = self.root(y)\n if xroot==yroot:\n return\n if self.tree[xroot]>self.tree[yroot]:\n xroot,yroot = yroot,xroot\n self.tree[xroot] += self.tree[yroot]\n self.tree[yroot] = xroot\n return\n \n def root(self,x):\n qu = []\n while self.tree[x]>=0:\n qu.append(x)\n x = self.tree[x]\n for i in qu:\n self.tree[i] = x \n return x\n \n def same(self,x,y):\n return self.root(x)==self.root(y)\n\n def size(self):\n arr = [0 for i in range(len(self.tree))]\n for i in range(len(self.tree)):\n arr[self.root(i)] += 1\n for i in range(len(self.tree)):\n if self.root(i)!=i:\n arr[i] += arr[self.root(i)]\n return arr\n\n def getnumroots(self):\n ans = 0\n for i in self.tree:\n if i<0:\n ans += 1\n return ans\n\n def getelements(self):\n arr = [-1 for i in range(len(self.tree))]\n ans = []\n c = 0\n for i in range(len(self.tree)):\n if arr[self.root(i)]==-1:\n arr[self.root(i)] = c\n ans.append([i])\n c += 1\n else:\n ans[arr[self.root(i)]].append(i)\n return ans \n \n \n\nfrom sys import stdin\ndef input():\n return stdin.readline()\n\ndef main():\n n,m = map(int,input().split())\n p = list(map(int,input().split()))\n uf = UnionFind(n)\n ans = 0\n for i in range(m):\n x,y = map(int,input().split())\n uf.union(x-1,y-1)\n arr = uf.getelements()\n for i in range(len(arr)):\n temp = []\n for j in arr[i]:\n temp.append(p[j]-1)\n ans += len(set(temp).intersection(arr[i]))\n print(ans)\n\ndef __starting_point():\n main()\n__starting_point()", "import sys\nfrom collections import deque\nreadline = sys.stdin.readline\nn, m = map(int, readline().split())\nP = list(map(lambda x:int(x)-1, readline().split()))\nG = [set() for _ in range(n)]\nfor i in range(m):\n x, y = map(lambda x:int(x)-1, readline().split())\n G[x].add(y)\n G[y].add(x)\n\nD = {}\ncnt = 0\nV = [-1]*n\nfor i in range(n):\n if V[i]!=-1: continue\n V[i] = cnt\n que = deque([i])\n D[cnt] = set([P[i]])\n while que:\n nw = que.popleft()\n for nx in G[nw]:\n if V[nx] != -1: continue\n D[cnt].add(P[nx])\n V[nx] = cnt\n que.append(nx)\n cnt += 1\nprint(sum([int(i in D[V[i]]) for i in range(n)]))", "N, M = map(int, input().split())\np = list(map(int, input().split()))\n\np = [0] + p\npar = list(range(N+1))\n\ndef find(x):\n if par[x] == x:\n return x\n else:\n par[x] = find(par[x])\n return par[x]\n \ndef unite(x, y):\n if find(x) != find(y):\n par[find(x)] = y\n \nfor _ in range(M):\n a, b = map(int, input().split())\n unite(a, b)\n \n# for i in range(1, N+1):\n# find(i)\n\n# print(p) #\n# print(par) #\n\nans = 0\nfor i in range(1, N+1):\n if find(p[i]) == find(p[p[i]]):\n ans += 1\n# print(ans) #\n \nprint(ans)", "N, M = list(map(int,input().split()))\np = list(map(int,input().split()))\nparent = [k for k in range(N)]\ndef find(x):\n if parent[x] == x:\n return x\n else:\n parent[x] = find(parent[x])\n return find(parent[x])\ndef unite(x,y):\n parent[find(x)] = find(y)\n\nfor _ in range(M):\n x, y = list(map(int,input().split()))\n unite(x-1,y-1)\nans = 0\nfor k in range(N):\n if find(k) == find(p[k]-1):\n ans += 1\nprint(ans)\n", "from collections import deque\n\nN, M = map(int, input().split())\nplist = list(map(int, input().split()))\n\npilist = []\nfor i, p in enumerate(plist):\n pilist.append((p, i+1))\n\npilist.sort(key=lambda x: x[0])\n\ndic = {k: [] for k in range(N+1)}\nfor _ in range(M):\n x, y = map(int, input().split())\n dic[plist[x-1]].append(plist[y-1])\n dic[plist[y-1]].append(plist[x-1])\ngroups = []\ndone = [0] * (N+1)\nfor p in range(1, N+1):\n if done[p]==0:\n done[p] = 1\n group_p = [p]\n group_i = [pilist[p-1][1]]\n queue = deque([p])\n while queue:\n q = queue.pop()\n for q_n in dic[q]:\n if done[q_n]==0:\n done[q_n] = 1\n group_p.append(q_n)\n group_i.append(pilist[q_n-1][1])\n queue.append(q_n)\n groups.append((group_p, group_i))\n\nans = 0\nfor group in groups:\n p = set(group[0])\n i = set(group[1])\n ans += len(p & i)\nprint(ans)", "n, m = map(int, input().split())\npn = list(map(lambda x:int(x)-1, input().split()))\nls = [-1] * n\nfor i in pn:\n ls[pn[i]] = i\n#print(ls)\n\npar = [i for i in range(n)]\n\ndef find(x):\n if par[x] == x:\n return x\n else:\n s = find(par[x])\n par[x] = s\n return s\n\ndef unite(x,y):\n s = find(x)\n t = find(y)\n if s>t:\n par[s] = t\n else:\n par[t] = s\n\n\nfor _ in range(m):\n x, y = map(lambda x:int(x)-1, input().split())\n unite(ls[x],ls[y])\n\n\nans2 = 0\nfor i in range(n): # i\u756a\u76ee\u306e\u6570\u5b57\u304c\u3044\u308b\u5834\u6240\u306e\u89aa\u3068i\u306e\u5834\u6240\n place1 = ls[pn[i]]\n place2 = ls[i]\n\n if find(place1)==find(place2):\n ans2+=1\nprint(ans2)", "import sys,math,collections,itertools\ninput = sys.stdin.readline\n\nN,M=list(map(int,input().split()))\nP = list(map(int,input().split()))\nbridge = [[] for i in range(N+1)]\nfor _ in range(M):\n x,y = list(map(int,input().split()))\n bridge[x].append(y)\n bridge[y].append(x)\n#-\u884c\u304d\u6765\u3067\u304d\u308b\u6570\u5b57\u306e\u7d44\u307f\u5408\u308f\u305b\u3092\u4f5c\u308b-#\nmemo = [-1]*(N+1)\nq = collections.deque([])\nnovisit = set(range(1,N+1))\ntmp = 0\nwhile novisit:\n q.append(novisit.pop())\n tmp+=1\n while q:\n now = q.pop()\n memo[now]=tmp\n for bri in bridge[now]:\n if bri in novisit:\n q.append(bri)\n novisit.discard(bri)\n#-memo\u304c\u540c\u3058\u6570\u5b57\u3060\u3063\u305f\u3089\u5165\u308c\u66ff\u3048\u53ef\u80fd-#\ncnt = 0\nfor i in range(N):\n if i+1 == P[i]:\n cnt += 1\n elif i+1 != P[i] and memo[P[i]] == memo[i+1] :\n cnt += 1\nprint(cnt)\n", "N,M=map(int,input().split())\n*P,=map(int,input().split())\nxy=[list(map(int,input().split()))for _ in range(M)]\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\nuf=UnionFind(N)\nfor x,y in xy:\n uf.union(x-1,y-1)\nans=sum(uf.find(i)==uf.find(P[i]-1)for i in range(N))\nprint(ans)", "def find(x):\n '''\n x\u306e\u6839\u3092\u6c42\u3081\u308b\n '''\n if par[x] < 0:\n return x\n else:\n par[x] = find(par[x])\n return par[x]\n\n\ndef union(x, y):\n '''\n x\u3068y\u306e\u5c5e\u3059\u308b\u96c6\u5408\u306e\u4f75\u5408\n '''\n x = find(x)\n y = find(y)\n \n if x == y:\n return\n\n if par[x] > par[y]:\n x, y = y, x\n\n par[x] += par[y]\n par[y] = x\n\n\ndef size(x):\n '''\n x\u304c\u5c5e\u3059\u308b\u96c6\u5408\u306e\u500b\u6570\n '''\n return -par[find(x)]\n\n\ndef same(x, y):\n '''\n x\u3068y\u304c\u540c\u3058\u96c6\u5408\u306b\u5c5e\u3059\u308b\u304b\u306e\u5224\u5b9a\n '''\n return find(x) == find(y)\n\n\nn, m = map(int, input().split())\np = list(map(int, input().split()))\n\npar = [-1] * n\n\npos = [-1] * n\nfor i in range(n):\n pos[p[i]-1] = i\n\nfor _ in range(m):\n x, y = map(int, input().split())\n union(x-1, y-1)\n\nres = 0\nfor i in range(n):\n if same(i, pos[i]):\n res += 1\n\nprint(res)", "#Union Find\nclass union_find:\n #\u521d\u671f\u5316\n #\u6839\u306a\u3089-size,\u5b50\u306a\u3089\u89aa\u306e\u9802\u70b9\n # par = [-1]*N\n def __init__(self, N):\n self.par = [-1]*N\n\n #x\u306e\u6839\u3092\u6c42\u3081\u308b\n def find(self, x):\n if self.par[x] < 0:\n return x\n else:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n\n #x\u3068y\u306e\u5c5e\u3059\u308b\u96c6\u5408\u306e\u4f75\u5408\n def unite(self, x,y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return False\n else:\n #size\u306e\u5927\u304d\u3044\u307b\u3046\u304cx\n if self.par[x] > self.par[y]:\n x,y = y,x\n self.par[x] += self.par[y]\n self.par[y] = x\n return True\n\n #x\u3068y\u304c\u540c\u3058\u96c6\u5408\u306b\u5c5e\u3059\u308b\u304b\u306e\u5224\u5b9a\n def same(self, x,y):\n return self.find(x) == self.find(y)\n\n #x\u304c\u5c5e\u3059\u308b\u96c6\u5408\u306e\u500b\u6570\n def size(self, x):\n return -self.par[self.find(x)]\n\nN, M = map(int, input().split())\nP = list(map(lambda x:int(x)-1, input().split()))\nuf = union_find(N)\nfor _ in range(M):\n x, y = map(int, input().split())\n x -= 1\n y -= 1\n uf.unite(x, y) \n\nans = 0\nfor i in range(N):\n if uf.same(P[i], i):\n ans += 1\nprint(ans)", "n,m= map(int,input().split())\npar = [-1]*(n)\ndef find(x):\n if par[x]<0:return x\n else:\n par[x]=find(par[x])\n return par[x]\ndef unite(x,y):\n px,py=find(x),find(y)\n if px==py:return False\n else:\n if px<py:px,py=py,px\n par[px]+=par[py]\n par[py]=px\n return True\np= list(map(int,input().split()))\ngl=[[] for _ in range(n)]\nfor i in range(m):\n x,y= map(int,input().split())\n unite(x-1,y-1)\nfor c in range(n):#par:\n ap=find(c)\n gl[ap].append(c)\ng=0\nfor sg in gl:\n temp=[p[index]-1 for index in sg]\n newset = set(sg) & set(temp)\n g+=len(newset)\nprint(g)", "from collections import defaultdict\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n group_members = defaultdict(list)\n for member in range(self.n):\n group_members[self.find(member)].append(member)\n return group_members\n\n def __str__(self):\n return '\\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())\n\ndef slove():\n N, M = map(int,input().split())\n u = UnionFind(N)\n P = list(map(int,input().split()))\n for _ in range(M):\n x, y = map(int,input().split())\n u.union(x-1,y-1)\n ans = 0\n for i,p in enumerate(P):\n if p-1 in u.members(i):\n ans += 1\n print(ans)\n\ndef slove2():\n N, M = map(int,input().split())\n P = list(map(int,input().split()))\n l = list(range(N+1))\n def find(p):\n if l[p] == p:\n return p\n else:\n l[p] = find(l[p])\n return l[p]\n for _ in range(M):\n x, y = map(int,input().split())\n x = find(x)\n y = find(y)\n if x > y:\n x, y = y, x\n l[y] = find(x)\n ans = 0\n for i,p in enumerate(P):\n if find(i+1) == find(p):\n ans += 1\n print(ans)\n\n\ndef __starting_point():\n #slove()\n slove2()\n__starting_point()", "n,m=map(int,input().split())\nP=[i-1 for i in list(map(int,input().split()))]\n\nclass UnionFind():\n def __init__(self,num):\n self.n = num #class\u5185\u5909\u6570n\u306b\u3001\u5916\u90e8\u304b\u3089\u5165\u529b\u3057\u305f\u5024num\u3092\u4ee3\u5165\n self.parents = [-1 for i in range(self.n)]\n #parents\u306f\u8981\u7d20\u306e\u89aa(1\u3053\u4e0a\u306e\u3084\u3064)\u756a\u53f70~n-1\u3092\u683c\u7d0d\u3001\u81ea\u5206\u304c\u6700\u89aa\u306a\u3089-(\u8981\u7d20\u6570)\u3092\u683c\u7d0d(\u521d\u671f\u5024\u306f-1)\n\n #x\u306e\u6700\u89aa\u306f\u8ab0\uff1f\n def find(self,x):\n if self.parents[x]<0:\n return x\n else:\n self.parents[x]=self.find(self.parents[x]) #\u518d\u5e30\u3057\u30661\u756a\u4e0a\u307e\u3067\u3044\u3063\u3066\u308b\n #\u8abf\u3079\u306a\u304c\u3089parents\u306e\u5024\u3092\u66f4\u65b0\u3057\u3066\u308b\uff01\uff08\u7d4c\u8def\u5727\u7e2e\uff09\n return self.parents[x]\n\n #\u7d50\u5408\u305b\u3088\n #x\u306e\u89aa\u3068y\u306e\u89aa\u3092\u304f\u3063\u3064\u3051\u308b\n def union(self,x,y):\n xx=self.find(x) #xx\u306fx\u306e\u6700\u89aa\n yy=self.find(y) #yy\u306fy\u306e\u6700\u89aa\n if xx==yy:\n return #\u540c\u3058\u5c4b\u6839\u306e\u4e0b\u306b\u3042\u3063\u305f\u5834\u5408\u306f\u4f55\u3082\u3057\u306a\u3044\n else:\n size_xx=abs(self.parents[xx]) #x\u304c\u542b\u307e\u308c\u308b\u6728\u306e\u30b5\u30a4\u30ba\n size_yy=abs(self.parents[yy]) #y\u304c\u542b\u307e\u308c\u308b\u6728\u306e\u30b5\u30a4\u30ba\n if size_xx>size_yy:\n xx,yy=yy,xx #yy\u306e\u65b9\u304c\u5927\u304d\u3044\u6728\u3001\u3063\u3066\u3053\u3068\u306b\u3059\u308b\n\n self.parents[yy]+=self.parents[xx] #\u5927\u304d\u3044\u6728\u306e\u30b5\u30a4\u30ba\u66f4\u65b0\n self.parents[xx]=yy #\u30b5\u30a4\u30ba\u304c\u5c0f\u3055\u3044\u6728\u3092\u5927\u304d\u3044\u6728\u306b\u63a5\u3050\n\n #x\u306e\u5c5e\u3059\u308b\u6728\u306e\u5927\u304d\u3055\uff08\u307e\u3042union\u3067\u3082\u4f7f\u3063\u305f\u3051\u3069\uff09\n def size(self,x):\n xx=self.find(x)\n return abs(self.parents[xx])\n\n #x\u3068y\u306f\u3053\u306e\u7a7a\u306e\u7d9a\u304f\u5834\u6240\u306b\u3044\u307e\u3059\u304b\u3000\u3044\u3064\u3082\u306e\u3088\u3046\u306b\u7b11\u9854\u3067\u3044\u3066\u304f\u308c\u307e\u3059\u304b\u3000\u4eca\u306f\u305f\u3060\u305d\u308c\u3092\u9858\u3044\u7d9a\u3051\u308b\n def same(self,x,y):\n return 1 if self.find(x)==self.find(y) else 0\n\n #x\u3068\u3000\u540c\u3058\u6728\u306b\u3044\u308b\u3000\u30e1\u30f3\u30d0\u30fc\u306f\uff1f\n def members(self,x):\n xx=self.find(x)\n return [i for i in range(self.n) if self.find(i)==xx]\n #if\u306e\u6761\u4ef6\u5f0f\u306b\u6f0f\u308c\u305f\u3089\u7121\u8996\n\n #\u6700\u89aa\u3060\u3051\u3092\u4e26\u3079\u3042\u3052\u308b\n def roots(self):\n return [i for i,x in enumerate(self.parents) if x < 0]\n #\u3044\u3084\u3053\u308c\u306f\u5929\u624d\u3059\u304e\u308b\u3001basis\u306eenumerate.py\u53c2\u7167\n\n #\u3059\u3079\u3066\u306e\u6700\u89aa\u306b\u3064\u3044\u3066\u3001\u30e1\u30f3\u30d0\u30fc\u3092\u8f9e\u66f8\u3067\n def all_group_members(self):\n return {r:self.members(r) for r in self.roots()}\n\n #\u30b0\u30eb\u30fc\u30d7\u5206\u3051\u3069\u3046\u306a\u308a\u307e\u3057\u305f\u304b\u3001\uff12\u91cd\u30ea\u30b9\u30c8\u3067\n def state_grouping(self):\n return list(self.all_group_members().values())\n\n\nuf=UnionFind(n)\nfor i in range(m):\n a,b=map(int,input().split())\n a-=1;b-=1\n uf.union(a,b)\nans=0\nfor i in range(n):\n ans+= uf.same(i,P[i])\nprint(ans)", "from collections import deque\n\nn, m = map(int, input().split())\nplst = list(map(int, input().split()))\nedges = [[] for _ in range(n)]\nfor _ in range(m):\n x, y = map(int, input().split())\n x -= 1\n y -= 1\n edges[x].append(y)\n edges[y].append(x)\n \ncheck = [False for _ in range(n)]\nuni = [0 for _ in range(n)]\npos = 0\nqueue = deque()\nfor i in range(n):\n if check[i]:\n continue\n pos += 1\n queue.append(i)\n check[i] = True\n while queue:\n now = queue.popleft()\n uni[now] += pos\n uni[plst[now] - 1] -= pos\n for aft in edges[now]:\n if check[aft]:\n continue\n check[aft] = True\n queue.append(aft)\nprint(uni.count(0))", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def all_group_members(self):\n return [set(self.members(r)) for r in self.roots()]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\ndef main():\n n, m = list(map(int, input().split()))\n P = list([int(x) - 1 for x in input().split()])\n uf = UnionFind(n)\n for _ in range(m):\n x, y = [int(x) - 1 for x in input().split()]\n uf.union(x, y)\n ans = 0\n for i, p in enumerate(P):\n if uf.same(i, p):\n ans += 1\n print(ans)\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import deque\nn,m = map(int, input().split())\np= list(map(int, input().split()))\ng = [[] for i in range(n)]\nfor i in range(m):\n a, b = map(int, input().split())\n g[a-1].append(b-1)\n g[b-1].append(a-1)\nv = [-1 for i in range(n)]\ns = 0\nfor i in range(n):\n if v[i]!=-1:\n continue\n s+=1\n v[i]=s\n d = deque([i])\n while len(d):\n x = d.popleft()\n for i in g[x]:\n if v[i] == -1:\n d.append(i)\n v[i]=s\nans=0\nfor i in range(n):\n if v[i]==v[p[i]-1]:\n ans+=1\nprint(ans)", "class UnionFind:\n def __init__(self, n):\n self.parent = list(range(n)) #\u89aa\u30ce\u30fc\u30c9\n self.size = [1]*n #\u30b0\u30eb\u30fc\u30d7\u306e\u8981\u7d20\u6570\n \n def root(self, x): #root(x): x\u306e\u6839\u30ce\u30fc\u30c9\u3092\u8fd4\u3059\uff0e\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]\n x = self.parent[x]\n return x \n \n def merge(self, x, y): #merge(x,y): x\u306e\u3044\u308b\u7d44\u3068y\u306e\u3044\u308b\u7d44\u3092\u307e\u3068\u3081\u308b\n x, y = self.root(x), self.root(y)\n if x == y: return False\n if self.size[x] < self.size[y]: x,y=y,x #x\u306e\u8981\u7d20\u6570\u304c\u5927\u304d\u3044\u3088\u3046\u306b\n self.size[x] += self.size[y] #x\u306e\u8981\u7d20\u6570\u3092\u66f4\u65b0\n self.parent[y] = x #y\u3092x\u306b\u3064\u306a\u3050\n return True\n \n def issame(self, x, y): #same(x,y): x\u3068y\u304c\u540c\u3058\u7d44\u306a\u3089True\n return self.root(x) == self.root(y)\n \n def getsize(self,x): #size(x): x\u306e\u3044\u308b\u30b0\u30eb\u30fc\u30d7\u306e\u8981\u7d20\u6570\u3092\u8fd4\u3059\n return self.size[self.root(x)]\n\n# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\n#n = int(readline())\nn,m = list(map(int,readline().split()))\n*p, = list(map(int,readline().split()))\n\nUF = UnionFind(n)\nfor _ in range(m):\n x,y = list(map(int,readline().split()))\n UF.merge(x-1,y-1)\n\nq = [set() for _ in range(n)] \nr = [set() for _ in range(n)] \n\nfor i in range(n):\n v = UF.root(i)\n q[v].add(i)\n r[v].add(p[i]-1)\n\n#print(q,r)\nans = 0\nfor i in range(n):\n ans += len(q[i]&r[i])\n #print(q[i]&r[i])\n\nprint(ans)\n\n\n\n\n", "from collections import defaultdict\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n group_members = defaultdict(list)\n for member in range(self.n):\n group_members[self.find(member)].append(member)\n return group_members\n\n def __str__(self):\n return '\\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())\n \nN,M = map(int,input().split())\nP = list(map(int,input().split()))\nuf = UnionFind(N)\nfor i in range(M):\n x,y = map(int,input().split())\n uf.union(x-1,y-1)\nans = 0\nfor i in range(N):\n if uf.same(i,P[i]-1):\n ans += 1\nprint(ans)", "import sys\nimport math\nimport collections\nimport bisect\nimport copy\nimport itertools\n\n# import numpy as np\n\nsys.setrecursionlimit(10 ** 7)\nINF = 10 ** 16\nMOD = 10 ** 9 + 7\n# MOD = 998244353\n\nni = lambda: int(sys.stdin.readline().rstrip())\nns = lambda: list(map(int, sys.stdin.readline().rstrip().split()))\nna = lambda: list(map(int, sys.stdin.readline().rstrip().split()))\nna1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().rstrip().split()])\n\n\n# ===CODE===\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\n\ndef main():\n n, m = ns()\n p = na1()\n\n uf = UnionFind(n)\n\n for _ in range(m):\n x, y = ns()\n uf.union(x - 1, y - 1)\n\n ans = 0\n for i, pi in enumerate(p):\n if uf.same(i, pi):\n ans += 1\n\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "class Unionfind(): # Unionfind\n def __init__(self, N):\n self.N = N\n self.parents = [-1] * N\n\n def find(self, x): # \u30b0\u30eb\u30fc\u30d7\u306e\u6839\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y): # \u30b0\u30eb\u30fc\u30d7\u306e\u4f75\u5408\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def all_group_members(self): # \u30b0\u30eb\u30fc\u30d7\u3054\u3068\u306e\u8f9e\u66f8\n members_dict = {i: set([i]) for i, x in enumerate(self.parents) if x < 0}\n for i, x in enumerate(self.parents):\n if x >= 0:\n members_dict[self.find(x)].add(i)\n return members_dict\n\n\nn, m = list(map(int, input().split()))\np = list(map(int, input().split()))\nxy = [list(map(int, input().split())) for _ in range(m)]\n\nuf = Unionfind(n)\nfor x, y in xy:\n uf.union(x - 1, y - 1)\n\nans = 0\nfor lst in list(uf.all_group_members().values()):\n ans += sum((p[num] - 1 in lst) for num in lst)\nprint(ans)\n", "class UnionFind:\n def __init__(self,n):\n self.n=n\n self.parents=[-1]*n\n\n def find(self,x):\n if self.parents[x]<0:\n return x\n else:\n self.parents[x]=self.find(self.parents[x])\n return self.parents[x]\n\n def unite(self,x,y):\n x=self.find(x)\n y=self.find(y)\n if x==y:\n return\n if self.parents[x]>self.parents[y]:\n x,y=y,x\n self.parents[x]+=self.parents[y]\n self.parents[y]=x\n\n def same(self,x,y):\n return self.find(x)==self.find(y)\n\n def size(self,x):\n return -self.parents[self.find(x)]\n\n def members(self,x):\n root=self.find(x)\n return [i for i in range(self.n) if self.find(i)==root]\n\n def roots(self):\n return [i for i,x in enumerate(self.parents) if x<0]\n\n\nn,m=map(int,input().split())\np=list(map(int,input().split()))\nuf=UnionFind(n)\nfor i in range(m):\n x,y=map(int,input().split())\n uf.unite(x-1,y-1)\nans=0\nfor i in range(n):\n if uf.same(i,p[i]-1):\n ans+=1\nprint(ans)", "import sys\nfrom collections import deque\n\ninput = sys.stdin.readline\n\ndef bfs(N, G, p):\n # Connected compoponent\n c_comp_p_list = []\n c_comp_i_list = []\n visited = [False] * N\n for i in range(N):\n if visited[i]:\n continue\n visited[i] = True\n c_comp_p_list.append([p[i]])\n c_comp_i_list.append(set([i + 1]))\n cc_p_add = c_comp_p_list[-1].append\n cc_i_add = c_comp_i_list[-1].add\n\n queue = deque(G[i])\n while queue:\n u = queue.popleft()\n if visited[u]:\n continue\n visited[u] = True\n cc_p_add(p[u])\n cc_i_add(u + 1)\n\n for v in G[u]:\n if visited[v]:\n continue\n queue.append(v)\n\n res = 0\n for c_comp_p, c_comp_i in zip(c_comp_p_list, c_comp_i_list):\n for pp in c_comp_p:\n if pp in c_comp_i:\n res += 1\n return res\n\n\ndef main():\n N, M = list(map(int, input().split()))\n p = tuple(map(int, input().split()))\n G = [[] for _ in range(N)]\n for _ in range(M):\n x, y = list(map(int, input().split()))\n x -= 1\n y -= 1\n G[x].append(y)\n G[y].append(x)\n \n ans = bfs(N, G, p)\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import deque\n\nn,m = map(int,input().split())\n\np = list(map(int,input().split()))\n\nroot = [[] for i in range(n)]\nfor _ in range(m):\n a, b = (int(x) for x in input().split())\n root[b-1].append(a-1)\n root[a-1].append(b-1)\n\ncheck = [-1]*n\n\nfor j in range(n):\n if check[j] != -1:\n continue\n stack=deque([j])\n check[j] = j\n while len(stack)>0:\n v = stack.popleft()\n for i in root[v]:\n if check[i] == -1:\n check[i]=j\n stack.append(i)\n\nans = 0\nfor key, value in enumerate(p):\n if check[key] == check[value-1]:\n ans += 1\nprint(ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\ndef main():\n N, M = map(int, input().split())\n P = list(map(int, input().split()))\n uni = UnionFind(N)\n\n for i in range(N):\n P[i] -= 1\n\n for _ in range(M):\n x, y = map(int, input().split())\n x -= 1\n y -= 1\n uni.union(x,y)\n ans = 0\n for i in range(N):\n if P[i] == i:\n ans += 1\n else:\n if uni.same(i,P[i]):\n ans += 1\n\n print(ans)\n\n\n\ndef __starting_point():\n main()\n__starting_point()", "class UnionFind:\n\n def __init__(self, n: int):\n self.parent = [i for i in range(n + 1)]\n self.rank = [0] * (n + 1)\n\n def find(self, x: int) -> int:\n if self.parent[x] == x:\n return x\n else:\n self.parent[x] = self.find(self.parent[x])\n return self.parent[x]\n\n def unit(self, x: int, y: int):\n parent_x = self.find(x)\n parent_y = self.find(y)\n if self.rank[parent_x] < self.rank[parent_y]:\n self.parent[parent_x] = parent_y\n else:\n self.parent[parent_y] = parent_x\n if self.rank[parent_y] == self.rank[parent_x]:\n self.rank[parent_x] += 1\n\n def same_check(self, x: int, y: int) -> bool:\n return self.find(x) == self.find(y)\n\n\nN, M = list(map(int, input().split()))\n\np = list(map(int, input().split()))\n\nxy = UnionFind(N)\n\nfor _ in range(M):\n x, y = list(map(int, input().split()))\n xy.unit(x, y)\n\nans = 0\n\nfor i in range(N):\n if xy.same_check(p[i], i + 1):\n ans += 1\n\nprint(ans)\n", "import sys\n\nsys.setrecursionlimit(6500)\n\ndef find(n):\n if d[n]<0:\n return n\n else:\n d[n]=find(d[n])\n return d[n]\n\ndef union(a,b):\n a=find(a)\n b=find(b)\n if a==b:return False\n if d[a]<=d[b]:\n d[a]+=d[b]\n d[b]=a\n else:\n d[b]+=d[a]\n d[a]=b\n return True\n\ndef members(n):\n p=find(n)\n ans=[]\n for i in range(N):\n if find(i)==p:\n ans.append(i)\n return ans\n\ndef same(a,b):\n if find(a)==find(b):return True\n else:return False\n\nN,M=map(int,input().split())\np=list(map(int,input().split()))\n\nd=[-1]*N\n\nfor i in range(M):\n x,y=map(int,input().split())\n x,y=x-1,y-1\n union(x,y)\n\nans=0\nfor i in range(N):\n if same(i,p[i]-1):\n ans+=1\nprint(ans)", "from collections import Counter,deque,defaultdict\nn,m=map(int,input().split())\np=list(map(int,input().split()))\nidx_lst=[0]*n\nfor i,x in enumerate(p):\n idx_lst[x-1]=i\nlst=[[] for _ in range(n)]\nfor i in range(m):\n x,y=map(int,input().split())\n lst[x-1].append(y-1)\n lst[y-1].append(x-1)\nseen=[False]*n\nans=0\nfor i in range(n):\n if seen[i]:\n continue\n seen[i]=True\n q=deque([i])\n dic=defaultdict(int)\n dic[i]+=1\n while q:\n t=q.pop()\n for j in lst[t]:\n if seen[j]:\n continue\n seen[j]=True\n dic[j]+=1\n q.append(j)\n for k in list(dic.keys()):\n if dic[idx_lst[k]]:\n ans+=1\nprint(ans)", "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10 ** 7)\n\nclass UnionFindPathCompression():\n def __init__(self, n):\n self.parents = list(range(n))\n self.rank = [1]*n\n self.size = [1]*n\n \n\n def find(self, x):\n if self.parents[x] == x:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n px = self.find(x)\n py = self.find(y)\n\n if px == py:\n return\n else:\n if self.rank[px] < self.rank[py]:\n self.parents[px] = py\n self.size[py] += self.size[px]\n else:\n self.parents[py] = px\n self.size[px] += self.size[py]\n #\u30e9\u30f3\u30af\u306e\u66f4\u65b0\n if self.rank[px] == self.rank[py]:\n self.rank[px] += 1\n\n\nn,m = map(int,input().split())\nP = list(map(int, input().split()))\nufpc = UnionFindPathCompression(n)\nfor i in range(m):\n x,y = map(int,input().split())\n x,y = x-1, y-1\n ufpc.union(x,y)\n\nans = 0\nfor i,p in enumerate(P):\n if ufpc.find(i) == ufpc.find(p-1):\n ans += 1\nprint(ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nn,m = map(int,input().split())\np = list(map(int,input().split()))\nu = UnionFind(n)\nfor _ in range(m):\n x,y = map(int,input().split())\n x -= 1\n y -= 1\n u.union(x,y)\n\nans = 0\nfor i in range(n):\n pi = p[i]\n pi -= 1\n if u.same(i,pi):\n ans += 1\nprint(ans)", "class UnionFind:\n def __init__(self, num):\n self.parent = [i for i in range(num + 1)]\n\n def find(self, node):\n if self.parent[node] == node:\n return node\n\n self.parent[node] = self.find(self.parent[node])\n return self.parent[node]\n\n def union(self, node1, node2):\n node1 = self.find(node1)\n node2 = self.find(node2)\n\n if node1 == node2:\n return\n\n if self.parent[node1] > self.parent[node2]:\n node1, node2 = node2, node1\n\n self.parent[node2] = node1\n return\n\n def same(self, node1, node2):\n return self.find(node1) == self.find(node2)\n\n\nn, m = list(map(int, input().split()))\np = list(map(int, input().split()))\n\nuf = UnionFind(n)\nfor _ in range(m):\n x, y = list(map(int, input().split()))\n x -= 1\n y -= 1\n uf.union(p[x], p[y])\n\nans = 0\nfor i in range(n):\n if p[i] == i + 1 or uf.same(p[i], i + 1):\n ans += 1\n\nprint(ans)\n\n", "class UnionFind():\n def __init__(self, n):\n self.par = [i for i in range(n)]\n self.rank = [0] * n\n self.members = [{i} for i in range(n)]\n self.roots = {i for i in range(n)}\n\n def root(self, x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.root(self.par[x])\n return self.par[x]\n\n def union(self, x, y):\n rx = self.root(x)\n ry = self.root(y)\n if rx != ry:\n if self.rank[rx] < self.rank[ry]:\n self.par[rx] = ry\n self.members[ry] |= self.members[rx]\n self.roots.discard(rx)\n else:\n self.par[ry] = rx\n self.members[rx] |= self.members[ry]\n self.roots.discard(ry)\n if self.rank[rx] == self.rank[ry]:\n self.rank[rx] += 1\n\n def same(self, x, y):\n return self.root(x) == self.root(y)\n\nN, M = list(map(int, input().split()))\nP = list([int(x) - 1 for x in input().split()])\nX = UnionFind(N)\nY = UnionFind(N)\nfor _ in range(M):\n x, y = list(map(int, input().split()))\n x -= 1; y -= 1\n X.union(x, y)\n Y.union(P[x], P[y])\n\nans = 0\nroots = X.roots\nfor r in roots:\n A = X.members[r]\n B = Y.members[P[r]]\n ans += len(A & B)\n\nprint(ans)\n", "import sys\n# sys.setrecursionlimit(100000)\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\ndef input_int():\n return int(input())\n\n\ndef input_int_list():\n return [int(i) for i in input().split()]\n\n\nclass UnionFind:\n \"\"\" 0-indexed Union Find Tree (a.k.a Disjoint Union Tree)\n \"\"\"\n\n def __init__(self, n: int):\n self.nodes = n\n self.parents = [-1] * n\n self.rank = [0] * n\n\n # retrun the root of element x\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n # unite the group include element x and group include element y\n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.rank[x] < self.rank[y]:\n self.parents[y] += self.parents[x]\n self.parents[x] = y\n else:\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n\n # get size of the gourp which element x belongs\n def get_size(self, x):\n return -self.parents[self.find(x)]\n\n # check if element x and element y is same group\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n # return groups as array of set\n def get_groups(self, index_base=0) -> list:\n d = {}\n for i in range(index_base, self.nodes):\n p = self.find(i)\n if p not in list(d.keys()):\n d[p] = set()\n d[p].add(i)\n return list(d.values())\n\n\ndef main():\n n, m = input_int_list()\n A = [None] + input_int_list() # 1-indexed\n djs = UnionFind(n + 1)\n\n for _ in range(m):\n x, y = input_int_list()\n djs.unite(x, y)\n groups = djs.get_groups()\n ans = 0\n for group in groups:\n v = set()\n for i in group:\n v.add(A[i])\n ans += len(group & v)\n print(ans)\n\n return\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "def find(x):\n if par[x] < 0:\n return x\n else:\n par[x] = find(par[x])\n return par[x]\ndef unite(x, y):\n p = find(x)\n q = find(y)\n if p == q:\n return None\n if p > q:\n p, q = q, p\n par[p] += par[q]\n par[q] = p\ndef same(x, y):\n return find(x) == find(y)\ndef size(x):\n return -par[find(x)]\nn, m = map(int, input().split())\npar = [-1 for i in range(n)]\np = list(map(int, input().split()))\nfor i in range(m):\n x, y = map(int, input().split())\n unite(x - 1, y - 1)\nans = 0\nfor i in range(n):\n if same(p[i] - 1, i):\n ans += 1\nprint(ans)", "import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy\n\nsys.setrecursionlimit(10**7)\ninf=10**20\nmod=10**9+7\ndd=[(-1,0),(0,1),(1,0),(0,-1)]\nddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\n# def LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef LS(): return sys.stdin.readline().split()\ndef S(): return input()\n\n# Union-Find -- START --\nclass UnionFind():\n def __init__(self,sz):\n self.sz=sz\n self.data=[-1]*sz\n self.amount=[0]*sz\n\n def unite(self,x,y):\n x=self.find(x)\n y=self.find(y)\n if x==y:\n return False\n self.amount[x]+=self.amount[y]\n self.amount[y]+=self.amount[x]\n if self.data[x]>self.data[y]:\n x,y=y,x\n self.data[x]+=self.data[y]\n self.data[y]=x\n return True\n\n def find(self,k):\n if self.data[k]<0:\n return k\n self.data[k]=self.find(self.data[k])\n return self.data[k]\n\n def size(self,k):\n return -self.data[self.find(k)]\n\n def set_amount(self,k,k_amount):\n self.amount[k]=k_amount\n\n def get_amount(self,k):\n return self.amount[k]\n# Union-Find --- END ---\n\ndef main():\n n,k=LI()\n l=LI()\n d={}\n uf=UnionFind(n)\n for i,x in enumerate(l):\n x-=1\n d[i]=x\n \n for _ in range(k):\n a,b=LI()\n uf.unite(a-1,b-1)\n\n ans=0\n for x in l:\n x-=1\n if uf.find(x)==uf.find(d[x]):\n ans+=1\n\n return ans\n\n# main()\nprint((main()))\n", "class UnionFind:\n def __init__(self, n):\n # n: \u9802\u70b9\u6570\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n # x\u306e\u6839\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n # \u7121\u5411\u8fba\u3092\u306f\u308b\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n # x\u306e\u5c5e\u3059\u308b\u96c6\u56e3\u306e\u9802\u70b9\u6570\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n # \u540c\u96c6\u56e3\u306b\u5c5e\u3059\u308b\u304b\u3069\u3046\u304b\n return self.find(x) == self.find(y)\n\n def members(self):\n ret = dict()\n for i in range(self.n):\n x = self.find(i)\n if x in ret:\n ret[x].add(i)\n else:\n ret[x] = {i}\n return ret\n\nN,M=map(int,input().split())\np=list(map(int,input().split()))\nuf = UnionFind(N)\nfor _ in range(M):\n x,y =map(int,input().split())\n uf.union(x-1,y-1)\n# uf\u4e0a\u306egroup\u3054\u3068\u306b\u3001group\u306eindex\u3068\u305d\u306e\u8981\u7d20\u306e\u7a4d\u96c6\u5408\u306e\u30b5\u30a4\u30ba\u3092\u3068\u308b\nans = 0\nfor id_s in uf.members().values():\n val_s = set()\n for i in id_s:\n val_s.add(p[i]-1)\n ans += len(id_s & val_s)\n #print(id_s,val_s)\nprint(ans)", "def find(x):\n if par[x] == x:\n return x\n else:\n par[x] = find(par[x]) #\u7d4c\u8def\u5727\u7e2e\n return par[x]\ndef same(x,y):\n return find(x) == find(y)\ndef unite(x,y):\n x = find(x)\n y = find(y)\n if x == y:\n return 0\n par[x] = y\n size[y] = size[x] + size[y]\n size[x] = 0\n\nN,M = list(map(int, input().split()))\nplist = list(map(int,input().split()))\nABs = [list(map(int, input().split())) for _ in range(M)]\npar = [i for i in range(N+1)]\nsize = [1 for _ in range(N+1)]\n\nfor AB in ABs:\n unite(AB[0],AB[1])\n\nAns = 0\nfor i in range(len(plist)):\n if plist[i] == i+1:\n Ans +=1\n else:\n if same(plist[i],i+1):\n Ans += 1\nprint(Ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def num_roots(self):\n return len([i for i, x in enumerate(self.parents) if x < 0])\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def num_members(self,x):\n return abs(self.parents[self.find(x)])\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nN, M = list(map(int, input().split()))\nP = list(map(int, input().split()))\nuf = UnionFind(N)\nfor _ in range(M):\n x,y = list(map(int, input().split()))\n uf.union(x-1,y-1)\nfrom collections import defaultdict\nd = defaultdict(lambda: [])\nfor i in range(N):\n d[uf.find(i)].append(i)\nfrom bisect import bisect_left\ndef binary_search(A,p):\n if A[0]<=p and p<=A[-1]:\n if p == A[bisect_left(A,p)]:\n return True\n return False\nans = 0\nfor v in list(d.values()):\n lis = sorted(v)\n for a in v:\n if binary_search(lis,P[a]-1):\n ans += 1\nprint(ans)\n\n\n\n", "import sys\nstdin = sys.stdin\nsys.setrecursionlimit(10**6)\nni = lambda: int(ns())\nna = lambda: list(map(int, stdin.readline().split()))\nnn = lambda: list(stdin.readline().split())\nns = lambda: stdin.readline().rstrip()\n\nimport collections\nimport itertools\nimport operator\n\nclass UnionFind:\n def __init__(self, elems=None):\n class KeyDict(dict):\n def __missing__(self, key):\n self[key] = key\n return key\n\n self.parent = KeyDict()\n self.rank = collections.defaultdict(int)\n self.size_ = collections.defaultdict(lambda: 1)\n\n if elems is not None:\n for elem in elems:\n _, _, _ = self.parent[elem], self.rank[elem], self.size_[elem]\n\n def find(self, x):\n if self.parent[x] == x:\n return x\n else:\n self.parent[x] = self.find(self.parent[x])\n return self.parent[x]\n\n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.rank[x] < self.rank[y]:\n self.parent[x] = y\n self.size_[y] += self.size_[x]\n else:\n self.parent[y] = x\n self.size_[x] += self.size_[y]\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n\n def are_same(self, x, y):\n return self.find(x) == self.find(y)\n\n def grouper(self):\n roots = [(x, self.find(x_par)) for x, x_par in self.parent.items()]\n root = operator.itemgetter(1)\n for _, group in itertools.groupby(sorted(roots, key=root), root):\n yield [x for x, _ in group]\n\n def size(self,x):\n return self.size_[self.find(x)]\n\nn,m = na()\np = na()\nuf = UnionFind()\nfor i in range(m):\n x,y = na()\n uf.unite(x,y)\n\ndp = []\nfor i in range(n):\n dp.append(uf.find(i+1))\n\nans = 0\nfor i in range(n):\n if dp[i] == uf.find(p[i]) or i+1 == p[i]: ans += 1\n\nprint(ans)", "import bisect, collections, copy, heapq, itertools, math, string, sys\ninput = lambda: sys.stdin.readline().rstrip() \nsys.setrecursionlimit(10**7)\nINF = float('inf')\ndef I(): return int(input())\ndef F(): return float(input())\ndef SS(): return input()\ndef LI(): return [int(x) for x in input().split()]\ndef LI_(): return [int(x)-1 for x in input().split()]\ndef LF(): return [float(x) for x in input().split()]\ndef LSS(): return input().split()\n\ndef resolve():\n N, M = LI()\n p = LI_()\n G = [[] for _ in range(N)]\n for _ in range(M):\n x, y = LI_()\n G[x].append(y)\n G[y].append(x)\n # print(G)\n\n visited = [False] * N\n def dfs(c, tmp):\n visited[c] = True\n tmp.append(c)\n for n in G[c]:\n if not visited[n]:\n dfs(n, tmp)\n\n # \u9023\u7d50\u6210\u5206\u5185\u306fswap\u3067\u81ea\u7531\u306a\u4f4d\u7f6e\u306b\u79fb\u52d5\u53ef\u80fd\n c = []\n for i in range(N):\n if not visited[i]:\n tmp = []\n dfs(i, tmp)\n c.append(tmp)\n # print(c)\n\n ans = sum([len({p[j] for j in i} & set(i)) for i in c])\n print(ans)\n\n\n\ndef __starting_point():\n resolve()\n\n__starting_point()", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nN, M = map(int, input().split())\nPs = [0] + list(map(int, input().split()))\n\nuf = UnionFind(N+1)\n\nfor _ in range(M):\n x, y = map(int, input().split())\n uf.union(x, y)\n\nrlt = 0\nfor i in range(1,N+1):\n if uf.find(i) == uf.find(Ps[i]):\n rlt += 1\n \nprint(rlt)", "N, M = list(map(int, input().split()))\np = list(map(int, input().split()))\n\npairs = [list(map(int, input().split())) for _ in range(M)]\n\n\nclass UnionFind:\n def __init__(self, n):\n self.par = [i for i in range(n + 1)]\n\n def root(self, x):\n if self.par[x] == x:\n return x\n self.par[x] = self.root(self.par[x])\n return self.par[x]\n\n def union(self, x, y):\n x = self.root(x)\n y = self.root(y)\n if x == y:\n return\n self.par[x] = y\n\n def check(self, x, y):\n return self.root(x) == self.root(y)\n\n\nu = UnionFind(N)\n\nfor x, y in pairs:\n u.union(x, y)\n\nans = 0\nfor j in range(1, N + 1):\n if u.check(p[j - 1], j):\n ans += 1\nprint(ans)\n", "def read_values(): return list(map(int, input().split()))\ndef read_index(): return [int(x) - 1 for x in input().split()]\ndef read_list(): return list(read_values())\ndef read_lists(N): return [read_list() for n in range(N)]\n\n\nclass UF:\n def __init__(self, N):\n self.state = [-1] * N\n self.rank = [0] * N\n self.num_group = N\n \n def get_parent(self, a):\n p = self.state[a]\n if p < 0:\n return a\n \n q = self.get_parent(p)\n self.state[a] = q\n return q\n\n def make_pair(self, a, b):\n pa = self.get_parent(a)\n pb = self.get_parent(b)\n if pa == pb:\n return\n\n if self.rank[pa] > self.rank[pb]:\n pa, pb = pb, pa\n a, b = b, a\n elif self.rank[pa] == self.rank[pb]:\n self.rank[pb] += 1\n\n self.state[pb] += self.state[pa]\n self.state[pa] = pb\n self.state[a] = pb\n self.num_group -= 1\n \n def is_pair(self, a, b):\n return self.get_parent(a) == self.get_parent(b)\n\n def get_size(self, a):\n return -self.state[self.get_parent(a)]\n\n\nN, M = read_values()\nA = read_list()\nuf = UF(N)\nfor _ in range(M):\n i, j = read_index()\n uf.make_pair(A[i] - 1, A[j] - 1)\n\nres = 0\nfor i, a in enumerate(A):\n if uf.is_pair(i, A[i] - 1):\n res += 1\n\nprint(res)\n", "n, m = map(int, input().split())\npn = list(map(lambda x:int(x)-1, input().split()))\nls = [-1] * n\nfor i in pn:\n ls[pn[i]] = i\npar = [i for i in range(n)]\ndef find(x):\n if par[x] == x:\n return x\n else:\n s = find(par[x])\n par[x] = s\n return s\ndef unite(x,y):\n s = find(x)\n t = find(y)\n if s>t:\n par[s] = t\n else:\n par[t] = s\nfor _ in range(m):\n x, y = map(lambda x:int(x)-1, input().split())\n unite(ls[x],ls[y])\nans2 = 0\nfor i in range(n):\n if find(i)==find(ls[i]):\n ans2+=1\nprint(ans2)", "class UnionFind(object):\n def __init__(self, n=1):\n self.par = [i for i in range(n)]\n self.rank = [0 for _ in range(n)]\n self.size = [1 for _ in range(n)]\n\n def find(self, x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x != y:\n if self.rank[x] < self.rank[y]:\n x, y = y, x\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n self.par[y] = x\n self.size[x] += self.size[y]\n\n def is_same(self, x, y):\n return self.find(x) == self.find(y)\n\n def get_size(self, x):\n x = self.find(x)\n return self.size[x]\n\n\nN, M = map(int, input().split())\np = list(map(int, input().split()))\n\nuf = UnionFind(N)\n\nfor i in range(M):\n x, y = map(int, input().split())\n uf.union(p[x-1]-1, p[y-1]-1)\n\nans = 0\nfor i in range(N):\n if uf.is_same(p[i]-1, i):\n ans += 1\n\nprint(ans)", "ma = lambda :map(int,input().split())\nlma = lambda :list(map(int,input().split()))\nni = lambda:int(input())\nyn = lambda fl:print(\"Yes\") if fl else print(\"No\")\nimport collections\nimport math\nimport itertools\nimport heapq as hq\n\nclass unionfind():\n def __init__(self,n):\n self.par = list(range(n))\n self.size = [1]*n\n self.rank = [0]*n\n\n def root(self,x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.root(self.par[x])\n return self.par[x]\n\n def same(self,x,y):\n return self.root(x) == self.root(y)\n\n def unite(self,x,y):\n x = self.root(x)\n y = self.root(y)\n if x==y:return\n else:\n if self.rank[x] < self.rank[y]:\n x,y = y,x\n if self.rank[x] == self.rank[y]:\n self.rank[x]+=1\n self.par[y] = x\n self.size[x] +=self.size[y]\n def get_size(self,x):\n x = self.root(x)\n return self.size[x]\nn,m = ma()\nP = lma()\nuf = unionfind(n+1)\nfor i in range(m):\n x,y = ma()\n uf.unite(x,y)\nans = 0\nfor i in range(n):\n if uf.same(i+1,P[i]):\n ans+=1\nprint(ans)\n", "class UnionFind:\n def __init__(self, n):\n self.par = [i for i in range(n+1)]\n self.rank = [0] * (n+1)\n\n # \u691c\u7d22\n def find(self, x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n\n # \u4f75\u5408\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if self.rank[x] < self.rank[y]:\n self.par[x] = y\n else:\n self.par[y] = x\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n\n # \u540c\u3058\u96c6\u5408\u306b\u5c5e\u3059\u308b\u304b\u5224\u5b9a\n def same_check(self, x, y):\n return self.find(x) == self.find(y)\n\nN,M=list(map(int,input().split()))\n\nS=list(map(int,input().split()))\n\nans=0\nTA=[]\nTB=[]\nfor i in range(M):\n a,b=list(map(int,input().split()))\n TA.append(a)\n TB.append(b)\n\nuni=UnionFind(N)\nfor i in range(M):\n uni.union(TA[i],TB[i])\n\n \nfor i in range(N):\n if uni.same_check(i+1,S[i])==True:\n ans+=1\n #print(\"mohu\",i)\n \n \n \n \nprint(ans)\n", "from collections import defaultdict\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n \nN, M = list(map(int,input().split()))\nuf = UnionFind(N)\np = list(map(int,input().split()))\n\nfor _ in range(M):\n x, y = list(map(int,input().split()))\n x -= 1; y -= 1;\n uf.union(x, y)\n\nans = 0\nfor i in range(N):\n if uf.same(i, p[i]-1):\n ans += 1\n \nprint(ans)\n\n \n \n", "from collections import defaultdict,deque\nimport sys,heapq,bisect,math,itertools,string,queue,datetime\ndef inpl(): return list(map(int, input().split()))\ndef inpl_s(): return list(input().split())\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nN, M = map(int, input().split())\np = inpl()\nuf = UnionFind(N)\nfor i in range(M):\n x, y = map(int, input().split())\n x -= 1\n y -= 1\n uf.union(x, y)\n\nans = 0\nfor i in range(N):\n if uf.same(p[i]-1,i):\n ans += 1\n\nprint(ans)", "n, m = map(int, input().split())\npn = list(map(lambda x:int(x)-1, input().split()))\nls = [-1] * n\nfor i in pn:\n ls[pn[i]] = i\n#print(ls)\n\npar = [i for i in range(n)]\n\ndef find(x):\n if par[x] == x:\n return x\n else:\n s = find(par[x])\n par[x] = s\n return s\n\ndef unite(x,y):\n s = find(x)\n t = find(y)\n if s>t:\n par[s] = t\n else:\n par[t] = s\n\n\nfor _ in range(m):\n x, y = map(lambda x:int(x)-1, input().split())\n unite(ls[x],ls[y])\n\nans2 = 0\nfor i in range(n): \n place1 = i\n place2 = ls[i]\n\n if find(place1)==find(place2):\n ans2+=1\nprint(ans2)", "n,m=map(int,input().split())\n*p,=map(int,input().split())\np=[z-1 for z in p]\nes=[[] for _ in range(n)]\nfor _ in range(m):\n x,y=map(int,input().split())\n es[x-1].append(y-1)\n es[y-1].append(x-1)\n\ngroup=[-1]*n\nlast=-1\nfor i in range(n):\n if group[i]==-1:\n last+=1\n group[i]=last\n stack=[i]\n while stack:\n j=stack.pop()\n for e in es[j]:\n if group[e]==-1:\n stack.append(e)\n group[e]=last\ngroupset=set(group)\ngroup1=[[] for g in groupset]\ngroup2=[[] for g in groupset]\n\nfor i in range(n):\n group1[group[i]].append(i)\n group2[group[i]].append(p[i])\n\nans=0\nfor g in groupset:\n ans+=len(set(group1[g])&set(group2[g]))\nprint(ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.root = [-1]*(n+1)\n self.rnk = [0]*(n+1)\n def find(self, x):\n if(self.root[x] < 0):\n return x\n else:\n self.root[x] = self.find(self.root[x])\n return self.root[x]\n def unite(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if(x == y):return \n elif(self.rnk[x] > self.rnk[y]):\n self.root[x] += self.root[y]\n self.root[y] = x\n else:\n self.root[y] += self.root[x]\n self.root[x] = y\n if(self.rnk[x] == self.rnk[y]):\n self.rnk[y] += 1\n def same(self, x, y):\n return self.find(x) == self.find(y)\nn,m=map(int,input().split())\np=[0]+list(map(int,input().split()))\nuf=UnionFind(n)\nfor _ in range(m):\n a,b=map(int,input().split())\n uf.unite(a,b)\ncnt=0\nfor i,j in enumerate(p):\n if uf.same(i,j):cnt+=1\nprint(cnt-1)", "n,m=list(map(int,input().split()))\na=list(map(int,input().split()))\ns=[[] for i in range(n)]\nfor i in range(m):\n inp=list(map(int,input().split()))\n s[inp[0]-1].append(inp[1]-1)\n s[inp[1]-1].append(inp[0]-1)\nc=0\nd=[0 for i in range(n)]\nfor i in range(n):\n if d[i]:\n continue\n c+=1\n d[i]=c\n st=s[i]\n while st:\n ns=[]\n for j in st:\n if d[j]:\n continue\n d[j]=c\n ns+=s[j]\n st=ns\nc=0\nfor i in range(n):\n if d[i]==d[a[i]-1]:\n c+=1\nprint(c)", "N,M=map(int,input().split())\np=[0]+list(map(int,input().split()))\nxy=[list(map(int,input().split())) for i in range(M)]\nli=[[] for i in range(N+1)]\nfor i in range(M):\n li[xy[i][0]].append(xy[i][1])\n li[xy[i][1]].append(xy[i][0])\nlis=[0]*(N+1)\nma=0\nfor i in range(1,N+1):\n if lis[i]==0:\n deque=[i]\n lis[i]=i\n ma=i\n while deque:\n x=deque.pop(0)\n for j in li[x]:\n if lis[j]==0:\n lis[j]=i\n deque.append(j)\nlit=[[] for i in range(ma)]\nlif=[[] for i in range(ma)]\nfor i in range(1,N+1):\n lit[lis[i]-1].append(i)\n lif[lis[i]-1].append(p[i])\nans=0\nfor i in range(ma):\n ans+=len(set(lit[i])&set(lif[i]))\nprint(ans)", "n,m=map(int,input().split())\nP=[i-1 for i in list(map(int,input().split()))]\n\nclass UnionFind():\n def __init__(self,num):\n self.n = num #class\u5185\u5909\u6570n\u306b\u3001\u5916\u90e8\u304b\u3089\u5165\u529b\u3057\u305f\u5024num\u3092\u4ee3\u5165\n self.parents = [-1 for i in range(self.n)]\n #parents\u306f\u8981\u7d20\u306e\u89aa(1\u3053\u4e0a\u306e\u3084\u3064)\u756a\u53f70~n-1\u3092\u683c\u7d0d\u3001\u81ea\u5206\u304c\u6700\u89aa\u306a\u3089-(\u8981\u7d20\u6570)\u3092\u683c\u7d0d(\u521d\u671f\u5024\u306f-1)\n\n #x\u306e\u6700\u89aa\u306f\u8ab0\uff1f\n def find(self,x):\n if self.parents[x]<0:\n return x\n else:\n self.parents[x]=self.find(self.parents[x]) #\u518d\u5e30\u3057\u30661\u756a\u4e0a\u307e\u3067\u3044\u3063\u3066\u308b\n #\u8abf\u3079\u306a\u304c\u3089parents\u306e\u5024\u3092\u66f4\u65b0\u3057\u3066\u308b\uff01\uff08\u7d4c\u8def\u5727\u7e2e\uff09\n return self.parents[x]\n\n #\u7d50\u5408\u305b\u3088\n #x\u306e\u89aa\u3068y\u306e\u89aa\u3092\u304f\u3063\u3064\u3051\u308b\n def union(self,x,y):\n xx=self.find(x) #xx\u306fx\u306e\u6700\u89aa\n yy=self.find(y) #yy\u306fy\u306e\u6700\u89aa\n if xx==yy:\n return #\u540c\u3058\u5c4b\u6839\u306e\u4e0b\u306b\u3042\u3063\u305f\u5834\u5408\u306f\u4f55\u3082\u3057\u306a\u3044\n else:\n size_xx=abs(self.parents[xx]) #x\u304c\u542b\u307e\u308c\u308b\u6728\u306e\u30b5\u30a4\u30ba\n size_yy=abs(self.parents[yy]) #y\u304c\u542b\u307e\u308c\u308b\u6728\u306e\u30b5\u30a4\u30ba\n if size_xx>size_yy:\n xx,yy=yy,xx #yy\u306e\u65b9\u304c\u5927\u304d\u3044\u6728\u3001\u3063\u3066\u3053\u3068\u306b\u3059\u308b\n\n self.parents[yy]+=self.parents[xx] #\u5927\u304d\u3044\u6728\u306e\u30b5\u30a4\u30ba\u66f4\u65b0\n self.parents[xx]=yy #\u30b5\u30a4\u30ba\u304c\u5c0f\u3055\u3044\u6728\u3092\u5927\u304d\u3044\u6728\u306b\u63a5\u3050\n\n #x\u306e\u5c5e\u3059\u308b\u6728\u306e\u5927\u304d\u3055\uff08\u307e\u3042union\u3067\u3082\u4f7f\u3063\u305f\u3051\u3069\uff09\n def size(self,x):\n xx=self.find(x)\n return abs(self.parents[xx])\n\n #x\u3068y\u306f\u3053\u306e\u7a7a\u306e\u7d9a\u304f\u5834\u6240\u306b\u3044\u307e\u3059\u304b\u3000\u3044\u3064\u3082\u306e\u3088\u3046\u306b\u7b11\u9854\u3067\u3044\u3066\u304f\u308c\u307e\u3059\u304b\u3000\u4eca\u306f\u305f\u3060\u305d\u308c\u3092\u9858\u3044\u7d9a\u3051\u308b\n def same(self,x,y):\n return 1 if self.find(x)==self.find(y) else 0\n\n #x\u3068\u3000\u540c\u3058\u6728\u306b\u3044\u308b\u3000\u30e1\u30f3\u30d0\u30fc\u306f\uff1f\n def members(self,x):\n xx=self.find(x)\n return [i for i in range(self.n) if self.find(i)==xx]\n #if\u306e\u6761\u4ef6\u5f0f\u306b\u6f0f\u308c\u305f\u3089\u7121\u8996\n\n #\u6700\u89aa\u3060\u3051\u3092\u4e26\u3079\u3042\u3052\u308b\n def roots(self):\n return [i for i,x in enumerate(self.parents) if x < 0]\n #\u3044\u3084\u3053\u308c\u306f\u5929\u624d\u3059\u304e\u308b\u3001basis\u306eenumerate.py\u53c2\u7167\n\n #\u3059\u3079\u3066\u306e\u6700\u89aa\u306b\u3064\u3044\u3066\u3001\u30e1\u30f3\u30d0\u30fc\u3092\u8f9e\u66f8\u3067\n def all_group_members(self):\n return {r:self.members(r) for r in self.roots()}\n\n #\u30b0\u30eb\u30fc\u30d7\u5206\u3051\u3069\u3046\u306a\u308a\u307e\u3057\u305f\u304b\u3001\uff12\u91cd\u30ea\u30b9\u30c8\u3067\n def state_grouping(self):\n return list(self.all_group_members().values())\n\n\nuf=UnionFind(n)\nfor i in range(m):\n a,b=map(int,input().split())\n a-=1;b-=1\n uf.union(a,b)\nans=0\nfor i in range(n):\n ans+= uf.same(i,P[i])\nprint(ans)", "class UnionFindTree:\n def __init__(self, n):\n self.nodes = [-1] * n #\u6839\u306b\u30b5\u30a4\u30ba\u3092\u8ca0\u306e\u5024\u3067\u683c\u7d0d\u3059\u308b\u3002\n def find(self, i):\n if self.nodes[i] < 0: #\u5024\u304c\u8ca0\u306e\u5834\u5408\u306f\u6839\n return i\n else:\n self.nodes[i] = self.find(self.nodes[i]) #\u7e2e\u7d04\n return self.nodes[i]\n\n def union(self, i, j):\n i = self.find(i)\n j = self.find(j)\n if i == j:\n return\n if self.nodes[i] > self.nodes[j]: #\u30b5\u30a4\u30ba\u6bd4\u8f03\u3057\u3066i\u306e\u65b9\u304c\u30b5\u30a4\u30ba\u304c\u5927\u304d\u3044\u3088\u3046\u306b\u3059\u308b\n i, j = j, i\n self.nodes[i] += self.nodes[j] #\u5927\u304d\u3044\u65b9\u306b\u5c0f\u3055\u3044\u65b9\u3092\u7d71\u5408\u3057\u30b5\u30a4\u30ba\u3092\u767b\u9332\u3059\u308b\u3002\n self.nodes[j] = i # j\u306e\u89aa\u306fi\n \n def size(self, i): # \u6240\u5c5e\u3059\u308b\u96c6\u5408\u306e\u5927\u304d\u3055\u3092\u8fd4\u3059\n i = self.find(i)\n return -self.nodes[i]\n\nn, m = list(map(int, input().split()))\np = list([int(x) - 1 for x in input().split()])\nuft = UnionFindTree(n)\nfor _ in range(m):\n x, y = [int(x) - 1 for x in input().split()]\n uft.union(x, y)\n\nans = 0\nfor i in range(n):\n if uft.find(p[i]) == uft.find(i):\n ans += 1\nprint(ans)\n", "n,m=map(int,input().split())\nP=[int(i) for i in input().split()]\n\nuf=[i for i in range(n+1)]\ndef ufuf(x):\n while x!=uf[x]:\n x=uf[x]\n return x\n\nfor i in range(m):\n x,y=map(int,input().split())\n if ufuf(x)<ufuf(y):\n uf[ufuf(y)]=ufuf(x)\n else:\n uf[ufuf(x)]=ufuf(y)\n\nans=0\nfor i in range(1,n+1):\n if ufuf(i)==ufuf(P[i-1]):\n ans+=1\nprint(ans)", "import sys\ndef input(): return sys.stdin.readline().strip()\ndef mapint(): return map(int, input().split())\nsys.setrecursionlimit(10**9)\n\nN, M = mapint()\nPs = [p-1 for p in list(mapint())]\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\nuf = UnionFind(N)\nfor _ in range(M):\n x, y = mapint()\n uf.union(x-1, y-1)\n\nroots = uf.roots()\nroot_set = [set() for _ in range(N)]\n\nfor i in range(N):\n root_set[uf.find(i)].add(i)\n\nans = 0\nfor i in range(N):\n p = Ps[i]\n if p in root_set[uf.find(i)]:\n ans += 1\nprint(ans)", "class Unionfind(): # Unionfind\n def __init__(self, N):\n self.N = N\n self.parents = [-1] * N\n\n def find(self, x): # \u30b0\u30eb\u30fc\u30d7\u306e\u6839\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y): # \u30b0\u30eb\u30fc\u30d7\u306e\u4f75\u5408\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def groups(self): # \u5168\u3066\u306e\u30b0\u30eb\u30fc\u30d7\u3054\u3068\u306e\u8981\u7d20\n members_dict = {i: set() for i, x in enumerate(self.parents) if x < 0}\n for i in range(self.N):\n members_dict[self.find(i)].add(i)\n return members_dict\n\n\nn, m = list(map(int, input().split()))\np = list(map(int, input().split()))\nxy = [list(map(int, input().split())) for _ in range(m)]\n\nuf = Unionfind(n)\nfor x, y in xy:\n uf.union(x - 1, y - 1)\n\nans = 0\nfor lst in list(uf.groups().values()):\n ans += sum((p[num] - 1 in lst) for num in lst)\nprint(ans)\n", "class UnionFind:\n def __init__(self, N):\n self.par=[i for i in range(N)]\n self.rank=[0 for _ in range(N)]\n self.size=[1 for _ in range(N)]\n \n def unite(self, x, y):\n x=self.getroot(x)\n y=self.getroot(y)\n if x!=y:\n if self.rank[x]<self.rank[y]:\n x, y=y, x\n if self.rank[x]==self.rank[y]:\n self.rank[x]+=1\n self.par[y]=x\n self.size[x]+=self.size[y]\n \n def united(self, x, y):\n return self.getroot(x)==self.getroot(y)\n \n def getroot(self, x):\n if self.par[x]==x:\n return x\n else:\n self.par[x]=self.getroot(self.par[x])\n return self.par[x]\n\n def getsize(self, x):\n return self.size[self.getroot(x)]\n \n\nN, M=map(int, input().split())\nUF=UnionFind(N+1)\np=[0]+list(map(int, input().split()))\nfor _ in range(M):\n x, y=map(int, input().split())\n UF.unite(x, y)\n \nprint(sum([1 for i in range(1, N+1) if UF.getroot(i)==UF.getroot(p[i])]))", "N,M=map(int,input().split())\n*P,=map(int,input().split())\nxy=[list(map(int,input().split()))for _ in range(M)]\n\nR=[-1]*(N+1)\ndef root(x):\n while R[x]>=0:\n x=R[x]\n return x\ndef union(x,y):\n x=root(x)\n y=root(y)\n if x==y:\n return\n if R[x]>R[y]:\n x,y=y,x\n R[x]+=R[y]\n R[y]=x\n\nfor x,y in xy:\n union(x,y)\nans=sum(root(i+1)==root(P[i])for i in range(N))\nprint(ans)", "import sys\n\ninput = sys.stdin.readline\n\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def all_group_members(self):\n d = {root: [] for root in self.roots()}\n for i in range(self.n):\n d[self.find(i)].append(i)\n return d\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nN, M = list(map(int, input().split()))\np = list(map(int, input().split()))\nxy = [list(map(int, input().split())) for _ in range(M)]\nuf = UnionFind(N)\n\nfor x, y in xy:\n x -= 1\n y -= 1\n uf.union(x, y)\n\nans = 0\nfor renketu_seibun in list(uf.all_group_members().values()):\n can_reach = set([p[v]-1 for v in renketu_seibun])\n for v in renketu_seibun:\n ans += v in can_reach\nprint(ans)\n", "n,m=map(int,input().split())\np=[[0]]+[[int(i)]for i in input().split()]\nq=[[i]for i in range(n+1)]\npar=[i for i in range(n+1)]\ndef find(x):\n if x==par[x]:\n return x\n else:\n par[x]=find(par[x])\n return par[x]\ndef unite(x,y):\n x,y=find(x),find(y)\n if x>y:x,y=y,x\n if x!=y:\n par[y]=x\n p[x]+=p[y]\n q[x]+=q[y]\nfor _ in range(m):\n a,b=map(int,input().split())\n unite(a,b)\nfor i in range(n):find(i)\nans=-1\nfor i in set(par):\n ans+=len(set(p[i])&set(q[i]))\nprint(ans)", "N,M=map(int,input().split())\n*P,=map(int,input().split())\nxy=[list(map(int,input().split()))for _ in range(M)]\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nuf=UnionFind(N)\nfor x,y in xy:\n uf.union(x-1,y-1)\nans=sum(uf.same(i,P[i]-1)for i in range(N))\nprint(ans)", "import sys\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\nclass DisjointSet:\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n\nN, M = list(map(int, input().split()))\nP = list([int(x) - 1 for x in input().split()])\nds = DisjointSet(N)\nfor _ in range(M):\n x, y = [int(x) - 1 for x in input().split()]\n ds.union(x, y)\nprint((sum(ds.same(P[i], i) for i in range(N))))\n", "n,m=list(map(int,input().split()))\np=list(map(int,input().split()))\nfrom collections import defaultdict\nfrom collections import deque\nc=0\nfor i in range(n):\n if p[i]==i+1:\n c+=1\nvis=[0]*n\ndef dfs(x):\n vis[x]=1\n a.add(x+1)\n \n di = deque()\n di.append(x)\n while di:\n now = di.popleft()\n for j in d[now]:\n if not vis[j]:\n vis[j] = 1\n a.add(j+1)\n di.append(j)\n \n \n for u in d[x]:\n if vis[u]==0:\n dfs(u)\nd=defaultdict(list)\nfor i in range(m):\n a,b=list(map(int,input().split()))\n d[a-1].append(b-1)\n d[b-1].append(a-1)\nans=0\nfor i in range(n):\n if vis[i]==0:\n a=set()\n dfs(i)\n l=0\n z=0\n for j in a:\n if p[j-1] in a:\n z+=1\n if p[j-1]==j:\n l+=1\n ans=max(ans,c+z-l)\nprint(ans)\n \n \n \n \n \n \n", "import sys\n\ninput = sys.stdin.readline\nN, M = map(int, input().split())\nP = list(map(int, input().split()))\n\nedges = [[] for _ in range(N)]\nfor _ in range(M):\n x, y = map(int, input().split())\n edges[x-1].append(y-1)\n edges[y-1].append(x-1)\n\n\nans = 0\nvisited = set()\nfor i in range(N):\n q = [i]\n loop = set()\n values = set()\n while q:\n x = q.pop()\n if x in visited:\n continue\n visited.add(x)\n loop.add(x+1)\n values.add(P[x])\n\n for nx in edges[x]:\n if nx not in visited:\n q.append(nx)\n\n ans += len(loop & values)\n\nprint(ans)", "from collections import Counter\n\nclass Unionfind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * (n+1)\n \n def find(self, x):\n if(self.parents[x] < 0):\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n \n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n \n if(x == y):\n return\n \n if(self.parents[x] > self.parents[y]):\n x, y = y, x\n \n self.parents[x] += self.parents[y]\n self.parents[y] = x\n \n def size(self, x):\n return -self.parents[self.find(x)]\n \n def same(self, x, y):\n return self.find(x) == self.find(y)\n \n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n \n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n \n def group_count(self):\n return len(self.roots())\n \n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n \n def __str__(self):\n return '\\n'.join('{}:{}'.format(r, self.members(r)) for r in self.roots())\n\nN, M = map(int, input().split())\np = list(map(int, input().split()))\n\nuf = Unionfind(N)\n\nfor i in range(M):\n x, y = map(int, input().split())\n uf.union(x-1, y-1)\n\ncnt = sum(uf.same(p[i]-1, i) for i in range(N))\nprint(cnt)", "#!/usr/bin/env python3\nimport sys\n\n\ndef input():\n return sys.stdin.readline().rstrip()\n\n\nclass UnionFind:\n def __init__(self, n):\n self.parents = [i for i in range(n + 1)]\n self.rank = [0] * (n + 1)\n\n def find(self, x):\n if self.parents[x] == x:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if self.rank[x] < self.rank[y]:\n self.parents[x] = y\n else:\n self.parents[y] = x\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n\ndef main():\n N, M = list(map(int, input().split()))\n P = list([int(x) - 1 for x in input().split()])\n XY = [list([int(x) - 1 for x in input().split()]) for _ in range(M)]\n\n value_to_index = [0] * N\n for i, p in enumerate(P):\n value_to_index[p] = i\n\n uf = UnionFind(N)\n for x, y in XY:\n uf.union(x, y)\n\n ans = 0\n for i in range(N):\n if uf.find(i) == uf.find(value_to_index[i]):\n ans += 1\n\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import deque\nN,M = map(int,input().split())\nP = list(map(int,input().split()))\nP.insert(0,0)\nG = {i:[] for i in range(1,N+1)}\nfor _ in range(M):\n x,y = map(int,input().split())\n G[x].append(y)\n G[y].append(x)\ncol = [-1 for _ in range(N+1)]\ncnt = 0\nfor i in range(1,N+1):\n if col[i]<0:\n col[i]=cnt\n que = deque([i])\n while que:\n x = que.popleft()\n for y in G[x]:\n if col[y]<0:\n col[y]=cnt\n que.append(y)\n cnt += 1\nC = {c:[] for c in range(cnt)}\nfor i in range(1,N+1):\n C[col[i]].append(i)\nB = {c:[] for c in range(cnt)}\nfor c in C:\n for i in C[c]:\n B[c].append(P[i])\nans = 0\nfor c in C:\n a = set(C[c])\n b = set(B[c])\n ans += len(a&b)\nprint(ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nN, M = list(map(int, input().split()))\nuf = UnionFind(N+1)\np_list = list(map(int, input().split()))\n\nfor i in range(M):\n x, y = list(map(int, input().split()))\n uf.union(x, y)\n\nans = 0\nfor i in range(N):\n if uf.find(p_list[i]) == uf.find(i+1):\n ans += 1\nprint(ans)\n", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.root = [-1]*(n+1)\n self.rnk = [0]*(n+1)\n\n def find_root(self, x):\n if(self.root[x] < 0):\n return x\n else:\n self.root[x] = self.find_root(self.root[x])\n return self.root[x]\n \n def unite(self, x, y):\n x = self.find_root(x)\n y = self.find_root(y)\n if(x == y):\n return \n elif(self.rnk[x] > self.rnk[y]):\n self.root[x] += self.root[y]\n self.root[y] = x\n else:\n self.root[y] += self.root[x]\n self.root[x] = y\n if(self.rnk[x] == self.rnk[y]):\n self.rnk[y] += 1\n \n def is_same_group(self, x, y):\n return self.find_root(x) == self.find_root(y)\n\n def count(self, x):\n return -self.root[self.find_root(x)]\n\n \nf=lambda:map(int,input().split())\nN,M=f()\nuf=UnionFind(N+1)\n\np=list(f())\np_index=[[] for _ in [0]*(N+1)]\nfor i in range(1,N+1):\n p_index[p[i-1]]=i\nfor _ in [0]*M:\n uf.unite(*f())\n\n\nindex_list=[[] for _ in [0]*(N+1)]\ngroup_list=[[] for _ in [0]*(N+1)]\n\nfor i in range(1,N+1):\n index_list[uf.find_root(i)].append(p_index[i])\n group_list[uf.find_root(i)].append(i)\n \nres=0\nfor i in range(1,N+1):\n if i==uf.find_root(i):\n res+=len(set(index_list[i]) & set(group_list[i]))\n\nprint(res)", "import bisect\nimport heapq\nimport itertools\nimport sys\nimport math\nimport random\nimport time\nfrom collections import Counter, deque, defaultdict\nfrom functools import reduce\nfrom operator import xor\nfrom types import FunctionType\nfrom typing import List\n\nmod = 10 ** 9 + 7\nsys.setrecursionlimit(10 ** 9)\n\n\ndef lmi():\n return list(map(int, input().split()))\n\n\ndef narray(*shape, init=0):\n if shape:\n num = shape[0]\n return [narray(*shape[1:], init=init) for _ in range(num)]\n return init\n\n\nclass UnionFind:\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n for i in range(self.n):\n if self.find(i) == root:\n yield i\n\n def roots(self):\n for i, x in enumerate(self.parents):\n if x < 0:\n yield i\n\n def group_count(self):\n return len(list(self.roots()))\n\n def all_group_members(self):\n ret = defaultdict(list)\n for i in range(self.n):\n root = self.find(i)\n ret[root].append(i)\n return ret\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, list(members)) for r, members in self.all_group_members())\n\n\ndef main():\n N, M = lmi()\n P = lmi()\n XY = [lmi() for _ in range(M)]\n uf = UnionFind(N)\n for x, y in XY:\n x, y = x - 1, y - 1\n uf.union(P[x] - 1, P[y] - 1)\n ans = 0\n for i in range(N):\n ans += uf.same(P[i] - 1, i)\n print(ans)\n\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "class UnionFind:\n # \u3053\u306e\u6642\u70b9\u3067\u305d\u308c\u305e\u308c\u306e\u30ce\u30fc\u30c9\u306f\u81ea\u5206\u3092\u89aa\u3068\u3057\u3066\u3044\u308b\n # \u521d\u671f\u5316\u6642\u306b\u554f\u984c\u304c0\u306e\u9802\u70b9\u3092\u8a8d\u3081\u308b\u304b\u306b\u6ce8\u610f\u3059\u308b\u3053\u3068\n def __init__(self, n):\n self.N = n\n self.parent = [i for i in range(n)]\n self.rank = [0 for _ in range(n)]\n\n # x\u306e\u6839\u3092\u8fd4\u3059\u95a2\u6570\n def root(self, x):\n visited_nodes = []\n while True:\n p = self.parent[x]\n if p == x:\n # \u7e2e\u7d04\n for node in visited_nodes:\n self.parent[node] = x\n return x\n else:\n visited_nodes.append(x)\n x = p\n\n # \u6728\u306e\u7d50\u5408\u3092\u884c\u3046\u3002\u89aa\u306e\u914d\u4e0b\u306b\u5165\u308b\n def unite(self, x, y):\n if not self.root(x) == self.root(y):\n if self.rank[x] > self.rank[y]:\n self.parent[self.root(y)] = self.root(x)\n else:\n self.parent[self.root(x)] = self.root(y)\n if self.rank[x] == self.rank[y]:\n self.rank[self.root(y)] += 1\n\n def ifSame(self, x, y):\n return self.root(x) == self.root(y)\n\n # \u6728\u306e\u6839\u306b\u5230\u9054\u3059\u307e\u3067\u306b\u305f\u3069\u308b\u30ce\u30fc\u30c9\u306e\u914d\u5217\u3092\u8fd4\u3059\n def printDebugInfo(self):\n print([self.root(i) for i in range(self.N)])\n\n\nN, M = list(map(int, input().split()))\nP = [int(x) for x in input().split()]\ntree = UnionFind(N)\nfor _ in range(M):\n X, Y = list(map(int, input().split()))\n tree.unite(X - 1, Y - 1)\n\ncount = 0\nfor i in range(N):\n if tree.ifSame(P[i]-1, i):\n count += 1\nprint(count)\n", "n,m=list(map(int,input().split()))\np=list(map(int,input().split()))\nxy=[list(map(int,input().split())) for _ in range(m)]\n\nfrom collections import defaultdict\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n group_members = defaultdict(list)\n for member in range(self.n):\n group_members[self.find(member)].append(member)\n return group_members\n\n def __str__(self):\n return '\\n'.join(f'{r}: {m}' for r, m in list(self.all_group_members().items()))\n\n\nuf=UnionFind(n)\nfor i in xy:\n uf.union(i[0]-1,i[1]-1)\n\nans=0\nfor i in range(n):\n if uf.same(i,p[i]-1):\n ans+=1\n\nprint(ans)\n", "from collections import defaultdict\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n group_members = defaultdict(list)\n for member in range(self.n):\n group_members[self.find(member)].append(member)\n return group_members\n\n def __str__(self):\n return '\\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())\n\nn, m = map(int, input().split())\np = list(map(int, input().split()))\na = [list(map(int, input().split())) for i in range(m)]\nuf = UnionFind(n)\nfor i in range(m):\n uf.union(a[i][0]-1, a[i][1]-1)\nans = 0\nfor i in range(n):\n if uf.same(p[i]-1, i):\n ans += 1\nprint(ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nn,m = list(map(int,input().split()))\nuf = UnionFind(n)\np = list(map(int,input().split()))\nfor _ in range(m):\n a,b=list(map(int,input().split()))\n a-=1\n b-=1\n uf.union(a,b)\n\npp = [set() for _ in range(n)]\nqq = [set() for _ in range(n)]\n\nfor i in range(n):\n r = uf.find(i)\n pp[r].add(i)\n qq[r].add(p[i]-1)\n\nans = 0\nfor i in range(n):\n ans += len(pp[i] & qq[i])\nprint(ans)\n", "n,m=map(int,input().split())\np=[int(i)for i in input().split()]\npar=[i for i in range(n)]\ndef find(x):\n if x==par[x]:\n return x\n else:\n par[x]=find(par[x])\n return par[x]\ndef unite(x,y):\n x,y=find(x),find(y)\n if x>y:x,y=y,x\n if x!=y:\n par[y]=x\nfor _ in range(m):\n a,b=map(int,input().split())\n unite(a-1,b-1)\nfor i in range(n):find(i)\nprint(sum(find(i)==find(p[i]-1)for i in range(n)))", "import sys\nimport queue\n\ninput_methods=['clipboard','file','key']\nusing_method=0\ninput_method=input_methods[using_method]\n\ntin=lambda : map(int, input().split())\nlin=lambda : list(tin())\nmod=1000000007\n\n#+++++\n\ndef main():\n\t#a = int(input())\n\tn, m = tin()\n\t#s = input()\n\tal = [-1]+lin()\n\tbb=[[] for _ in range(n+1)]\n\tfor _ in range(m):\n\t\ta, b = tin()\n\t\tbb[a].append(b)\n\t\tbb[b].append(a)\n\t\t\n\tll=[]\n\tis_open = [0] *(n+1)\n\tfor i in range(n+1):\n\t\tq=queue.Queue()\n\t\tq.put(i)\n\t\tt=[]\n\t\twhile not q.empty():\n\t\t\tpp=q.get()\n\t\t\tif is_open[pp] != 0:\n\t\t\t\tcontinue\n\t\t\tis_open[pp]=1\n\t\t\tt.append(pp)\n\t\t\tfor v in bb[pp]:\n\t\t\t\tq.put(v)\n\t\tll.append(t)\n\t\n\tret = 0\n\t#pa(ll)\n\tfor t in ll:\n\t\tst=set(t)\n\t\tfor v in t:\n\t\t\tif al[v] in st:\n\t\t\t\tret += 1\n\tprint(ret)\n\t\t\t\t\n\t\t\n\t\t\n\t\n\t\n\t\n\t\n\t\n#+++++\nisTest=False\n\ndef pa(v):\n\tif isTest:\n\t\tprint(v)\n\t\t\ndef input_clipboard():\n\timport clipboard\n\tinput_text=clipboard.get()\n\tinput_l=input_text.splitlines()\n\tfor l in input_l:\n\t\tyield l\n\ndef __starting_point():\n\tif sys.platform =='ios':\n\t\tif input_method==input_methods[0]:\n\t\t\tic=input_clipboard()\n\t\t\tinput = lambda : ic.__next__()\n\t\telif input_method==input_methods[1]:\n\t\t\tsys.stdin=open('inputFile.txt')\n\t\telse:\n\t\t\tpass\n\t\tisTest=True\n\telse:\n\t\tpass\n\t\t#input = sys.stdin.readline\n\t\t\t\n\tret = main()\n\tif ret is not None:\n\t\tprint(ret)\n__starting_point()", "import sys\nimport math\nimport collections\nimport bisect\nimport copy\nimport itertools\n\n# import numpy as np\n\nsys.setrecursionlimit(10 ** 7)\nINF = 10 ** 16\nMOD = 10 ** 9 + 7\n# MOD = 998244353\n\nni = lambda: int(sys.stdin.readline().rstrip())\nns = lambda: list(map(int, sys.stdin.readline().rstrip().split()))\nna = lambda: list(map(int, sys.stdin.readline().rstrip().split()))\nna1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().rstrip().split()])\n\n\n# ===CODE===\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\n\ndef main():\n n, m = ns()\n p = na1()\n\n uf = UnionFind(n)\n\n for _ in range(m):\n x, y = ns()\n uf.union(x - 1, y - 1)\n\n ans = 0\n for i, pi in enumerate(p):\n if uf.same(i, pi):\n ans += 1\n\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "class UnionFind(object):\n def __init__(self, n=1):\n self.par = [i for i in range(n)]\n self.rank = [0 for _ in range(n)]\n\n def find(self, x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x != y:\n if self.rank[x] < self.rank[y]:\n x, y = y, x\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n self.par[y] = x\n\n def is_same(self, x, y):\n return self.find(x) == self.find(y)\n\nn,m=map(int, input().split())\nuf1=UnionFind(n)\np=list(map(int,input().split()))\nfor i in range(m):\n a,b=map(int, input().split())\n uf1.union(a-1,b-1)\n\nfor i in range(n):uf1.find(i) \nans=0\nfor i in range(n):\n if uf1.par[i]==uf1.par[p[i]-1]:\n ans+=1\nprint(ans)", "class UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\ndef func(x):\n return x - 1\n\ndef main():\n N, M = map(int, input().split())\n P = list(map(func, map(int, input().split())))\n uni = UnionFind(N)\n for _ in range(M):\n x, y = map(int, input().split())\n x -= 1\n y -= 1\n uni.union(x,y)\n\n ans = 0\n for i, p in enumerate(P):\n if uni.same(i,p):\n ans += 1\n\n print(ans)\n\n\ndef __starting_point():\n main()\n__starting_point()", "N, M = list(map(int, input().split()))\np_list = list(map(int, input().split()))\nqueries = [list(map(int, input().split())) for i in range(M)]\npaths = [[] for i in range(N+1)]\nfor a, b in queries:\n paths[a].append(b)\n paths[b].append(a)\n\ngroups = []\nvisited = [False] * (N+1)\nfor start in range(N+1):\n if visited[start] == True:\n continue\n queue = [start]\n t_group = set()\n t_group.add(start)\n visited[start] = True\n while queue:\n now = queue.pop()\n for next in paths[now]:\n if visited[next] == True:\n continue\n queue.append(next)\n t_group.add(next)\n visited[next] = True\n groups.append(t_group)\n\nresult = 0\nfor group in groups[1:]: # \u30bb\u30c3\u30c8\u306e\u6700\u521d\u306f{0}\u306b\u306a\u3063\u3066\u3044\u308b\u305f\u3081\n result += sum(1 for m in group if p_list[m-1] in group)\n\nprint(result)\n\n", "class Union_Find():\n def __init__(self,N):\n \"\"\"0,1,...,n-1\u3092\u8981\u7d20\u3068\u3057\u3066\u521d\u671f\u5316\u3059\u308b.\n\n n:\u8981\u7d20\u6570\n \"\"\"\n self.n=N\n self.parents=[-1]*N\n self.rank=[0]*N\n\n def find(self, x):\n \"\"\"\u8981\u7d20x\u306e\u5c5e\u3057\u3066\u3044\u308b\u65cf\u3092\u8abf\u3079\u308b.\n\n x:\u8981\u7d20\n \"\"\"\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n \"\"\"\u8981\u7d20x,y\u3092\u540c\u4e00\u8996\u3059\u308b.\n\n x,y:\u8981\u7d20\n \"\"\"\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.rank[x]>self.rank[y]:\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n else:\n self.parents[y] += self.parents[x]\n self.parents[x] = y\n\n if self.rank[x]==self.rank[y]:\n self.rank[y]+=1\n\n def size(self, x):\n \"\"\"\u8981\u7d20x\u306e\u5c5e\u3057\u3066\u3044\u308b\u8981\u7d20\u306e\u6570.\n\n x:\u8981\u7d20\n \"\"\"\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n \"\"\"\u8981\u7d20x,y\u306f\u540c\u4e00\u8996\u3055\u308c\u3066\u3044\u308b\u304b?\n\n x,y:\u8981\u7d20\n \"\"\"\n return self.find(x) == self.find(y)\n\n def members(self, x):\n \"\"\"\u8981\u7d20x\u304c\u5c5e\u3057\u3066\u3044\u308b\u65cf\u306e\u8981\u7d20.\n \u203b\u65cf\u306e\u8981\u7d20\u306e\u500b\u6570\u304c\u6b32\u3057\u3044\u3068\u304d\u306fsize\u3092\u4f7f\u3046\u3053\u3068!!\n\n x:\u8981\u7d20\n \"\"\"\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n \"\"\"\u65cf\u306e\u540d\u524d\u306e\u30ea\u30b9\u30c8\n \"\"\"\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n \"\"\"\u65cf\u306e\u500b\u6570\n \"\"\"\n return len(self.roots())\n\n def all_group_members(self):\n \"\"\"\u5168\u3066\u306e\u65cf\u306e\u51fa\u529b\n \"\"\"\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n#================================================\nN,M=map(int,input().split())\nP=list(map(lambda x:int(x)-1,input().split()))\n\nU=Union_Find(N)\nfor _ in range(M):\n a,b=map(int,input().split())\n U.union(a-1,b-1)\n\nK=0\nfor x in range(N):\n K+=U.same(x,P[x])\nprint(K)", "N, M = map(int, input().split())\nP = list(map(int, input().split()))\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nuf = UnionFind(N)\nfor _ in range(M):\n x, y = map(int, input().split())\n uf.union(x-1, y-1)\n\nans = 0\nfor i in range(N):\n if uf.same(i, P[i]-1):\n ans += 1\n\nprint(ans)", "# unionfind\nclass Uf:\n\tdef __init__(self, N):\n\t\tself.p = list(range(N))\n\t\tself.rank = [0] * N\n\t\tself.size = [1] * N\n\t#\u691c\u7d22 \u30ce\u30fc\u30c9\u756a\u53f7\u3092\u53d7\u3051\u53d6\u3063\u3066\u4e00\u756a\u4e0a\u306e\u89aa\u30ce\u30fc\u30c9\u306e\u756a\u53f7\u3092\u5e30\u3059\n\tdef root(self, x):\n\t\tif self.p[x] != x:\n\t\t\tself.p[x] = self.root(self.p[x])\n\n\t\treturn self.p[x]\n\t#\u540c\u3058\u96c6\u5408\u306b\u5c5e\u3059\u308b\u304b\u5224\u5b9a\n\tdef same(self, x, y):\n\t\treturn self.root(x) == self.root(y)\n\t#\u4f75\u5408\n\tdef unite(self, x, y):\n\t\t# \u6839\u3092\u63a2\u3059\n\t\tu = self.root(x)\n\t\tv = self.root(y)\n\n\t\tif u == v: return\n\n\t\t#\u6728\u306e\u9ad8\u3055\u3092\u6bd4\u8f03\u3057\u3001\u4f4e\u3044\u307b\u3046\u304b\u3089\u9ad8\u3044\u307b\u3046\u306b\u8fba\u3092\u5f35\u308b\n\t\tif self.rank[u] < self.rank[v]:\n\t\t\tself.p[u] = v\n\t\t\tself.size[v] += self.size[u]\n\t\t\tself.size[u] = 0\n\t\telse:\n\t\t\tself.p[v] = u\n\t\t\tself.size[u] += self.size[v]\n\t\t\tself.size[v] = 0\n\t\t\t#\u6728\u306e\u9ad8\u3055\u304c\u540c\u3058\u306a\u3089\u7247\u65b9\u30921\u5897\u3084\u3059\n\t\t\tif self.rank[u] == self.rank[v]:\n\t\t\t\tself.rank[u] += 1\n\t#\u30ce\u30fc\u30c9\u756a\u53f7\u3092\u53d7\u3051\u53d6\u3063\u3066\u3001\u305d\u306e\u30ce\u30fc\u30c9\u304c\u542b\u307e\u308c\u3066\u3044\u308b\u96c6\u5408\u306e\u30b5\u30a4\u30ba\u3092\u8fd4\u3059\n\tdef count(self, x):\n\t\treturn self.size[self.root(x)]\n\nN, M = map(int, input().split())\nuf=Uf(N)\nP = list(map(int, input().split()))\nP=[i-1 for i in P]\nfor i in range(M):\n\tx, y = map(int, input().split())\n\tx-=1\n\ty-=1\n\tuf.unite(x,y)\n\n#\u300c\u5024i\u3092\u542b\u3080\u4f4d\u7f6ej\u3068\u4f4d\u7f6ei\u304c\u540c\u3058\u30b0\u30eb\u30fc\u30d7\u306b\u5c5e\u3057\u3066\u3044\u308b\u300d\u3068\u3044\u3046\u6761\u4ef6\u3092\u6e80\u305f\u3059i\u306e\u6570\u3092\u6570\u3048\u308b\nans=0\nfor i in range(N):\n\tif uf.root(P[i]) == uf.root(i):\n\t\tans+=1\nprint(ans)", "'''\n\u81ea\u5b85\u7528PC\u3067\u306e\u89e3\u7b54\n'''\nimport math\n#import numpy as np\nimport itertools\nimport queue\nimport bisect\nfrom collections import deque,defaultdict\nimport heapq as hpq\nfrom sys import stdin,setrecursionlimit\n#from scipy.sparse.csgraph import dijkstra\n#from scipy.sparse import csr_matrix\nipt = stdin.readline\nsetrecursionlimit(10**7)\nmod = 10**9+7\ndir = [(-1,0),(0,-1),(1,0),(0,1)]\nalp = \"abcdefghijklmnopqrstuvwxyz\"\n\n#UnionFind\u306e\u30af\u30e9\u30b9\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1] * n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n def size(self, x):\n return -self.parents[self.find(x)]\n def same(self, x, y):\n return self.find(x) == self.find(y)\n def members(self, x):\n root = self.find(x)\n return set([i for i in range(self.n) if self.find(i) == root])\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n def group_count(self):\n return len(self.roots())\n def all_group_members(self):\n return [self.members(r) for r in self.roots()]\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\n\ndef main():\n n,m = list(map(int,ipt().split()))\n p = [int(i)-1 for i in ipt().split()]\n uf = UnionFind(n)\n for i in range(m):\n x,y = list(map(int,ipt().split()))\n uf.union(x-1,y-1)\n\n ans = 0\n for i in range(n):\n if uf.same(i,p[i]):\n ans += 1\n\n print(ans)\n\n return None\n\ndef __starting_point():\n main()\n\n__starting_point()", "n, m = map(int, input().split())\npn = list(map(lambda x:int(x)-1, input().split()))\nls = [-1] * n\nfor i in pn:\n ls[pn[i]] = i\n#print(ls)\n\npar = [i for i in range(n)]\n\ndef find(x):\n if par[x] == x:\n return x\n else:\n s = find(par[x])\n par[x] = s\n return s\n\ndef unite(x,y):\n s = find(x)\n t = find(y)\n if s>t:\n par[s] = t\n else:\n par[t] = s\n\n\nfor _ in range(m):\n x, y = map(lambda x:int(x)-1, input().split())\n unite(ls[x],ls[y])\n\ndic = {}\nfor i in range(n):\n a = find(i)\n if a in dic:\n dic[a].add(ls[i])\n else:\n dic[a] = set([ls[i]])\n#print(dic)\n#print(par)\nans = 0\nfor i in range(n):\n if i in dic[find(i)]:\n ans+=1\nprint(ans)", "import sys\n\nsys.setrecursionlimit(6500)\n\ndef find(n):\n if d[n]<0:\n return n\n else:\n d[n]=find(d[n])\n return d[n]\n\ndef union(a,b):\n a=find(a)\n b=find(b)\n if a==b:return False\n if d[a]<=d[b]:\n d[a]+=d[b]\n d[b]=a\n else:\n d[b]+=d[a]\n d[a]=b\n return True\n\ndef members(n):\n p=find(n)\n ans=[]\n for i in range(N):\n if find(i)==p:\n ans.append(i)\n return ans\n\ndef same(a,b):\n if find(a)==find(b):return True\n else:return False\n\nN,M=map(int,input().split())\np=list(map(int,input().split()))\n\nd=[-1]*N\n\nfor i in range(M):\n x,y=map(int,input().split())\n x,y=x-1,y-1\n union(x,y)\n\nq=[-1]*N\nfor i in range(N):\n q[p[i]-1]=i\nans=0\nfor i in range(N):\n if same(i,q[i]):\n ans+=1\nprint(ans)", "class Unionfind(): # Unionfind\n def __init__(self, N):\n self.N = N\n self.parents = [-1] * N\n\n def find(self, x): # \u30b0\u30eb\u30fc\u30d7\u306e\u6839\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y): # \u30b0\u30eb\u30fc\u30d7\u306e\u4f75\u5408\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def groups(self): # \u5168\u3066\u306e\u30b0\u30eb\u30fc\u30d7\u3054\u3068\u306e\u8981\u7d20\n members_dict = {}\n for i in range(self.N):\n if self.find(i) not in members_dict:\n members_dict[self.find(i)] = set()\n members_dict[self.find(i)].add(i)\n return members_dict\n\n\nn, m = list(map(int, input().split()))\np = list(map(int, input().split()))\nxy = [list(map(int, input().split())) for _ in range(m)]\n\nuf = Unionfind(n)\nfor x, y in xy:\n uf.union(x - 1, y - 1)\n\nans = 0\nfor lst in list(uf.groups().values()):\n ans += sum((p[num] - 1 in lst) for num in lst)\nprint(ans)\n", "n,m=list(map(int, input().split()))\np=list([int(x)-1 for x in input().split()])\n\nclass UnionFind():\n def __init__(self, n):\n self.n = n\n self.parents = [-1]*n\n\n def find(self, x):\n if self.parents[x] < 0:\n return x\n else:\n self.parents[x] = self.find(self.parents[x])\n return self.parents[x]\n\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n if x == y:\n return\n if self.parents[x] > self.parents[y]:\n x, y = y, x\n self.parents[x] += self.parents[y]\n self.parents[y] = x\n\n def size(self, x):\n return -self.parents[self.find(x)]\n\n def is_same(self, x, y):\n return self.find(x) == self.find(y)\n\n def roots(self):\n return [i for i, x in enumerate(self.parents) if x < 0]\n\n def members(self, x):\n root = self.find(x)\n return [i for i in range(self.n) if self.find(i) == root]\n\n def group_count(self):\n return len(self.roots())\n\n def all_group_members(self):\n return {r: self.members(r) for r in self.roots()}\n\n def __str__(self):\n return '\\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())\n\nuf=UnionFind(n)\nfor _ in range(m):\n x,y=[int(x)-1 for x in input().split()]\n uf.union(x,y)\n\nans=0\nfor i in range(len(p)):\n if uf.is_same(i, p[i]):\n ans+=1\nprint(ans)\n", "import sys\nstdin=sys.stdin\n\nip=lambda: int(sp())\nfp=lambda: float(sp())\nlp=lambda:list(map(int,stdin.readline().split()))\nsp=lambda:stdin.readline().rstrip()\nyp=lambda:print('Yes')\nnp=lambda:print('No')\n\nfrom collections import Counter\n\nclass union_find():\n def __init__(self,n):\n self.n=n\n ##\u89aa\u8981\u7d20\u306e\u30ce\u30fc\u30c9\u756a\u53f7\u3092\u683c\u7d0d\u3002par[x]==x\u306e\u3068\u304d\u305d\u306e\u30ce\u30fc\u30c9\u306f\u6839\n ##\u89aa\u3068\u306f\u305d\u306e\u4e0a\u306b\u30ce\u30fc\u30c9\u306a\u3057\uff01\uff01\u3000\n self.par=[-1 for i in range(n)]\n self.rank=[0]*(n)\n\n def find(self,x):\n if self.par[x]<0:\n return x\n else:\n self.par[x]=self.find(self.par[x])\n \n return self.par[x]\n\n def union(self,x,y):\n x=self.find(x)\n y=self.find(y)\n\n ##\u6728\u306e\u9ad8\u3055\u3092\u6bd4\u8f03\u3057\u3001\u4f4e\u3044\u65b9\u304b\u3089\u9ad8\u3044\u65b9\u3078\u8fba\u3092\u306f\u308b\n if x==y:\n return\n\n if self.par[x]>self.par[y]:\n x,y=y,x\n \n self.par[x]+=self.par[y]\n self.par[y]=x\n\n def same(self,x,y):\n return self.find(x) == self.find(y)\n \n def size(self,x):\n return -self.par[self.find(x)]\n \n def members(self,x):\n root=self.find(x)\n return [i for i in range(self.n) if self.find(i)==root]\n \n def roots(self):\n return [i for i, x in enumerate(self.par) if x<0]\n \n def all_group_member(self):\n return {r:self.members(r) for r in self.roots()}\n \nn,m=lp()\na=lp()\nuf=union_find(n)\nfor _ in range(m):\n x,y=lp()\n uf.union(x-1,y-1)\n \nans=0\nfor i in range(n):\n now=a[i]-1\n if uf.same(i,now):\n ans+=1\n\nprint(ans)", "n,m=list(map(int,input().split()))\np=list(map(int,input().split()))\nnum=[[] for _ in range(n)]\nfor i in range(m):\n x,y=list(map(int,input().split()))\n num[x-1].append(y)\n num[y-1].append(x)\nseen=[False]*n\nans=list(range(n))\nfor i in range(n):\n if seen[i]==False:\n queue=[i]\n seen[i]=True\n for j in range(n):\n if len(queue)==0:\n break\n num1=queue.pop()\n ans[num1]=i\n for k in range(len(num[num1])):\n num2=num[num1][k]-1\n if seen[num2]==False:\n queue.append(num2)\n seen[num2]=True\nans2=0\nfor i in range(n):\n if ans[i]==ans[p[i]-1]:\n ans2+=1\nprint(ans2)\n"] | {"inputs": ["5 2\n5 3 1 4 2\n1 3\n5 4\n", "3 2\n3 2 1\n1 2\n2 3\n", "10 8\n5 3 6 8 7 10 9 1 2 4\n3 1\n4 1\n5 9\n2 5\n6 5\n3 5\n8 9\n7 9\n", "5 1\n1 2 3 4 5\n1 5\n"], "outputs": ["2\n", "3\n", "8\n", "5\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 120,849 | |
97be36bf5e0696c0598722956b451d32 | UNKNOWN | You are given two integer sequences, each of length N: a_1, ..., a_N and b_1, ..., b_N.
There are N^2 ways to choose two integers i and j such that 1 \leq i, j \leq N. For each of these N^2 pairs, we will compute a_i + b_j and write it on a sheet of paper.
That is, we will write N^2 integers in total.
Compute the XOR of these N^2 integers.
Definition of XOR
The XOR of integers c_1, c_2, ..., c_m is defined as follows:
- Let the XOR be X. In the binary representation of X, the digit in the 2^k's place (0 \leq k; k is an integer) is 1 if there are an odd number of integers among c_1, c_2, ...c_m whose binary representation has 1 in the 2^k's place, and 0 if that number is even.
For example, let us compute the XOR of 3 and 5. The binary representation of 3 is 011, and the binary representation of 5 is 101, thus the XOR has the binary representation 110, that is, the XOR is 6.
-----Constraints-----
- All input values are integers.
- 1 \leq N \leq 200,000
- 0 \leq a_i, b_i < 2^{28}
-----Input-----
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
b_1 b_2 ... b_N
-----Output-----
Print the result of the computation.
-----Sample Input-----
2
1 2
3 4
-----Sample Output-----
2
On the sheet, the following four integers will be written: 4(1+3), 5(1+4), 5(2+3) and 6(2+4). | ["#!/usr/bin/env python3\n\ndef main():\n N = int(input())\n A = list(map(int, input().split()))\n B = list(map(int, input().split()))\n ans = 0\n for k in range(30):\n C = [x & ((1 << (k+1)) - 1) for x in A]\n D = [x & ((1 << (k+1)) - 1) for x in B]\n C.sort()\n D.sort()\n # print(f'k = {k}')\n # print(f'C = {C}')\n # print(f'D = {D}')\n p, q, r = 0, 0, 0\n for i in range(N-1, -1, -1):\n while p < N:\n if C[i] + D[p] >= 1 << k: break\n p += 1\n while q < N:\n if C[i] + D[q] >= 2 << k: break\n q += 1\n while r < N:\n if C[i] + D[r] >= 3 << k: break\n r += 1\n x = ((q - p) + (N - r)) % 2\n # print(p, q, r, x)\n ans = ans ^ (x << k)\n print(ans)\n\nmain()\n", "import bisect\n\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\nans = 0\nfor i in range(29):\n div_ = pow(2, i+1)\n A_tmp = sorted([x%div_ for x in A])\n B_tmp = sorted([x%div_ for x in B])\n cnt = 0\n tmp = pow(2, i)\n idx1 = N\n idx2 = N\n idx3 = N\n for a in A_tmp:\n while idx2>0 and B_tmp[idx2-1]>=2*tmp-a:\n idx2 -= 1\n while idx1>0 and B_tmp[idx1-1]>=tmp-a:\n idx1 -= 1\n while idx3>0 and B_tmp[idx3-1]>=3*tmp-a:\n idx3 -= 1\n cnt += ((idx2-idx1)+(N-idx3))%2\n if cnt % 2 == 1:\n ans += tmp\nprint(ans)\n", "N = int(input())\nA = [int(a) for a in input().split()]\nB = [int(a) for a in input().split()]\n\ndef xor(L):\n a = 0\n for l in L: a ^= l\n return a\n\ndef chk(L1, L2, k):\n L1.sort()\n L2.sort()\n s, j = 0, 0\n for i in range(N)[::-1]:\n while j < N and L1[i] + L2[j] < k:\n j += 1\n s += N - j\n return s % 2 * k\n\nt = (xor(A) ^ xor(B)) * (N % 2)\nfor i in range(28):\n m = (1 << i+1) - 1\n t ^= chk([a&m for a in A], [b&m for b in B], m + 1)\n\nprint(t)", "import sys\ninput = sys.stdin.readline\nN = int(input())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nres = 0\nln = max(max(a), max(b)).bit_length() + 1\nfor i in range(ln):\n y = (1 << (i + 1))\n u = [x % y for x in a]\n v = [x % y for x in b]\n y >>= 1\n u.sort(reverse = True)\n v.sort()\n t = 0\n k = 0\n kk = 0\n for x in u:\n while k < N and x + v[k] < y: k += 1\n t += N - k\n while kk < N and x + v[kk] < y * 2: kk += 1\n t -= N - kk\n k = 0\n kk = 0\n #print(t)\n for x in u:\n while k < N and x + v[k] < y * 2 + y: k += 1\n t += N - k\n while kk < N and x + v[kk] < y * 4: kk += 1\n t -= N - kk\n #print(t)\n #print(u, v, t)\n res ^= t % 2 * y\nprint(res)\n", "import bisect\n\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\nans = 0\nfor i in range(29):\n div_ = pow(2, i+1)\n A_tmp = sorted([x%div_ for x in A])\n B_tmp = sorted([x%div_ for x in B])\n cnt = 0\n tmp = pow(2, i)\n idx1 = N\n idx2 = N\n idx3 = N\n for a in A_tmp:\n idx2 = bisect.bisect_left(B_tmp, 2*tmp-a, hi=idx2)\n idx1 = bisect.bisect_left(B_tmp, tmp-a, hi=min(idx1, idx2))\n idx3 = bisect.bisect_left(B_tmp, 3*tmp-a, lo=idx2, hi=idx3)\n cnt += ((idx2-idx1)+(N-idx3))%2\n if cnt % 2 == 1:\n ans += tmp\nprint(ans)\n", "def read():\n return int(input())\n \ndef reads():\n return [int(x) for x in input().split()]\n \nN = read()\nA = reads()\nB = reads()\n \nD = 28\nxor = 0\nfor d in range(D + 1):\n mask = (1 << (d + 1)) - 1 # [1] * (d+1)\n AA = sorted(x & mask for x in A)\n BB = sorted(x & mask for x in B)\n count = 0\n itr = [N] * 4\n for a in AA:\n vs = [\n (1 << d) - a,\n (1 << (d + 1)) - a,\n (1 << d) + (1 << (d + 1)) - a,\n (1 << (d + 2)) - a\n ]\n for i in range(4):\n while 0 < itr[i] and vs[i] <= BB[itr[i]-1]:\n itr[i] -= 1\n count += (itr[1] - itr[0]) + (itr[3] - itr[2])\n if count & 1:\n xor |= 1 << d\n \nprint(xor)", "from numpy import*\na,b=loadtxt(open(0),'i',skiprows=1)\nc=0\nl=1<<29\nwhile l:u=l;l>>=1;c+=sum(diff(searchsorted(sort(r_[b%u-u,b%u]),([u],[l])-a%u).T))%2*l\nprint(c)", "\n\"\"\"\n\nhttps://atcoder.jp/contests/arc092/tasks/arc092_b\n\n\u6841\u306b\u304a\u3051\u308b1\u306e\u6570\u306e\u5076\u5947\u3060\u3051\u3067\u6c7a\u307e\u308b\n1+1 -> 0 (1\u7e70\u308a\u4e0a\u304c\u308a)\n1+0 -> 1\n0+0 -> 0\n\u306a\u306e\u3067\u30011\u306e\u4f4d\u306b\u304a\u3044\u3066\u306f\u305d\u3046\n\n2\u306e\u4f4d\u3067\u306f\uff1f\u7e70\u308a\u4e0a\u304c\u308a\u304c\u3042\u308b\n\u7e70\u308a\u4e0a\u304c\u308a\u3082\u542b\u3081\u3066\u30011\u304c\u3044\u304f\u3064\u3042\u308b\u304b\u308f\u304b\u308c\u3070\u3044\u3044\n\u305d\u306e\u6841\u3078\u306e\u7e70\u308a\u4e0a\u304c\u308a\u304c\u3042\u308b\u304b\u306f\u3001\u4e8c\u5206\u63a2\u7d22\u3067\u308f\u304b\u308b\u306f\u305a\n\n200000*28*log\n\n\"\"\"\n\nfrom sys import stdin\nimport bisect\n\nN = int(stdin.readline())\na = list(map(int,stdin.readline().split()))\nb = list(map(int,stdin.readline().split()))\n\nans = 0\n\nfor i in range(29):\n\n ndig = 2**i\n now = 0\n\n for j in a:\n if j & ndig > 0:\n if N % 2 == 1:\n now ^= 1\n for j in b:\n if j & ndig > 0:\n if N % 2 == 1:\n now ^= 1\n \n nb = [j % ndig for j in b]\n nb.sort()\n nb.reverse()\n #print (now)\n \n for j in a:\n \n na = j % ndig\n l = -1\n r = N\n\n while r-l != 1:\n m = (l+r)//2\n if nb[m] + na < ndig:\n r = m\n else:\n l = m\n\n if r % 2 == 1:\n now ^= 1\n\n ans += now * ndig\n\nprint (ans)\n \n", "def main():\n from bisect import bisect_right as br\n import numpy as np\n n = int(input())\n a = np.array(list(map(int, input().split())))\n b = np.array(list(map(int, input().split())))\n #n = 100000\n #a = np.array([i+1 for i in range(n)])\n #b = np.array([2*i+2 for i in range(n)])\n a = np.sort(a)\n b = np.sort(b[::-1])\n m = n % 2\n xor = 0\n for i in b:\n xor ^= i\n b = pow(2, 28) - b\n ans = 0\n for loop in range(28, -1, -1):\n j = pow(2, loop)\n k = (xor & j) // j\n temp = br(b, j-1)\n b[temp:] -= j\n b = np.sort(b)\n temp = br(a, j-1)\n k += sum((a & j) // j)\n a[temp:] -= j\n x = (k+br(b, 0))*m % 2\n a = np.sort(a)\n x += np.sum(np.searchsorted(b, a+1))\n ans += (x % 2)*j\n print(ans)\n\n\nmain()\n", "# seishin.py\nN = int(input())\n*A, = map(int, input().split())\n*B, = map(int, input().split())\n\nM = 32\nMOD = [(2 << i) for i in range(M+1)]\n\nfrom bisect import bisect\ndef make(B):\n S = [None]*M\n s = {}; get = s.get\n for b in B:\n s[b] = get(b, 0) ^ 1\n S[M-1] = sorted(b for b in s if s[b])\n\n for i in range(M-2, -1, -1):\n t = S[i+1]; l = len(t)\n m = MOD[i]\n mid = bisect(t, m-1)\n def gen(p, q):\n while p < mid and q < l:\n u = t[p]; v = t[q]\n if u+m == v:\n p += 1; q += 1\n elif u+m < v:\n yield t[p]; p += 1\n else:\n yield t[q]-m; q += 1\n while p < mid:\n yield t[p]; p += 1\n while q < l:\n yield t[q]-m; q += 1\n *S[i], = gen(0, mid)\n return S\nS = make(A)\nT = make(B)\n\nans = 0\nif 0 in S[0]:\n ans ^= 1 in T[0]\nif 1 in S[0]:\n ans ^= 0 in T[0]\n\nfor i in range(1, M):\n s = S[i]; ls = len(S)\n t = T[i]; lt = len(t)\n m = MOD[i]; p = MOD[i-1]\n P = p+m; Q = 2*m\n\n if lt:\n c = 0\n f = lt\n while P <= t[f-1]:\n f -= 1\n\n u = f; v = lt\n for a in s:\n while u > -lt and P <= a + t[u-1] + (u > 0)*m:\n u -= 1\n while v > -lt and Q <= a + t[v-1] + (v > 0)*m:\n v -= 1\n c += (v - u)\n if c & 1:\n ans ^= 1 << i\nprint(ans)", "import bisect\nimport functools\nimport os\nimport sys\n\nsys.setrecursionlimit(10000)\nINF = float('inf')\n\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n\ndef debug(fn):\n if not os.getenv('LOCAL'):\n return fn\n\n @functools.wraps(fn)\n def wrapper(*args, **kwargs):\n ret = fn(*args, **kwargs)\n print('DEBUG: {}({}) -> '.format(\n fn.__name__,\n ', '.join(\n list(map(str, args)) +\n ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]\n )\n ), end='')\n print(ret)\n return ret\n\n return wrapper\n\n\n@debug\ndef calc_bit(k):\n \"\"\"\n \u7b54\u3048\u306e\u4e0b\u304b\u3089 k \u30d3\u30c3\u30c8\u76ee\u3092\u8fd4\u3059\n :param int k:\n :return:\n \"\"\"\n # \u7b54\u3048\u306e k \u30d3\u30c3\u30c8\u76ee\u304c\u5076\u6570\u306a\u3089 0\u3001\u5947\u6570\u306a\u3089 1\n\n # \u3053\u308c\u4ee5\u4e0a\u306e\u6841\u306f\u4e0d\u8981\n mod = 1 << (k + 1)\n amod = [a & (mod - 1) for a in A]\n bmod = [b & (mod - 1) for b in B]\n amod.sort()\n bmod.sort()\n ret = 0\n\n # bmod + amod \u306e\u3046\u3061 k \u30d3\u30c3\u30c8\u76ee\u304c 1 \u3068\u306a\u308b\u6570\n # => (1 << k) \u4ee5\u4e0a (2 << k) \u672a\u6e80\u307e\u305f\u306f (3 << k) \u4ee5\u4e0a (4 << k) \u672a\u6e80\n # \u3057\u3083\u304f\u3068\u308b\n b01 = bisect.bisect_left(bmod, (1 << k) - amod[0])\n b10 = bisect.bisect_left(bmod, (2 << k) - amod[0])\n b11 = bisect.bisect_left(bmod, (3 << k) - amod[0])\n for a in range(len(amod)):\n while b01 - 1 >= 0 and bmod[b01 - 1] >= (1 << k) - amod[a]:\n b01 -= 1\n while b10 - 1 >= 0 and bmod[b10 - 1] >= (2 << k) - amod[a]:\n b10 -= 1\n while b11 - 1 >= 0 and bmod[b11 - 1] >= (3 << k) - amod[a]:\n b11 -= 1\n # (1 << k) \u4ee5\u4e0a (2 << k) \u672a\u6e80\n ret += b10 - b01\n # (3 << k) \u4ee5\u4e0a (4 << k) \u672a\u6e80\n ret += len(bmod) - b11\n\n return ret % 2\n\n\nans = 0\nfor i in range(30):\n ans += calc_bit(i) * (2 ** i)\nprint(ans)\n", "from bisect import bisect_left\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\nans = 0\nT = 1 << 30\nfor k in range(30, -1, -1):\n cnt = 0\n\n TT = T << 1\n for i in range(N):\n A[i] %= TT\n B[i] %= TT\n\n A = sorted(A)\n B = sorted(B)\n\n d0 = bisect_left(B, T - A[0])\n d1 = bisect_left(B, 2 * T - A[0])\n d2 = bisect_left(B, 3 * T - A[0])\n for i in range(N):\n while d0 - 1 >= 0 and B[d0 - 1] >= T - A[i]:\n d0 -= 1\n while d1 - 1 >= 0 and B[d1 - 1] >= 2 * T - A[i]:\n d1 -= 1\n while d2 - 1 >= 0 and B[d2 - 1] >= 3 * T - A[i]:\n d2 -= 1\n\n cnt += d1 - d0\n cnt += N - d2\n\n if cnt % 2 == 1:\n ans |= T\n\n T = T >> 1\n\nprint(ans)", "import numpy as np\nN = int(input())\nA = np.array(input().split(), dtype=np.int32)\nB = np.array(input().split(), dtype=np.int32)\n \ndef sum_count(A,B,x):\n # A,B is sorted. \n # return count(a+b < x)\n C = np.searchsorted(B, x-A)\n return C.sum()\n \n\t\t\ndef f(t,A,B):\n power = 1<<t\n mask = (power<<1)-1\n AA = A & mask\n BB = B & mask\n AA.sort()\n BB.sort()\n\n x1,x2,x3 = (sum_count(AA,BB,v) for v in [power, 2*power, 3*power])\n zero_cnt = x1 + (x3-x2)\n return (N-zero_cnt)%2\n \nanswer = 0\nfor t in range(30):\n\tx = f(t,A,B)\n\tif x == 1:\n\t\tanswer += 1<<t\n\nprint(answer)\n", "# \u5199\u7d4c\n# https://atcoder.jp/contests/arc092/submissions/5244389\n\nfrom bisect import bisect_left\n\nINF = float('inf')\n\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\ndef calc_bit(k):\n # \u3053\u308c\u4ee5\u4e0a\u306e\u6841\u306f\u4e0d\u8981\n mod = 1 << (k + 1)\n amod = [a & (mod - 1) for a in A]\n bmod = [b & (mod - 1) for b in B]\n amod.sort()\n bmod.sort()\n ret = 0\n\n # bmod + amod \u306e\u3046\u3061 k \u30d3\u30c3\u30c8\u76ee\u304c 1 \u3068\u306a\u308b\u6570\n # => (1 << k) \u4ee5\u4e0a (2 << k) \u672a\u6e80\u307e\u305f\u306f (3 << k) \u4ee5\u4e0a (4 << k) \u672a\u6e80\n # \u3057\u3083\u304f\u3068\u308b\n b01 = bisect_left(bmod, (1 << k) - amod[0])\n b10 = bisect_left(bmod, (2 << k) - amod[0])\n b11 = bisect_left(bmod, (3 << k) - amod[0])\n for a in range(len(amod)):\n while b01 - 1 >= 0 and bmod[b01 - 1] >= (1 << k) - amod[a]:\n b01 -= 1\n while b10 - 1 >= 0 and bmod[b10 - 1] >= (2 << k) - amod[a]:\n b10 -= 1\n while b11 - 1 >= 0 and bmod[b11 - 1] >= (3 << k) - amod[a]:\n b11 -= 1\n # (1 << k) \u4ee5\u4e0a (2 << k) \u672a\u6e80\n ret += b10 - b01\n # (3 << k) \u4ee5\u4e0a (4 << k) \u672a\u6e80\n ret += N - b11\n\n return ret % 2\n\n\nans = 0\nfor i in range(30):\n ans += calc_bit(i) * (1<<i)\nprint(ans)\n", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\n# resort list X O(len(X))\ndef sorting(X, l):\n eX = []\n oX = []\n for x in X:\n if x&(1<<l):\n oX.append(x)\n else:\n eX.append(x)\n return eX + oX\n\nans = 0\nfor shift in range(30):\n A = sorting(A, shift)\n B = sorting(B, shift)\n div = (1<<(shift+1))\n count = 0\n l1 = N\n r1 = N\n l2 = N\n r2 = N\n for a in A:\n while a%div + B[l1-1]%div >= div//2 and l1 > 0:\n l1 -= 1\n while a%div + B[r1-1]%div >= div and r1 > 0:\n r1 -= 1\n while a%div + B[l2-1]%div >= div//2*3 and l2 > 0:\n l2 -= 1\n while a%div + B[r2-1]%div >= 2*div and r2 > 0:\n r2 -= 1\n count += (r1-l1) + (r2-l2)\n if count%2 == 1:\n ans += (1<<shift)\n\nprint(ans)", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn, = map(int,input().split())\n*a, = map(int,input().split())\n*b, = map(int,input().split())\n\ndef bsort(a,d):\n a0 = []\n a1 = []\n for i in a:\n if i>>d&1:\n a1.append(i)\n else:\n a0.append(i)\n return a0+a1\n \n\nans = 0\nfor d in range(29):\n res = 0\n a = bsort(a,d)\n b = bsort(b,d)\n r1 = r2 = r3 = 0\n MASK = (1<<(d+1))-1\n #print([i&MASK for i in a],[i&MASK for i in b])\n for bi in b[::-1]:\n bi &= MASK\n while r1 < n and bi+(a[r1]&MASK) < 1<<d:\n r1 += 1\n while r2 < n and bi+(a[r2]&MASK) < 2<<d:\n r2 += 1\n while r3 < n and bi+(a[r3]&MASK) < 3<<d:\n r3 += 1\n #print(d,bi,r1,r2,r3,n)\n res += r2-r1 + n-r3\n ans |= (res%2)<<d\n \nprint(ans)", "# seishin.py\nN = int(input())\n*A, = map(int, input().split())\n*B, = map(int, input().split())\n\nM = 32\nMOD = [(2 << i) for i in range(M+1)]\n\nfrom bisect import bisect\ndef make(B, mode):\n S = [None]*M\n s = {}; get = s.get\n for b in B:\n s[b] = get(b, 0) ^ 1\n S[M-1] = sorted(b for b in s if s[b])\n\n for i in range(M-2, -1, -1):\n t = S[i+1]; l = len(t)\n m = MOD[i]\n mid = bisect(t, m-1)\n def gen(p, q):\n while p < mid and q < l:\n u = t[p]; v = t[q]\n if u+m == v:\n p += 1; q += 1\n elif u+m < v:\n yield t[p]; p += 1\n else:\n yield t[q]-m; q += 1\n while p < mid:\n yield t[p]; p += 1\n while q < l:\n yield t[q]-m; q += 1\n *S[i], = gen(0, mid)\n if mode:\n for i in range(M):\n m = MOD[i]\n S[i] += list(map(lambda x: x+m, S[i]))\n return S\nS = make(A, 0)\nT = make(B, 1)\n\nans = 0\nif 0 in S[0]:\n ans ^= 1 in T[0]\nif 1 in S[0]:\n ans ^= 0 in T[0]\n\nfor i in range(1, M):\n s = S[i]; ls = len(S)\n t = T[i]; lt = len(t)\n m = MOD[i]; p = MOD[i-1]\n P = p+m; Q = 2*m\n\n if lt:\n c = 0\n f = lt\n while P <= t[f-1]:\n f -= 1\n\n u = f; v = lt\n for a in s:\n while u > 0 and P <= a + t[u-1]:\n u -= 1\n while v > 0 and Q <= a + t[v-1]:\n v -= 1\n c += (v - u)\n if c & 1:\n ans ^= 1 << i\nprint(ans)", "from numpy import*\na,b=loadtxt(open(c:=0),'i',skiprows=1)\nl=1<<29\nwhile l:u=l;l>>=1;c+=sum(diff(searchsorted(sort(r_[b%u-u,b%u]),([u],[l])-a%u).T))%2*l\nprint(c)", "from bisect import bisect_left, bisect_right\n\ndef solve():\n maxD = 30\n\n N = int(input())\n As = list(map(int, input().split()))\n Bs = list(map(int, input().split()))\n\n As.sort()\n Bs.sort()\n\n ans = 0\n for d in reversed(list(range(maxD))):\n m1 = 1 << d\n\n iA = bisect_left(As, m1)\n iB = bisect_left(Bs, m1)\n\n num1 = N * (N-iA + N-iB)\n\n As = As[:iA] + [A-m1 for A in As[iA:]]\n Bs = Bs[:iB] + [B-m1 for B in Bs[iB:]]\n\n As.sort()\n Bs.sort(reverse=True)\n\n iB = 0\n for A in As:\n while iB < N and A + Bs[iB] >= m1:\n iB += 1\n num1 += iB\n\n Bs.reverse()\n\n if num1 % 2:\n ans |= m1\n\n print(ans)\n\n\nsolve()\n", "from bisect import bisect_left,bisect_right\nN=int(input())\nA=[int(i) for i in input().split()]\nB=[int(i) for i in input().split()]\n\nnum=[0]*30\nfor i in range(30):\n t = pow(2,i)\n K=sorted(i%(2*t) for i in A)\n L=sorted(i%(2*t) for i in B)\n #L=sort()\n #print(K,L)\n a = 0\n #\u5c3a\u53d6\u308a\u6cd5,i*t\u3088\u308a\u5c0f\u3055\u3044\u6574\u6570\u3092\u6570\u3048\u308b\n S=[i*t for i in range(1,5)]\n count=[N]*4\n for k in K:\n for j in range(4):\n while L[count[j]-1]+k>=S[j] and count[j]>0:\n count[j]-=1\n a +=count[3]-count[2]+count[1]-count[0]\n #print(count,a)\n num[i]=a%2\nans =0\ns=1\nfor z in num:\n ans += z*s\n s*=2\nprint(ans)\n\n", "import numpy as np\nn=int(input())\na=np.array(input().split(),dtype=np.int32)\nb=np.array(input().split(),dtype=np.int32)\ndef f(t,a,b):\n power=1<<t\n mask=(power<<1)-1\n aa=a&mask\n bb=b&mask\n aa.sort()\n bb.sort()\n x1,x2,x3=(np.searchsorted(bb,v-aa).sum() for v in [power,power*2,power*3])\n zero_cnt=x1+(x3-x2)\n return (n-zero_cnt)%2\nans=0\nfor t in range(30):\n x=f(t,a,b)\n if x==1:\n ans+=1<<t\nprint(ans)\n", "N, = list(map(int, input().split()))\nP = list(map(int, input().split()))\nQ = list(map(int, input().split()))\nmxk = 29\nmsk = (1<<mxk) - 1\nmsk2 = (1<<(mxk-1))\nr = 0\nfor i in range(mxk):\n # \u4e0b\u304b\u3089i\u30d3\u30c3\u30c8\u76ee\u3092\u307f\u308b\n for j in range(N):\n Q[j] = Q[j] & msk\n P[j] = P[j] & msk\n msk >>= 1\n P.sort()\n Q.sort()\n j1 = N-1\n j2 = N-1\n b = 0\n ss = N\n# print(P, Q)\n for l in range(N):\n if P[l] & msk2:\n ss = l\n break\n k1 = msk2 - (P[l]&msk)\n k2 = k1 + msk2\n while j1 >= 0:\n if Q[j1] < k1:\n break\n j1 -= 1\n while j2 >= 0:\n if Q[j2] < k2:\n break\n j2 -= 1\n b += j2 - j1\n# print(\"a\",j2-j1,k1,k2,j1,j2)\n\n j1 = N-1\n j2 = N-1\n# print(ss)\n for l in range(ss, N):\n k1 = msk2 - (P[l]&msk)\n k2 = k1 + msk2\n while j1 >= 0:\n if Q[j1] < k1:\n break\n j1 -= 1\n while j2 >= 0:\n if Q[j2] < k2:\n break\n j2 -= 1\n# print(\"b\",j1 - j2 + N)\n b += j1 + N - j2\n\n# b = 0\n# for p in P:\n# if p & msk2:\n# x = g(2*msk2 - (p&msk))\n# z = g(msk2 - (p&msk))\n# b += z+N-x\n# else:\n# x = g(2*msk2 - (p&msk))\n# z = g(msk2 - (p&msk))\n# b += x-z\n# print(b, r, i)\n if b%2:\n r += 1<<(mxk-1-i)\n msk2 >>= 1\nprint(r)\n", "import numpy as np\nn=int(input())\na=np.array(input().split(),dtype=np.int32)\nb=np.array(input().split(),dtype=np.int32)\ndef f(t,a,b):\n power=1<<t\n mask=(power<<1)-1\n aa=a&mask\n bb=b&mask\n aa.sort()\n bb.sort()\n x1,x2,x3=(np.searchsorted(bb,v-aa).sum() for v in [power,power*2,power*3])\n zero_cnt=x1+(x3-x2)\n return (n-zero_cnt)%2\nans=0\nfor t in range(30):\n x=f(t,a,b)\n if x==1:\n ans+=1<<t\nprint(ans)", "from bisect import bisect_left\n\nn = int(input())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\n\nm = 30\nd = []\n# d[i] = 1<<i\nfor i in range(m+1):\n d.append(1<<i)\n\nc = [[] for i in range(m)]\nfor bi in b:\n for i in range(m):\n c[i].append(bi&(d[i+1]-1))\nfor i in range(m):\n c[i].sort()\n\nketa = [0]*m\n\n# \u3057\u3083\u304f\u3068\u308a\u3059\u308b\u306a\u3089\u6841\u3054\u3068\u306b\u3084\u308b\u3057\u304b\u7121\u3044\nfor i in range(m):\n aa = [ai&(d[i+1]-1) for ai in a]\n aa.sort()\n a0 = aa[0]\n\n i1 = d[i]\n i2 = d[i+1]\n i3 = i2+i1\n b1 = bisect_left(c[i], i1-a0)\n b2 = bisect_left(c[i], i2-a0)\n b3 = bisect_left(c[i], i3-a0)\n\n for ai in aa:\n # \u5c3a\u53d6\n # ai\u306f\u5927\u304d\u304f\u306a\u308b\u2192\u5883\u754c\u306f\u5c0f\u3055\u304f\u306a\u308b\n # \u5f15\u3044\u305f\u3042\u3068\u306eindex\u304c0\u4ee5\u4e0a\u3067\u3042\u308b\u3053\u3068\u3082\u5fc5\u8981\n while b1-1 >= 0 and c[i][b1-1] >= i1-ai:\n b1 -= 1\n while b2-1 >= 0 and c[i][b2-1] >= i2-ai:\n b2 -= 1\n while b3-1 >= 0 and c[i][b3-1] >= i3-ai:\n b3 -= 1\n keta[i] += b2-b1 + n-b3\n keta[i] %= 2\n\n#print(keta)\n\nans = 0\nfor i in range(m):\n ans += keta[i]*(1<<i)\n\nprint(ans)", "N = int(input())\nA = [int(x) for x in input().split()]\nB = [int(x) for x in input().split()]\n \ndef sum_count(A,B,x):\n # A,B is sorted. \n # return count(a+b < x)\n p = len(B)-1\n result = 0\n for a in A:\n while p != -1 and a + B[p] >= x:\n p -= 1\n result += p+1\n return result\n \n\t\t\ndef f(t,A,B):\n power = (1<<t)\n AA = [x&(2*power-1) for x in A]\n BB = [x&(2*power-1) for x in B]\n AA.sort()\n BB.sort()\n \n x1,x2,x3 = (sum_count(AA,BB,v) for v in [power, 2*power, 3*power])\n zero_cnt = x1 + (x3-x2)\n return (N-zero_cnt)%2\n \nans = 0\nfor t in range(30):\n\tx = f(t,A,B)\n\tif x == 1:\n\t\tans += 1<<t\n \nprint(ans)", "N = int(input())\nA = [int(a) for a in input().split()]\nB = [int(a) for a in input().split()]\n\ndef xor(L):\n a = 0\n for l in L: a ^= l\n return a\n\ndef chk(L1, L2, k):\n L1.sort()\n L2.sort()\n s, j = 0, 0\n for i in range(N)[::-1]:\n while j < N and L1[i] + L2[j] < k:\n j += 1\n s += N - j\n return s % 2 * k\n\nt = (xor(A) ^ xor(B)) * (N % 2)\nfor i in range(28):\n m = 1 << i+1\n t ^= chk([a%m for a in A], [b%m for b in B], m)\n\nprint(t)", "from numpy import*\na,b=loadtxt(open(0),'i',skiprows=1)\nc=0\nl=1<<29\nwhile l:u=l;l>>=1;c+=sum(diff(searchsorted(sort(hstack((b%u-u,b%u))),([u],[l])-a%u).T))%2*l\nprint(c)", "\"\"\"\n\u611f\u60f3\n- \u6841dp,\u305d\u306e\u6841\u306b1\u7acb\u3064\u304b\u8abf\u3079\u308b\n- \u6841\u306b1\u304c\u7acb\u3064=\u5024\u306e\u7bc4\u56f2\u304c[T,2T), [3T, 4T)...\n- \u305d\u306e\u6841\u3092\u3057\u308b\u305f\u3081\u306b\u306fmod 2*T\u306e\u5024\u3060\u3051\u898b\u308c\u3070\u5341\u5206\n- \u5024\u306e\u7bc4\u56f2\u306e\u500b\u6570\u3092bisect\u3067\u63a2\u308b\n- bisect\u3060\u3068python\u3060\u3068\u6b7b\u306c\n - NlogN\u306f\u3060\u3081?\n - \u5c3a\u53d6\u30672*N\u306b\u3059\u308b\n - \u3067\u3082\u30bd\u30fc\u30c8\u3057\u3066\u308b\u304b\u3089NlogN\u3058\u3083\uff1f\n - \u5b9a\u6570\u500d\u306e\u30ae\u30ea\u30ae\u30ea\u306e\u554f\u984c\uff1f=>bisect\u4e00\u500b\u306a\u3089\u30bb\u30fc\u30d5, \u63a2\u7d22\u7bc4\u56f2\u7d5e\u3063\u3066bisect\u306e\u30b3\u30fc\u30c9\u306f\u672c\u5f53\u306b\u30ae\u30ea\u30ae\u30ea\u3067\u904b\u6b21\u7b2c\u3067AC(\u540c\u3058\u30b3\u30fc\u30c9\u3067TLE\u3068AC)\n\"\"\"\nN = int(input())\nA = list(map(int, input().split()))\nB = list(map(int, input().split()))\n\nans = 0\nfor i in range(29):\n div_ = pow(2, i+1)\n A_tmp = sorted([x%div_ for x in A])\n B_tmp = sorted([x%div_ for x in B])\n cnt = 0\n tmp = pow(2, i)\n idx1 = N\n idx2 = N\n idx3 = N\n for a in A_tmp:\n while idx2>0 and B_tmp[idx2-1]>=2*tmp-a:\n idx2 -= 1\n while idx1>0 and B_tmp[idx1-1]>=tmp-a:\n idx1 -= 1\n while idx3>0 and B_tmp[idx3-1]>=3*tmp-a:\n idx3 -= 1\n cnt += ((idx2-idx1)+(N-idx3))%2\n if cnt % 2 == 1:\n ans += tmp\nprint(ans)\n", "import numpy as np\nn=int(input())\na=np.array(input().split(),dtype=np.int32)\nb=np.array(input().split(),dtype=np.int32)\ndef f(t,a,b):\n power=1<<t\n mask=(power<<1)-1\n aa=a&mask\n bb=b&mask\n aa.sort()\n bb.sort()\n x1,x2,x3=(np.searchsorted(bb,v-aa).sum() for v in [power,power*2,power*3])\n zero_cnt=x1+(x3-x2)\n return (n*n-zero_cnt)%2\nans=0\nfor t in range(30):\n x=f(t,a,b)\n if x==1:\n ans+=1<<t\nprint(ans)\n", "import sys,bisect\ninput = sys.stdin.readline\n\n\ndef main():\n n = int(input())\n a = tuple(map(int,input().split()))\n b = tuple(map(int,input().split()))\n\n\n res = 0\n p = 0\n\n for i in range(1,30):\n p += 1<<(i-1)\n A = []\n B = []\n\n for j in range(n):\n A.append(a[j]&p)\n B.append(b[j]&p)\n A.sort()\n B.sort()\n\n cnt = 0\n\n q2 = p+1\n q1 = q2>>1\n q3 = q2<<1\n\n k1,k2,k3,k4 = 0,0,0,0\n\n for j in range(n-1,-1,-1):\n while k1 < n and A[j]+B[k1] < q1:\n k1 += 1\n while k2 < n and A[j]+B[k2] < q2:\n k2 += 1\n while k3 < n and A[j]+B[k3] < 3*q1:\n k3 += 1\n while k4 < n and A[j]+B[k4] < q3:\n k4 += 1\n cnt += k4 + k2 - k1 - k3\n\n \n if cnt%2 != 0:\n res += 1<<(i-1)\n\n print(res)\n\n\ndef __starting_point():\n main()\n__starting_point()", "# seishin.py\nN = int(input())\n*A, = map(int, input().split())\n*B, = map(int, input().split())\n\nM = 32\nMOD = [(2 << i) for i in range(M+1)]\n\nfrom bisect import bisect\ndef make(B, mode):\n S = [None]*M\n s = {}; get = s.get\n for b in B:\n s[b] = get(b, 0) ^ 1\n S[M-1] = sorted(b for b in s if s[b])\n\n for i in range(M-2, -1, -1):\n t = S[i+1]; l = len(t)\n m = MOD[i]\n mid = q = bisect(t, m-1)\n p = 0\n if q < l:\n if p < mid:\n def gen(p, q):\n u = t[p]; v = t[q]\n while p < mid and q < l:\n if u+m == v:\n p += 1; u = t[p] if p < mid else None\n q += 1; v = t[q] if q < l else None\n elif u+m < v:\n yield u\n p += 1; u = t[p] if p < mid else None\n else:\n yield v-m\n q += 1; v = t[q] if q < l else None\n while p < mid:\n yield t[p]; p += 1\n while q < l:\n yield t[q]-m; q += 1\n *S[i], = gen(p, q)\n else:\n *S[i], = (u-m for u in t)\n else:\n *S[i], = t\n if mode:\n for i in range(M):\n m = MOD[i]\n S[i] += list(map(lambda x: x+m, S[i]))\n return S\nS = make(A, 0)\nT = make(B, 1)\n\nans = 0\nif 0 in S[0]:\n ans ^= 1 in T[0]\nif 1 in S[0]:\n ans ^= 0 in T[0]\n\nfor i in range(1, M):\n s = S[i]; ls = len(S)\n t = T[i]; lt = len(t)\n m = MOD[i]; p = MOD[i-1]\n P = p+m; Q = 2*m\n\n if lt:\n c = 0\n f = lt\n while P <= t[f-1]:\n f -= 1\n\n u = f; v = lt\n for a in s:\n while u > 0 and P <= a + t[u-1]:\n u -= 1\n while v > 0 and Q <= a + t[v-1]:\n v -= 1\n c += (v - u)\n if c & 1:\n ans ^= 1 << i\nprint(ans)", "N = int(input())\nA = list(map(int,input().split()))\nB = list(map(int,input().split()))\n\nA.sort()\nB.sort()\n\nBit_num = max(A[-1],B[-1]).bit_length()\n\ndef derive(i, A, B): #i\u6841\u76ee\u3092\u6c42\u3081\u308b\n pow_2_i = pow(2,i)\n a = [x % pow_2_i for x in A]\n b = [x % pow_2_i for x in B]\n a.sort()\n b.sort()\n #print(i,a,b)\n ans = 0\n \n th1 = pow_2_i + pow_2_i//2 #\u7b2c\uff11\u533a\u9593\u3092\u8db3\u3059\n ib = N-1\n for ia in range(N):\n a_now = a[ia]\n while ib >= 0 and a_now + b[ib] >= th1:\n ib -= 1\n ans += N-1 - ib\n #print(\" \", ia, ib,1)\n th2 = pow_2_i #\u7b2c\uff12\u533a\u9593\u3092\u5f15\u304f\n ib = N-1\n for ia in range(N):\n a_now = a[ia]\n while ib >= 0 and a_now + b[ib] >= th2:\n ib -= 1\n ans -= N-1 - ib\n #print(\" \", ia,ib,2)\n th3 = pow_2_i//2 #\u7b2c\uff13\u533a\u9593\u3092\u8db3\u3059\n ib = N-1\n for ia in range(N):\n a_now = a[ia]\n while ib >= 0 and a_now + b[ib] >= th3:\n ib -= 1\n ans -= N-1 - ib\n #print(\" \", ia,ib,3) \n return ans % 2 == 1 #Xor\u3092\u3068\u308b\u30021\u306a\u3089True\n \nans = 0\nfor i in range(Bit_num+1,0,-1):\n ans += int(derive(i, A, B))\n #print(i,ans)\n ans *= 2\n \nprint((ans//2))\n", "import numpy as np\nN = int(input())\nA = np.array(input().split(), dtype=np.int32)\nB = np.array(input().split(), dtype=np.int32)\n\t\ndef f(t,A,B):\n power = 1<<t\n mask = (power<<1)-1\n AA = A & mask\n BB = B & mask\n AA.sort()\n BB.sort()\n\n x1,x2,x3 = (np.searchsorted(BB, v-AA).sum() for v in [power, 2*power, 3*power])\n zero_cnt = x1 + (x3-x2)\n return (N-zero_cnt)%2\n \nanswer = 0\nfor t in range(30):\n\tx = f(t,A,B)\n\tif x == 1:\n\t\tanswer += 1<<t\n\nprint(answer)\n", "def main():\n from bisect import bisect_right as br\n n = int(input())\n a = sorted(list(map(int, input().split())))\n b = sorted(list(map(int, input().split())), reverse=True)\n m = n % 2\n xor = 0\n for i in b:\n xor ^= i\n for i in range(n):\n b[i] = 2**28 - b[i]\n ans = 0\n for loop in range(28, -1, -1):\n j = pow(2, loop)\n k = (xor & j) // j\n temp = br(b, j-1)\n for i in range(temp, n):\n b[i] -= j\n b.sort()\n temp = br(a, j-1)\n for i in a[:temp]:\n k += (i & j) // j\n for i in range(temp, n):\n k += (a[i] & j) // j\n a[i] -= j\n x = (k+br(b, 0))*m % 2\n a.sort()\n l = 0\n for i in a:\n while l < n:\n if i >= b[l]:\n l += 1\n else:\n break\n x += l % 2\n ans += (x % 2)*j\n print(ans)\n\n\nmain()\n", "import sys\ninput = lambda : sys.stdin.readline().rstrip()\nsys.setrecursionlimit(max(1000, 10**9))\nwrite = lambda x: sys.stdout.write(x+\"\\n\")\n\n\nn = int(input())\na = list(map(int, input().split()))\nb = list(map(int, input().split()))\nl = 29\nval = 0\n\ndef lcount(a,b,x):\n \"\"\"\u30bd\u30fc\u30c8\u6e08a,b\u306b\u5bfe\u3057\u3066, a[i]+b[j]<=x\u306a\u308bi,j\u306e\u500b\u6570\n \"\"\"\n la = len(a)\n lb = len(b)\n j = -1\n ans = 0\n for i in range(la-1, -1, -1):\n while j+1<lb and a[i]+b[j+1]<=x:\n j += 1\n ans += (j+1)\n return ans\nfor k in range(l):\n # i\u6841\u76ee\u3092\u6c42\u3081\u308b\n tmp = pow(2, k+1)\n bb = [item%(tmp) for item in b]\n aa = [item%(tmp) for item in a]\n aa.sort()\n bb.sort()\n ans = n**2 - lcount(aa,bb,tmp//2*3-1) + lcount(aa,bb,tmp-1) - lcount(aa,bb,tmp//2-1)\n if ans%2:\n val += pow(2, k)\nprint(val)", "import sys\nreadline = sys.stdin.readline\n\nN = int(readline())\nA = list(map(int, readline().split()))\nB = list(map(int, readline().split()))\nA.sort()\nB.sort()\ncnta = [0]*29\ncntb = [0]*29\nfor idx in range(N):\n a, b = A[idx], B[idx]\n for i in range(29):\n if (1<<i) & a:\n cnta[i] = 1 - cnta[i]\n if (1<<i) & b:\n cntb[i] = 1 - cntb[i]\n\ncarry = [0]*30\nbwa = [0]*N\nbwb = [0]*N\nfor i in range(29):\n m = (1<<(i+1))-1\n bwbc = sorted([b&m for b in B])\n bwac = sorted([m+1 if a&m == 0 else m&(-(a&m)) for a in A])\n r = N\n for idx in range(N-1, -1, -1):\n a = bwac[idx]\n while r and bwbc[r-1] >= a:\n r -= 1\n carry[i+1] += N - r\n \nans = 0\nfor i in range(29):\n if (carry[i] + (cnta[i]+cntb[i])*N) % 2 == 1:\n ans |= 1<<i\nprint(ans)"] | {"inputs": ["2\n1 2\n3 4\n", "6\n4 6 0 0 3 3\n0 5 6 5 0 3\n", "5\n1 2 3 4 5\n1 2 3 4 5\n", "1\n0\n0\n"], "outputs": ["2\n", "8\n", "2\n", "0\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 33,428 | |
b9aa27e2587af00f44118eda049daab0 | UNKNOWN | Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer $k$ and positive integer $n$, let $k\bmod n$ denote the remainder when $k$ is divided by $n$. More formally, $r=k\bmod n$ is the smallest non-negative integer such that $k-r$ is divisible by $n$. It always holds that $0\le k\bmod n\le n-1$. For example, $100\bmod 12=4$ and $(-1337)\bmod 3=1$.
Then the shuffling works as follows. There is an array of $n$ integers $a_0,a_1,\ldots,a_{n-1}$. Then for each integer $k$, the guest in room $k$ is moved to room number $k+a_{k\bmod n}$.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
-----Input-----
Each test consists of multiple test cases. The first line contains a single integer $t$ ($1\le t\le 10^4$) — the number of test cases. Next $2t$ lines contain descriptions of test cases.
The first line of each test case contains a single integer $n$ ($1\le n\le 2\cdot 10^5$) — the length of the array.
The second line of each test case contains $n$ integers $a_0,a_1,\ldots,a_{n-1}$ ($-10^9\le a_i\le 10^9$).
It is guaranteed that the sum of $n$ over all test cases does not exceed $2\cdot 10^5$.
-----Output-----
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
-----Example-----
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
-----Note-----
In the first test case, every guest is shifted by $14$ rooms, so the assignment is still unique.
In the second test case, even guests move to the right by $1$ room, and odd guests move to the left by $1$ room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by $1$ room, and the other guests move to the right by $5$ rooms. We can show that the assignment is still unique.
In the fourth test case, guests $0$ and $1$ are both assigned to room $3$.
In the fifth test case, guests $1$ and $2$ are both assigned to room $2$. | ["t = int(input())\n\nfor _ in range(t):\n n = int(input())\n l = [int(x) for x in input().split()]\n vals = [(x + i) % n for i, x in enumerate(l)]\n print(\"YES\" if len(set(vals)) == n else \"NO\")\n", "import sys\ninput = sys.stdin.readline\n\nt = int(input())\nout = []\nfor i in range(t):\n n = int(input())\n l = list([int(x) % n for x in input().split()])\n\n taken = [False] * n\n for i in range(n):\n taken[(i + l[i]) % n] = True\n \n for i in range(n):\n if not taken[i]:\n out.append('NO')\n break\n else:\n out.append('YES')\nprint('\\n'.join(out))\n", "import sys\ndef input():\n\treturn sys.stdin.readline()[:-1]\nt = int(input())\nfor _ in range(t):\n\tn = int(input())\n\ta = list(map(int, input().split()))\n\tused = [False for _ in range(n)]\n\tfor i in range(n):\n\t\tif used[(i + a[i]) % n]:\n\t\t\tprint(\"NO\")\n\t\t\tbreak\n\t\telse:\n\t\t\tused[(i + a[i]) % n] = True\n\telse:\n\t\tprint(\"YES\")", "import sys\nreadline = sys.stdin.readline\n\nT = int(readline())\nAns = ['NO']*T\n\nfor qu in range(T):\n N = int(readline())\n A = list(map(int, readline().split()))\n S = set()\n for i in range(N):\n S.add((i+A[i])%N)\n if len(S) == N:\n Ans[qu] = 'YES'\nprint('\\n'.join(map(str, Ans)))", "from sys import stdin\ninput = stdin.readline\nq = int(input())\nfor _ in range(q):\n\tn = int(input())\n\tl = list(map(int,input().split()))\n\tcyk = [(i + l[i])%n for i in range(n)]\n\tcyk.sort()\n\tdupa = 1\n\tfor i in range(1,n):\n\t\tif cyk[i] != cyk[i-1]+1:\n\t\t\tdupa = 0\n\tif dupa:\n\t\tprint(\"YES\")\n\telse:\n\t\tprint(\"NO\")", "for t in range(int(input())):\n n = int(input())\n a = list(map(int, input().split()))\n graph = [[] for i in range(n)]\n for i in range(n):\n graph[(i + a[i]) % n].append(i)\n graph[i].append((i + a[i]) % n)\n for v in graph:\n if len(v) != 2:\n print(\"NO\")\n break\n else:\n print(\"YES\")\n"] | {
"inputs": [
"6\n1\n14\n2\n1 -1\n4\n5 5 5 1\n3\n3 2 1\n2\n0 1\n5\n-239 -2 -100 -3 -11\n",
"10\n1\n1000000000\n1\n-1000000000\n2\n1000000000 0\n2\n0 1000000000\n2\n1000000000 1\n2\n1 1000000000\n2\n-1000000000 0\n2\n0 -1000000000\n2\n-1000000000 1\n2\n1 -1000000000\n",
"10\n3\n-15 -33 79\n16\n45 -84 19 85 69 -64 93 -70 0 -53 2 -52 -55 66 33 -60\n2\n14 -2\n4\n-65 -76 5 25\n5\n55 -66 63 -66 -35\n5\n-87 59 78 2 -10\n1\n25\n1\n-19\n1\n-8\n12\n32 34 43 -83 57 8 -86 88 -25 96 22 -44\n"
],
"outputs": [
"YES\nYES\nYES\nNO\nNO\nYES\n",
"YES\nYES\nYES\nYES\nNO\nNO\nYES\nYES\nNO\nNO\n",
"NO\nNO\nYES\nNO\nNO\nNO\nYES\nYES\nYES\nNO\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 2,030 | |
e6d799ea6f9878a05ee545f44e18f429 | UNKNOWN | Allen and Bessie are playing a simple number game. They both know a function $f: \{0, 1\}^n \to \mathbb{R}$, i. e. the function takes $n$ binary arguments and returns a real value. At the start of the game, the variables $x_1, x_2, \dots, x_n$ are all set to $-1$. Each round, with equal probability, one of Allen or Bessie gets to make a move. A move consists of picking an $i$ such that $x_i = -1$ and either setting $x_i \to 0$ or $x_i \to 1$.
After $n$ rounds all variables are set, and the game value resolves to $f(x_1, x_2, \dots, x_n)$. Allen wants to maximize the game value, and Bessie wants to minimize it.
Your goal is to help Allen and Bessie find the expected game value! They will play $r+1$ times though, so between each game, exactly one value of $f$ changes. In other words, between rounds $i$ and $i+1$ for $1 \le i \le r$, $f(z_1, \dots, z_n) \to g_i$ for some $(z_1, \dots, z_n) \in \{0, 1\}^n$. You are to find the expected game value in the beginning and after each change.
-----Input-----
The first line contains two integers $n$ and $r$ ($1 \le n \le 18$, $0 \le r \le 2^{18}$).
The next line contains $2^n$ integers $c_0, c_1, \dots, c_{2^n-1}$ ($0 \le c_i \le 10^9$), denoting the initial values of $f$. More specifically, $f(x_0, x_1, \dots, x_{n-1}) = c_x$, if $x = \overline{x_{n-1} \ldots x_0}$ in binary.
Each of the next $r$ lines contains two integers $z$ and $g$ ($0 \le z \le 2^n - 1$, $0 \le g \le 10^9$). If $z = \overline{z_{n-1} \dots z_0}$ in binary, then this means to set $f(z_0, \dots, z_{n-1}) \to g$.
-----Output-----
Print $r+1$ lines, the $i$-th of which denotes the value of the game $f$ during the $i$-th round. Your answer must have absolute or relative error within $10^{-6}$.
Formally, let your answer be $a$, and the jury's answer be $b$. Your answer is considered correct if $\frac{|a - b|}{\max{(1, |b|)}} \le 10^{-6}$.
-----Examples-----
Input
2 2
0 1 2 3
2 5
0 4
Output
1.500000
2.250000
3.250000
Input
1 0
2 3
Output
2.500000
Input
2 0
1 1 1 1
Output
1.000000
-----Note-----
Consider the second test case. If Allen goes first, he will set $x_1 \to 1$, so the final value will be $3$. If Bessie goes first, then she will set $x_1 \to 0$ so the final value will be $2$. Thus the answer is $2.5$.
In the third test case, the game value will always be $1$ regardless of Allen and Bessie's play. | ["n, r = [int(x) for x in input().split()]\n\nn = 2 ** n\n\nxs = [int(x) for x in input().split()]\n\ns = sum(xs)\n\nres = [0 for _ in range(r+1)]\nfor i in range(r):\n res[i] = s / n\n i, val = [int(x) for x in input().split()]\n s += val - xs[i]\n xs[i] = val\nres[r] = s / n\nprint(\"\\n\".join(map(str, res)))\n", "n, r = [int(x) for x in input().split()]\nn = 2 ** n\nxs = [int(x) for x in input().split()]\ns = sum(xs)\nres = [0 for _ in range(r+1)]\nfor i in range(r):\n res[i] = s / n\n i, val = [int(x) for x in input().split()]\n s += val - xs[i]\n xs[i] = val\nres[r] = s / n\nprint(\"\\n\".join(map(str, res)))", "import sys\n\nn, r = [int(x) for x in sys.stdin.readline().split()]\na = [int(x) for x in sys.stdin.readline().split()]\ns = sum(a)\nn = 2**n\nsys.stdout.write(str(s / n)+\"\\n\")\nfor i in range(r):\n\tp, x = [int(x) for x in sys.stdin.readline().split()]\n\ts = s - a[p] + x\n\ta[p] = x\n\tsys.stdout.write(str(s / n)+\"\\n\")", "R = lambda:list(map(int,input().split()))\nsum1 = 0\np1 = 1\na = [0]*263000\nb = a\nn,r = R()\np1 = 2**n\na = R()\nsum1 = sum(a)\np2 = sum1 / p1\nfor i in range(r):\n\tz,g=R()\n\tsum1 = sum1 - a[z] + g\n\ta[z] = g\n\tb[i] = sum1/p1\nprint(p2)\nfor i in range(r):\n\tprint(b[i])"] | {
"inputs": [
"2 2\n0 1 2 3\n2 5\n0 4\n",
"1 0\n2 3\n",
"2 0\n1 1 1 1\n"
],
"outputs": [
"1.500000\n2.250000\n3.250000\n",
"2.500000\n",
"1.000000\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 1,261 | |
aca7d3179fd2984b83fc3c74d576a657 | UNKNOWN | Johnny has just found the new, great tutorial: "How to become a grandmaster?". The tutorial tells many strange and unexpected for Johnny things, such as you have to be patient or that very important is solving many harder and harder problems.
The boy has found an online judge with tasks divided by topics they cover. He has picked $p^{k_i}$ problems from $i$-th category ($p$ is his favorite number). He wants to solve them in two weeks (the patience condition is too hard for Johnny, so for simplicity, he looks only at easy tasks, which can be solved in such a period). Now our future grandmaster has to decide which topics to cover first and which the second week. Help him assign topics in such a way, that workload is balanced.
Formally, given $n$ numbers $p^{k_i}$, the boy wants to divide them into two disjoint sets, minimizing the absolute difference between sums of numbers in each set. Find the minimal absolute difference. Output the result modulo $10^{9}+7$.
-----Input-----
Input consists of multiple test cases. The first line contains one integer $t$ $(1 \leq t \leq 10^5)$ — the number of test cases. Each test case is described as follows:
The first line contains two integers $n$ and $p$ $(1 \leq n, p \leq 10^6)$. The second line contains $n$ integers $k_i$ $(0 \leq k_i \leq 10^6)$.
The sum of $n$ over all test cases doesn't exceed $10^6$.
-----Output-----
Output one integer — the reminder of division the answer by $1\,000\,000\,007$.
-----Example-----
Input
4
5 2
2 3 4 4 3
3 1
2 10 1000
4 5
0 1 1 100
1 8
89
Output
4
1
146981438
747093407
-----Note-----
You have to minimize the difference, not it's remainder. For example, if the minimum difference is equal to $2$, but there is also a distribution where the difference is $10^9 + 8$, then the answer is $2$, not $1$.
In the first test case of the example, there're the following numbers: $4$, $8$, $16$, $16$, and $8$. We can divide them into such two sets: ${4, 8, 16}$ and ${8, 16}$. Then the difference between the sums of numbers in sets would be $4$. | ["import sys\ninput = sys.stdin.readline\n\nMOD = 10 ** 9 + 7\n\nt = int(input())\nfor _ in range(t):\n n, p = list(map(int, input().split()))\n l = list(map(int, input().split()))\n if p == 1:\n print(n % 2)\n else:\n l.sort(reverse = True)\n curr = l[0]\n out = 0\n real = True\n\n for v in l:\n if v < curr:\n diff = curr - v\n if 10 ** (7/diff) < p and out > 0:\n real = False\n out *= pow(p, diff, MOD)\n if out > 10 ** 7:\n real = False\n out %= MOD\n\n curr = v\n if out > 0 or not real:\n out -= 1\n else:\n out += 1\n out %= MOD\n\n out *= pow(p, curr, MOD)\n print(out % MOD)\n", "import sys\nreadline = sys.stdin.readline\n\nT = int(readline())\nAns = [None]*T\nMOD = 10**9+7\nmod = 10**9+9\nfor qu in range(T):\n N, P = map(int, readline().split())\n A = list(map(int, readline().split()))\n if P == 1:\n if N&1:\n Ans[qu] = 1\n else:\n Ans[qu] = 0\n continue\n if N == 1:\n Ans[qu] = pow(P, A[0], MOD)\n continue\n A.sort(reverse = True)\n cans = 0\n carry = 0\n res = 0\n ra = 0\n for a in A:\n if carry == 0:\n carry = pow(P, a, mod)\n cans = pow(P, a, MOD)\n continue\n res = (res + pow(P, a, mod))%mod \n ra = (ra + pow(P, a, MOD))%MOD\n \n if res == carry and ra == cans:\n carry = 0\n cans = 0\n ra = 0\n res = 0\n Ans[qu] = (cans-ra)%MOD\n \n \nprint('\\n'.join(map(str, Ans)))", "import sys\ninput = sys.stdin.readline\nmod=1000000007\n\nt=int(input())\nfor tests in range(t):\n n,p=list(map(int,input().split()))\n K=sorted(map(int,input().split()),reverse=True)\n\n if p==1:\n if n%2==0:\n print(0)\n else:\n print(1)\n continue\n\n ANS=[0,0]\n flag=0\n\n for i in range(n):\n k=K[i]\n \n if ANS[0]==0:\n ANS=[1,k]\n \n elif ANS[1]==k:\n ANS[0]-=1\n\n else:\n while ANS[1]>k:\n ANS[0]*=p\n ANS[1]-=1\n\n if ANS[0]>10**7:\n flag=1\n lastind=i\n break\n\n if flag==1:\n A=ANS[0]*pow(p,ANS[1],mod)%mod\n #print(A,ANS)\n\n for j in range(lastind,n):\n A=(A-pow(p,K[j],mod))%mod\n print(A)\n break\n else:\n ANS[0]-=1\n\n if flag==0:\n print(ANS[0]*pow(p,ANS[1],mod)%mod)\n \n \n \n\n \n\n \n", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\n\n\nT = int(input())\nP = 10 ** 9 + 7\nfor _ in range(T):\n N, b = list(map(int, input().split()))\n A = sorted([int(a) for a in input().split()])\n if b == 1:\n print(N % 2)\n continue\n a = A.pop()\n pre = a\n s = 1\n ans = pow(b, a, P)\n while A:\n a = A.pop()\n s *= b ** min(pre - a, 30)\n if s >= len(A) + 5:\n ans -= pow(b, a, P)\n if ans < 0: ans += P\n while A:\n a = A.pop()\n ans -= pow(b, a, P)\n if ans < 0: ans += P\n print(ans)\n break\n \n if s:\n s -= 1\n ans -= pow(b, a, P)\n if ans < 0: ans += P\n pre = a\n else:\n s = 1\n ans = -ans\n if ans < 0: ans += P\n ans += pow(b, a, P)\n if ans >= P: ans -= P\n pre = a\n else:\n print(ans)\n\n"] | {
"inputs": [
"4\n5 2\n2 3 4 4 3\n3 1\n2 10 1000\n4 5\n0 1 1 100\n1 8\n89\n",
"1\n1 2\n88\n",
"1\n20 22328\n2572 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n"
],
"outputs": [
"4\n1\n146981438\n747093407\n",
"140130951\n",
"1000000004\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,949 | |
b81a74b84eb8989e469df5cb3aa0b9c2 | UNKNOWN | This is an easier version of the next problem. The difference is only in constraints.
You are given a rectangular $n \times m$ matrix $a$. In one move you can choose any column and cyclically shift elements in this column. You can perform this operation as many times as you want (possibly zero). You can perform this operation to a column multiple times.
After you are done with cyclical shifts, you compute for every row the maximal value in it. Suppose that for $i$-th row it is equal $r_i$. What is the maximal possible value of $r_1+r_2+\ldots+r_n$?
-----Input-----
The first line contains an integer $t$ ($1 \le t \le 40$), the number of test cases in the input.
The first line of each test case contains integers $n$ and $m$ ($1 \le n \le 4$, $1 \le m \le 100$) — the number of rows and the number of columns in the given matrix $a$.
Each of the following $n$ lines contains $m$ integers, the elements of $a$ ($1 \le a_{i, j} \le 10^5$).
-----Output-----
Print $t$ integers: answers for all test cases in the order they are given in the input.
-----Example-----
Input
2
2 3
2 5 7
4 2 4
3 6
4 1 5 2 10 4
8 6 6 4 9 10
5 4 9 5 8 7
Output
12
29
-----Note-----
In the first test case, you can shift the third column down by one, this way there will be $r_1 = 5$ and $r_2 = 7$.
In the second case you can don't rotate anything at all, this way there will be $r_1 = r_2 = 10$ and $r_3 = 9$. | ["rnd_mod = 1234567890133\nrnd_x = 987654321098\ndef rnd():\n nonlocal rnd_x\n rnd_x = rnd_x**2 % rnd_mod\n return (rnd_x>>5) % (1<<20)\ndef randrange(a):\n return rnd() % a\n\nT = int(input())\nfor _ in range(T):\n N, M = list(map(int, input().split()))\n X = []\n for __ in range(N):\n X.append([int(a) for a in input().split()])\n Y = [[X[i][j] for i in range(N)] for j in range(M)]\n ma = 0\n for t in range(577):\n for i in range(M):\n a = randrange(N)\n Y[i] = [Y[i][j-a] for j in range(N)]\n ma = max(ma, sum([max([Y[i][j] for i in range(M)]) for j in range(N)]))\n print(ma)\n", "import sys\ninput = sys.stdin.readline\n\nt=int(input())\nfor testcases in range(t):\n n,m=list(map(int,input().split()))\n A=[list(map(int,input().split())) for i in range(n)]\n\n B=[]\n for j in range(m):\n B.append([A[i][j] for i in range(n)])\n\n B.sort(key=lambda x:max(x),reverse=True)\n\n B=B[:n]\n\n #print(B)\n LEN=len(B)\n\n if LEN==1:\n print(sum(B[0]))\n\n elif LEN==2:\n ANS=0\n for i in range(n):\n A=0\n for k in range(n):\n A+=max(B[0][k],B[1][(i+k)%n])\n\n ANS=max(ANS,A)\n\n print(ANS)\n\n elif LEN==3:\n\n ANS=0\n for i in range(n):\n for j in range(n):\n \n A=0\n for k in range(n):\n A+=max(B[0][k],B[1][(i+k)%n],B[2][(j+k)%n])\n\n ANS=max(ANS,A)\n\n print(ANS)\n\n elif LEN==4:\n\n ANS=0\n for i in range(n):\n for j in range(n):\n for l in range(n):\n \n A=0\n for k in range(n):\n A+=max(B[0][k],B[1][(i+k)%n],B[2][(j+k)%n],B[3][(l+k)%n])\n\n ANS=max(ANS,A)\n\n print(ANS)\n \n \n\n \n \n", "from sys import stdin\n\ndef f(lst, num):\n new = lst[num:] + lst[:num]\n return new\n\nt = int(stdin.readline())\nfor i in range(t):\n row, col = tuple(int(x) for x in stdin.readline().split())\n lst = list([int(x)] for x in stdin.readline().split())\n \n for j in range(row-1):\n line = tuple(int(x) for x in stdin.readline().split())\n for k in range(len(line)):\n lst[k].append(line[k])\n \n lst.sort(key=lambda x: max(x), reverse = True)\n\n ans = float('-inf')\n for a in range(4):\n for b in range(4):\n for c in range(4):\n for d in range(4):\n if col >= 1:\n aa = f(lst[0], a)\n else:\n aa = (0,)*row\n if col >= 2:\n bb = f(lst[1], b)\n else:\n bb = (0,)*row\n if col >= 3:\n cc = f(lst[2], c)\n else:\n cc = (0,)*row\n if col >= 4:\n dd = f(lst[3], d)\n else:\n dd = (0,)*row\n\n ans = max(ans,\n sum(max(x[j] for x in (aa, bb, cc, dd))\n for j in range(row)))\n print(ans)\n", "from random import randint\nfor _ in range(int(input())):\n n, m = map(int, input().split())\n A = [list(map(int, input().split())) for _ in range(n)]\n ans = 0\n for _ in range(100):\n for j in range(m):\n x = randint(0, n - 1)\n if x:\n B = []\n for i in range(n):\n B.append(A[i][j])\n B = B[x:] + B[:x]\n for i in range(n):\n A[i][j] = B[i]\n c = 0\n for i in range(n):\n c += max(A[i])\n ans = max(ans, c)\n print(ans)", "t = int(input())\nfor i in range(t):\n n, m = [int(item) for item in input().split()]\n mat = []\n col = [[] for _ in range(m)]\n for j in range(n):\n line = [int(item) for item in input().split()]\n for k, item in enumerate(line):\n col[k].append(item)\n mat.append(line)\n colmax = []\n for line in col:\n colmax.append([max(line), line])\n colmax.sort(reverse=True)\n colmax = colmax[:n]\n ans = 0\n for j in range(n ** (n-1)):\n index = j\n rot = [0]\n for k in range(n-1):\n rot.append(index % n)\n index //= n \n ret = 0\n for l in range(n):\n val = 0\n for k in range(len(colmax)):\n val = max(val, colmax[k][1][(l + rot[k]) % n])\n ret += val\n ans = max(ans, ret)\n print(ans)", "import random \nfor _ in range(int(input())):\n N, M = list(map(int, input().split()))\n X = [[int(a) for a in input().split()] for _ in range(N)]\n Y = [[X[i][j] for i in range(N)] for j in range(M)]\n ma = 0\n for t in range(99):\n for i in range(M):\n a = random.randrange(N)\n Y[i] = [Y[i][j-a] for j in range(N)]\n ma = max(ma, sum([max([Y[i][j] for i in range(M)]) for j in range(N)]))\n print(ma)\n", "q = int(input())\nfor rquer in range(q):\n\tc, r = list(map(int, input().split()))\n\tmatt = [list(map(int,input().split())) for i in range(c)]\n\tmat = [[matt[i][j] for i in range(c)] for j in range(r)]\n\tfor i in range(r):\n\t\tmat[i].append(max(mat[i]))\n\t\tmat[i].reverse()\n\tmat.sort()\n\tmat.reverse()\n\twork = mat[:min(4, r)]\n\tfor t in work:\n\t\tt.pop(0)\n\tr = min(4, r)\n\twyn = 0\n\tfor num in range(c**r):\n\t\tshif = [(num//(c**i))%c for i in range(r)]\n\t\tnew = 0\n\t\tfor i in range(c):\n\t\t\tkol = [work[j][(i + shif[j])%c] for j in range(r)]\n\t\t\tnew += max(kol)\n\t\twyn = max(wyn, new)\n\tprint(wyn)\n", "for _ in range(int(input())):\n N, M = map(int, input().split())\n X = [[int(a) for a in input().split()] for _ in range(N)]\n Y = [[X[i][j] for i in range(N)] for j in range(M)]\n ma = 0\n dp = [[0] * (1<<N) for _ in range(M+1)]\n for j in range(M):\n for mask in range(1<<N):\n maskpre = mask\n while maskpre >= 0:\n maskpre &= mask\n ma = 0\n for k in range(N):\n s = 0\n for i in range(N):\n if (maskpre >> i) & 1 == 0 and (mask >> i) & 1:\n s += X[i-k][j]\n ma = max(ma, s)\n dp[j+1][mask] = max(dp[j+1][mask], dp[j][maskpre] + ma)\n \n maskpre -= 1\n print(dp[-1][-1])", "t = int(input())\ndef maxsa(A):\n ans = 0\n #print(\"asdasd\")\n for i in range(n):\n cur_maxx = 0\n for j in range(4):\n cur_maxx = max(cur_maxx, A[j][i])\n ans+= cur_maxx\n return ans\n\ndef fu(A):\n answer = 0\n for j in range(n):\n A[0] = A[0][1:] + A[0][:1]\n for i in range(n):\n A[1] = A[1][1:] + A[1][:1]\n for k in range(n):\n A[2] = A[2][1:] + A[2][:1]\n for l in range(n):\n A[3] = A[3][1:] + A[3][:1]\n #print(A)\n cur_ans = maxsa(A)\n answer = max(answer, cur_ans)\n return answer\n\n\nfor j in range(t):\n n,m = map(int,input().split())\n A = [0] * n\n inds = [-1,-1,-1,-1]\n maxs =[ 0,0,0,0]\n for j in range(n):\n A[j] = list(map(int,input().split()))\n for j in range(m):\n cur_maxs = 0\n for i in range(n):\n cur_maxs = max(cur_maxs, A[i][j])\n maxs.append(cur_maxs)\n inds.append(j)\n ind = 4\n #print(cur_maxs)\n while ind !=0 and maxs[ind] > maxs[ind-1]:\n inds[ind], inds[ind-1] = inds[ind-1] , inds[ind]\n maxs[ind], maxs[ind - 1] = maxs[ind - 1], maxs[ind]\n ind-=1\n maxs.pop()\n inds.pop()\n\n\n #print(maxs)\n #print(inds)\n S = [0] * 4\n for j in range(4):\n if inds[j] != -1:\n #print(A)\n #print(inds[j])\n S[j] = [s[inds[j]] for s in A]\n #print(S[j])\n else:\n S[j] = [0] * n\n #print(S)\n print(fu(S))", "t = int(input())\ndef maxsa(A):\n ans = 0\n #print(\"asdasd\")\n for i in range(n):\n cur_maxx = 0\n for j in range(4):\n cur_maxx = max(cur_maxx, A[j][i])\n ans+= cur_maxx\n return ans\n\ndef fu(A):\n answer = 0\n for j in range(n):\n A[0] = A[0][1:] + A[0][:1]\n for i in range(n):\n A[1] = A[1][1:] + A[1][:1]\n for k in range(n):\n A[2] = A[2][1:] + A[2][:1]\n for l in range(n):\n A[3] = A[3][1:] + A[3][:1]\n #print(A)\n cur_ans = maxsa(A)\n answer = max(answer, cur_ans)\n return answer\n\n\nfor j in range(t):\n n,m = map(int,input().split())\n A = [0] * n\n inds = [-1,-1,-1,-1]\n maxs =[ 0,0,0,0]\n for j in range(n):\n A[j] = list(map(int,input().split()))\n for j in range(m):\n cur_maxs = 0\n for i in range(n):\n cur_maxs = max(cur_maxs, A[i][j])\n maxs.append(cur_maxs)\n inds.append(j)\n ind = 4\n #print(cur_maxs)\n while ind !=0 and maxs[ind] > maxs[ind-1]:\n inds[ind], inds[ind-1] = inds[ind-1] , inds[ind]\n maxs[ind], maxs[ind - 1] = maxs[ind - 1], maxs[ind]\n ind-=1\n maxs.pop()\n inds.pop()\n\n\n #print(maxs)\n #print(inds)\n S = [0] * 4\n for j in range(4):\n if inds[j] != -1:\n #print(A)\n #print(inds[j])\n S[j] = [s[inds[j]] for s in A]\n #print(S[j])\n else:\n S[j] = [0] * n\n #print(S)\n print(fu(S))", "from random import randint\nfor _ in range(int(input())):\n n, m = map(int, input().split())\n A = [list(map(int, input().split())) for _ in range(n)]\n ans = 0\n for _ in range(100):\n for j in range(m):\n x = randint(0, n - 1)\n if x:\n B = []\n for i in range(n):\n B.append(A[i][j])\n B = B[x:] + B[:x]\n for i in range(n):\n A[i][j] = B[i]\n c = 0\n for i in range(n):\n c += max(A[i])\n ans = max(ans, c)\n print(ans)", "\n\n\ndef solve(matrix, col, N, M):\n if col == M:\n '''\n for row in matrix:\n print(row)\n print()\n '''\n\n ans = 0\n for row in matrix:\n if len(row) == 1:\n ans += row[0]\n else:\n ans += max(*row)\n\n return ans\n\n # girar la columna `col` N - 1 veces\n\n if N == 1:\n return solve(matrix, col + 1, N, M)\n\n ans = solve(matrix, col + 1, N, M)\n for _ in range(N-1):\n tmp = matrix[0][col]\n for n in range(1, N):\n matrix[n-1][col] = matrix[n][col]\n matrix[N-1][col] = tmp\n\n local_ans = solve(matrix, col + 1, N, M)\n if local_ans > ans:\n ans = local_ans\n\n return ans\n\ndef main():\n T = int(input())\n for t in range(T):\n N, M = list([int(x) for x in input().split()])\n\n matrix = []\n for n in range(N):\n matrix.append(\n list([int(x) for x in input().split()])\n )\n\n elements = []\n for n in range(N):\n for m in range(M):\n elements.append((matrix[n][m], m))\n\n elements.sort(reverse=True)\n\n candidates = []\n for t in elements:\n if t[1] not in candidates:\n candidates.append(t[1])\n if len(candidates) == N:\n break\n\n simplified = []\n for n in range(N):\n row = []\n for m in candidates:\n row.append(matrix[n][m])\n simplified.append(row)\n\n ans = solve(simplified, 0, N, min(N, M))\n print(ans)\n\nmain()\n", "for _ in range(int(input())):\n N, M = list(map(int, input().split()))\n X = [[int(a) for a in input().split()] for _ in range(N)]\n Y = [[X[i][j] for i in range(N)] for j in range(M)]\n ma = 0\n dp = [[0] * (1<<N) for _ in range(M+1)]\n for j in range(M):\n for mask in range(1<<N):\n maskpre = mask\n while maskpre >= 0:\n maskpre &= mask\n ma = 0\n for k in range(N):\n s = 0\n for i in range(N):\n if (maskpre >> i) & 1 == 0 and (mask >> i) & 1:\n s += X[i-k][j]\n ma = max(ma, s)\n dp[j+1][mask] = max(dp[j+1][mask], dp[j][maskpre] + ma)\n \n maskpre -= 1\n print(dp[-1][-1])\n"] | {
"inputs": [
"2\n2 3\n2 5 7\n4 2 4\n3 6\n4 1 5 2 10 4\n8 6 6 4 9 10\n5 4 9 5 8 7\n",
"40\n2 2\n5 2\n1 5\n1 1\n3\n1 2\n1 1\n1 2\n1 1\n1 2\n2 3\n2 1\n1\n1\n1 1\n1\n2 1\n1\n1\n1 2\n2 3\n2 2\n1 3\n3 3\n1 1\n1\n2 1\n3\n4\n1 1\n2\n2 2\n1 1\n1 1\n2 2\n1 1\n1 1\n1 1\n1\n2 1\n1\n1\n2 1\n5\n3\n1 1\n2\n1 2\n2 2\n2 1\n1\n1\n2 2\n3 2\n2 4\n1 1\n5\n1 2\n2 1\n1 2\n1 1\n1 2\n1 1\n1 2\n1 1\n1 1\n3\n2 2\n1 2\n2 2\n1 2\n4 3\n1 1\n3\n2 1\n2\n2\n1 2\n3 2\n2 1\n3\n1\n2 1\n1\n1\n2 1\n1\n2\n2 2\n2 1\n2 1\n1 1\n2\n1 2\n3 5\n1 1\n2\n",
"1\n4 2\n1 1\n2 1\n1 2\n2 2\n"
],
"outputs": [
"12\n29\n",
"10\n3\n1\n1\n3\n2\n1\n2\n3\n6\n1\n7\n2\n2\n2\n1\n2\n8\n2\n2\n2\n7\n5\n2\n1\n1\n1\n3\n4\n4\n3\n4\n3\n4\n2\n3\n4\n2\n5\n2\n",
"7\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 13,231 | |
125084542f6da6af8d2641dddd93a2f0 | UNKNOWN | Recently Lynyrd and Skynyrd went to a shop where Lynyrd bought a permutation $p$ of length $n$, and Skynyrd bought an array $a$ of length $m$, consisting of integers from $1$ to $n$.
Lynyrd and Skynyrd became bored, so they asked you $q$ queries, each of which has the following form: "does the subsegment of $a$ from the $l$-th to the $r$-th positions, inclusive, have a subsequence that is a cyclic shift of $p$?" Please answer the queries.
A permutation of length $n$ is a sequence of $n$ integers such that each integer from $1$ to $n$ appears exactly once in it.
A cyclic shift of a permutation $(p_1, p_2, \ldots, p_n)$ is a permutation $(p_i, p_{i + 1}, \ldots, p_{n}, p_1, p_2, \ldots, p_{i - 1})$ for some $i$ from $1$ to $n$. For example, a permutation $(2, 1, 3)$ has three distinct cyclic shifts: $(2, 1, 3)$, $(1, 3, 2)$, $(3, 2, 1)$.
A subsequence of a subsegment of array $a$ from the $l$-th to the $r$-th positions, inclusive, is a sequence $a_{i_1}, a_{i_2}, \ldots, a_{i_k}$ for some $i_1, i_2, \ldots, i_k$ such that $l \leq i_1 < i_2 < \ldots < i_k \leq r$.
-----Input-----
The first line contains three integers $n$, $m$, $q$ ($1 \le n, m, q \le 2 \cdot 10^5$) — the length of the permutation $p$, the length of the array $a$ and the number of queries.
The next line contains $n$ integers from $1$ to $n$, where the $i$-th of them is the $i$-th element of the permutation. Each integer from $1$ to $n$ appears exactly once.
The next line contains $m$ integers from $1$ to $n$, the $i$-th of them is the $i$-th element of the array $a$.
The next $q$ lines describe queries. The $i$-th of these lines contains two integers $l_i$ and $r_i$ ($1 \le l_i \le r_i \le m$), meaning that the $i$-th query is about the subsegment of the array from the $l_i$-th to the $r_i$-th positions, inclusive.
-----Output-----
Print a single string of length $q$, consisting of $0$ and $1$, the digit on the $i$-th positions should be $1$, if the subsegment of array $a$ from the $l_i$-th to the $r_i$-th positions, inclusive, contains a subsequence that is a cyclic shift of $p$, and $0$ otherwise.
-----Examples-----
Input
3 6 3
2 1 3
1 2 3 1 2 3
1 5
2 6
3 5
Output
110
Input
2 4 3
2 1
1 1 2 2
1 2
2 3
3 4
Output
010
-----Note-----
In the first example the segment from the $1$-st to the $5$-th positions is $1, 2, 3, 1, 2$. There is a subsequence $1, 3, 2$ that is a cyclic shift of the permutation. The subsegment from the $2$-nd to the $6$-th positions also contains a subsequence $2, 1, 3$ that is equal to the permutation. The subsegment from the $3$-rd to the $5$-th positions is $3, 1, 2$, there is only one subsequence of length $3$ ($3, 1, 2$), but it is not a cyclic shift of the permutation.
In the second example the possible cyclic shifts are $1, 2$ and $2, 1$. The subsegment from the $1$-st to the $2$-nd positions is $1, 1$, its subsequences are not cyclic shifts of the permutation. The subsegment from the $2$-nd to the $3$-rd positions is $1, 2$, it coincides with the permutation. The subsegment from the $3$ to the $4$ positions is $2, 2$, its subsequences are not cyclic shifts of the permutation. | ["import sys\n\t\t\t\t\ninp = [int(x) for x in sys.stdin.read().split()]\n\nn, m, q = inp[0], inp[1], inp[2]\n\np = [inp[idx] for idx in range(3, n + 3)]\n\nindex_arr = [0] * (n + 1)\nfor i in range(n):\tindex_arr[p[i]] = i\n\na = [inp[idx] for idx in range(n + 3, n + 3 + m)]\n\nleftmost_pos = [m] * (n + 1)\nnext = [-1] * m\n\nfor i in range(m - 1, -1, -1):\n\tindex = index_arr[a[i]]\n\tright_index = 0 if index == n - 1 else index + 1\n\tright = p[right_index]\n\tnext[i] = leftmost_pos[right]\n\tleftmost_pos[a[i]] = i\n\t\nlog = 0\nwhile (1 << log) <= n: log += 1\nlog += 1\ndp = [[m for _ in range(m + 1)] for _ in range(log)]\n\nfor i in range(m):\n\tdp[0][i] = next[i]\n\nfor j in range(1, log):\n\tfor i in range(m):\n\t\tdp[j][i] = dp[j - 1][dp[j - 1][i]]\n\nlast = [0] * m\nfor i in range(m):\n\tp = i\n\tlen = n - 1\n\tfor j in range(log - 1, -1, -1):\n\t\tif (1 << j) <= len:\n\t\t\tp = dp[j][p]\n\t\t\tlen -= (1 << j)\n\tlast[i] = p\n\t\nfor i in range(m - 2, -1, -1):\n\tlast[i] = min(last[i], last[i + 1])\n\t\ninp_idx = n + m + 3\nans = []\nfor i in range(q):\n\tl, r = inp[inp_idx] - 1, inp[inp_idx + 1] - 1\n\tinp_idx += 2\n\tif last[l] <= r:\n\t\tans.append('1')\n\telse:\n\t\tans.append('0')\nprint(''.join(ans))", "import sys\n \nclass segmentTree:\n\tdef __init__(self, n):\n\t\tself.n = n\n\t\tself.seg = [self.n + 1] * (self.n << 1)\n\t\t\n\tdef update(self, p, value):\n\t\tp += self.n\n\t\tself.seg[p] = value\n\t\twhile p > 1:\n\t\t\tp >>= 1\n\t\t\tself.seg[p] = min(self.seg[p * 2], self.seg[p * 2 + 1])\n\t\t\t\n\t\n\tdef query(self, l, r):\n\t\tres = self.n\n\t\tl += self.n\n\t\tr += self.n\n\t\twhile l < r:\n\t\t\tif l & 1:\n\t\t\t\tres = min(res, self.seg[l])\n\t\t\t\tl += 1\n\t\t\tif r & 1:\n\t\t\t\tres = min(res, self.seg[r - 1])\n\t\t\t\tr -= 1\n\t\t\tl >>= 1\n\t\t\tr >>= 1\n\t\treturn res\n\t\t\t\t\ninp = [int(x) for x in sys.stdin.read().split()]\n \nn, m, q = inp[0], inp[1], inp[2]\n \np = [inp[idx] for idx in range(3, n + 3)]\n \nindex_arr = [0] * (n + 1)\nfor i in range(n):\tindex_arr[p[i]] = i\n \na = [inp[idx] for idx in range(n + 3, n + 3 + m)]\n \nleftmost_pos = [m] * (n + 1)\nnext = [-1] * m\n \nfor i in range(m - 1, -1, -1):\n\tindex = index_arr[a[i]]\n\tright_index = 0 if index == n - 1 else index + 1\n\tright = p[right_index]\n\tnext[i] = leftmost_pos[right]\n\tleftmost_pos[a[i]] = i\n\t\nlog = 0\nwhile (1 << log) <= n: log += 1\nlog += 1\ndp = [[m for _ in range(m + 1)] for _ in range(log)]\n \nfor i in range(m):\n\tdp[0][i] = next[i]\n \nfor j in range(1, log):\n\tfor i in range(m):\n\t\tdp[j][i] = dp[j - 1][dp[j - 1][i]]\n \ntree = segmentTree(m)\nfor i in range(m):\n\tp = i\n\tlen = n - 1\n\tfor j in range(log - 1, -1, -1):\n\t\tif (1 << j) <= len:\n\t\t\tp = dp[j][p]\n\t\t\tlen -= (1 << j)\n\ttree.update(i, p)\n \ninp_idx = n + m + 3\nans = []\nfor i in range(q):\n\tl, r = inp[inp_idx] - 1, inp[inp_idx + 1] - 1\n\tinp_idx += 2\n\tif tree.query(l, r + 1) <= r:\n\t\tans.append('1')\n\telse:\n\t\tans.append('0')\nprint(''.join(ans))"] | {
"inputs": [
"3 6 3\n2 1 3\n1 2 3 1 2 3\n1 5\n2 6\n3 5\n",
"2 4 3\n2 1\n1 1 2 2\n1 2\n2 3\n3 4\n",
"1 1 1\n1\n1\n1 1\n"
],
"outputs": [
"110\n",
"010\n",
"1\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 3,016 | |
e052c89990a52be82afefc9b8d3d08a5 | UNKNOWN | In number world, two different numbers are friends if they have a lot in common, but also each one has unique perks.
More precisely, two different numbers $a$ and $b$ are friends if $gcd(a,b)$, $\frac{a}{gcd(a,b)}$, $\frac{b}{gcd(a,b)}$ can form sides of a triangle.
Three numbers $a$, $b$ and $c$ can form sides of a triangle if $a + b > c$, $b + c > a$ and $c + a > b$.
In a group of numbers, a number is lonely if it doesn't have any friends in that group.
Given a group of numbers containing all numbers from $1, 2, 3, ..., n$, how many numbers in that group are lonely?
-----Input-----
The first line contains a single integer $t$ $(1 \leq t \leq 10^6)$ - number of test cases.
On next line there are $t$ numbers, $n_i$ $(1 \leq n_i \leq 10^6)$ - meaning that in case $i$ you should solve for numbers $1, 2, 3, ..., n_i$.
-----Output-----
For each test case, print the answer on separate lines: number of lonely numbers in group $1, 2, 3, ..., n_i$.
-----Example-----
Input
3
1 5 10
Output
1
3
3
-----Note-----
For first test case, $1$ is the only number and therefore lonely.
For second test case where $n=5$, numbers $1$, $3$ and $5$ are lonely.
For third test case where $n=10$, numbers $1$, $5$ and $7$ are lonely. | ["import os\nimport sys\nfrom io import BytesIO, IOBase\n\n\ndef main():\n pass\n\n\n# region fastio\n\nBUFSIZE = 8192\n\n\nclass FastIO(IOBase):\n newlines = 0\n\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n\n\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n\n\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\nprimes = []\nprime = [True] * (10 ** 6 +5)\nprime[0] = False\n\nfor i in range(2, 10 ** 6):\n if prime[i]:\n for j in range(2 * i, 10 ** 6 + 5, i):\n prime[j] = False\n\npref = [0]\nfor i in range(1, 10 ** 6 + 5):\n pref.append(pref[-1])\n if prime[i]:\n pref[-1] += 1\n s = round(i ** .5)\n if s * s == i and prime[s] and i != 1:\n pref[-1] -= 1\n\nn = int(input())\nl = list(map(int, input().split()))\nout = []\nfor v in l:\n out.append(pref[v])\nprint('\\n'.join(map(str,out)))\n", "import os\nimport sys\nfrom io import BytesIO, IOBase\n \n# region fastio\nBUFSIZE = 8192\nclass FastIO(IOBase):\n newlines = 0\n \n def __init__(self, file):\n import os\n self.os = os\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n \n def read(self):\n while True:\n b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n \n def readline(self):\n while self.newlines == 0:\n b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n \n def flush(self):\n if self.writable:\n self.os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n \n \nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n \n \nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\n\"\"\"\nNew numbers are only lonely if prime.\nWhen does a prime stop being lonely\n\n\"\"\"\n\ndef get_p(n):\n \"\"\" Returns a list of primes < n \"\"\"\n z = int(n**0.5)+1\n for s in range(4,len(sieve),2):\n sieve[s] = False\n for i in range(3,z,2):\n if sieve[i]:\n sieve[i*i::2*i]=[False]*((n-i*i-1)//(2*i)+1)\n if i <= 1000:\n sq_primes.add(i*i)\n return\n\nlim = 10**6\nsieve = [True]*(lim+1)\nsq_primes = set()\nsq_primes.add(4)\nget_p(lim+1)\nans = [0,1]\nfor i in range(2,10**6+1):\n tmp = ans[-1]\n if sieve[i]:\n tmp += 1\n elif i in sq_primes:\n tmp -= 1\n ans.append(tmp) \n\n\ndef solve():\n T = int(input().strip())\n A = [int(s) for s in input().split()]\n print(*[ans[A[j]] for j in range(T)])\n return \nsolve()\n#print(time.time()-start_time)\n", "import os\nimport sys\nfrom io import BytesIO, IOBase\n# region fastio\nBUFSIZE = 8192\nclass FastIO(IOBase):\n newlines = 0\n \n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n \n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n \n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n \n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n \n \nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n \n \nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n \n# ------------------------------\n \ndef RL(): return list(map(int, sys.stdin.readline().rstrip().split()))\ndef RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))\ndef N(): return int(input())\ndef print_list(l):\n print(' '.join(map(str,l)))\n# import sys\n# sys.setrecursionlimit(5010)\n# from heapq import *\n# from collections import deque as dq\nfrom math import ceil,floor,sqrt,pow\n# import bisect as bs\n# from collections import Counter\n# from collections import defaultdict as dc \n\ndef judgePrime(n):\n if n < 2:\n return [] \n else:\n output = [1] * n\n output[0],output[1] = 0,0\n for i in range(2,int(n**0.5)+1): \n if output[i] == 1:\n output[i*i:n:i] = [0] * len(output[i*i:n:i])\n return output\n\nprime = judgePrime(1000005)\ns = [0]\nfor i in range(1,1000005):\n s.append(s[-1]+prime[i])\n\nt = N()\na = RL()\nfor n in a:\n print(s[n]-s[int(sqrt(n))]+1)\n", "import sys\ninput=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)\n\n\nMAXPRIME=10**6\nisPrime=[0 for _ in range(MAXPRIME+1)]\nisPrime[0]=-1;isPrime[1]=-1 #0 and 1 are not prime numbers\nfor i in range(2,MAXPRIME//2+1):\n if isPrime[i]==0: #i is prime\n for multiple in range(i*i,MAXPRIME+1,i):\n if isPrime[multiple]==0:\n isPrime[multiple]=i \nprimeNumberSet=set()\nfor i in range(len(isPrime)):\n if isPrime[i]==0:\n primeNumberSet.add(i)\nprimes=sorted(list(primeNumberSet))\n\nlookupTable=[None for _ in range(MAXPRIME+1)]\n\npIdx=-1\npSqRtIdx=-1\nfor i in range(1,MAXPRIME+1):\n while pIdx+1<len(primes) and primes[pIdx+1]<=i:\n pIdx+=1\n while pSqRtIdx+1<len(primes) and (primes[pSqRtIdx+1])**2<=i:\n pSqRtIdx+=1\n total=(pIdx+1)-(pSqRtIdx+1)+1 #1 is always lonely\n lookupTable[i]=total\n\n#print(lookupTable[:30])\n\n#a number is lonely if its gcd with all other numbers is 1. i.e. it is prime and its square > n. also, 1 is always lonely\nt=int(input())\nn=[int(x) for x in input().split()]\nfor nn in n:\n print(lookupTable[nn])\n\n\n\n\n#def gcd(x, y):\n# while y != 0:\n# (x, y) = (y, x % y)\n# return x\n#lonely=[]\n#for i in range(1,n+1):\n# ok=False\n# for j in range(1,n+1):\n# g=gcd(i,j)\n# a=g\n# b=i//g\n# c=j//g\n# if a+b>c and b+c>a and a+c>b:\n# ok=True\n# if i in primeNumberSet:\n# print(i,j)\n# break\n# if ok==False:\n# lonely.append(i)\n#print(lonely)\n", "import sys\ninput=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)\n\nMAXPRIME=10**6\nisPrime=[0 for _ in range(MAXPRIME+1)]\nisPrime[0]=-1;isPrime[1]=-1 #0 and 1 are not prime numbers\nfor i in range(2,MAXPRIME//2+1):\n if isPrime[i]==0: #i is prime\n for multiple in range(i*i,MAXPRIME+1,i):\n if isPrime[multiple]==0:\n isPrime[multiple]=i \nprimeNumberSet=set()\nfor i in range(len(isPrime)):\n if isPrime[i]==0:\n primeNumberSet.add(i)\nprimes=sorted(list(primeNumberSet))\n\nlookupTable=[None for _ in range(MAXPRIME+1)]\n\npIdx=-1\npSqRtIdx=-1\nfor i in range(1,MAXPRIME+1):\n while pIdx+1<len(primes) and primes[pIdx+1]<=i:\n pIdx+=1\n while pSqRtIdx+1<len(primes) and (primes[pSqRtIdx+1])**2<=i:\n pSqRtIdx+=1\n total=(pIdx+1)-(pSqRtIdx+1)+1 #1 is always lonely\n lookupTable[i]=total\n\n#print(lookupTable[:30])\n\n#a number is lonely if its gcd with all other numbers is 1. i.e. it is prime and its square > n. also, 1 is always lonely\nt=int(input())\nn=[int(x) for x in input().split()]\nans=[str(lookupTable[nn]) for nn in n]\nprint('\\n'.join(ans))", "import sys\ninput=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)\n\nMAXPRIME=10**6\nisPrime=[0 for _ in range(MAXPRIME+1)]\nisPrime[0]=-1;isPrime[1]=-1 #0 and 1 are not prime numbers\nfor i in range(2,MAXPRIME//2+1):\n if isPrime[i]==0: #i is prime\n for multiple in range(i*i,MAXPRIME+1,i):\n if isPrime[multiple]==0:\n isPrime[multiple]=i \nprimeNumberSet=set()\nfor i in range(len(isPrime)):\n if isPrime[i]==0:\n primeNumberSet.add(i)\nprimes=sorted(list(primeNumberSet))\n\nlookupTable=[None for _ in range(MAXPRIME+1)]\n\npIdx=-1\npSqRtIdx=-1\nfor i in range(1,MAXPRIME+1):\n while pIdx+1<len(primes) and primes[pIdx+1]<=i:\n pIdx+=1\n while pSqRtIdx+1<len(primes) and (primes[pSqRtIdx+1])**2<=i:\n pSqRtIdx+=1\n total=(pIdx+1)-(pSqRtIdx+1)+1 #1 is always lonely\n lookupTable[i]=total\n\n#print(lookupTable[:30])\n\n#a number is lonely if its gcd with all other numbers is 1. i.e. it is prime and its square > n. also, 1 is always lonely\nt=int(input())\nn=[int(x) for x in input().split()]\nprint('\\n'.join([str(lookupTable[nn]) for nn in n]))", "import os\nimport sys\nfrom io import BytesIO, IOBase\n# region fastio\nBUFSIZE = 8192\nclass FastIO(IOBase):\n newlines = 0\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\nMAXPRIME=10**6\nisPrime=[0 for _ in range(MAXPRIME+1)]\nisPrime[0]=-1;isPrime[1]=-1 #0 and 1 are not prime numbers\nfor i in range(2,MAXPRIME//2+1):\n if isPrime[i]==0: #i is prime\n for multiple in range(i*i,MAXPRIME+1,i):\n if isPrime[multiple]==0:\n isPrime[multiple]=i \nprimeNumberSet=set()\nfor i in range(len(isPrime)):\n if isPrime[i]==0:\n primeNumberSet.add(i)\nprimes=sorted(list(primeNumberSet))\n\nlookupTable=[None for _ in range(MAXPRIME+1)]\n\npIdx=-1\npSqRtIdx=-1\nfor i in range(1,MAXPRIME+1):\n while pIdx+1<len(primes) and primes[pIdx+1]<=i:\n pIdx+=1\n while pSqRtIdx+1<len(primes) and (primes[pSqRtIdx+1])**2<=i:\n pSqRtIdx+=1\n total=(pIdx+1)-(pSqRtIdx+1)+1 #1 is always lonely\n lookupTable[i]=total\n\n#print(lookupTable[:30])\n\n#a number is lonely if its gcd with all other numbers is 1. i.e. it is prime and its square > n. also, 1 is always lonely\nt=int(input())\nn=[int(x) for x in input().split()]\nprint('\\n'.join([str(lookupTable[nn]) for nn in n]))", "# ------------------- fast io --------------------\nimport os\nimport sys\nfrom io import BytesIO, IOBase\n \nBUFSIZE = 8192\n \nclass FastIO(IOBase):\n newlines = 0\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n \n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n \n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n \n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n \n \nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n \n \nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\ninput = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n# ------------------- fast io --------------------\nfrom bisect import bisect_left as bsl;import math\ndef sieve(n): \n prime = [True for i in range(n + 1)] \n p = 2\n while (p * p <= n): \n if (prime[p] == True): \n for i in range(p * 2, n + 1, p): \n prime[i] = False\n p += 1\n prime[0]= False\n prime[1]= False\n pp=[]\n for p in range(n + 1): \n if prime[p]: \n pp.append(p)\n return pp\nprimes=sieve(10**6)\nt=int(input());vals=list(map(int,input().split()))\nfor j in range(t):\n n=vals[j]\n ind1=min(bsl(primes,math.floor(math.sqrt(n))),len(primes)-1)\n ind2=min(bsl(primes,n),len(primes)-1)\n if primes[ind1]>math.floor(math.sqrt(n)):\n ind1-=1\n if primes[ind2]>n:\n ind2-=1\n print(ind2+1-ind1)", "\"\"\"\n Author - Satwik Tiwari .\n 27th Sept , 2020 - Sunday\n\"\"\"\n\n#===============================================================================================\n#importing some useful libraries.\n\n\n\nfrom fractions import Fraction\nimport sys\nimport os\nfrom io import BytesIO, IOBase\n\n\n# from itertools import *\nfrom heapq import *\n# from math import gcd, factorial,floor,ceil\n\nfrom copy import deepcopy\nfrom collections import deque\n\n\n# from collections import Counter as counter # Counter(list) return a dict with {key: count}\n# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]\n# from itertools import permutations as permutate\n\n\nfrom bisect import bisect_left as bl\nfrom bisect import bisect_right as br\nfrom bisect import bisect\n\n#==============================================================================================\n#fast I/O region\nBUFSIZE = 8192\n\n\nclass FastIO(IOBase):\n newlines = 0\n\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\n\n\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\n\n\ndef print(*args, **kwargs):\n \"\"\"Prints the values to a stream, or to sys.stdout by default.\"\"\"\n sep, file = kwargs.pop(\"sep\", \" \"), kwargs.pop(\"file\", sys.stdout)\n at_start = True\n for x in args:\n if not at_start:\n file.write(sep)\n file.write(str(x))\n at_start = False\n file.write(kwargs.pop(\"end\", \"\\n\"))\n if kwargs.pop(\"flush\", False):\n file.flush()\n\n\nif sys.version_info[0] < 3:\n sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)\nelse:\n sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\n\n# inp = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")\n\n#===============================================================================================\n### START ITERATE RECURSION ###\nfrom types import GeneratorType\ndef iterative(f, stack=[]):\n def wrapped_func(*args, **kwargs):\n if stack: return f(*args, **kwargs)\n to = f(*args, **kwargs)\n while True:\n if type(to) is GeneratorType:\n stack.append(to)\n to = next(to)\n continue\n stack.pop()\n if not stack: break\n to = stack[-1].send(to)\n return to\n return wrapped_func\n#### END ITERATE RECURSION ####\n\n#===============================================================================================\n#some shortcuts\n\nmod = 10**9+7\ndef inp(): return sys.stdin.readline().rstrip(\"\\r\\n\") #for fast input\ndef out(var): sys.stdout.write(str(var)) #for fast output, always take string\ndef lis(): return list(map(int, inp().split()))\ndef stringlis(): return list(map(str, inp().split()))\ndef sep(): return list(map(int, inp().split()))\ndef strsep(): return list(map(str, inp().split()))\n# def graph(vertex): return [[] for i in range(0,vertex+1)]\ndef zerolist(n): return [0]*n\ndef nextline(): out(\"\\n\") #as stdout.write always print sring.\ndef testcase(t):\n for pp in range(t):\n solve(pp)\ndef printlist(a) :\n for p in range(0,len(a)):\n out(str(a[p]) + ' ')\ndef google(p):\n print('Case #'+str(p)+': ',end='')\ndef lcm(a,b): return (a*b)//gcd(a,b)\ndef power(x, y, p) :\n res = 1 # Initialize result\n x = x % p # Update x if it is more , than or equal to p\n if (x == 0) :\n return 0\n while (y > 0) :\n if ((y & 1) == 1) : # If y is odd, multiply, x with result\n res = (res * x) % p\n\n y = y >> 1 # y = y/2\n x = (x * x) % p\n return res\ndef ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))\ndef isPrime(n) :\n if (n <= 1) : return False\n if (n <= 3) : return True\n if (n % 2 == 0 or n % 3 == 0) : return False\n i = 5\n while(i * i <= n) :\n if (n % i == 0 or n % (i + 2) == 0) :\n return False\n i = i + 6\n return True\n\n#===============================================================================================\n# code here ;))\nans = [0]*(10**6+5)\n\ndef sieve(a): #O(n loglogn) nearly linear\n #all odd mark 1\n for i in range(3,((10**6)+5),2):\n a[i] = 1\n #marking multiples of i form i*i 0. they are nt prime\n for i in range(3,((10**6)+5),2):\n for j in range(i*i,((10**6)+5),i):\n a[j] = 0\n a[2] = 1 #special left case\n return (a)\n\n\na = [0]*((10**6)+6)\na = sieve(a)\nprimes = []\nfor i in range(10**6+1):\n if(a[i]):\n primes.append(i)\n\n# primes = primes[1:]\n# print(ans[:20])\n\n\nfor i in primes:\n ans[i] += 1\n ans[min(10**6+2,i*i)] -=1\n\n# print(ans[:20])\nfor i in range(2,10**6+1):\n ans[i] +=ans[i-1]\n\n# print(ans[:20])\n\n\ndef solve(case):\n n = int(inp())\n aa = lis()\n print('\\n'.join(str(ans[i]+1) for i in aa))\n\n\n\n\ntestcase(1)\n# testcase(int(inp()))\n", "import sys\ninput = sys.stdin.buffer.readline\nn = int(input())\na = list(map(int,input().split()))\nn = max(a)+1\nspf = [i for i in range(n)]\nfor i in range(4,n,2): spf[i] = 2\nfor i in range(3,int(n**.5)+1,2):\n if spf[i]!=i:continue\n for j in range(i*i, n, i):\n if spf[j]==j:spf[j] = i\ncnt = 0\ndp = [0]*n\nfor i in range(1,n):\n if spf[i]==i: cnt+=1\n dp[i] = cnt\ndef query(n):\n return dp[n]-dp[int(n**.5)]+1\nprint(\"\\n\".join(str(dp[n]-dp[int(n**.5)]+1) for n in a))\n", "import sys\nimport os\nfrom io import BytesIO, IOBase\nBUFSIZE = 8192\nclass FastIO(IOBase):\n newlines = 0\n def __init__(self, file):\n self._fd = file.fileno()\n self.buffer = BytesIO()\n self.writable = \"x\" in file.mode or \"r\" not in file.mode\n self.write = self.buffer.write if self.writable else None\n def read(self):\n while True:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n if not b:\n break\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines = 0\n return self.buffer.read()\n def readline(self):\n while self.newlines == 0:\n b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))\n self.newlines = b.count(b\"\\n\") + (not b)\n ptr = self.buffer.tell()\n self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)\n self.newlines -= 1\n return self.buffer.readline()\n def flush(self):\n if self.writable:\n os.write(self._fd, self.buffer.getvalue())\n self.buffer.truncate(0), self.buffer.seek(0)\nclass IOWrapper(IOBase):\n def __init__(self, file):\n self.buffer = FastIO(file)\n self.flush = self.buffer.flush\n self.writable = self.buffer.writable\n self.write = lambda s: self.buffer.write(s.encode(\"ascii\"))\n self.read = lambda: self.buffer.read().decode(\"ascii\")\n self.readline = lambda: self.buffer.readline().decode(\"ascii\")\nsys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)\n################################# fast IO ###############################\n\n\n\ninput = sys.stdin.buffer.readline\nn = int(input())\na = list(map(int,input().split()))\nn = max(a)+1\nspf = [i for i in range(n)]\nfor i in range(4,n,2): spf[i] = 2\nfor i in range(3,int(n**.5)+1,2):\n if spf[i]!=i:continue\n for j in range(i*i, n, i):\n if spf[j]==j:spf[j] = i\ncnt = 0\ndp = [0]*n\nfor i in range(1,n):\n if spf[i]==i: cnt+=1\n dp[i] = cnt\nprint(\"\\n\".join(str(dp[n]-dp[int(n**.5)]+1) for n in a))\n", "import os,io\ninput = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline\nn = 10**6+1\nprimes = [1]*n\nprimes[0],primes[1] = 0,0\nv = int(n**0.5)+1\nfor i in range(2,v):\n if primes[i]:\n for j in range(i*i,n,i):\n primes[j]=0\nfor i in range(1,n):\n primes[i]+=primes[i-1]\n\ncases = int(input())\nfor t in range(cases):\n n1 = list(map(int,input().split()))\n for ni in n1:\n print(primes[ni]-primes[int(ni**0.5)]+1)"] | {
"inputs": [
"3\n1 5 10\n",
"6\n12 432 21 199 7 1\n",
"7\n1 10 100 1000 10000 100000 1000000\n",
"100\n42 486 341 527 189 740 490 388 989 489 711 174 305 844 971 492 998 954 832 442 424 619 906 154 293 395 439 735 738 915 453 748 786 550 871 932 693 326 53 904 732 835 354 364 691 669 157 719 282 875 573 672 695 790 58 872 732 751 557 779 329 39 213 844 289 137 50 951 284 671 474 829 906 736 395 366 22 133 418 552 649 636 109 974 775 852 971 384 945 335 961 472 651 335 543 560 135 85 952 558\n",
"100\n838 147 644 688 727 940 991 309 705 409 27 774 951 92 277 835 804 589 103 529 11 304 171 655 378 792 679 590 36 65 378 152 958 746 980 434 139 222 26 349 473 300 781 394 960 918 242 768 246 607 429 971 534 44 430 198 901 624 781 657 428 366 652 558 570 490 623 46 606 375 302 867 384 32 601 46 376 223 688 509 290 739 54 2 445 966 907 792 146 468 732 908 673 506 825 424 325 624 836 524\n",
"100\n324 624 954 469 621 255 536 588 821 334 231 20 850 642 5 735 199 506 97 358 554 589 344 513 456 226 472 625 601 816 813 297 609 819 38 185 493 646 557 305 45 204 209 687 966 198 835 911 176 523 219 637 297 76 349 669 389 891 894 462 899 163 868 418 903 31 333 670 32 705 561 505 920 414 81 723 603 513 25 896 879 703 415 799 271 440 8 596 207 296 116 458 646 781 842 963 174 157 747 207\n",
"100\n996 361 371 721 447 566 438 566 449 522 176 79 740 757 156 436 296 23 704 542 572 455 886 962 194 219 301 437 315 122 513 299 468 760 133 713 348 692 792 276 318 380 217 74 913 819 834 966 318 784 350 578 670 11 482 149 220 243 137 164 541 471 185 477 57 681 319 466 271 45 181 540 750 670 200 322 479 51 171 33 806 915 976 399 213 629 504 419 324 850 364 900 397 180 845 99 495 326 526 186\n",
"100\n791 303 765 671 210 999 106 489 243 635 807 104 558 628 545 926 35 3 75 196 35 460 523 621 748 45 501 143 240 318 78 908 207 369 436 6 285 200 236 864 731 786 915 672 293 563 141 708 698 646 48 128 603 716 681 329 389 489 683 616 875 510 20 493 141 176 803 106 92 928 20 762 203 336 586 258 56 781 172 115 890 104 595 491 607 489 628 653 635 960 449 549 909 977 124 621 741 275 206 558\n"
],
"outputs": [
"1\n3\n3\n",
"4\n76\n7\n41\n4\n1\n",
"1\n3\n22\n158\n1205\n9528\n78331\n",
"11\n85\n62\n92\n37\n123\n86\n69\n156\n86\n119\n35\n56\n137\n154\n87\n158\n153\n137\n78\n75\n106\n145\n32\n56\n70\n78\n122\n122\n147\n80\n124\n129\n93\n141\n149\n117\n60\n13\n145\n121\n137\n65\n65\n117\n113\n33\n120\n55\n141\n97\n113\n117\n130\n13\n141\n121\n125\n94\n129\n60\n10\n42\n137\n55\n29\n12\n152\n56\n113\n84\n137\n145\n122\n70\n65\n7\n28\n73\n93\n110\n107\n26\n154\n129\n137\n154\n69\n151\n61\n152\n84\n110\n61\n92\n94\n28\n20\n152\n94\n",
"137\n30\n109\n116\n121\n150\n157\n57\n118\n73\n7\n129\n152\n21\n54\n137\n131\n99\n24\n91\n4\n56\n34\n111\n67\n130\n115\n99\n9\n15\n67\n32\n153\n124\n155\n77\n30\n42\n7\n64\n84\n56\n129\n70\n153\n147\n48\n127\n48\n103\n75\n154\n91\n12\n75\n40\n145\n106\n129\n111\n75\n65\n110\n94\n96\n86\n106\n12\n102\n67\n56\n141\n69\n9\n102\n12\n67\n43\n116\n90\n55\n123\n13\n2\n79\n152\n146\n130\n30\n84\n121\n146\n114\n89\n135\n75\n60\n106\n137\n92\n",
"60\n106\n153\n84\n106\n49\n91\n99\n134\n61\n45\n7\n137\n108\n3\n122\n41\n89\n22\n65\n93\n99\n62\n90\n80\n43\n84\n106\n102\n133\n133\n56\n103\n133\n10\n37\n87\n109\n94\n56\n12\n41\n41\n116\n152\n40\n137\n147\n35\n92\n42\n107\n56\n18\n64\n113\n70\n145\n145\n82\n145\n34\n141\n73\n145\n9\n61\n113\n9\n118\n94\n89\n148\n73\n19\n120\n102\n90\n7\n145\n142\n118\n73\n131\n53\n78\n4\n100\n41\n56\n27\n81\n109\n129\n137\n152\n35\n33\n124\n41\n",
"157\n65\n66\n120\n79\n95\n77\n95\n80\n91\n35\n19\n123\n126\n32\n77\n56\n8\n118\n92\n97\n80\n144\n152\n39\n42\n56\n77\n59\n26\n90\n56\n84\n126\n28\n119\n63\n117\n130\n53\n60\n68\n42\n18\n147\n133\n137\n152\n60\n129\n64\n98\n113\n4\n85\n31\n42\n48\n29\n34\n92\n84\n37\n84\n13\n115\n60\n83\n53\n12\n37\n91\n124\n113\n41\n60\n85\n12\n34\n9\n131\n147\n154\n71\n42\n106\n89\n74\n60\n137\n65\n145\n71\n36\n137\n22\n87\n60\n92\n37\n",
"130\n56\n127\n113\n41\n158\n24\n86\n48\n107\n131\n24\n94\n106\n92\n148\n9\n3\n18\n39\n9\n81\n92\n106\n124\n12\n88\n30\n47\n60\n18\n146\n41\n66\n77\n3\n56\n41\n46\n141\n121\n129\n147\n113\n56\n95\n30\n118\n117\n109\n13\n27\n102\n119\n115\n60\n70\n86\n116\n104\n141\n90\n7\n87\n30\n35\n131\n24\n21\n148\n7\n127\n41\n61\n98\n50\n13\n129\n34\n27\n145\n24\n100\n87\n103\n86\n106\n111\n107\n153\n80\n93\n146\n155\n26\n106\n123\n53\n41\n94\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 26,878 | |
0e86a213cd6012f9ea2444dcb05b4fdb | UNKNOWN | Creatnx has $n$ mirrors, numbered from $1$ to $n$. Every day, Creatnx asks exactly one mirror "Am I beautiful?". The $i$-th mirror will tell Creatnx that he is beautiful with probability $\frac{p_i}{100}$ for all $1 \le i \le n$.
Some mirrors are called checkpoints. Initially, only the $1$st mirror is a checkpoint. It remains a checkpoint all the time.
Creatnx asks the mirrors one by one, starting from the $1$-st mirror. Every day, if he asks $i$-th mirror, there are two possibilities: The $i$-th mirror tells Creatnx that he is beautiful. In this case, if $i = n$ Creatnx will stop and become happy, otherwise he will continue asking the $i+1$-th mirror next day; In the other case, Creatnx will feel upset. The next day, Creatnx will start asking from the checkpoint with a maximal number that is less or equal to $i$.
There are some changes occur over time: some mirrors become new checkpoints and some mirrors are no longer checkpoints. You are given $q$ queries, each query is represented by an integer $u$: If the $u$-th mirror isn't a checkpoint then we set it as a checkpoint. Otherwise, the $u$-th mirror is no longer a checkpoint.
After each query, you need to calculate the expected number of days until Creatnx becomes happy.
Each of this numbers should be found by modulo $998244353$. Formally, let $M = 998244353$. It can be shown that the answer can be expressed as an irreducible fraction $\frac{p}{q}$, where $p$ and $q$ are integers and $q \not \equiv 0 \pmod{M}$. Output the integer equal to $p \cdot q^{-1} \bmod M$. In other words, output such an integer $x$ that $0 \le x < M$ and $x \cdot q \equiv p \pmod{M}$.
-----Input-----
The first line contains two integers $n$, $q$ ($2 \leq n, q \le 2 \cdot 10^5$) — the number of mirrors and queries.
The second line contains $n$ integers: $p_1, p_2, \ldots, p_n$ ($1 \leq p_i \leq 100$).
Each of $q$ following lines contains a single integer $u$ ($2 \leq u \leq n$) — next query.
-----Output-----
Print $q$ numbers – the answers after each query by modulo $998244353$.
-----Examples-----
Input
2 2
50 50
2
2
Output
4
6
Input
5 5
10 20 30 40 50
2
3
4
5
3
Output
117
665496274
332748143
831870317
499122211
-----Note-----
In the first test after the first query, the first and the second mirrors are checkpoints. Creatnx will ask the first mirror until it will say that he is beautiful, after that he will ask the second mirror until it will say that he is beautiful because the second mirror is a checkpoint. After that, he will become happy. Probabilities that the mirrors will say, that he is beautiful are equal to $\frac{1}{2}$. So, the expected number of days, until one mirror will say, that he is beautiful is equal to $2$ and the answer will be equal to $4 = 2 + 2$. | ["import sys\nreadline = sys.stdin.readline\nfrom itertools import accumulate\nfrom collections import Counter\nfrom bisect import bisect as br, bisect_left as bl\nclass PMS:\n #1-indexed\n def __init__(self, A, B, issum = False):\n #A\u306b\u521d\u671f\u72b6\u614b\u306e\u8981\u7d20\u3092\u3059\u3079\u3066\u5165\u308c\u308b,B\u306f\u5024\u57df\u306e\u30ea\u30b9\u30c8\n self.X, self.comp = self.compress(B)\n self.size = len(self.X)\n self.tree = [0] * (self.size + 1)\n self.p = 2**(self.size.bit_length() - 1)\n self.dep = self.size.bit_length()\n \n CA = Counter(A)\n S = [0] + list(accumulate([CA[self.X[i]] for i in range(self.size)]))\n for i in range(1, 1+self.size):\n self.tree[i] = S[i] - S[i - (i&-i)]\n if issum:\n self.sumtree = [0] * (self.size + 1)\n Ssum = [0] + list(accumulate([CA[self.X[i]]*self.X[i] for i in range(self.size)]))\n for i in range(1, 1+self.size):\n self.sumtree[i] = Ssum[i] - Ssum[i - (i&-i)]\n \n def compress(self, L):\n #\u5ea7\u5727\n L2 = list(set(L))\n L2.sort()\n C = {v : k for k, v in enumerate(L2, 1)}\n # 1-indexed\n return L2, C\n \n def leng(self):\n #\u4eca\u5165\u3063\u3066\u3044\u308b\u500b\u6570\u3092\u53d6\u5f97\n return self.count(self.X[-1])\n \n def count(self, v):\n #v(B\u306e\u5143)\u4ee5\u4e0b\u306e\u500b\u6570\u3092\u53d6\u5f97\n i = self.comp[v]\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n \n def less(self, v):\n #v(B\u306e\u5143\u3067\u3042\u308b\u5fc5\u8981\u306f\u306a\u3044)\u672a\u6e80\u306e\u500b\u6570\u3092\u53d6\u5f97\n i = bl(self.X, v)\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n \n def leq(self, v):\n #v(B\u306e\u5143\u3067\u3042\u308b\u5fc5\u8981\u306f\u306a\u3044)\u4ee5\u4e0b\u306e\u500b\u6570\u3092\u53d6\u5f97\n i = br(self.X, v)\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n \n def add(self, v, x):\n #v\u3092x\u500b\u5165\u308c\u308b,\u8ca0\u306ex\u3067\u53d6\u308a\u51fa\u3059,i\u306e\u500b\u6570\u4ee5\u4e0a\u53d6\u308a\u51fa\u3059\u3068\u30a8\u30e9\u30fc\u3092\u51fa\u3055\u305a\u306b\u30d0\u30b0\u308b\n i = self.comp[v]\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n def get(self, i):\n # i\u756a\u76ee\u306e\u5024\u3092\u53d6\u5f97\n if i <= 0:\n return -1\n s = 0\n k = self.p\n for _ in range(self.dep):\n if s + k <= self.size and self.tree[s+k] < i:\n s += k\n i -= self.tree[s]\n k //= 2\n return self.X[s]\n \n def gets(self, v):\n #\u7d2f\u7a4d\u548c\u304cv\u4ee5\u4e0b\u3068\u306a\u308b\u6700\u5927\u306eindex\u3092\u8fd4\u3059\n v1 = v\n s = 0\n k = self.p\n for _ in range(self.dep):\n if s + k <= self.size and self.sumtree[s+k] < v:\n s += k\n v -= self.sumtree[s]\n k //= 2\n if s == self.size:\n return self.leng()\n return self.count(self.X[s]) + (v1 - self.countsum(self.X[s]))//self.X[s]\n \n def addsum(self, i, x):\n #sum\u3092\u6271\u3044\u305f\u3044\u3068\u304d\u306badd\u306e\u4ee3\u308f\u308a\u306b\u4f7f\u3046\n self.add(i, x)\n x *= i\n i = self.comp[i]\n while i <= self.size:\n self.sumtree[i] += x\n i += i & -i\n \n def countsum(self, v):\n #v(B\u306e\u5143)\u4ee5\u4e0b\u306esum\u3092\u53d6\u5f97\n i = self.comp[v]\n s = 0\n while i > 0:\n s += self.sumtree[i]\n i -= i & -i\n return s\n \n def getsum(self, i):\n #i\u756a\u76ee\u307e\u3067\u306esum\u3092\u53d6\u5f97\n x = self.get(i)\n return self.countsum(x) - x*(self.count(x) - i)\n \nN, Q = map(int, readline().split())\nP = list(map(int, readline().split()))\nMOD = 998244353\nT = [100*pow(pi, MOD-2, MOD)%MOD for pi in P]\n\nAT = [None]*N\nAT[0] = T[0]\nfor i in range(1, N):\n AT[i] = (AT[i-1]+1)*T[i]%MOD\nAM = [None]*N\nAMi = [None]*N\nAM[0] = T[0]\nfor i in range(1, N):\n AM[i] = AM[i-1]*T[i]%MOD\nAMi[N-1] = pow(AM[N-1], MOD-2, MOD)\nfor i in range(N-2, -1, -1):\n AMi[i] = AMi[i+1]*T[i+1]%MOD\nAT += [0]\nAM += [1]\nAMi += [1]\n\nAns = [None]*Q\nkk = set([0, N])\nPM = PMS([0, N], list(range(N+1)))\nans = AT[N-1]\nfor qu in range(Q):\n f = int(readline()) - 1\n if f not in kk:\n kk.add(f)\n PM.add(f, 1)\n fidx = PM.count(f)\n fm = PM.get(fidx-1)\n fp = PM.get(fidx+1)\n am = (AT[f-1] - AM[f-1]*AMi[fm-1]*AT[fm-1])%MOD\n ap = (AT[fp-1] - AM[fp-1]*AMi[f-1]*AT[f-1])%MOD\n aa = (AT[fp-1] - AM[fp-1]*AMi[fm-1]*AT[fm-1])%MOD\n ans = (ans - aa + am + ap)%MOD\n else:\n kk.remove(f)\n fidx = PM.count(f)\n fm = PM.get(fidx-1)\n fp = PM.get(fidx+1)\n PM.add(f, -1)\n am = (AT[f-1] - AM[f-1]*AMi[fm-1]*AT[fm-1])%MOD\n ap = (AT[fp-1] - AM[fp-1]*AMi[f-1]*AT[f-1])%MOD\n aa = (AT[fp-1] - AM[fp-1]*AMi[fm-1]*AT[fm-1])%MOD\n ans = (ans + aa - am - ap)%MOD\n Ans[qu] = ans\nprint('\\n'.join(map(str, Ans)))"] | {
"inputs": [
"2 2\n50 50\n2\n2\n",
"5 5\n10 20 30 40 50\n2\n3\n4\n5\n3\n",
"2 2\n38 4\n2\n2\n"
],
"outputs": [
"4\n6\n",
"117\n665496274\n332748143\n831870317\n499122211\n",
"262695910\n577931032\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 5,553 | |
4ab4663d11ef7996e1b460692bed9975 | UNKNOWN | You are given a sequence of $n$ digits $d_1d_2 \dots d_{n}$. You need to paint all the digits in two colors so that: each digit is painted either in the color $1$ or in the color $2$; if you write in a row from left to right all the digits painted in the color $1$, and then after them all the digits painted in the color $2$, then the resulting sequence of $n$ digits will be non-decreasing (that is, each next digit will be greater than or equal to the previous digit).
For example, for the sequence $d=914$ the only valid coloring is $211$ (paint in the color $1$ two last digits, paint in the color $2$ the first digit). But $122$ is not a valid coloring ($9$ concatenated with $14$ is not a non-decreasing sequence).
It is allowed that either of the two colors is not used at all. Digits painted in the same color are not required to have consecutive positions.
Find any of the valid ways to paint the given sequence of digits or determine that it is impossible to do.
-----Input-----
The first line contains a single integer $t$ ($1 \le t \le 10000$) — the number of test cases in the input.
The first line of each test case contains an integer $n$ ($1 \le n \le 2\cdot10^5$) — the length of a given sequence of digits.
The next line contains a sequence of $n$ digits $d_1d_2 \dots d_{n}$ ($0 \le d_i \le 9$). The digits are written in a row without spaces or any other separators. The sequence can start with 0.
It is guaranteed that the sum of the values of $n$ for all test cases in the input does not exceed $2\cdot10^5$.
-----Output-----
Print $t$ lines — the answers to each of the test cases in the input.
If there is a solution for a test case, the corresponding output line should contain any of the valid colorings written as a string of $n$ digits $t_1t_2 \dots t_n$ ($1 \le t_i \le 2$), where $t_i$ is the color the $i$-th digit is painted in. If there are several feasible solutions, print any of them.
If there is no solution, then the corresponding output line should contain a single character '-' (the minus sign).
-----Example-----
Input
5
12
040425524644
1
0
9
123456789
2
98
3
987
Output
121212211211
1
222222222
21
-
-----Note-----
In the first test case, $d=040425524644$. The output $t=121212211211$ is correct because $0022444$ (painted in $1$) concatenated with $44556$ (painted in $2$) is $002244444556$ which is a sorted sequence of $n$ given digits. | ["for __ in range(int(input())):\n n = int(input())\n s = list(map(int, input()))\n r = [0] * n\n for i in range(10):\n left_lim = 0\n for j, c in enumerate(s):\n if c < i: left_lim = j + 1\n prv = [-1, -1, -1]\n flg = True\n for j, c in enumerate(s):\n r[j] = 1 if c < i or (c == i and j >= left_lim) else 2\n if c < prv[r[j]]: flg = False; break\n prv[r[j]] = c\n if flg:\n print(''.join(map(str, r)))\n break\n if not flg:\n print('-')", "def calc(X):\n for i in range(10):\n RET = []\n h = i\n l = 0\n for j in range(len(X)):\n if X[j] >= h:\n h = X[j]\n RET.append(\"2\")\n elif l <= X[j] <= i:\n l = X[j]\n RET.append(\"1\")\n else:\n break\n else:\n print(\"\".join(RET))\n break\n else:\n print(\"-\")\n\nT = int(input())\nfor _ in range(T):\n N = int(input())\n A = [int(a) for a in input()]\n calc(A)\n\n", "def main():\n from sys import stdin, stdout\n input1 = stdin.readline\n print1 = stdout.write\n for _ in range(int(input1())):\n input1()\n t = tuple(map(int, input1().rstrip('\\n')))\n for mid in range(10):\n ans = []\n lasts = [0, 0, 0]\n lasts[2] = mid\n for ti in t:\n if ti < lasts[1]:\n break\n if ti < lasts[2]:\n color = 1\n else:\n color = 2\n ans.append(str(color))\n lasts[color] = ti\n else:\n if lasts[1] == mid:\n print1(''.join(ans) + '\\n')\n break\n else:\n print1('-\\n')\n\n\nmain()\n", "import sys\nl1 = []\nl2 = []\n\n\ndef iss():\n for i in range(len(l1) - 1):\n if l1[i+1] < l1[i]:\n return False\n for i in range(len(l2) - 1):\n if l2[i+1] < l2[i]:\n return False\n return True\n\n\n\n\n\n\nfor q in range(int(input())):\n n = int(sys.stdin.readline())\n data = [int(i) for i in sys.stdin.readline().strip()]\n done = False\n for d in range(10):\n mnl2 = -1\n mxl1 = -1\n same = []\n l1 = []\n l2 = []\n ans = ['0']*n\n for i in range(n):\n f = data[i]\n if f > d:\n l2.append(f)\n ans[i] = '2'\n \n if mnl2 == -1:\n mnl2 = i\n elif f < d:\n ans[i] = '1'\n l1.append(f)\n mxl1 = i\n else:\n same.append(i)\n # print(d, same, l1, l2, iss(), mxl1, mnl2)\n if not iss():\n continue\n good = True\n for s in same:\n if s > mxl1:\n ans[s] = '1'\n elif s < mnl2:\n ans[s] = '2'\n else:\n good = False\n break\n if not good:\n continue\n sys.stdout.write(\"\".join(ans) + '\\n')\n done = True\n break\n if not done:\n sys.stdout.write('-\\n')\n\n \n\n\n", "#!/usr/bin/env python3\nimport sys\n\ndef rint():\n return list(map(int, sys.stdin.readline().split()))\n#lines = stdin.readlines()\n\nt = int(input())\nfor tt in range(t):\n n = int(input())\n d_str = input()\n d = []\n for i in range(n):\n d.append(int(d_str[i]))\n #print(d)\n di=[]\n for i in range(n):\n di.append(i)\n #print(d)\n for b in range(10):\n one_min = -1\n two_min = -1\n not_ok = 0\n ans = []\n for i in range(n):\n if d[i] < b:\n if d[i] < one_min:\n not_ok = 1\n break\n one_min = d[i]\n ans.append(1)\n\n elif d[i] > b:\n if d[i] < two_min:\n not_ok = 1\n break\n two_min = d[i]\n ans.append(2)\n else:\n if b >= two_min:\n two_min = b\n ans.append(2)\n elif b >= one_min:\n one_min = b\n ans.append(1)\n else:\n not_ok = 1\n break\n if not_ok != 1:\n print(\"\".join(map(str,ans)))\n break\n else:\n print(\"-\")\n\n\n\n\n\n", "t = int(input())\n\nfor i in range(t):\n n = int(input())\n s = input().rstrip()\n sint = [int(item) for item in s]\n for div in range(10):\n is_ok = True\n ga = []; gb = []\n a = 0; b = div \n for i, item in enumerate(sint):\n # b should take\n if item > div:\n if b > item:\n is_ok = False\n break\n else:\n gb.append(i)\n b = item\n elif item == div:\n if b == div:\n gb.append(i)\n else:\n a = item\n ga.append(i)\n else:\n if a > item:\n is_ok = False\n break\n else:\n ga.append(i)\n a = item\n if is_ok:\n break\n if is_ok:\n ans = [1] * n\n for item in gb:\n ans[item] = 2\n print(\"\".join([str(item) for item in ans]))\n else:\n print(\"-\")", "T = int(input())\nfor t in range(T):\n N = int(input())\n sequence = input().strip()\n digits = set(sequence)\n isPossible = False\n number = \"\"\n ret = []\n for minTwo in digits:\n ret = []\n one = str(0)\n two = minTwo\n for i, digit in enumerate(sequence):\n if digit < one:\n break\n elif digit >= two:\n two = digit\n ret.append(\"2\")\n elif digit > minTwo:\n break\n else:\n one = digit\n ret.append(\"1\")\n if i == len(sequence) - 1:\n isPossible = True\n if isPossible:\n break\n if isPossible:\n ret = \"\".join(ret)\n print(ret)\n else:\n print(\"-\")\n", "for t in range(int(input())):\n n = int(input())\n ans = [2]*n\n d = list(map(int,input()))\n k = d[0]\n ind_1 = -1\n for i in range(n):\n if d[i] > k:\n k = d[i]\n if d[i] < k:\n ans[i] = 1\n if ind_1 == -1:\n ind_1 = i\n for i in range(ind_1):\n if d[i] <= d[ind_1]:\n ans[i] = 1\n itog = []\n for i in range(n):\n if ans[i] == 1:\n itog.append(d[i])\n for i in range(n):\n if ans[i] == 2:\n itog.append(d[i])\n for i in range(1,n):\n if itog[i] < itog[i-1]:\n print('-')\n break\n else:\n print(''.join(map(str,ans)))\n\n\n\n", "import sys\ndef main():\n def input():\n return sys.stdin.readline()[:-1]\n t = int(input())\n for z in range(t):\n flag = 0\n n = int(input())\n s = [int(x) for x in input()]\n for limit in range(10):\n ans = [0 for k in range(n)]\n p = 0\n for now in range(limit+1):\n for k in range(p,n):\n if s[k] == now:\n p = k\n ans[k] = 1\n p = 0\n for now in range(limit,10):\n for k in range(p,n):\n if s[k] == now and ans[k] == 0:\n p = k\n ans[k] = 2\n if 0 not in ans:\n flag = 1\n print(*ans,sep=\"\")\n break\n if flag == 0:\n print(\"-\")\n\ndef __starting_point():\n main()\n\n__starting_point()"] | {
"inputs": [
"5\n12\n040425524644\n1\n0\n9\n123456789\n2\n98\n3\n987\n",
"5\n4\n6148\n1\n7\n5\n49522\n3\n882\n2\n51\n",
"5\n1\n3\n5\n74730\n1\n4\n5\n49554\n2\n59\n"
],
"outputs": [
"121212211211\n1\n222222222\n21\n-\n",
"2112\n2\n-\n221\n21\n",
"2\n-\n2\n-\n22\n"
]
} | COMPETITION | PYTHON3 | CODEFORCES | 8,281 | |
9bed21c3cda6cbdedb74612e3049be86 | UNKNOWN | In Finite Encyclopedia of Integer Sequences (FEIS), all integer sequences of lengths between 1 and N (inclusive) consisting of integers between 1 and K (inclusive) are listed.
Let the total number of sequences listed in FEIS be X. Among those sequences, find the (X/2)-th (rounded up to the nearest integer) lexicographically smallest one.
-----Constraints-----
- 1 \leq N,K \leq 3 × 10^5
- N and K are integers.
-----Input-----
Input is given from Standard Input in the following format:
K N
-----Output-----
Print the (X/2)-th (rounded up to the nearest integer) lexicographically smallest sequence listed in FEIS, with spaces in between, where X is the total number of sequences listed in FEIS.
-----Sample Input-----
3 2
-----Sample Output-----
2 1
There are 12 sequences listed in FEIS: (1),(1,1),(1,2),(1,3),(2),(2,1),(2,2),(2,3),(3),(3,1),(3,2),(3,3).
The (12/2 = 6)-th lexicographically smallest one among them is (2,1). | ["k,n = map(int,input().split())\nif k %2 ==0:\n ans = []\n ans.append(k//2)\n for i in range(n-1):\n ans.append(k)\n print(*ans)\nelse:\n ans = []\n for i in range(n):\n ans.append(k//2+1)\n sage = (n)//2\n for i in range(sage):\n if ans[-1] == 1:\n ans.pop()\n else:\n ans[-1] -= 1\n while len(ans) < n:\n ans.append(k)\n print(*ans)", "#!/usr/bin/env python3\n\nimport math\n\ndef main():\n [K, N] = list(map(int, input().split()))\n\n r = []\n if K == 1:\n r = [1] * ((N + 1) // 2)\n elif K % 2 == 0:\n r = [K // 2]\n r += [K] * (N - 1)\n else:\n t = N // 2\n x = int(math.log(N * (K - 1) + 1, K) - 1)\n while t < ((K ** (x + 1) - 1) / (K - 1) + x) // 2:\n x -= 1\n x += 1\n r = [(K + 1) // 2] * (N - x)\n r += [0] * x\n t = ((K ** (x + 1) - 1) / (K - 1) + x) // 2 - t\n for i in range(x, 0, -1):\n r[N - i] = 1\n t -= 1\n for j in range(K - 1):\n if t == 0:\n break\n if K ** i - 1 <= t * (K - 1):\n r[N - i] += 1\n t -= (K ** i - 1) // (K - 1)\n if t == 0:\n break\n\n for i in range(len(r) - 1, -1, -1):\n if r[i] == 0:\n r.pop()\n else:\n break\n\n\n print((' '.join(list(map(str, r)))))\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "from itertools import chain,repeat\nK,N = list(map(int,input().split()))\n\ndef solve():\n\n if K % 2 == 0:\n return ' '.join(map(str, chain((K//2,),repeat(K,N-1))))\n else:\n seq = [K//2+1]*N\n d = N//2\n for _ in range(d):\n if seq[-1] == 1:\n seq.pop()\n else:\n seq[-1] -= 1\n seq.extend(repeat(K,N-len(seq)))\n return ' '.join(map(str, seq))\n\ndef naive():\n from itertools import product\n s = sorted(chain.from_iterable(product(list(range(1,K+1)),repeat=i) for i in range(1,N+1)))\n return ' '.join(map(str, s[(len(s)-1)//2]))\n\nprint((solve()))\n# print(naive())\n", "K, N = list(map(int, input().split()))\n\nif K % 2 == 0:\n ans = [K//2] + [K] * (N-1)\nelse:\n ans = [(K+1)//2] * N\n for i in range(N//2):\n if ans[-1] == 1:\n ans.pop()\n else:\n ans[-1] -= 1\n ans += [K] * (N - len(ans))\n\nprint((' '.join(map(str, ans))))\n", "def solve(k, n):\n if k & 1 == 0:\n return [k // 2] + [k] * (n - 1)\n ans = [k // 2 + 1] * n\n l = n\n for i in range((n - 2) // 2 + 1):\n if ans[-1] == 1:\n ans.pop()\n l -= 1\n else:\n ans[-1] -= 1\n if l < n:\n ans += [k] * (n - l)\n l = n\n return ans\n\n\nk, n = list(map(int, input().split()))\n\nprint((*solve(k, n)))\n", "def main():\n K,N = map(int,input().split())\n\n if K % 2 == 0:\n ans = [K//2]\n for i in range(N-1):\n ans.append(K)\n else:\n back = N // 2\n mid = K // 2 + 1\n ans = [mid for i in range(N)]\n for i in range(back):\n if ans[-1] == 1:\n ans.pop()\n else:\n ans[-1] -= 1\n while len(ans) < N:\n ans.append(K)\n print(' '.join(map(str, ans)))\n\ndef __starting_point():\n main()\n__starting_point()", "import sys\nreadline = sys.stdin.readline\n\nINF = 10**9+7\ndef calc(n, k):\n if k == 1:\n return n\n if n > 20:\n return INF\n return min(INF, (pow(k, n)-1)//(k-1))\n \n\nK, N = list(map(int, readline().split()))\n\nif K%2 == 0:\n ans = [K//2] + [K]*(N-1)\n print((*ans))\nelse: \n ans = []\n cnt = 0\n half = True\n for l in range(N, 0, -1):\n clk = calc(l, K)\n if half:\n c = 1+K//2\n if l%2 == 0:\n cnt += 1\n if clk//2 == cnt:\n ans.append(c)\n break\n if clk//2 < cnt:\n c -= 1\n half = False\n cnt -= clk//2 + 1\n \n while cnt >= clk:\n cnt -= clk\n c -= 1\n if cnt == clk-1:\n ans.append(c)\n break\n else:\n c = K\n while cnt >= clk:\n cnt -= clk\n c -= 1\n if cnt == clk-1:\n ans.append(c)\n break\n ans.append(c)\n print((*ans))\n", "# seishin.py\nK, N = list(map(int, input().split()))\nif K % 2 == 0:\n print((*[K//2] + [K]*(N-1)))\nelse:\n X = [(K+1)//2] * N\n for i in range(N//2):\n if X[-1] == 1:\n X.pop()\n else:\n X[-1] -= 1\n X.extend([K]*(N-len(X)))\n print((*X))\n", "K,N = list(map(int,input().split()))\nif K % 2 == 0:\n ans = [K//2]\n for i in range(N-1):\n ans.append(K)\nelse:\n back = N//2\n mid = K//2 + 1\n ans = [mid for i in range(N)]\n for i in range(back):\n if ans[-1] == 1:\n ans.pop()\n else:\n ans[-1] -= 1\n while len(ans) < N:\n ans.append(K)\nprint((' '.join(map(str,ans))))\n", "import sys\ninput = sys.stdin.readline\n\nK,N = map(int,input().split())\n\nif K % 2 == 0:\n L = K // 2\n R = L + 1\n # \u5148\u982d\u306e\u6587\u5b57\u304c L \u306e\u3082\u306e\u306e\u6700\u5f8c\u3001R \u306e\u3082\u306e\u306e\u6700\u521d\u3001\u3067\u5883\u754c\n arr = [L] + [K] * (N-1)\nelse:\n \"\"\"\n [3,3,3,3,3] \u3060\u3068 \u624b\u524d\u306b3 33 333 3333 \u304c\u4f59\u5206\u30022\u6b69\u623b\u308b\u3002\n \"\"\"\n arr = [(K+1)//2] * N\n x = N//2# x\u6b69 \u623b\u308b\n for i in range(x):\n arr[-1] -= 1\n if arr[-1] == 0:\n arr.pop()\n continue\n L = len(arr)\n if L < N:\n arr += [K] * (N-L)\n\nanswer = ' '.join(map(str,arr))\nprint(answer)", "import math\n\n\ndef main(K, N):\n ans = []\n\n if K % 2 == 0:\n for i in range(N):\n if i == 0:\n ans.append(K // 2)\n else:\n ans.append(K)\n elif K == 1:\n n2 = math.ceil(N / 2)\n for i in range(n2):\n ans.append(1)\n else:\n K2 = math.ceil(K / 2)\n ans = [K2] * N\n n = N // 2\n for i in range(n):\n if ans[-1] == 1:\n ans.pop()\n else:\n ans[-1] -= 1\n while len(ans) < N:\n ans.append(K)\n\n return ' '.join(map(str, ans))\n\n\nK, N = list(map(int, input().split()))\nprint((main(K, N)))\n", "a,n=map(int,input().split())\nif a%2==0:\n print(*[a//2]+[a]*(n-1))\nelse:\n d=[(a+1)//2]*n\n for i in range(n//2):\n if d[-1]==1:\n d.pop()\n else:\n d[-1]-=1\n d.extend([a]*(n-len(d)))\n print(\" \".join(str(i)for i in d))", "k, n = map(int, input().split())\nif k % 2 == 0:\n print(k // 2, end=\" \")\n for i in range(n - 1):\n print(k, end=\" \")\nelse:\n l = [(k + 1) // 2 for i in range(n)]\n for i in range(n // 2):\n if l[-1] == 1:\n l.pop()\n else:\n l[-1] -= 1\n for j in range(n - len(l)):\n l.append(k)\n print(*l, sep=\" \")", "k,n = map(int,input().split())\nif k%2 == 0:\n ans = [k//2]+[k]*(n-1)\nelse:\n t = n//2\n ans = [k//2+1]*n\n for i in range(t):\n if ans[-1] == 1:\n ans.pop()\n else:\n ans[-1] -= 1\n while len(ans) < n:\n ans.append(k)\nprint(*ans)", "import sys\nsys.setrecursionlimit(10**6)\nk, n = map(int, input().split())\n\ndef calc_x(K, N):\n\treturn (pow(K, N+1)-K) // (K-1)\ndef lexico(K, N, X):\n\t#print(K, N, X)\n\tnonlocal ans\n\tif X == 0:\n\t\treturn\n\tq = (calc_x(K, N-1)+1)\n\tif N > 1:\n\t\tans.append((X//q) + 1)\n\telse:\n\t\tans.append((X//q))\n\tlexico(K, N-1, (X-1)%q)\n\nif k == 1:\n\tprint(*[1 for _ in range((n+1)//2)])\nelif n == 1:\n\tprint((k+1)//2)\nelif k%2 == 0:\n\tans = [k//2] + [k] * (n-1)\n\tprint(*ans)\nelse:\n\tif n%2 == 1:\n\t\tcur, i = 1, n\n\telse:\n\t\tcur, i = 0, n\n\twhile cur <= i:\n\t\ti -= 1\n\t\tcur += pow(k, n-i)\n\tans = [(k+1)//2] * i\n\tind = (cur-i) // 2\n\tlexico(k, n-i, ind)\n\tprint(*ans)", "K, N = map(int, input().split())\nif K % 2 == 0:\n print(K // 2, end = ' ')\n for i in range(1, N):\n if i != N - 1:\n print(K, end = ' ')\n else:\n print(K)\nelse:\n def superlist(L, n):\n if n % 2 == 1:\n return [L // 2 + 1] + superlist(L, n-1)\n else:\n Ax = [L // 2 + 1 for i in range(n)]\n j = n - 1\n for i in range(n // 2):\n Ax[j] -= 1\n if Ax[j] == 0:\n j -= 1\n else:\n for m in range(j + 1, n):\n Ax[m] = L\n j = n - 1\n return Ax\n if K == 1:\n for i in range((N - 1) // 2 + 1):\n if i != (N - 1) // 2:\n print(1, end = ' ')\n else:\n print(1)\n else:\n A = superlist(K, N)\n for _ in range(N):\n if _ != N - 1 and A[_] != 0:\n print(A[_], end = ' ')\n elif _ == N - 1 and A[_] != 0:\n print(A[_])", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\ndef main():\n k,n=MI()\n end = n - 1\n if k%2:\n ans=[k//2+1]*n\n for _ in range(n//2):\n if ans[end]==1:\n end-=1\n else:\n ans[end]-=1\n if end!=n-1:\n for i in range(end+1,n):\n ans[i]=k\n end=n-1\n else:\n ans=[k//2]+[k]*(n-1)\n print(*ans[:end+1])\n\nmain()", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\nsys.setrecursionlimit(10**5)\n\nk,n = list(map(int, read().split()))\n\nif k%2==0:\n print((*([k//2]+[k]*(n-1))))\n return\n\nif k==1:\n print((*[1]*((n+1)//2)))\n return\n\nans = [(k+1)//2]*n\nd = 0\ndef f(k,i,d):\n # d <= 1+k+...+k^i?\n v = 1\n for j in range(i):\n v *= k\n v += 1\n if v > d: return True\n return False\n\ndef g(k,i):\n # 1+k+...+k^i\n v = 1\n for j in range(i):\n v *= k\n v += 1\n return v\n \nfor i in range(1,n):\n if f(k,n-i-1,d):\n d += 1\n continue\n \"\"\"\n \u4ee5\u4e0b\u3000300000 >= d >= 1+k+...+k^(n-i-1)\n i \u756a\u76ee\u306e\u9805\u304b\u3089\u771f\u3093\u4e2d\u306b\u306a\u3089\u306a\u3044 \n v \u756a\u76ee\u3092\u76ee\u6307\u3059\n \"\"\"\n v = (g(k,n-i)+d+1)//2 - d - 1\n \n for j in range(i,n):\n #print(v)\n if v==0:\n ans[j] = 0\n continue\n\n p = g(k,n-j-1)\n q = (v-1)//p \n #print(v,j,p,q)\n \n ans[j] = q+1\n v -= 1+q*p \n\n\n\n \n break\n\n\nwhile ans[-1]==0:\n ans.pop()\nprint((*ans))\n\n\n\n\n\n\n\n", "N,K=map(int,input().split())\n#1 2 3...N\nif N%2==0:\n L=[str(N)]*K\n L[0]=str(N//2)\n print(\" \".join(L))\n return\n#L[0]=N//2+1\n#N//2\u306e\u305a\u308c\uff1f\nL=[(N//2)+1]*K\nfor i in range(K//2):\n if L[-1]==1:\n L.pop(-1)\n elif len(L)!=K:\n L[-1]-=1\n L+=[N]*(K-len(L))\n else:\n L[-1]-=1\nL=list(map(str,L))\nprint(\" \".join(L))"] | {"inputs": ["3 2\n", "2 4\n", "5 14\n"], "outputs": ["2 1 \n", "1 2 2 2\n", "3 3 3 3 3 3 3 3 3 3 3 3 2 2 \n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 11,720 | |
e2cb6ba12b73cf78dc9f50c321e55251 | UNKNOWN | We have a tree with N vertices. The vertices are numbered 1, 2, ..., N. The i-th (1 ≦ i ≦ N - 1) edge connects the two vertices A_i and B_i.
Takahashi wrote integers into K of the vertices. Specifically, for each 1 ≦ j ≦ K, he wrote the integer P_j into vertex V_j. The remaining vertices are left empty. After that, he got tired and fell asleep.
Then, Aoki appeared. He is trying to surprise Takahashi by writing integers into all empty vertices so that the following condition is satisfied:
- Condition: For any two vertices directly connected by an edge, the integers written into these vertices differ by exactly 1.
Determine if it is possible to write integers into all empty vertices so that the condition is satisfied. If the answer is positive, find one specific way to satisfy the condition.
-----Constraints-----
- 1 ≦ N ≦ 10^5
- 1 ≦ K ≦ N
- 1 ≦ A_i, B_i ≦ N (1 ≦ i ≦ N - 1)
- 1 ≦ V_j ≦ N (1 ≦ j ≦ K) (21:18, a mistake in this constraint was corrected)
- 0 ≦ P_j ≦ 10^5 (1 ≦ j ≦ K)
- The given graph is a tree.
- All v_j are distinct.
-----Input-----
The input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
:
A_{N-1} B_{N-1}
K
V_1 P_1
V_2 P_2
:
V_K P_K
-----Output-----
If it is possible to write integers into all empty vertices so that the condition is satisfied, print Yes. Otherwise, print No.
If it is possible to satisfy the condition, print N lines in addition. The v-th (1 ≦ v ≦ N) of these N lines should contain the integer that should be written into vertex v. If there are multiple ways to satisfy the condition, any of those is accepted.
-----Sample Input-----
5
1 2
3 1
4 3
3 5
2
2 6
5 7
-----Sample Output-----
Yes
5
6
6
5
7
The figure below shows the tree when Takahashi fell asleep. For each vertex, the integer written beside it represents the index of the vertex, and the integer written into the vertex is the integer written by Takahashi.
Aoki can, for example, satisfy the condition by writing integers into the remaining vertices as follows:
This corresponds to Sample Output 1. Note that other outputs that satisfy the condition will also be accepted, such as:
Yes
7
6
8
7
7
| ["import sys\ninput = lambda: sys.stdin.readline().rstrip()\n\nfrom collections import deque\nN = int(input())\nX = [[] for i in range(N)]\nfor i in range(N-1):\n x, y = map(int, input().split())\n X[x-1].append(y-1)\n X[y-1].append(x-1)\n\nY = [(-10**9, 10**9) for _ in range(N)]\nK = int(input())\nfor _ in range(K):\n v, p = map(int, input().split())\n Y[v-1] = (p, p)\n\nP = [-1] * N\nQ = deque([0])\nR = []\nwhile Q:\n i = deque.popleft(Q)\n R.append(i)\n for a in X[i]:\n if a != P[i]:\n P[a] = i\n X[a].remove(i)\n deque.append(Q, a)\n\n\ndef calc():\n for i in R[::-1]:\n e, o = 0, 0\n l, r = Y[i]\n if r != 10 ** 9:\n if l % 2:\n o = 1\n else:\n e = 1\n for j in X[i]:\n a, b = Y[j]\n if b == 10**9: continue\n if a % 2:\n e = 1\n else:\n o = 1\n l = max(l, a - 1)\n r = min(r, b + 1)\n if (e and o) or (l > r):\n print(\"No\")\n return 0\n elif e or o:\n Y[i] = (l, r)\n \n for i in R[1:]:\n if Y[P[i]][0] - 1 >= Y[i][0]:\n Y[i] = (Y[P[i]][0] - 1, 0)\n else:\n Y[i] = (Y[P[i]][0] + 1, 0)\n \n print(\"Yes\")\n for i in range(N):\n print(Y[i][0])\n\ncalc()", "class Tree():\n def __init__(self, n, edge, indexed=1):\n self.n = n\n self.tree = [[] for _ in range(n)]\n for e in edge:\n self.tree[e[0] - indexed].append(e[1] - indexed)\n self.tree[e[1] - indexed].append(e[0] - indexed)\n\n def setroot(self, root):\n self.root = root\n self.parent = [None for _ in range(self.n)]\n self.parent[root] = -1\n self.depth = [None for _ in range(self.n)]\n self.depth[root] = 0\n self.order = []\n self.order.append(root)\n stack = [root]\n while stack:\n node = stack.pop()\n for adj in self.tree[node]:\n if self.parent[adj] is None:\n self.parent[adj] = node\n self.depth[adj] = self.depth[node] + 1\n self.order.append(adj)\n stack.append(adj)\n\nINF = 10**18\n\nimport sys\ninput = sys.stdin.readline\n\nN = int(input())\nE = [tuple(map(int, input().split())) for _ in range(N - 1)]\n\nnum = [None for _ in range(N)]\n\nK = int(input())\n\nfor _ in range(K):\n v, p = map(int, input().split())\n num[v - 1] = p\n\ntree = Tree(N, E)\ntree.setroot(v - 1)\n\neven = []\nodd = []\n\nfor i in range(N):\n if num[i] is not None:\n if tree.depth[i] % 2 == 0:\n even.append(num[i] % 2)\n else:\n odd.append(num[i] % 2)\n\nif not ((all(even) or not any(even)) and (all(odd) or not any(odd))):\n print('No')\n\nelse:\n I = [[-INF, INF] for _ in range(N)]\n for i in range(N):\n if num[i] is not None:\n I[i] = [num[i], num[i]]\n for node in tree.order[::-1]:\n lt, rt = I[node]\n for adj in tree.tree[node]:\n lt = max(lt, I[adj][0] - 1)\n rt = min(rt, I[adj][1] + 1)\n if lt > rt:\n print('No')\n break\n I[node] = [lt, rt]\n\n else:\n stack = [v - 1]\n visited = [0 for _ in range(N)]\n visited[v - 1] = 1\n while stack:\n node = stack.pop()\n for adj in tree.tree[node]:\n if visited[adj]:\n continue\n visited[adj] = 1\n if I[adj][0] <= num[node] - 1 <= I[adj][1]:\n num[adj] = num[node] - 1\n elif I[adj][0] <= num[node] + 1 <= I[adj][1]:\n num[adj] = num[node] + 1\n else:\n print('No')\n break\n stack.append(adj)\n else:\n continue\n break\n else:\n print('Yes')\n print('\\n'.join(map(str, num)))", "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10**7)\n\nN = int(input())\nG = [[] for _ in range(N+1)]\nfor _ in range(N-1):\n A, B = map(int, input().split())\n G[A].append(B)\n G[B].append(A)\nK = int(input())\nnum = [-1] * (N+1)\nfor _ in range(K):\n V, P = map(int, input().split())\n num[V] = P\n\n# check parity\nstack = [1]\ndepth = [-1] * (N+1)\ndepth[1] = 0\nwhile stack:\n v = stack.pop()\n for c in G[v]:\n if depth[c] == -1:\n depth[c] = depth[v] + 1\n stack.append(c)\nparity = [set(), set()]\nfor i in range(1, N+1):\n if num[i] != -1:\n parity[depth[i] % 2].add(num[i] % 2)\nif len(parity[0]) == 2 or len(parity[1]) == 2:\n print('No')\n return\n\nINF = 10**9\nlb = [-INF] * (N+1)\nub = [INF] * (N+1)\n\ndef dfs1(v, p):\n for c in G[v]:\n if c == p:\n continue\n dfs1(c, v)\n lb[v] = max(lb[v], lb[c] - 1)\n ub[v] = min(ub[v], ub[c] + 1)\n if num[v] != -1:\n lb[v] = ub[v] = num[v]\n\ndfs1(1, 0)\n\ndef dfs2(v, p):\n for c in G[v]:\n if c == p:\n continue\n for c in G[v]:\n if c == p:\n continue\n lb[c] = max(lb[c], lb[v] - 1)\n ub[c] = min(ub[c], ub[v] + 1)\n dfs2(c, v)\n\ndfs2(1, 0)\n\nfor i in range(1, N+1):\n if lb[i] > ub[i]:\n print('No')\n return\n\nprint('Yes')\n\ndef dfs3(v, p):\n for c in G[v]:\n if c == p:\n continue\n if lb[c] <= num[v] - 1:\n num[c] = num[v] - 1\n else:\n num[c] = num[v] + 1\n dfs3(c, v)\n\nnum[1] = lb[1]\ndfs3(1, 0)\n\nprint(*num[1:], sep='\\n')", "def N(): return int(input())\ndef NM():return map(int,input().split())\ndef L():return list(NM())\ndef LN(n):return [N() for i in range(n)]\ndef LL(n):return [L() for i in range(n)]\nn=N()\nedge=[[] for i in range(n+1)]\nfor i in range(n-1):\n a,b=map(int,input().split())\n edge[a].append(b)\n edge[b].append(a)\nINF=float(\"inf\")\nma=[INF]*(n+1)\nmi=[-INF]*(n+1)\nk=N()\nvp=LL(k)\nfor v,p in vp:\n ma[v]=p\n mi[v]=p\n\nimport sys\nsys.setrecursionlimit(10**6)\ndef dfs(v,d,hi,lo):\n dep[v]=d\n ma[v]=min(ma[v],hi)\n mi[v]=max(mi[v],lo)\n hi=ma[v]\n lo=mi[v]\n for i in edge[v]:\n if dep[i]==-1:\n hi,lo=dfs(i,d+1,hi+1,lo-1)\n ma[v]=min(ma[v],hi)\n mi[v]=max(mi[v],lo)\n hi=ma[v]\n lo=mi[v]\n return hi+1,lo-1\nfor i in range(2):\n dep=[-1 for i in range(n+1)]\n dfs(v,0,p,p)\nfor i,j in zip(mi,ma):\n if i>j or (i-j)%2==1:\n print(\"No\")\n break\nelse:\n print(\"Yes\")\n for i in mi[1:]:\n print(i)", "import heapq\nimport sys\ninput = sys.stdin.readline\nINF = 10 ** 18\n\n\nn = int(input())\nedges = [list(map(int, input().split())) for i in range(n - 1)]\nk = int(input())\ninfo = [list(map(int, input().split())) for i in range(k)]\n\ntree = [[] for i in range(n)]\nfor a, b in edges:\n a -= 1\n b -= 1\n tree[a].append(b)\n tree[b].append(a)\n\nans = [INF] * n\nq = []\nfor v, val in info:\n v -= 1\n ans[v] = val\n heapq.heappush(q, (-val, v))\n for nxt_v in tree[v]:\n if ans[nxt_v] != INF and abs(ans[v] - ans[nxt_v]) != 1:\n print(\"No\")\n return\n\nwhile q:\n val, v = heapq.heappop(q)\n val = -val\n for nxt_v in tree[v]:\n if ans[nxt_v] == INF:\n ans[nxt_v] = val - 1\n heapq.heappush(q, (-(val - 1), nxt_v))\n else:\n if abs(ans[v] - ans[nxt_v]) != 1:\n print(\"No\")\n return\n\nprint(\"Yes\")\nfor val in ans:\n print(val)", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nn, = map(int,readline().split())\n\ng = [[] for _ in range(n)]\nfor _ in range(n-1):\n a,b = map(int,readline().split())\n g[a-1].append(b-1)\n g[b-1].append(a-1)\n \n\norder = []\nparent = [-1]*n\nst = [0]\nwhile st:\n v = st.pop()\n order.append(v)\n for c in g[v]:\n if parent[v] != c:\n parent[c] = v\n st.append(c)\n\nINF = 1<<30\nhigh = [INF]*n\nlow = [-INF]*n\nval = [INF]*n\n\nk, = map(int,readline().split())\nfor _ in range(k):\n v,p = map(int,readline().split())\n high[v-1] = low[v-1] = val[v-1] = p\n\nfor v in order[:0:-1]:\n p = parent[v]\n #elif val[v]== INF: # v\u306b\u597d\u304d\u306a\u6570\u66f8\u3051\u308b\n h,l = high[v]+1,low[v]-1\n \n if h >= INF:\n pass\n elif high[p]>=INF:\n high[p] = h\n low[p] = l\n elif (high[p]-h)&1==0: #\u5076\u5947\u4e00\u81f4\n if h < high[p]: high[p] = h\n if l > low[p]: low[p] = l\n if high[p] < low[p]:\n print(\"No\")\n break\n else: #\u5076\u5947\u9055\u3063\u3066\u30c0\u30e1\n print(\"No\")\n break\n #print(v,val,high,low)\n \nelse: #OK\n print(\"Yes\")\n for v in order:\n if val[v] == INF:\n val[v] = low[v]\n for c in g[v]:\n high[c] = min(high[c],val[v]+1)\n low[c] = max(low[c],val[v]-1)\n \n \n print(*val,sep=\"\\n\")\n\n\n\n\n\n\n", "import sys\nreadline = sys.stdin.readline \n\ndef getpar(Edge, p):\n N = len(Edge)\n par = [0]*N\n par[0] = -1\n par[p] -1\n stack = [p]\n visited = set([p])\n while stack:\n vn = stack.pop()\n for vf in Edge[vn]:\n if vf in visited:\n continue\n visited.add(vf)\n par[vf] = vn\n stack.append(vf)\n return par\n\ndef topological_sort_tree(E, r):\n Q = [r]\n L = []\n visited = set([r])\n while Q:\n vn = Q.pop()\n L.append(vn)\n for vf in E[vn]:\n if vf not in visited:\n visited.add(vf)\n Q.append(vf)\n return L\n\ndef getcld(p):\n res = [[] for _ in range(len(p))]\n for i, v in enumerate(p[1:], 1):\n res[v].append(i)\n return res\n\n\ndef check(L, Par, wri, even):\n for i in range(len(Par)):\n if wri[i] and (wri[i] % 2 == even[i]):\n return False\n \n inf = 10**9+7\n dpu = [w if w is not None else inf for w in wri]\n dpd = [w if w is not None else -inf for w in wri]\n for l in L[::-1][:-1]:\n if dpu[l] == inf:\n continue\n if dpd[l] > dpu[l]:\n return False\n p = Par[l]\n dpu[p] = min(dpu[p], dpu[l] + 1)\n dpd[p] = max(dpd[p], dpd[l] - 1)\n if dpd[root] > dpu[root]:\n return False\n ans = [None]*N\n ans[root] = wri[root]\n for l in L[1:]:\n p = Par[l]\n if ans[p] - 1 >= dpd[l]:\n ans[l] = ans[p] - 1\n else:\n ans[l] = ans[p] + 1\n return ans\nN = int(readline())\nEdge = [[] for _ in range(N)]\nfor _ in range(N-1):\n a, b = map(int, readline().split())\n a -= 1\n b -= 1\n Edge[a].append(b)\n Edge[b].append(a)\nK = int(readline())\n\nVP = [tuple(map(lambda x: int(x), readline().split())) for _ in range(K)]\nwri = [None]*N\nfor v, p in VP:\n wri[v-1] = p\n\nroot = VP[0][0] - 1\nPar = getpar(Edge, root)\nL = topological_sort_tree(Edge, root)\n\neven = [True]*N\neven[root] = (wri[root] %2 == 0)\nfor l in L[1:]:\n p = Par[l]\n even[l] = not even[p]\nans = check(L, Par, wri, even)\nif ans == False:\n print('No')\nelse:\n print('Yes')\n print('\\n'.join(map(str, ans)))", "import sys\nsys.setrecursionlimit(10**7)\ndef main0(n,ab,k,vp):\n ki=[[] for _ in range(n)]\n for a,b in ab:\n a,b=a-1,b-1\n ki[a].append(b)\n ki[b].append(a)\n lrf=[[-1,-1,-1,] for _ in range(n)]\n for v,p in vp:\n v-=1\n lrf[v]=[p,p,p%2]\n flg=[True]\n def func(p,v):\n if lrf[v][2]!=-1:\n l,r,f=lrf[v]\n # \u89aa\u9802\u70b9\u3068\u306e\u6574\u5408\u6027\n if p>=0:\n pl,pr,pf=lrf[p]\n if pl-1<=l<=pr+1 and pf^f==1:\n # ok\n pass\n else:\n flg[0]=False\n else:\n # \u89aa\u9802\u70b9\u304b\u3089\u6761\u4ef6\u3092\u8a08\u7b97\n pl,pr,pf=lrf[p]\n l,r,f=pl-1,pr+1,pf^1\n lrf[v]=[l,r,f]\n l,r,f=lrf[v]\n for nv in ki[v]:\n if nv==p:continue\n # \u5b50\u9802\u70b9\u305f\u3061\u306e\u6761\u4ef6\u304b\u3089\u3001\u81ea\u5206\u306e\u6761\u4ef6\u3092\u66f4\u65b0\n nl,nr,nf=func(v,nv)\n if f^nf==0:flg[0]=False\n l=max(l,nl-1)\n r=min(r,nr+1)\n if l>r:flg[0]=False\n lrf[v]=[l,r,f]\n # \u6700\u7d42\u7684\u306a\u81ea\u5206\u306e\u6761\u4ef6\u3092\u8fd4\u3059\n return (l,r,f)\n func(-1,vp[0][0]-1)\n if not flg[0]:return []\n ret=[0]*n\n def func0(p,v):\n l,r,f=lrf[v]\n np=ret[p]\n if l<=np-1<=r and (np-1)%2==f:\n ret[v]=np-1\n elif l<=np+1<=r and (np+1)%2==f:\n ret[v]=np+1\n else:\n flg[0]=False\n for nv in ki[v]:\n if nv!=p:\n func0(v,nv)\n ret[vp[0][0]-1]=vp[0][1]\n for nv in ki[vp[0][0]-1]:\n func0(vp[0][0]-1,nv)\n if flg[0]:return ret\n else:return []\n\n\ndef __starting_point():\n n=int(input())\n ab=[list(map(int,input().split())) for _ in range(n-1)]\n k=int(input())\n vp=[list(map(int,input().split())) for _ in range(k)]\n ret0=main0(n,ab,k,vp)\n if len(ret0)==0:print('No')\n else:\n print('Yes')\n for x in ret0:print(x)\n\n__starting_point()", "class Graph:\n def __init__(self, n_vertices, edges, directed=True):\n self.n_vertices = n_vertices\n self.directed = directed\n self.edges = edges\n\n @property\n def adj(self):\n try:\n return self._adj\n except AttributeError:\n adj = [[] for _ in range(self.n_vertices)]\n if self.directed:\n for u,v in self.edges:\n adj[u].append(v)\n else:\n for u,v in self.edges:\n adj[u].append(v)\n adj[v].append(u)\n self._adj = adj\n return adj\n\n\ndef solve(tree, vp):\n\n adj = tree.adj\n n = tree.n_vertices\n q = [v-1 for v,p in vp]\n ranges = [None]*n\n for v,p in vp:\n ranges[v-1] = (p,p)\n \n while q:\n nq = []\n for v in q:\n a,b = ranges[v]\n na,nb = a-1,b+1\n for u in adj[v]:\n if ranges[u] is None:\n ranges[u] = na,nb\n nq.append(u)\n else:\n c,d = ranges[u]\n if (c+na)%2 == 1:\n return None\n x,y = max(na,c),min(nb,d)\n if x > y:\n return None\n ranges[u] = (x,y)\n if (x,y) != (c,d):\n nq.append(u)\n q = nq\n return [a for a,b in ranges]\n\n\ndef __starting_point():\n n = int(input())\n edges = [tuple(map(lambda x:int(x)-1,input().split())) for _ in range(n-1)]\n k = int(input())\n vp = [tuple(map(int,input().split())) for _ in range(k)]\n\n tree = Graph(n, edges, False)\n\n res = solve(tree, vp)\n if res is None:\n print('No')\n else:\n print('Yes')\n print(*res,sep='\\n')\n__starting_point()", "import sys\nsys.setrecursionlimit(500000)\n\nN = int(input())\nE = [[] for _ in range(N+1)]\nfor _ in range(N-1):\n a, b = list(map(int, input().split()))\n E[a].append(b)\n E[b].append(a)\nK = int(input())\nL = [-float(\"inf\")] * (N+1)\nR = [float(\"inf\")] * (N+1)\nfor _ in range(K):\n v, p = list(map(int, input().split()))\n L[v] = p\n R[v] = p\n\ntour = []\ndef dfs(v, p):\n tour.append(v)\n for u in E[v]:\n if u!=p:\n dfs(u, v)\n tour.append(v)\ndfs(v, 0)\n\nl, r = L[v], R[v]\nodd = p % 2\nfor v in tour[1:]:\n l -= 1\n r += 1\n odd = 1 - odd\n l_, r_ = L[v], R[v]\n if r_ != float(\"inf\") and r_%2 != odd:\n print(\"No\")\n return\n l = max(l, l_)\n r = min(r, r_)\n L[v] = l\n R[v] = r\nfor v in tour[-2::-1]:\n l -= 1\n r += 1\n odd = 1 - odd\n l_, r_ = L[v], R[v]\n l = max(l, l_)\n r = min(r, r_)\n if l > r:\n print(\"No\")\n return\n L[v] = l\n R[v] = r\nAns = [-1] * (N+1)\nprint(\"Yes\")\nprint((\"\\n\".join(map(str, L[1:]))))\n"] | {"inputs": ["5\n1 2\n3 1\n4 3\n3 5\n2\n2 6\n5 7\n", "5\n1 2\n3 1\n4 3\n3 5\n3\n2 6\n4 3\n5 7\n", "4\n1 2\n2 3\n3 4\n1\n1 0\n"], "outputs": ["Yes\n5\n6\n6\n5\n7\n", "No\n", "Yes\n0\n-1\n-2\n-3\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 16,525 | |
0bfb94da4091a41b65e78d9235c68d2a | UNKNOWN | We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand.
When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second.
When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries.
Each query is in the form of (t_i,a_i).
For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
-----Constraints-----
- 1≤X≤10^9
- 1≤K≤10^5
- 1≤r_1<r_2< .. <r_K≤10^9
- 1≤Q≤10^5
- 0≤t_1<t_2< .. <t_Q≤10^9
- 0≤a_i≤X (1≤i≤Q)
- All input values are integers.
-----Input-----
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
-----Output-----
For each query, print the answer in its own line.
-----Sample Input-----
180
3
60 120 180
3
30 90
61 1
180 180
-----Sample Output-----
60
1
120
In the first query, 30 out of the initial 90 grams of sand will drop from bulb A, resulting in 60 grams.
In the second query, the initial 1 gram of sand will drop from bulb A, and nothing will happen for the next 59 seconds. Then, we will turn over the sandglass, and 1 second after this, bulb A contains 1 gram of sand at the time in question. | ["import bisect\ndef inpl(): return [int(i) for i in input().split()]\n\nX = int(input())\nK = int(input())\nr = [0] + inpl()\nstu = [()]*(K+1)\nstu[0] = (X, 0, 0)\nfor i, v in enumerate(r[1:], 1):\n s, t, u = stu[i-1]\n if i%2:\n rs = r[i-1] - r[i]\n ap = - rs - t\n if ap >= s:\n stu[i] = 0, 0, 0\n elif ap >= u:\n stu[i] = s, t+rs, ap\n else:\n stu[i] = s, t+rs, u\n else:\n rs = r[i] - r[i-1]\n ap = X - rs - t\n if ap >= s:\n stu[i] = s, t+rs, u\n elif ap >= u:\n stu[i] = ap, t+rs, u\n else:\n stu[i] = X, 0, X\nQ = int(input())\nfor _ in range(Q):\n ti, a = inpl()\n x = bisect.bisect_right(r, ti)\n ti -= r[x-1]\n s, t, u = stu[x-1]\n if a >= s:\n R = s + t\n elif a >= u:\n R = a + t\n else:\n R = u + t\n if x % 2:\n print(max(0, R - ti))\n else:\n print(min(X, R + ti))", "from bisect import bisect\nX=int(input())\nK=int(input())\nrs=[0]\nfor r in input().split():\n rs.append(int(r))\nA=[[(0,0),(X,X)]]\nmin_sup=0\nmax_inf=X\npre_r=0\nfor i,r in enumerate(rs[1:]):\n d=r-pre_r\n pre_r=r\n m,M=A[-1][0][0],A[-1][1][0]\n if i%2==0:\n if m-d>=0:\n new_m=m-d\n else:\n new_m=0\n min_sup=min_sup+d-m\n if M-d>0:\n new_M=M-d\n else:\n new_M=0\n max_inf=0\n else:\n if M+d<=X:\n new_M=M+d\n else:\n new_M=X\n max_inf=max_inf-(d-(X-M))\n if m+d<X:\n new_m=m+d\n else:\n new_m=X\n min_sup=X\n if new_m==new_M:\n min_sup=X\n max_inf=0 \n A.append([(new_m,min_sup),(new_M,max_inf)])\nQ=int(input())\nfor q in range(Q):\n t,a=list(map(int,input().split()))\n r_num=bisect(rs,t)-1\n m,min_sup=A[r_num][0]\n M,max_inf=A[r_num][1]\n r=rs[r_num]\n if r_num%2==0:\n if a<=min_sup:\n print((max(m-(t-r),0)))\n elif min_sup<a<max_inf:\n print((max(m+(a-min_sup)-(t-r),0)))\n else:\n print((max(M-(t-r),0)))\n else:\n if a<=min_sup:\n print((min(m+(t-r),X)))\n elif min_sup<a<max_inf:\n print((min(m+(a-min_sup)+(t-r),X)))\n else:\n print((min(M+(t-r),X)))\n", "X = int(input())\nK = int(input())\nr_lst = [int(_) for _ in input().split()]\nQ = int(input())\nt_lst, a_lst = [], []\nfor i in range(Q):\n buf = input().split()\n t_lst.append(int(buf[0]))\n a_lst.append(int(buf[1]))\n \npos_lst = []\nfor i, r in enumerate(r_lst):\n direc = \"+\" if i%2==0 else \"-\"\n pos_lst.append((r, direc))\nfor i, t in enumerate(t_lst):\n pos_lst.append((t, i))\npos_lst = sorted(pos_lst, key=lambda tup: tup[0])\n\n\nleft, right = 0, X\nval = [0, 0, X] \n\ndirec = \"-\"\nprv = 0\nfor pos in pos_lst:\n# print(left, right)\n# print(val)\n# print(pos)\n# print()\n \n elapsed = pos[0] - prv\n prv = pos[0]\n \n if direc == \"+\":\n val[0] = min(X, val[0] + elapsed)\n val[1] += elapsed\n val[2] = min(X, val[2] + elapsed)\n right = min(right, X - val[1])\n else:\n val[0] = max(0, val[0] - elapsed)\n val[1] -= elapsed\n val[2] = max(0, val[2] - elapsed) \n left = max(left, -(val[1]))\n \n if pos[1] == \"+\" or pos[1] == \"-\":\n direc = pos[1]\n else: #is query\n a = a_lst[pos[1]]\n \n if a <= left:\n print(val[0])\n elif a >= right:\n print(val[2])\n else:\n print( a + val[1])", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\ngosa = 1.0 / 10**10\nmod = 10**9+7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\n\ndef main():\n x = I()\n k = I()\n r = LI()\n q = I()\n t = [LI() for _ in range(q)]\n a = [[0,0,0,x,0,0]]\n d = 0\n for i in range(k):\n c = a[-1][:]\n rr = r[i] - d\n d = r[i]\n if i % 2 == 0:\n c[1] -= rr\n c[3] -= rr\n c[4] -= rr\n if c[0] > c[1]:\n c[0] = c[1]\n else:\n c[1] += rr\n c[3] += rr\n c[4] += rr\n if c[2] < c[1]:\n c[2] = c[1]\n if c[3] > x:\n c[3] = x\n if c[3] < 0:\n c[3] = 0\n if c[4] > x:\n c[4] = x\n if c[4] < 0:\n c[4] = 0\n\n c[5] = r[i]\n\n a.append(c)\n def bs(i):\n ma = k\n mi = 0\n mm = 0\n while ma > mi and (ma+mi) // 2 != mm:\n mm = (ma+mi) // 2\n if a[mm][5] < i:\n mi = mm\n else:\n ma = mm - 1\n if a[mm][5] > i:\n return mm-1\n if mm == k:\n return k\n if a[mm+1][5] <= i:\n return mm+1\n return mm\n\n #print(a)\n rr = []\n for c,d in t:\n ti = bs(c)\n ai = a[ti]\n e = x-d\n #print(c,d,e,ti,ai)\n if d + ai[0] <= 0:\n tt = ai[4]\n elif e - ai[2] <= 0:\n tt = ai[3]\n else:\n tt = d + ai[1]\n #print('tt',tt)\n if ti % 2 == 0:\n tt -= c - ai[5]\n else:\n tt += c - ai[5]\n #print('tt2',tt)\n if tt < 0:\n tt = 0\n elif tt > x:\n tt = x\n rr.append(tt)\n\n return '\\n'.join(map(str,rr))\n\n\nprint((main()))\n\n", "def main():\n import sys\n from operator import itemgetter\n input = sys.stdin.readline\n\n X = int(input())\n K = int(input())\n R = list(map(int, input().split()))\n Q = []\n for r in R:\n Q.append((r, -1))\n q = int(input())\n for _ in range(q):\n t, a = list(map(int, input().split()))\n Q.append((t, a))\n Q.sort(key=itemgetter(0))\n\n #print(Q)\n prev = 0\n m = 0\n M = X\n flg = -1\n R_cs = 0\n for t, a in Q:\n if a < 0:\n r = t - prev\n R_cs -= r * flg\n if flg == -1:\n m = max(0, m-r)\n M = max(0, M-r)\n flg = 1\n else:\n m = min(X, m+r)\n M = min(X, M+r)\n flg = -1\n prev = t\n else:\n if m == M:\n if flg == 1:\n print((min(X, m + t - prev)))\n else:\n print((max(0, m - t + prev)))\n else:\n am = m + R_cs\n aM = M + R_cs\n #print('am', am, 'aM', aM, m, M)\n if a <= am:\n if flg == 1:\n print((min(X, m + t - prev)))\n else:\n print((max(0, m - t + prev)))\n elif a >= aM:\n if flg == 1:\n print((min(X, M + t - prev)))\n else:\n print((max(0, M - t + prev)))\n else:\n if flg == 1:\n print((min(X, m + (a - am) + t - prev)))\n else:\n print((max(0, m + (a - am) - t + prev)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "X=int(input())\nK=int(input())\nr=list(map(int,input().split()))\nQ=int(input())\np=[tuple(map(int,input().split())) for i in range(Q)]\n\nN=Q\nL=0\nR=Q-1\nstart=0\nsign=\"-\"\n\n# N: \u51e6\u7406\u3059\u308b\u533a\u9593\u306e\u9577\u3055\n\nN0 = 2**(N-1).bit_length()\ndata = [0]*(2*N0)\nINF = 0\n# \u533a\u9593[l, r+1)\u306e\u5024\u3092v\u306b\u66f8\u304d\u63db\u3048\u308b\n# v\u306f(t, value)\u3068\u3044\u3046\u5024\u306b\u3059\u308b (\u65b0\u3057\u3044\u5024\u307b\u3069t\u306f\u5927\u304d\u304f\u306a\u308b)\ndef update(l, r, v):\n L = l + N0; R = r + N0\n while L < R:\n if R & 1:\n R -= 1\n data[R-1] += v\n\n if L & 1:\n data[L-1] += v\n L += 1\n L >>= 1; R >>= 1\n# a_i\u306e\u73fe\u5728\u306e\u5024\u3092\u53d6\u5f97\ndef query(k):\n k += N0-1\n s = INF\n while k >= 0:\n s += data[k]\n k = (k - 1) // 2\n return s\n\nq=[]\nfor i in range(Q):\n t,a=p[i]\n p[i]=(a,t,i)\n\np.sort()\ndic=[-1]*Q\nfor i in range(Q):\n a,t,id=p[i]\n update(i,i+1,a)\n dic[id]=i\n q.append((t,id,0))\n\nfor i in range(K):\n q.append((r[i],-1,r[i]-r[i-1]*(i>0)))\n\nq.sort()\nans=[0]*Q\nfor val,id,c in q:\n if id==-1:\n if sign==\"-\":\n update(L,R+1,-c)\n while query(L+1)<0 and L<R:\n L+=1\n a=query(L)\n if a<0:\n update(L,L+1,-a)\n start=val\n sign=\"+\"\n else:\n update(L,R+1,c)\n while query(R-1)>X and L<R:\n R-=1\n a=query(R)\n if a>X:\n update(R,R+1,X-a)\n start=val\n sign=\"-\"\n else:\n pid,id=id,dic[id]\n if sign==\"-\":\n if id<L:\n res=max(query(L)-(val-start),0)\n elif id>R:\n res=max(query(R)-(val-start),0)\n else:\n res=max(query(id)-(val-start),0)\n else:\n if id<L:\n res=min(query(L)+(val-start),X)\n elif id>R:\n res=min(query(R)+(val-start),X)\n else:\n res=min(query(id)+(val-start),X)\n ans[pid]=res\n\n\nfor i in range(Q):\n print((ans[i]))\n", "X = int(input())\nK = int(input())\nR = [int(x) for x in reversed(input().split())]\nfor i in range(0,K-1): R[i] -= R[i+1]\nQ = int(input())\n\naM = X\nM = X\nam = 0\nm = 0\nnow = 0\nsign = -1\ntimer = R.pop()\n\ndef Go(time):\n nonlocal aM,M,am,m\n if sign==1:\n if m+time>X:\n m = X\n M = X\n aM = am\n elif M+time>X:\n m += time\n M = X\n aM = am + M - m\n else:\n m += time\n M += time\n else:\n if M-time<0:\n m = 0\n M = 0\n am = aM\n elif m-time<0:\n m = 0\n M -= time\n am = aM + m - M\n else:\n m -= time\n M -= time\n\nfor i in range(Q):\n t,a = [int(x) for x in input().split()]\n t -= now\n now += t\n \n while t>=timer:\n Go(timer)\n t -= timer\n if R:\n timer = R.pop()\n else:\n timer = float(\"inf\")\n sign *= -1\n \n Go(t)\n timer -= t\n \n if a<am:\n print(m)\n elif a>aM:\n print(M)\n else:\n print(m+a-am)", "X = int(input())\nK = int(input())\nR = list(map(int, input().split()))\nQ = int(input())\n\n\nami = [0]*(K+1)\nama = [X] + [0]*K\ncusummi = [0]*(K+1)\ncusumma = [0]*(K+1)\ncusum = [0]*(K+1)\npr = 0\nfor i, r in enumerate(R):\n d = pr-r if i%2==0 else r-pr\n cusum[i+1] = cusum[i] + d\n cusummi[i+1] = min(cusummi[i], cusum[i+1])\n cusumma[i+1] = max(cusumma[i], cusum[i+1])\n ami[i+1] = min(max(ami[i] + d, 0), X)\n ama[i+1] = min(max(ama[i] + d, 0), X)\n pr = r\n\nimport bisect\nfor _ in range(Q):\n t, a = list(map(int, input().split()))\n i = bisect.bisect_right(R, t)\n t1 = R[i-1] if i!=0 else 0\n t2 = t-t1\n d = -t2 if i%2==0 else t2\n if ama[i]==ami[i]:\n print((min(max(ama[i] + d, 0), X)))\n continue\n ans = a+cusum[i]\n if -cusummi[i]>a:\n ans += -cusummi[i]-a\n if cusumma[i]>(X-a):\n ans -= cusumma[i]-(X-a)\n print((min(max(ans+d, 0), X)))\n", "input = __import__('sys').stdin.readline\nMIS = lambda: map(int,input().split())\n \n# f(a) = z a <= x1\n# a+z-x1 x1 <= a <= x2\n# x2+z-x1 x2 <= a\nclass Sandgraph:\n def __init__(_, X):\n _.z = _.x1 = 0\n _.x2 = X\n \n def add(_, dt):\n # Go towards the ceiling\n d1 = min(dt, X-(_.x2+_.z-_.x1))\n _.z+= d1\n dt-= d1\n # Reduce the diagonal\n d1 = min(dt, _.x2-_.x1)\n _.z+= d1\n _.x2-= d1\n \n def sub(_, dt):\n # Go towards the floor\n d1 = min(dt, _.z)\n _.z-= d1\n dt-= d1\n # Reduce the diagonal\n d1 = min(dt, _.x2-_.x1)\n _.x1+= d1\n \n def __call__(_, a):\n if a <= _.x1: return _.z\n elif a <= _.x2: return a + _.z - _.x1\n else: return _.x2 + _.z - _.x1\n \nX = int(input())\nk = int(input())\nrev = list(MIS())\nQ = int(input())\nsand = Sandgraph(X)\n \nlast_t = 0\ni = 0 # even -, odd +\nfor QUERY in range(Q):\n t, a = MIS()\n while i<k and rev[i] <= t:\n dt = rev[i] - last_t\n if i%2 == 0: sand.sub(dt)\n else: sand.add(dt)\n last_t = rev[i]\n i+= 1\n dt = t - last_t\n if i%2 == 0: sand.sub(dt)\n else: sand.add(dt)\n print(sand(a))\n last_t = t", "import sys\ninput = sys.stdin.readline\n\n\"\"\"\nX\u5b9a\u6570\u3060\u3063\u305f\u3002\u4e21\u6975\u7aef\u306a\u5834\u5408\u304c\u5408\u6d41\u3059\u308b\u3002\n[0,L]\u4e0a\u5b9a\u6570A\u3001[R,X]\u4e0a\u5b9a\u6570B\u3001\u305d\u306e\u9593\u306f\u7dda\u5f62\n\"\"\"\n\nX = int(input())\nK = int(input())\nR = [int(x) for x in input().split()]\nQ = int(input())\nTA = [tuple(int(x) for x in input().split()) for _ in range(Q)]\n\ntask = sorted([(r,-1) for r in R] + [(t,a) for t,a in TA])\n\nL = 0\nR = X\nA = 0\nB = X\ndx = -1 # \u521d\u3081\u306f\u6e1b\u308b\u65b9\ncurrent = 0\nanswer = []\nfor t,a in task:\n # \u3068\u308a\u3042\u3048\u305a\u4e0a\u9650\u3092\u7a81\u7834\u3057\u3066\u843d\u3068\u3059\n A += dx * (t-current)\n B += dx * (t-current)\n current = t\n if a != -1:\n # \u4f53\u7a4d\u306e\u8a08\u7b97\n if a <= L:\n x = A\n elif a >= R:\n x = B\n else:\n x = A+(B-A)//(R-L)*(a-L)\n if x < 0:\n x = 0\n if x > X:\n x = X\n answer.append(x)\n else:\n dx = -dx\n if A < B:\n if A < 0:\n L += (-A)\n A = 0\n if B > X:\n R -= (B-X)\n B = X\n if A > X:\n A = X\n B = X\n L = 0\n R = 0\n if B < 0:\n A = 0\n B = 0\n L = 0\n R = 0\n elif A >= B:\n if A > X:\n L += (A-X)\n A = X\n if B < 0:\n R -= (-B)\n B = 0\n if A < 0:\n A = 0\n B = 0\n L = 0\n R = 0\n if B > X:\n A = X\n B = X\n L = 0\n R = 0\n if R < L:\n R = L\n\nprint(*answer,sep='\\n')\n\n", "import sys\ninput = sys.stdin.readline\n\nx = int(input())\nk = int(input())\nR = [(_r, i%2) for i, _r in enumerate(map(int, input().split()))]\nn = int(input())\nTA = [list(map(int, input().split())) for _ in range(n)]\nT, A = zip(*TA)\nL = [None]*n\nb = 0\nfor i, t in enumerate(T, 1):\n R.append((t, -i))\nR.sort()\ndx = 1\nl, r, p, q = 0, x, 0, x\nfor _r, i in R:\n d = _r-b\n b = _r\n if dx == 1:\n if d <= p:\n p -= d\n q -= d\n elif d < q:\n q -= d\n l = r-q\n p = 0\n else:\n l = 0\n r = 0\n p = 0\n q = 0\n else:\n if d <= x-q:\n p += d\n q += d\n elif d < x-p:\n p += d\n r = l+(x-p)\n q = x\n else:\n l = x\n r = x\n p = x\n q = x\n if i >= 0:\n dx = i\n else:\n a = A[-i-1]\n if a < l:\n res = p\n elif a <= r:\n res = (a-l)+p\n else:\n res = q\n L[-i-1] = res\nprint(*L, sep=\"\\n\")", "#!/usr/bin/env python3\nimport bisect\n\ndef main():\n X = int(input())\n K = int(input())\n r = list(map(int, input().split()))\n Q = int(input())\n q_list = []\n for i in range(Q):\n q_list.append(list(map(int, input().split())))\n\n r = [0] + r\n a = [0]\n upper_limit = [X]\n lower_limit = [0]\n\n x, ux, lx = 0, X, 0\n for i in range(1, K + 1):\n diff = r[i] - r[i - 1]\n if i % 2 == 1:\n x -= diff\n ux -= diff\n ux = max(ux, 0)\n lx -= diff\n lx = max(lx, 0)\n else:\n x += diff\n ux += diff\n ux = min(ux, X)\n lx += diff\n lx = min(lx, X)\n a.append(x)\n upper_limit.append(ux)\n lower_limit.append(lx)\n\n asc_i = [0]\n dsc_i = [1]\n x = 0\n for i in range(2, K + 1, 2):\n if x < a[i]:\n x = a[i]\n asc_i.append(i)\n x = a[1]\n for i in range(3, K + 1, 2):\n if a[i] < x:\n x = a[i]\n dsc_i.append(i)\n\n asc_a = [a[i] for i in asc_i]\n dsc_a = [-a[i] for i in dsc_i]\n\n\n for [t, a0] in q_list:\n ri = bisect.bisect_right(r, t) - 1\n\n ui = bisect.bisect_left(asc_a, X - a0)\n li = bisect.bisect_left(dsc_a, a0)\n\n ai, di = None, None\n if ui < len(asc_i):\n ai = asc_i[ui]\n if ri < ai:\n ai = None\n if li < len(dsc_i):\n di = dsc_i[li]\n if ri < di:\n di = None\n\n d = 0\n if (not ai is None) or (not di is None):\n if ai is None:\n d = -1\n elif di is None:\n d = 1\n else:\n d = 1 if ai < di else -1\n\n x = a0 + a[ri]\n if d == 1:\n x = upper_limit[ri]\n elif d == -1:\n x = lower_limit[ri]\n x += (t - r[ri]) * (-1 if ri % 2 == 0 else 1)\n x = min(max(x, 0), X)\n\n print(x)\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "X = int(input())\nK = int(input())\nR = list(map(int,input().split()))\nR.append(0)\n\nA = [X for _ in range(K+1)]\nB = [0 for _ in range(K+1)]\nC = [X for _ in range(K+1)]\nD = [0 for _ in range(K+1)]\nstate = -1\nfor i in range(K):\n dr = R[i] - R[i-1]\n if state == -1:\n C[i+1] = max(0, C[i]-dr)\n D[i+1] = max(0, D[i]-dr)\n B[i+1] = min(B[i] + (-min(0, D[i]-dr)), A[i])\n A[i+1] = A[i]\n \n else:\n C[i+1] = min(X, C[i]+dr)\n D[i+1] = min(X, D[i]+dr)\n A[i+1] = max(A[i] - max(0, C[i]+dr-X), B[i])\n B[i+1] = B[i]\n\n state *= -1\n\"\"\"\nprint(A)\nprint(B)\nprint(C)\nprint(D)\n\"\"\"\n\nQ = int(input())\nR.pop()\nimport bisect\nfor _ in range(Q):\n t, a = list(map(int,input().split()))\n j = bisect.bisect_right(R, t)\n if j == 0: r = 0\n else: r = R[j-1]\n pre_ans = (min(A[j],max(B[j],a)) - B[j]) + D[j]\n #print(pre_ans)\n pre_ans += ((-1)**(1-j%2)) * (t-r)\n #print(j, t, r)\n print((min(X, max(0, pre_ans))))\n \n", "X = int(input())\nK = int(input())\nrs = list(map(int,input().split()))\nQ = int(input())\nqs = [tuple(map(int,input().split())) for i in range(Q)]\n\ndx = -1\nri = 0\noffset = 0\nupper,lower = X,0\nprev_r = 0\nans = []\nfor t,a in qs:\n while ri < len(rs) and rs[ri] <= t:\n tmp_offset = dx * (rs[ri] - prev_r)\n if dx == 1:\n upper = min(X, upper + tmp_offset)\n lower = min(X, lower + tmp_offset)\n else:\n upper = max(0, upper + tmp_offset)\n lower = max(0, lower + tmp_offset)\n offset += tmp_offset\n dx *= -1\n prev_r = rs[ri]\n ri += 1\n a = max(lower, min(upper, a+offset))\n dt = t - prev_r\n a = max(0, min(X, a + dx*dt))\n ans.append(a)\n\nprint(*ans, sep='\\n')", "# F\n# input\nfrom bisect import bisect\nX = int(input())\nK = int(input())\nr_list = [0] + list(map(int, input().split()))\n\nQ = int(input())\nquery_list = [list(map(int, input().split())) for _ in range(Q)]\n\n\nMmRL_list = []\n\n# M:max, m:min, R:min_a(M), L:max_a(m)\nM = X\nm = 0\nR = X\nL = 0\n\nMmRL_list.append([M, m, R, L])\n\nfor i in range(K):\n M_ = M\n m_ = m\n R_ = R\n L_ = L\n lag = r_list[i+1] - r_list[i]\n # update\n if i % 2 == 0:\n if M_ - lag < 0:\n M = 0\n R = 0\n else:\n M = M_ - lag\n R = R_\n if m_ - lag < 0:\n m = 0\n L = L_ + lag - m_\n else:\n m = m_ - lag\n L = L_\n else:\n if M_ + lag > X:\n M = X\n R = R_ - (M_ + lag - X)\n else:\n M = M_ + lag\n R = R_\n if m_ + lag > X:\n m = X\n L = X\n else:\n m = m_ + lag\n L = L_\n MmRL_list.append([M, m, R, L])\n \n\n# print(MmRL_list)\nfor q in range(Q):\n t, a = query_list[q]\n j = bisect(r_list, t) - 1\n # find status then\n M, m, R, L = MmRL_list[j]\n if a <= L:\n a_ = m\n elif a >= R:\n a_ = M\n else:\n a_ = m + (a - L)\n t_ = t - r_list[j]\n if j % 2 == 0:\n res = max(a_ - t_, 0)\n else:\n res = min(a_ + t_, X)\n print(res)\n", "\ndef main1(x,k,rary,q,ta):\n aary=[]\n tary=[]\n for i,(t,a) in enumerate(ta):\n aary.append([a,i])\n tary.append([t,i])\n tary.sort(key=lambda x:x[0])\n aary.sort(key=lambda x:x[0])\n l,r=0,x # [l,r]:0,x\u306e\u58c1\u306b\u3076\u3064\u304b\u3063\u3066\u3044\u306a\u3044\u521d\u671fa\u306e\u7bc4\u56f2\n lt,rt=-1,-1 # \u58c1\u3076\u3064\u304b\u308a\u304c\u767a\u751f\u3057\u305f\u3042\u3068\u7802\u6642\u8a08\u304c\u3072\u3063\u304f\u308a\u8fd4\u308b\u6642\u9593\n tidx=0\n nowt=0\n nowu='A'\n da=0\n ret=[-1]*q\n daary={}\n rary.append(10**9+1)\n k+=1\n for i,ri in enumerate(rary):\n while tidx<q and tary[tidx][0]<=ri:\n t,j=tary[tidx]\n tidx+=1\n a=ta[j][1]\n if nowu=='A':\n if l<=a<=r:\n ret[j]=a+da-(t-nowt)\n elif a<l:\n ret[j]=da-daary[lt]-(t-nowt)\n else:\n ret[j]=x+da-daary[rt]-(t-nowt)\n else:\n if l<=a<=r:\n ret[j]=a+da+(t-nowt)\n elif a<l:\n ret[j]=da-daary[lt]+(t-nowt)\n else:\n ret[j]=x+da-daary[rt]+(t-nowt)\n ret[j]=max(0,ret[j])\n ret[j]=min(x,ret[j])\n if nowu=='A':\n dt=ri-nowt\n da-=dt\n if l<-da:\n l=-da\n lt=ri\n nowt=ri\n nowu='B'\n else:\n dt=ri-nowt\n da+=dt\n if r>x-da:\n r=x-da\n rt=ri\n nowt=ri\n nowu='A'\n daary[nowt]=da\n if l>=r:\n if nowu=='B':\n da=0\n else:\n da=x\n for ii in range(i+1,k):\n ri=rary[ii]\n while tidx<q and tary[tidx][0]<=ri:\n t,j=tary[tidx]\n tidx+=1\n if nowu=='A':\n ret[j]=da-(t-nowt)\n else:\n ret[j]=da+(t-nowt)\n ret[j]=max(0,ret[j])\n ret[j]=min(x,ret[j])\n if nowu=='A':\n da-=ri-nowt\n da=max(da,0)\n nowu='B'\n else:\n da+=ri-nowt\n da=min(da,x)\n nowu='A'\n nowt=ri\n break\n return ret\n\nimport sys\ninput=sys.stdin.readline\ndef __starting_point():\n x=int(input())\n k=int(input())\n r=list(map(int,input().split()))\n q=int(input())\n ta=[list(map(int,input().split())) for _ in range(q)]\n print(*main1(x,k,r,q,ta),sep='\\n')\n\n__starting_point()", "import bisect\noX = int(input())\nK = int(input())\nr= list(map(int,input().split()))\n\n# a X-a\n# min(max(0,a-r[0]))\n# a-r[0]+r[1]\n\ndef calc_time(t):\n val = bisect.bisect_left(t,r)\n diff= t- r[val]\n return val,diff\n\n\n# [sep1,sep2,a<sep1,sep1<a<sep2,a>sep2 ]\n\nlast =(0,oX,0 ,0,oX)\nres =[last]\nfor i,tr in enumerate(r):\n sep1,sep2,X,Y,Z=last\n dt = tr if i==0 else tr-r[i-1]\n if i%2==0: # a ->b\n\n X = max(0,X-dt)\n Y = Y-dt\n Z = max(0,Z-dt)\n sep1 = max(sep1,-Y)\n else: #b-> a\n X = min(oX,X+dt)\n Y= Y+dt\n\n Z = min(oX,Z+dt)\n sep2 = min(sep2,oX-Y)\n\n last = (sep1,sep2,X,Y,Z)\n res.append(last)\n\n#print(res)\n\n\nQ = int(input())\n\nr_index=0\nr.insert(0,0)\nr.append(10000000000)\nfor i in range(Q):\n def calc(X,r_index,diff):\n tmp = 1 if r_index%2 else -1\n return min(oX,max(0,X +tmp* diff))\n t,a =list(map(int,input().split()))\n while r[r_index]< t:\n if r[r_index+1] >t:\n break\n r_index+=1\n sep1, sep2, X, Y, Z = res[r_index]\n diff = t -r[r_index]\n #print(t,diff,r_index,r[r_index])\n if a< sep1:\n print((calc(X,r_index,diff)))\n elif a>sep2:\n print((calc(Z,r_index,diff)))\n else:\n print((calc(a+Y,r_index,diff)))\n\n", "import sys\nfrom bisect import bisect\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nx = int(input())\nk = int(input())\nz = [0] + list(map(int, input().split()))\ns = [z[i+1] - z[i] for i in range(k)]\n\nlr = [[0, x]]\npq = [[0, x]]\n\nfor i in range(k):\n\tl, r = lr[-1]\n\tp, q = pq[-1]\n\tif i%2 == 0:\n\t\tlr.append([max(l-s[i], 0), max(r-s[i], 0)])\n\t\tpq.append([min(p + max(min(s[i], x)-l, 0), q), q])\n\telse:\n\t\tlr.append([min(l+s[i], x), min(r+s[i], x)])\n\t\tpq.append([p, max(q - max(r-max(x-s[i], 0), 0), p)])\n\nq = int(input())\nfor _ in range(q):\n\tt, a = map(int, input().split())\n\ti = bisect(z, t) - 1\n\tt -= z[i]\n\tif a <= pq[i][0]:\n\t\ty = lr[i][0]\n\telif a >= pq[i][1]:\n\t\ty = lr[i][1]\n\telse:\n\t\ty = lr[i][0] + a - pq[i][0]\n\n\tif i%2 == 0:\n\t\tprint(max(y-t, 0))\n\telse:\n\t\tprint(min(y+t, x))", "x = int(input())\nk = int(input())\n*R, = map(int,input().split()+[1<<30])\nQ = int(input())\nta = [tuple(map(int,input().split())) for _ in range(Q)]\ndef f(x,l): return(max(l[0],min(l[1],x+l[2])))\nL = a,b,c = 0,x,0\nidx = t0 = 0\ng = -1\nfor r in R:\n while idx < Q and ta[idx][0] < r:\n print(f(f(ta[idx][1],L)+g*(ta[idx][0]-t0),(0,x,0)));idx += 1\n d,t0 = g*(r-t0),r\n L = a,b,c = f(a,(0,x,d)),f(b,(0,x,d)),c+d\n g *= -1", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\n\nx, = map(int,readline().split())\nk, = map(int,readline().split())\n*r, = map(int,readline().split())\nq, = map(int,readline().split())\nr.append(1<<30)\n\nINF = 1<<30\nID_M = (-INF,INF,0)\ndef compose(lst1,lst2):\n return (funcval(lst1[0],lst2),funcval(lst1[1],lst2),lst1[2]+lst2[2])\n\ndef funcval(x,lst):\n a,b,c = lst\n if x <= a-c: return a\n elif x >= b-c: return b\n else: return x+c\n\n#seg = segment_tree_dual(q, compose, funcval, ID_M)\n#seg.build([a for a,t,i in ati])\n\nseg = (0,x,0)\n\ntai = []\nfor i in range(q):\n t,a = map(int,readline().split())\n tai.append((t,a,i))\n\ntai.sort(key=lambda x:x[0])\n\nidx = 0\nans = [0]*q\nt0 = 0\ncoeff = -1\nfor i,ri in enumerate(r):\n while idx < q and tai[idx][0] < ri:\n t,a,j = tai[idx]\n v = funcval(a,seg)\n ans[j] = min(x,max(v+coeff*(t-t0),0))\n idx += 1\n \n seg = compose(seg,(0,x,coeff*(ri-t0)))\n \n t0 = ri\n coeff *= -1 \n\n #print(seg)\n\nprint(*ans,sep=\"\\n\")\n\n\n", "import sys\nfrom heapq import *\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\ndef main():\n x = int(input())\n k = int(input())\n rr = LI()\n q = int(input())\n ta = LLI(q)\n # [\u6642\u9593,\u547d\u4ee4,(a)]\u3067\u30bf\u30a4\u30e0\u30e9\u30a4\u30f3\u306b\u767b\u9332\n # \u547d\u4ee40\u3067\u3072\u3063\u304f\u308a\u8fd4\u3059 1\u3067\u8cea\u554f\u306b\u7b54\u3048\u308b\n timeline = []\n for r in rr:\n heappush(timeline, [r, 0, 0])\n for t, a in ta:\n heappush(timeline, [t, 1, a])\n # print(timeline)\n # A\u306e\u30d1\u30fc\u30c4\u304c\u4e00\u5ea6\u3067\u3082\u7a7a\u3084\u6e80\u30bf\u30f3\u306b\u306a\u308b\u3068\u3001a\u306f\u95a2\u4fc2\u306a\u304f\u306a\u308b\u306e\u304c\u5927\u4e8b\u306a\u6240\n # \u3060\u304b\u3089\u7a7a\u306b\u306a\u308ba\u306fal\u672a\u6e80\u306ea\u3068\u3057\u3066\u3072\u3068\u307e\u3068\u3081\n # \u6e80\u30bf\u30f3\u306b\u306a\u308ba\u306far\u3088\u308a\u5927\u304d\u3044a\u3068\u3057\u3066\n # \u3072\u3068\u307e\u3068\u3081\u3067\u7ba1\u7406\u3059\u308b\n # l r\n # a=0 1 2 3 4 5 6 7 8 9 10...\n # al ar\n # al(=2)\u672a\u6e80\u306ea\u306e\u7802\u306e\u91cfsl\n # ar(=6)\u3088\u308a\u5927\u304d\u3044a\u306e\u7802\u306e\u91cfsr\n # al\u4ee5\u4e0aar\u4ee5\u4e0b\u306ea\u306e\u7802\u306e\u91cfa+sm\n sl = sm = 0\n sr = x\n al = 0\n ar = x\n rev_t = 0\n trend = False\n while timeline:\n t, op, a = heappop(timeline)\n sd = t - rev_t\n if op:\n if trend:\n if a < al:\n print(min(sl + sd, x))\n elif a > ar:\n print(min(sr + sd, x))\n else:\n print(min(a + sm + sd, x))\n else:\n if a < al:\n print(max(sl - sd, 0))\n elif a > ar:\n print(max(sr - sd, 0))\n else:\n print(max(a + sm - sd, 0))\n else:\n if trend:\n sl = min(sl + sd, x)\n sr = min(sr + sd, x)\n ar = min(ar, x - sm - sd - 1)\n sm += sd\n else:\n sl = max(sl - sd, 0)\n sr = max(sr - sd, 0)\n al = max(al, sd - sm + 1)\n sm -= sd\n trend = not trend\n rev_t = t\n # print(t, op, a, al, ar, sl, sm, sr)\nmain()\n", "\n\"\"\"\nWriter: SPD_9X2\nhttps://atcoder.jp/contests/arc082/tasks/arc082_d\n\nai\u304c\u56fa\u5b9a\u306a\u3089\u3070\u3001\u305f\u3060\u30af\u30a8\u30ea\u3092\u30bd\u30fc\u30c8\u3057\u3066\u30b7\u30df\u30e5\u30ec\u30fc\u30b7\u30e7\u30f3\u3057\u306a\u304c\u3089\u7b54\u3048\u3092\u51fa\u305b\u3070\u3088\u3044\n\u4eca\u56de\u306f\u305d\u3046\u3067\u306a\u3044\u306e\u3067\u3001\u65b9\u6cd5\u3092\u8003\u3048\u308b\n\n\u4e00\u5ea6\u3067\u3082\u7802\u304c\u843d\u3061\u5207\u3063\u3066\u3057\u307e\u3048\u3070\u3001\u305d\u306e\u5f8c\u306fai\u306b\u95a2\u308f\u3089\u305a\u3001\u7b54\u3048\u306f\u7b49\u3057\u304f\u306a\u308b\n\u304a\u3061\u304d\u3063\u3066\u3044\u306a\u3044\u5834\u5408\u3001\u5e38\u306b\u7802\u304c\u79fb\u52d5\u3057\u7d9a\u3051\u308b\u306e\u3067\u3001\u521d\u671f\u5024\u304b\u3089\u306e\u5dee\u5206\u304c\u5e38\u306b\u7b49\u3057\u304f\u306a\u308b\n\u3088\u3063\u3066\u3001\u843d\u3061\u5207\u3089\u306a\u3044a\u306e\u7bc4\u56f2\u3092\u4fdd\u6301\u3057\u3001\u4e00\u5ea6\u3082\u843d\u3061\u5207\u3089\u306a\u3044\u5834\u5408\u306e\u521d\u671f\u304b\u3089\u306e\u5dee\u5206\n& \u843d\u3061\u5207\u3063\u3066\u3057\u307e\u3063\u305f\u5834\u5408\u306e\u30b7\u30df\u30e5\u30ec\u30fc\u30b7\u30e7\u30f3\u7d50\u679c\u3092\u7528\u3044\u3066\u7b54\u3048\u308c\u3070\u3088\u3044\n\n\u2192\u3069\u306e\u30bf\u30a4\u30df\u30f3\u30b0(\u533a\u9593)\u3067\u843d\u3061\u5207\u308b\u304b\u3067\u305d\u306e\u5f8c\u306e\u52d5\u304d\u304c\u9055\u304f\u306d\uff1f\uff1f\uff1f\n\u2192\u6b7b\n\n\u2192a\u306e\u533a\u9593\u306f\u9ad8\u30053\u3064\u306b\u5206\u3051\u3089\u308c\u308b\n\u2192 a\u304c\u5c11\u306a\u304f\u3001a=0\u3068\u540c\u3058\u306b\u53ce\u675f\u3059\u308b\u5834\u5408\u3001 a\u304c\u5927\u304d\u304f\u3001a=X\u3068\u540c\u3058\u306b\u53ce\u675f\u3059\u308b\u5834\u5408\u3002\u3001\u4e00\u5ea6\u3082\u843d\u3061\u5207\u3089\u306a\u3044\u5834\u5408\n\u2192\u305d\u3057\u3066\u3001a=0,a=X\u3068\u540c\u3058\u306b\u306a\u308b\u5834\u5408\u306f\u3001\u305d\u308c\u305e\u308ca\u306e\u521d\u671f\u5024\u306e\u533a\u9593\u306e\u4e21\u7aef\u304b\u3089\u4fb5\u98df\u3057\u3066\u3044\u304f\n\u2192\u3088\u3063\u3066\u3001a=0\u306e\u30b7\u30df\u30e5\u3001a=X\u306e\u30b7\u30df\u30e5\u3001\u843d\u3061\u5207\u3089\u306a\u3044\u5dee\u5206\u30b7\u30df\u30e5\u3002\u305d\u306e\u6642\u3042\u308ba\u304c\u3069\u308c\u306b\u5c5e\u3059\u304b\u306e\u533a\u9593\n\u3092\u7528\u3044\u3066\u30b7\u30df\u30e5\u30ec\u30fc\u30b7\u30e7\u30f3\u3057\u306a\u304c\u3089dp\u7684\u306b\u51e6\u7406\u3057\u3066\u3042\u3052\u308c\u3070\u3088\u3044\n\n\u3042\u3068\u306f\u5b9f\u88c5\u304c\u9762\u5012\u305d\u3046\n\"\"\"\nfrom collections import deque\nX = int(input())\nK = int(input())\n\nr = list(map(int,input().split()))\n#\u756a\u5175\nr.append(float(\"inf\"))\nr.append(0)\n\nta = deque([])\nQ = int(input())\n\nfor i in range(Q):\n t,a = list(map(int,input().split()))\n ta.append([t,a])\n\nZA = 0 #\u521d\u671f\u304ca=0\u306e\u6642\u306e\u30b7\u30df\u30e5\u7d50\u679c\nXA = X #\u521d\u671f\u304cX\u306e\u6642\nD = 0 #\u5dee\u5206\u8a08\u7b97\nZmax = 0 #a\u304cZmax\u4ee5\u4e0b\u306a\u3089ZA\u3068\u7b49\u3057\u304f\u306a\u308b\nXmin = X #a\u304cXmin\u4ee5\u4e0a\u306a\u3089XA\u3068\u7b49\u3057\u304f\u306a\u308b\n\nfor i in range(K+1):\n\n time = r[i] - r[i-1]\n\n #\u30af\u30a8\u30ea\u306e\u51e6\u7406(r[i]\u4ee5\u4e0b\u306b\u95a2\u3057\u3066)\n if i % 2 == 0: #A\u304c\u6e1b\u3063\u3066\u3044\u304f\n \n while len(ta) > 0 and ta[0][0] <= r[i]:\n t,a = ta.popleft()\n td = t - r[i-1]\n\n if a <= Zmax:\n print((max( 0 , ZA-td )))\n elif a >= Xmin:\n print((max (0 , XA-td )))\n else:\n print((max (0 , a+D-td)))\n\n D -= time\n Zmax = max(Zmax,-1*D)\n ZA = max(0,ZA-time)\n XA = max(0,XA-time)\n\n else: #A\u304c\u5897\u3048\u3066\u3044\u304f\n \n while len(ta) > 0 and ta[0][0] <= r[i]:\n t,a = ta.popleft()\n td = t - r[i-1]\n\n if a <= Zmax:\n print((min( X , ZA+td )))\n elif a >= Xmin:\n print((min (X , XA+td )))\n else:\n print((min (X , a+D+td)))\n\n D += time\n Xmin = min(Xmin,X-D)\n ZA = min(X,ZA+time)\n XA = min(X,XA+time)\n\n\n \n", "import sys\n\n# sys.stdin = open('f1.in')\n\n\ndef read_int_list():\n return list(map(int, input().split()))\n\n\ndef read_int():\n return int(input())\n\n\ndef read_str_list():\n return input().split()\n\n\ndef read_str():\n return input()\n\n\ndef solve():\n X = read_int()\n K = read_int()\n r = read_int_list()\n Q = read_int()\n j = 0\n sign = -1\n s = 0\n e = X\n y = 0\n origin = 0\n out = [0] * Q\n for i in range(Q):\n t, a = read_int_list()\n while j < K and r[j] < t:\n d = r[j] - origin\n y += d * sign\n if y < 0:\n s += abs(y)\n if s > e:\n s = e\n y = 0\n if y + e - s > X:\n diff = (y + e - s) - X\n e -= diff\n if e < s:\n e = s\n if y > X:\n y = X\n origin = r[j]\n j += 1\n sign *= -1\n d = t - origin\n if a <= s:\n res = y\n elif a <= e:\n res = y + a - s\n else:\n res = y + e - s\n res += d * sign\n if res < 0:\n res = 0\n if res > X:\n res = X\n out[i] = res\n return out\n\n\ndef main():\n res = solve()\n print(*res, sep='\\n')\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\ngosa = 1.0 / 10**10\nmod = 10**9+7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\n\ndef main():\n x = I()\n k = I()\n r = LI()\n q = I()\n t = [LI() for _ in range(q)]\n a = [[0,0,0,x,0,0]]\n d = 0\n for i in range(k):\n c = a[-1][:]\n rr = r[i] - d\n d = r[i]\n if i % 2 == 0:\n c[1] -= rr\n c[3] -= rr\n c[4] -= rr\n if c[0] > c[1]:\n c[0] = c[1]\n else:\n c[1] += rr\n c[3] += rr\n c[4] += rr\n if c[2] < c[1]:\n c[2] = c[1]\n if c[3] > x:\n c[3] = x\n if c[3] < 0:\n c[3] = 0\n if c[4] > x:\n c[4] = x\n if c[4] < 0:\n c[4] = 0\n\n c[5] = r[i]\n\n a.append(c)\n def bs(i):\n ma = k\n mi = 0\n mm = 0\n while ma > mi and (ma+mi) // 2 != mm:\n mm = (ma+mi) // 2\n if a[mm][5] < i:\n mi = mm\n else:\n ma = mm - 1\n if a[mm][5] > i:\n return mm-1\n if mm == k:\n return k\n if a[mm+1][5] <= i:\n return mm+1\n return mm\n\n #print(a)\n rr = []\n for c,d in t:\n ti = bs(c)\n ai = a[ti]\n e = x-d\n #print(c,d,e,ti,ai)\n if d + ai[0] <= 0:\n tt = ai[4]\n elif e - ai[2] <= 0:\n tt = ai[3]\n else:\n tt = d + ai[1]\n #print('tt',tt)\n if ti % 2 == 0:\n tt -= c - ai[5]\n else:\n tt += c - ai[5]\n #print('tt2',tt)\n if tt < 0:\n tt = 0\n elif tt > x:\n tt = x\n rr.append(tt)\n\n return '\\n'.join(map(str,rr))\n\n\nprint((main()))\n\n", "import sys\ninput = sys.stdin.readline\n\nx = int(input())\nk = int(input())\nR = [(_r, i%2) for i, _r in enumerate(map(int, input().split()))]\nn = int(input())\nTA = [list(map(int, input().split())) for _ in range(n)]\nT, A = zip(*TA)\nL = [None]*n\nb = 0\nfor i, t in enumerate(T, 1):\n R.append((t, -i))\nR.sort()\ndx = 1\nl, r, p, q = 0, x, 0, x\nfor _r, i in R:\n d = _r-b\n b = _r\n if dx == 1:\n if d <= p:\n p -= d\n q -= d\n elif d < q:\n q -= d\n l = r-q\n p = 0\n else:\n l = 0\n r = 0\n p = 0\n q = 0\n else:\n if d <= x-q:\n p += d\n q += d\n elif d < x-p:\n p += d\n r = l+(x-p)\n q = x\n else:\n l = x\n r = x\n p = x\n q = x\n if i >= 0:\n dx = i\n else:\n a = A[-i-1]\n if a < l:\n res = p\n elif a <= r:\n res = (a-l)+p\n else:\n res = q\n L[-i-1] = res\nprint(*L, sep=\"\\n\")"] | {"inputs": ["180\n3\n60 120 180\n3\n30 90\n61 1\n180 180\n", "100\n1\n100000\n4\n0 100\n90 100\n100 100\n101 100\n", "100\n5\n48 141 231 314 425\n7\n0 19\n50 98\n143 30\n231 55\n342 0\n365 100\n600 10\n"], "outputs": ["60\n1\n120\n", "100\n10\n0\n0\n", "19\n52\n91\n10\n58\n42\n100\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 39,417 | |
af282d4c6b7de84510d84d403dbd5704 | UNKNOWN | A subsequence of a string S is a string that can be obtained by deleting zero or more characters from S without changing the order of the remaining characters.
For example, arc, artistic and (an empty string) are all subsequences of artistic; abc and ci are not.
You are given a string A consisting of lowercase English letters.
Find the shortest string among the strings consisting of lowercase English letters that are not subsequences of A.
If there are more than one such string, find the lexicographically smallest one among them.
-----Constraints-----
- 1 \leq |A| \leq 2 \times 10^5
- A consists of lowercase English letters.
-----Input-----
Input is given from Standard Input in the following format:
A
-----Output-----
Print the lexicographically smallest string among the shortest strings consisting of lowercase English letters that are not subsequences of A.
-----Sample Input-----
atcoderregularcontest
-----Sample Output-----
b
The string atcoderregularcontest contains a as a subsequence, but not b. | ["A = [ord(a)-97 for a in input()]\nN = len(A)\nX = [0] * 26\nY = [0] * (N + 2)\nNE = [0] * N\nR = [N] * 26\ns = 0\nt = 1\nfor i in range(N)[::-1]:\n a = A[i]\n if X[a] == 0:\n X[a] = 1\n s += 1\n if s == 26:\n s = 0\n X = [0] * 26\n t += 1\n Y[i] = t\n NE[i] = R[a]\n R[a] = i\n\nANS = []\nii = 0\nfor i, a in enumerate(A):\n if i == ii:\n for j in range(26):\n if Y[R[j]+1] < Y[i]:\n ANS.append(j)\n ii = R[j]+1\n break\n R[a] = NE[i]\n\nprint(\"\".join([chr(a+97) for a in ANS]))", "from collections import *\n\ndef solve():\n s = input()\n n = len(s)\n nxt = [[float(\"inf\")] * (n + 10) for _ in range(26)]\n for i in range(n - 1, -1, -1):\n for j in range(26):\n nxt[j][i] = nxt[j][i + 1]\n nxt[ord(s[i]) - ord('a')][i] = i \n deq = deque()\n used = [False] * (n + 5)\n for i in range(26):\n if nxt[i][0] == float(\"inf\"):\n print((chr(ord('a') + i)))\n return \n deq.append((i, str(chr(ord('a') + i)), nxt[i][0]))\n used[nxt[i][0]] = True \n while True:\n siz = len(deq)\n for _ in range(siz):\n i, pre, pos = deq.popleft()\n for j in range(26):\n np = nxt[j][pos + 1]\n if np == float(\"inf\"):\n print((pre + str(chr(ord('a') + j))))\n return \n if not used[np]:\n used[np] = True \n deq.append((j, pre + str(chr(ord('a') + j)), np))\n\nsolve()\n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\ngosa = 1.0 / 10**10\nmod = 10**9+7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\n\ndef main():\n a = S()\n l = len(a)\n t = {}\n for c in string.ascii_lowercase:\n t[c] = l\n b = [(1,0,0) for _ in range(l)]\n b.append((1,'a',l))\n b.append((0,'',l+1))\n\n for c,i in reversed(list(zip(a,list(range(l))))):\n t[c] = i\n b[i] = min([(b[t[d]+1][0] + 1,d,t[d]+1) for d in string.ascii_lowercase])\n\n r = ''\n i = 0\n while i < l:\n r += b[i][1]\n i = b[i][2]\n return r\n\nprint((main()))\n\n\n\n", "# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return list(map(int, input().split()))\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nMOD = 10 ** 9 + 7\n\nS = input()\nN = len(S)\n\n# nxt[i][c] := i\u6587\u5b57\u76ee\u4ee5\u964d\u3067\u6700\u521d\u306b\u6587\u5b57c\u304c\u767b\u5834\u3059\u308bindex(\u5b58\u5728\u3057\u306a\u3044\u3068\u304d\u306fN)\nnxt = list2d(N+1, 26, N)\nfor i in range(N-1, -1, -1):\n for c in range(26):\n nxt[i][c] = nxt[i+1][c]\n c = ord(S[i]) - 97\n nxt[i][c] = i\n\n# dp[i] := i\u6587\u5b57\u76ee\u4ee5\u964d\u306b\u3064\u3044\u3066\u300c\u90e8\u5206\u6587\u5b57\u5217\u3068\u306a\u3089\u306a\u3044\u300d\u6700\u77ed\u306e\u6587\u5b57\u5217\u9577\ndp = [INF] * (N+1)\n# rest[i][(c, j)] := \u4f4d\u7f6ei\u304b\u3089\u898b\u3066\u3001\u6700\u5c0f\u9054\u6210\u306b\u7528\u3044\u305f\u6587\u5b57c\u3068\u3001\u6b21\u306b\u4f7f\u3046\u6587\u5b57\u306eindexj\nrest = [None] * (N+1)\ndp[N] = 1\n# \u5e38\u306b\u81ea\u5206\u3088\u308a\u5f8c\u308d\u3067\u306e\u6700\u5c0f\u304c\u5fc5\u8981\u306b\u306a\u308b\u306e\u3067\u3001\u5f8c\u308d\u304b\u3089\u57cb\u3081\u3066\u3044\u304f\nfor i in range(N-1, -1, -1):\n # i\u304b\u3089\u898b\u3066\u5148\u982d\u3068\u3057\u3066\u4f7f\u3046\u6587\u5b57\u309226\u901a\u308a\u5168\u90e8\u8a66\u3059\n # abc\u3092\u6607\u9806\u3067\u56de\u3057\u3066\u3001\u6700\u5c0f\u66f4\u65b0\u6761\u4ef6\u3092\u7b49\u53f7\u306a\u3057\u306b\u3059\u308b\u3053\u3068\u3067\u3001\u8f9e\u66f8\u9806\u3067\u5c0f\u3055\u3044\u65b9\u3092\u512a\u5148\u3067\u304d\u308b\n for c in range(26):\n # \u6b21\u306e\u6587\u5b57\u304c\u306a\u3044\u6642\n if nxt[i][c] == N:\n if dp[i] > 1:\n dp[i] = 1\n rest[i] = (c, N)\n # \u6b21\u306e\u6587\u5b57\u304c\u3042\u308b\u6642\n else:\n # i\u4ee5\u964d\u306b\u6587\u5b57c\u304c\u51fa\u73fe\u3059\u308bindex+1\u306e\u4f4d\u7f6e\u3067\u306e\u6700\u77ed\u6587\u5b57\u5217\u9577 + 1\n # \u4f8b\u3048\u3070a\u306b\u3064\u3044\u3066\u306a\u3089\u3001a****\u3068\u306a\u308b\u306e\u3067\u3001****\u3067\u306e\u6700\u5c0f\u3068a\u306e\u5206\u3067+1\n if dp[i] > dp[nxt[i][c]+1] + 1:\n dp[i] = dp[nxt[i][c]+1] + 1\n rest[i] = (c, nxt[i][c]+1)\n\n# \u5fa9\u5143\ni = 0\nans = []\nwhile i < N:\n c, idx = rest[i]\n ans.append(chr(c+97))\n i = idx\nprint((''.join(ans)))\n", "from collections import defaultdict\ninf = 10**10\nA = list(map(lambda x:ord(x)-ord('a'), list(input())))\nN = len(A)\nabc = 'abcdefghijklmbopqrstuvwxyz'\ns_to_i = [[N]*26 for _ in range(N+1)]\nfor i in range(N)[::-1]:\n for x in range(26):\n s_to_i[i][x] = s_to_i[i+1][x]\n s_to_i[i][A[i]] = i\ndp = [0]*(N+2)\ndp[-2] = 1\nfor i in range(N)[::-1]:\n now = max(s_to_i[i])+1\n dp[i] = dp[now]+1\nn = dp[0]\nnow = 0\nans = []\nfor i in range(n):\n for x in range(26):\n tmp = s_to_i[now][x]+1\n if dp[tmp] <= n-i-1:\n ans.append(chr(x+ord('a')))\n now = tmp\n break\nprint(*ans, sep = '')\n\n\n\n \n \n\n\n\n", "import bisect\nA = input()\nn = len(A)\nch = [[] for _ in range(26)]\nidx = []\nused = set()\nfor i in range(n-1, -1, -1):\n a = A[i]\n ch[ord(a)-ord(\"a\")].append(i)\n used.add(a)\n if len(used) == 26:\n idx.append(i)\n used = set()\nk = len(idx)\nidx = idx[::-1]\nfor j in range(26):\n ch[j] = ch[j][::-1]\nans = \"\"\nnow = -1\nfor i in range(k):\n for j in range(26):\n nxt = ch[j][bisect.bisect_right(ch[j], now)]\n if nxt >= idx[i]:\n now = nxt\n ans += chr(j+ord(\"a\"))\n break\nfor j in range(26):\n l = bisect.bisect_right(ch[j], now)\n if l == len(ch[j]):\n ans += chr(j+ord(\"a\"))\n break\nprint(ans)", "from bisect import bisect\ns = input()\nx,y,k,p = [1]*26,[len(s)],1,[[1] for i in range(26)]\nfor i in range(len(s)-1,-1,-1):\n\tn = ord(s[i])-97\n\tx[n] = 0\n\tp[n].append(-i)\n\tif sum(x)==0:\n\t\tk,x = k+1,[1]*26\n\t\ty.append(i)\ny,num,ans = y[::-1],0,\"\"\nfor i in range(k):\n\tfor j in range(97,123):\n\t\tif chr(j) not in s[num:y[i]]: break\n\tans+=chr(j)\n\tb = bisect(p[j-97],-y[i])-1\n\tnum = -p[j-97][b]+1\nprint(ans)", "S = input()\nN = len(S)\ninf = 10**18\n\nnxt = [[N+1] * 26 for _ in range(N + 2)]\nfor i in reversed(range(N)):\n for j in range(26):\n nxt[i][j] = nxt[i + 1][j]\n nxt[i][ord(S[i]) - ord(\"a\")] = i\n\ndp = [inf] * (N + 1)\ndp[N] = 1\nmemo = [N] * (N + 1)\nfor i in reversed(range(N)):\n for c, j in enumerate(nxt[i]):\n if j > N:\n if dp[i] > 1:\n dp[i] = 1\n memo[i] = c\n elif dp[i] > dp[j + 1] + 1:\n dp[i] = dp[j + 1] + 1\n memo[i] = c\n\nres = []\ni = 0\nwhile i <= N:\n res.append(chr(memo[i] + ord(\"a\")))\n i = nxt[i][memo[i]] + 1\nprint(\"\".join(res))", "import sys\ninput = sys.stdin.readline\n\nS = [ord(s) - ord('a') for s in input().rstrip()]\n\nINF = 10 ** 9\nN = len(S)\ndp = [None] * (N+1)\n# \u305d\u3053\u304b\u3089\u59cb\u3081\u305f\u3068\u304d\u3001\u6b21\u306bx\u304c\u73fe\u308c\u308b\u4f4d\u7f6e\u3001\u304a\u3088\u3073\u3001\u6b21\u306bx\u3092\u3068\u3063\u305f\u5834\u5408\u306b\u9577\u3055L\u306e\u3082\u306e\u304c\u5168\u3066\u4f5c\u308c\u308b\ndp[N] = [[INF] * 26, [0] * 26, 0]\n\nfor n in range(N-1,-1,-1):\n prev = dp[n+1]\n cur = [prev[0].copy(), prev[1].copy(), prev[2]]\n s = S[n]\n cur[0][s] = n\n cur[1][s] = prev[2] // 26 + 1\n cur[2] = prev[2] + cur[1][s] - prev[1][s]\n dp[n] = cur\n\nanswer = []\ni = 0\nwhile i < N:\n # \u8f9e\u66f8\u9806\u3067\u3001\u4f5c\u308c\u308b\u9577\u3055\u304c\u4e00\u756a\u77ed\u3044\u6587\u5b57\n L = dp[i][2] // 26\n for x in range(26):\n if dp[i][1][x] == L:\n break\n answer.append(chr(ord('a') + x))\n # \u305d\u306e\u6587\u5b57\u306e\u5834\u6240\u306b\u79fb\u52d5\n i = dp[i][0][x]\n i += 1\n\nprint(''.join(answer))", "from bisect import bisect_right, bisect_left\nA = [ord(t) - ord(\"a\") for t in input()]\nn = len(A)\nalf = [[] for i in range(26)]\nfor i, a in enumerate(A):\n alf[a].append(i)\nfor i in range(26):\n alf[i].append(n+1)\n\nfirst = [n]\nappeard = [0] * 26\ncnt = 0\nfor i in range(n - 1, -1, -1):\n a = A[i]\n if 1 - appeard[a]:\n appeard[a] = 1\n cnt += 1\n if cnt == 26:\n first.append(i)\n cnt = 0\n appeard = [0] * 26\n\ndef ntoa(x):\n return chr(ord(\"a\") + x)\n\nfirst.reverse()\nans = \"\"\n\nfor i in range(26):\n if 1 - appeard[i]:\n ans += ntoa(i)\n if alf[i]:\n last = alf[i][0]\n break\nif len(first) == 1:\n print(ans)\n return\n\nfor j in range(len(first) - 1):\n for i in range(26):\n nxt = alf[i][bisect_right(alf[i], last)]\n if nxt >= first[j+1]:\n ans += ntoa(i)\n last = nxt\n break\nprint(ans)\n", "def next_position(S):\n \"\"\"\n \u9589\u533a\u9593 (i,N-1] \u306e\u4e2d\u306e\u6700\u3082\u5de6\u7aef\u306b\u3042\u308b\u30a2\u30eb\u30d5\u30a1\u30d9\u30c3\u30c8s\u306eindex\n \"\"\"\n N=len(S)\n next_pos=[[N+1]*26 for _ in range(N+1)]\n for i in range(N-1,-1,-1):\n for s in range(26):\n next_pos[i][s]=next_pos[i+1][s]\n next_pos[i][ord(S[i])-ord(\"a\")]=i+1\n return next_pos\n\nS=input().rstrip()\nN=len(S)\nnext_pos=next_position(S)\ndp=[1<<32]*(N+2)\ndp[-1]=0\nrecover=[0]*(N+1)\nfor i in range(N,-1,-1):\n for s in range(25,-1,-1):\n if dp[next_pos[i][s]]+1<=dp[i]:\n dp[i]=dp[next_pos[i][s]]+1\n recover[i]=(next_pos[i][s],s)\n\nres=[]\ni=0\nwhile i<N:\n i,s=recover[i]\n res.append(chr(s+ord(\"a\")))\nprint(\"\".join(res))", "abc=\"abcdefghijklmnopqrstuvwxyz\"\n\nA=str(input())\nn=len(A)\n#make matrix (a-z)*(n characters)\n#\u6b21\u306bchr\u304c\u51fa\u3066\u304f\u308bindex\nword_pos=[]\nct=[n]*26\norda=ord(\"a\")\n\nfor i in range(n-1,-1,-1):\n ct[ord(A[i])-orda]=i\n word_pos.append(ct.copy())\n\nword_pos.reverse()\n\ndp=[0]*n+[1,0]\nj=n\nsep=[]\n#\u533a\u5207\u308c\u3081\u3092\u30de\u30fc\u30af\nfor i in range(n-1,-1,-1):\n ct=word_pos[i]\n if(max(ct)<j):\n #remove last chunk\n sep.append(i)\n j=min(ct)\n \nif(j==n):\n for i in abc:\n if(i not in A):\n print(i+\"\\n\")\n break\n\nelse:\n sep.reverse()\n ans=\"\"\n for i in abc:\n if(i not in A[:sep[0]]):\n ans+=i\n break\n\n for i in range(0,len(sep)):\n start=sep[i]\n try:\n end=sep[i+1]\n except:\n end=n\n #ans[-1]\u304c\u51fa\u73fe\u3059\u308b\u30bf\u30a4\u30df\u30f3\u30b0\n next=word_pos[start][ord(ans[-1])-orda]\n for i in range(0,26):\n if(word_pos[next+1][i]>end-1):\n ans+=chr(orda+i)\n break\n ans+=\"\\n\"\n print(ans)", "# import sys\nfrom sys import stdout\n# from copy import copy, deepcopy\n# from functools import lru_cache\n# from string import ascii_lowercase\n# from math import inf\n# inf = float('inf')\n\n\ndef main():\n ans = solve_case()\n stdout.write(\"{}\\n\".format(ans))\n\ndef solve_case():\n S = read_str()\n\n len_s = len(S)\n int_s = [ord(c) - ord('a') for c in S]\n\n # next_char_pos[from_idx][letter_idx] := the position of the next letter `letter_idx` from `from_idx`\n next_char_pos = make_list((len_s + 1, 26), len_s)\n for from_idx in reversed(list(range(len_s))):\n for letter_idx in range(26):\n if int_s[from_idx] == letter_idx:\n pos = from_idx\n else:\n pos = next_char_pos[from_idx+1][letter_idx]\n next_char_pos[from_idx][letter_idx] = pos\n\n # non_subseq_len[from_idx] := the length of the shortest \"non subsequence\" in S[from_idx:]\n non_subseq_len = make_list([len_s + 2], len_s + 1)\n non_subseq_len[len_s] = 1\n non_subseq_len[len_s + 1] = 0\n ans_next_pos = make_list([len_s + 1], len_s)\n ans_letter = make_list([len_s + 1], -1)\n for from_idx in reversed(list(range(len_s))):\n for letter_idx in range(26):\n new_len = non_subseq_len[next_char_pos[from_idx][letter_idx] + 1] + 1\n if non_subseq_len[from_idx] > new_len:\n non_subseq_len[from_idx] = new_len\n ans_letter[from_idx] = letter_idx\n ans_next_pos[from_idx] = next_char_pos[from_idx][letter_idx] + 1\n\n ans = ''\n idx = 0\n while idx < len(S):\n ans += chr(ord('a') + ans_letter[idx])\n idx = ans_next_pos[idx]\n return ans\n\n#################################\n\ndef read_str(): return input()\ndef read_int(): return int(input())\ndef read_str_list(): return input().split(' ')\ndef read_int_list(): return list(map(int, input().split(' ')))\ndef read_lines(n, read_func): return [read_func() for _ in range(n)]\ndef list_to_str(l, sep=' '): return sep.join(map(str, l))\nl2s = list_to_str\n# shape: tuple of ints | list of ints\ndef make_list(shape, value=None):\n if len(shape) == 1:\n return [value] * shape[0]\n return [make_list(shape[1:], value) for _ in range(shape[0])]\n\ndef __starting_point():\n # sys.setrecursionlimit(1000000)\n main()\n\n__starting_point()", "#!/usr/bin/env python3\n\ndef main():\n A = input()\n\n n = len(A)\n\n next_i = []\n ct = [n] * 26\n orda = ord(\"a\")\n for i in range(n - 1, -1, -1):\n ct[ord(A[i]) - orda] = i\n next_i.append(ct.copy())\n\n next_i.reverse()\n\n dp = [0] * (n + 1)\n dp[n] = 1\n j = -1\n for i in range(n - 1, -1, -1):\n ct = next_i[i]\n if max(ct) < n:\n j = i\n break\n else:\n dp[i] = 1\n\n if j == -1:\n ct = next_i[0]\n for c in range(26):\n if ct[c] == n:\n print((chr(orda + c)))\n return\n\n rt = [0] * n\n for i in range(j, -1, -1):\n ct = next_i[i]\n min_c = 0\n min_v = dp[ct[0] + 1]\n for c in range(1, 26):\n v = dp[ct[c] + 1]\n if v < min_v:\n min_c = c\n min_v = v\n rt[i] = min_c\n dp[i] = min_v + 1\n\n\n r = ''\n i = 0\n while i < n:\n if dp[i] == 1:\n for c in range(26):\n if not chr(orda + c) in A[i:]:\n r += chr(orda + c)\n break\n break\n r += chr(orda + rt[i])\n i = next_i[i][rt[i]] + 1\n\n\n print(r)\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "import sys\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nMOD = 10**9 + 7 # 998244353\ninput = lambda:sys.stdin.readline().rstrip()\ndef resolve():\n S = list(map(lambda c : ord(c) - ord('a'), input()))\n n = len(S)\n sigma = 26\n\n # next[i][c] : i \u6587\u5b57\u76ee\u4ee5\u964d\u3067 c \u304c\u73fe\u308c\u308b\u6700\u5c0f\u306e index\n next = [[-1] * sigma for _ in range(n + 1)]\n for i in range(n - 1, -1, -1):\n for c in range(sigma):\n next[i][c] = i if S[i] == c else next[i + 1][c]\n\n # dp[i] : S[i:] \u306b\u5bfe\u3059\u308b\u7b54\u3048\u306e\u9577\u3055\n dp = [INF] * (n + 1)\n dp[n] = 1\n # character[i] : S[i:] \u306b\u5bfe\u3059\u308b\u7b54\u3048\u306b\u5bfe\u3057\u3066\u63a1\u7528\u3059\u308b\u5148\u982d\u306e\u6587\u5b57\n character = [None] * (n + 1)\n character[n] = 0\n for i in range(n - 1, -1, -1):\n for c in range(sigma):\n length = 1 if next[i][c] == -1 else 1 + dp[next[i][c] + 1]\n if dp[i] > length:\n dp[i] = length\n character[i] = c\n\n # \u7d4c\u8def\u5fa9\u5143\n res = []\n now = 0\n while 1:\n res.append(character[now])\n now = next[now][character[now]] + 1\n if now == 0:\n break\n res = ''.join(map(lambda x : chr(x + ord('a')), res))\n print(res)\nresolve()", "# import sys\nfrom sys import stdout\n# from copy import copy, deepcopy\n# from functools import lru_cache\n# from string import ascii_lowercase\n# from math import inf\n# inf = float('inf')\n\n\ndef main():\n ans = solve_case()\n stdout.write(\"{}\\n\".format(ans))\n\ndef solve_case():\n S = read_str()\n\n len_s = len(S)\n int_s = [ord(c) - ord('a') for c in S]\n\n # next_char_pos[from_idx][letter_idx] := the position of the next letter `letter_idx` from `from_idx`\n next_char_pos = make_list((len_s + 1, 26), len_s)\n for from_idx in reversed(list(range(len_s))):\n for letter_idx in range(26):\n if int_s[from_idx] == letter_idx:\n pos = from_idx\n else:\n pos = next_char_pos[from_idx+1][letter_idx]\n next_char_pos[from_idx][letter_idx] = pos\n\n # non_subseq_len[from_idx] := the length of the shortest \"non subsequence\" in S[from_idx:]\n non_subseq_len = make_list([len_s + 2], len_s + 1)\n non_subseq_len[len_s] = 1\n non_subseq_len[len_s + 1] = 0\n ans_next_pos = make_list([len_s + 1], len_s)\n ans_letter = make_list([len_s + 1], -1)\n for from_idx in reversed(list(range(len_s))):\n for letter_idx in range(26):\n new_len = non_subseq_len[next_char_pos[from_idx][letter_idx] + 1] + 1\n if non_subseq_len[from_idx] > new_len:\n non_subseq_len[from_idx] = new_len\n ans_letter[from_idx] = letter_idx\n ans_next_pos[from_idx] = next_char_pos[from_idx][letter_idx] + 1\n\n ans = ''\n idx = 0\n while idx < len(S):\n ans += chr(ord('a') + ans_letter[idx])\n idx = ans_next_pos[idx]\n return ans\n\n#################################\n\ndef read_str(): return input()\ndef read_int(): return int(input())\ndef read_str_list(): return input().split(' ')\ndef read_int_list(): return list(map(int, input().split(' ')))\ndef read_lines(n, read_func): return [read_func() for _ in range(n)]\ndef list_to_str(l, sep=' '): return sep.join(map(str, l))\nl2s = list_to_str\n# shape: tuple of ints | list of ints\ndef make_list(shape, value=None):\n if len(shape) == 1:\n return [value] * shape[0]\n return [make_list(shape[1:], value) for _ in range(shape[0])]\n\ndef __starting_point():\n # sys.setrecursionlimit(1000000)\n main()\n\n__starting_point()", "A = input()\n\nimport string\np = {}\nfor x in string.ascii_lowercase: p[x] = len(A)\ntb = [(0, 0, 0)] * len(A)\ntb.append((1, 0, 0))\ntb.append((0, 0, 0))\n\nfor i, x in reversed(list(enumerate(A))):\n p[x] = i\n tb[i] = min([(tb[p[c]+1][0] + 1, c, p[c]+1) for c in string.ascii_lowercase])\n\ni = 0\nans = []\nwhile i < len(A):\n ans.append(tb[i][1])\n i = tb[i][2]\n\nprint((\"\".join(ans)))\n", "from collections import deque\n\nAs = input()\n\nAs = [ord(A) - ord('a') for A in As]\nlenA = len(As)\nposChars = [lenA] * 26\nposNexts = [[] for _ in range(lenA + 1)]\nfor i in reversed(list(range(lenA))):\n posNexts[i + 1] = posChars.copy()\n posChars[As[i]] = i\nposNexts[0] = posChars.copy()\n\nprevs = [None] * lenA\nQ = deque()\nQ.append((0, -1))\nwhile Q:\n lenAns, pos = Q.popleft()\n for ch in range(26):\n posNext = posNexts[pos + 1][ch]\n if posNext == lenA:\n ans = [chr(ord('a') + ch)]\n while pos != -1:\n ans.append(chr(ord('a') + As[pos]))\n pos = prevs[pos]\n print((''.join(reversed(ans))))\n return\n if prevs[posNext] is None:\n prevs[posNext] = pos\n Q.append((lenAns + 1, posNext)) \n", "S = input()\nN = len(S)\ninf = 10**18\n\nnxt = [[N+1] * 26 for _ in range(N + 2)]\nfor i in reversed(range(N)):\n for j in range(26):\n nxt[i][j] = nxt[i + 1][j]\n nxt[i][ord(S[i]) - ord(\"a\")] = i\n\ndp = [inf] * (N + 1)\ndp[N] = 1\nmemo = [N] * (N + 1)\nfor i in reversed(range(N)):\n for c, j in enumerate(nxt[i]):\n if j > N:\n if dp[i] > 1:\n dp[i] = 1\n memo[i] = c\n elif dp[i] > dp[j + 1] + 1:\n dp[i] = dp[j + 1] + 1\n memo[i] = c\n\nres = []\ni = 0\nwhile i <= N:\n res.append(chr(memo[i] + ord(\"a\")))\n i = nxt[i][memo[i]] + 1\nprint(\"\".join(res))", "import string\n\ndef __starting_point():\n A = input()\n\n p = {}\n for x in string.ascii_lowercase:\n p[x] = len(A)\n # print(p)\n '''\n tb\n 1\u3064\u76ee\uff1a\n 2\u3064\u76ee\uff1a\u30a2\u30eb\u30d5\u30a1\u30d9\u30c3\u30c8\n 3\u3064\u76ee\uff1a\n '''\n tb = [(0, 0, 0)] * len(A)\n tb.append((1, 0, 0))\n tb.append((0, 0, 0))\n # print(tb)\n for i, x in reversed(list(enumerate(A))):\n p[x] = i\n tb[i] = min([(tb[p[c] + 1][0] + 1, c, p[c] + 1) for c in string.ascii_lowercase])\n # print(tb)\n i = 0\n ans = []\n while i < len(A):\n ans.append(tb[i][1])\n i = tb[i][2]\n\n print((\"\".join(ans)))\n\n__starting_point()", "import sys\nfrom bisect import bisect_left as bl\ninput = sys.stdin.readline\nS = list(map(lambda x: ord(x) - ord(\"a\"), list(input())[: -1]))\ntable = [[] for _ in range(26)]\nfor i in range(len(S)):\n x = S[i]\n table[x].append(i + 1)\nfor c in range(26): table[c].append(len(S) + 1)\ndp = [len(S)] * (len(S) + 2)\ndp[-1] = 0\nrev = [0] * (len(S) + 1)\nrevc = [0] * (len(S) + 1)\nfor i in range(len(S) - 1, -1, -1):\n for x in range(26):\n j = table[x][bl(table[x], i + 1)]\n if dp[i] > dp[j] + 1:\n dp[i] = dp[j] + 1\n rev[i] = j\n revc[i] = x\n #print(i, x, j, table[x])\nx = 0\nres = []\nwhile x < len(S):\n c = revc[x]\n res.append(chr(c + ord(\"a\")))\n if x == len(S): break\n x = rev[x]\nprint(\"\".join(res))", "A = '.' + input()\n\nsmallalphas = list(map(chr, list(range(ord(\"a\"), ord(\"z\") + 1))))\n\nanswers = {c: 0 for c in smallalphas}\nlast_ch = 'a'\nhistory = []\nfor a in reversed(A):\n ch = 'a'\n for c in smallalphas:\n if answers[ch] > answers[c]:\n ch = c\n answers[a] = answers[ch] + 1\n history.append(ch)\n\nhistory.reverse()\n\n# print(history)\n\nans = [history[0]]\nfor i, a in enumerate(A):\n if ans[-1] == a:\n ans.append(history[i])\n\nprint((''.join(ans)))\n# minlen = min(map(len, answers))\n# ans = min(filter(lambda ans: len(ans) == minlen, answers))\n# print(ans)\n", "from string import ascii_lowercase\nfrom bisect import bisect\n\n\ndef solve(s):\n pos = [[] for _ in range(26)]\n offset = ord('a')\n for i, c in enumerate(s):\n c = ord(c) - offset\n pos[c].append(i)\n for l in pos:\n l.append(len(s))\n\n all_char_sequence_start_pos = []\n pos_i = [len(l) - 1 for l in pos]\n while all(pi >= 0 for pi in pos_i):\n i = min(l[pi] for pi, l in zip(pos_i, pos))\n all_char_sequence_start_pos.append(i)\n for j in range(26):\n while pos_i[j] >= 0 and pos[j][pos_i[j]] >= i:\n pos_i[j] -= 1\n all_char_sequence_start_pos.reverse()\n ans = []\n curr = -1\n for i in all_char_sequence_start_pos:\n for c in range(26):\n cj = bisect(pos[c], curr)\n j = pos[c][cj]\n if j >= i:\n ans.append(c)\n curr = j\n break\n return ''.join(chr(c + offset) for c in ans)\n\n\nprint((solve(input().strip())))\n", "a = list([ord(x)-ord(\"a\") for x in list(input())])\nn = len(a)\nm = 26\n\nb = [0]*n\npos = [[] for i in range(m)]\ns = set()\ncnt = 0\nfor i in reversed(list(range(n))):\n b[i] = cnt\n if a[i] not in s:\n s.add(a[i])\n pos[a[i]].append(i)\n if len(s) == m:\n cnt += 1\n s = set()\n\nfor i in range(m):\n pos[i].sort()\n\nk = cnt+1\n\nfrom bisect import bisect_right\n\nans = []\ncur = -1\nfor i in range(k):\n for j in range(m):\n pj = bisect_right(pos[j], cur)\n if pj == len(pos[j]):\n ans.append(j)\n break\n to = pos[j][pj]\n if b[to] != k-i-1:\n cur = to\n ans.append(j)\n break\n\nans = \"\".join(chr(ord(\"a\")+i) for i in ans)\nprint(ans)\n", "def main():\n import sys\n input = sys.stdin.readline\n\n a = list(input())[:-1]\n #print(a)\n n = len(a)\n\n d = dict()\n for i in range(26):\n d[chr(i+97)] = chr(i+97)\n \n\n for i in range(n-1,-1,-1):\n min_key = 'zz'\n min_len = 10**9\n for e in d:\n if (min_len == len(d[e]) and min_key > e) or (min_len > len(d[e])):\n min_key = e\n min_len = len(d[e])\n d[a[i]] = a[i]+d[min_key]\n\n res_len = len(d['a'])\n res_key = 'a'\n for e in d:\n if (res_len == len(d[e]) and res_key > e) or (res_len > len(d[e])):\n res_key = e\n res_len = len(d[e])\n print(d[res_key])\n\ndef __starting_point():\n main()\n__starting_point()", "import sys\ninput = sys.stdin.readline\n\na = list(input().rstrip())\nn = len(a)\nx = [[0] * 26 for _ in range(n + 1)]\nfor i in range(n):\n j = ord(a[i]) - 97\n x[i][j] = i + 1\nfor i in range(n - 1, -1, -1):\n for j in range(26):\n if x[i][j] == 0:\n x[i][j] = x[i + 1][j]\nminlen = [0] * (n + 1)\nminalph = [0] * (n + 1)\nfor i in range(n - 1, -1, -1):\n l = 114514\n for j in range(26):\n if x[i][j] == 0:\n l, m = 0, j\n break\n if l > minlen[x[i][j]] + 1:\n l, m = minlen[x[i][j]] + 1, j\n minlen[i] = l\n minalph[i] = m\nans = []\ni = 0\nfor _ in range(minlen[0] + 1):\n ans.append(chr(minalph[i] + 97))\n i = x[i][minalph[i]]\nans = \"\".join(ans)\nprint(ans)", "A=input()\nN=len(A)\nalphabet=[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"j\",\"k\",\"l\",\"m\",\"n\",\"o\",\"p\",\"q\",\"r\",\"s\",\"t\",\"u\",\"v\",\"w\",\"x\",\"y\",\"z\"]\nalp_to_n={}\nfor i,l in enumerate(alphabet):\n alp_to_n[l]=i\n \nD=[True]*26\nL=[N]\ns=0\nfor i in range(N)[::-1]:\n if D[alp_to_n[A[i]]]:\n D[alp_to_n[A[i]]]=False\n s+=1\n if s==26:\n D=[True]*26\n L.append(i)\n s=0\nL.reverse()\nans=[]\nD=[True]*26\nfor i in range(0,L[0]):\n D[alp_to_n[A[i]]]=False\n \nfor i in range(len(L)-1):\n num,pos=26,0\n for j in range(L[i],L[i+1]):\n if alp_to_n[A[j]]<num and D[alp_to_n[A[j]]]:\n num=alp_to_n[A[j]]\n pos=j\n ans.append(alphabet[num])\n D=[True]*26\n for j in range(pos+1,L[i+1]):\n D[alp_to_n[A[j]]]=False\nfor i in range(26):\n if D[i]:\n ans.append(alphabet[i])\n break\nprint((\"\".join(ans)))\n \n \n \n", "from collections import defaultdict\ninf = 10**10\nA = list(map(lambda x:ord(x)-ord('a'), list(input())))\nN = len(A)\nabc = 'abcdefghijklmbopqrstuvwxyz'\ns_to_i = [[N]*26 for _ in range(N+1)]\nfor i in range(N)[::-1]:\n for x in range(26):\n s_to_i[i][x] = s_to_i[i+1][x]\n s_to_i[i][A[i]] = i\ndp = [0]*(N+2)\ndp[-2] = 1\nfor i in range(N)[::-1]:\n now = max(s_to_i[i])+1\n dp[i] = dp[now]+1\nn = dp[0]\nnow = 0\nans = []\nfor i in range(n):\n for x in range(26):\n tmp = s_to_i[now][x]+1\n if dp[tmp] <= n-i-1:\n ans.append(chr(x+ord('a')))\n now = tmp\n break\nprint(*ans, sep = '')\n\n\n\n \n \n\n\n\n", "import sys\ninput = sys.stdin.readline\n\nA = input().rstrip()\ndp = [chr(c) for c in range(ord('a'), ord('z')+1)]\nfor c in A[::-1]:\n s = min(dp, key=lambda x: len(x))\n dp[ord(c) - ord('a')] = c + s\nprint(min(dp, key=lambda x: len(x)))", "S = input()\nN = len(S)\nINF = N+1\nnex = [[INF]*26 for _ in range(N+1)]\nfor i,c in enumerate(S[::-1]):\n ic = ord(c) - ord('a')\n for j in range(26):\n nex[N-i-1][j] = N-i-1 if j==ic else nex[N-i][j]\n\ndp = [N] * (N+3)\ndp[INF] = dp[INF+1] = 0\nfor i in range(N,-1,-1):\n tmp = INF\n for j in range(26):\n tmp = min(tmp, dp[nex[i][j]+1]+1)\n if tmp == 1: break\n dp[i] = tmp\n\nans = []\ni = 0\nfor v in range(dp[0]-1,-1,-1):\n for j in range(26):\n if dp[nex[i][j]+1] != v: continue\n ans.append(chr(j + ord('a')))\n i = nex[i][j]+1\n break\n\nprint(''.join(ans))", "from copy import copy\nfrom collections import deque\nimport sys\nA = input()\nN = len(A)\nM = 26\n\ndef alp(c):\n return chr(ord(\"a\")+c)\ndef num(s):\n return ord(s)-ord(\"a\")\n \n\nINF = 10**6\ntmp = [INF for _ in range(M)]\nNxt = [None for _ in range(N+1)]\nNxt[N] = copy(tmp)\nfor i in range(N-1,-1,-1):\n tmp[num(A[i])] = i+1\n Nxt[i] = copy(tmp)\n#print(*Nxt, sep = \"\\n\") \ntask = deque([(0, \"\")])\nvisited = {0}\n \nwhile task:\n i, s = task.popleft()\n for c, j in enumerate(Nxt[i]):\n if j == INF:\n print(\"\".join([s,alp(c)]))\n return\n if j not in visited:\n task.append((j, \"\".join([s,alp(c)])))\n visited.add(j)\n \nprint(\"error\")", "alp = [chr(i) for i in range(97, 97+26)]\n\nimport sys\ninput = sys.stdin.readline\n\nS = input().rstrip()\nN = len(S)\n\ndp = [[N]*26 for _ in range(N+1)]\n\nBest = [-1]*(N+1)\n\nfor i in reversed(range(N)):\n s = S[i]\n b = 10**14\n for k in range(26):\n if Best[dp[i+1][k]] < b:\n b = Best[dp[i+1][k]]\n if s == alp[k]:\n dp[i][k] = i\n else:\n dp[i][k] = dp[i+1][k]\n Best[i] = b+1\n\nb = 10**14\nfor k in range(26):\n if Best[dp[0][k]] < b:\n b = Best[dp[0][k]]\nL = b+1\n\nans = \"\"\nind = -1\nfor _ in range(L+1):\n best = Best[max(dp[ind+1])]\n for k in range(26):\n if Best[dp[ind+1][k]] == best:\n ans += alp[k]\n if ind != N:\n ind = dp[ind+1][k]\n break\nprint(ans)", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\ndef main():\n inf = 10 ** 7\n s = input()\n n = len(s)\n s += \"\".join(chr(i + 97) for i in range(26))\n # print(s)\n # \u6b21\u3092\u305d\u306e\u6587\u5b57\u306b\u3057\u305f\u6642\u306e\u300c\u9577\u3055\u3001\u4f4d\u7f6e\u300d\n size = [0] * 26\n pos = [n + i for i in range(26)]\n # \u89e3\u7b54\u5fa9\u5143\u306e\u305f\u3081\u306e\u79fb\u52d5\u5148\n nxt = [-1] * n\n # \u5f8c\u308d\u306e\u6587\u5b57\u304b\u3089\u9806\u306b\u898b\u308b\n for i in range(n - 1, -1, -1):\n min_size = inf\n min_pos = -1\n # \u6b21\u3092\u3069\u306e\u6587\u5b57\u306b\u3059\u308c\u3070\u77ed\u304f\u306a\u308b\u304b\u8abf\u3079\u308b\n # \u540c\u3058\u9577\u3055\u306e\u6642\u306f\u8f9e\u66f8\u9806\u512a\u5148\n for sz, p in zip(size, pos):\n if sz < min_size:\n min_size = sz\n min_pos = p\n code = ord(s[i]) - 97\n size[code] = min_size + 1\n pos[code] = i\n nxt[i] = min_pos\n # print(size)\n # print(pos)\n # print(nxt)\n # print()\n # \u6700\u77ed\u306b\u306a\u308b\u6700\u521d\u306e\u6587\u5b57\u3092\u8abf\u3079\u3066\u3001nxt\u306e\u9806\u306b\u305f\u3069\u308b\n min_size = inf\n min_pos = -1\n for sz, p in zip(size, pos):\n if sz < min_size:\n min_size = sz\n min_pos = p\n i = min_pos\n ans = s[i]\n while i < n:\n i = nxt[i]\n ans += s[i]\n print(ans)\n\nmain()\n", "from collections import deque\nalpha = \"abcdefghijklmnopqrstuvwxyz\"\nA = input()\nn = len(A)\nB = ord('a')\n\nlinks = [None]*(n+3)\n\nlink = [n]*26\nfor i in range(n-1, -1, -1):\n links[i] = link[:]\n link[ord(A[i]) - B] = i\nlinks[-1] = link\n\ndeq = deque()\ndeq.append(-1)\nprev = {-1: (None, 0)}\nwhile deq:\n v = deq.popleft()\n if v == n:\n break\n link = links[v]\n for c in range(26):\n if link[c] in prev:\n continue\n prev[link[c]] = (v, c)\n deq.append(link[c])\nv = n\nans = []\nwhile v is not None:\n v, c = prev[v]\n ans.append(chr(c+B))\nans.reverse()\nprint((\"\".join(ans[1:])))\n\n", "from bisect import bisect_left\n\nCHARACTERs = 'abcdefghijklmnopqrstuvwxyz'\n\nAs = input()\nlenA = len(As)\n\nposChars = dict([(ch, [lenA]) for ch in CHARACTERs])\ndp = [0] * lenA + [1, 0]\nfor i in reversed(list(range(lenA))):\n posChars[As[i]].append(i)\n dp[i] = min([dp[posChars[ch][-1] + 1] for ch in CHARACTERs]) + 1\n\nfor ch in CHARACTERs:\n posChars[ch] = posChars[ch][::-1]\n\nans = []\ni = 0\nfor k in reversed(list(range(dp[0]))):\n for ch in CHARACTERs:\n pos = posChars[ch][bisect_left(posChars[ch], i)]\n if dp[pos + 1] == k:\n ans.append(ch)\n i = pos + 1\n break\n\nprint((''.join(ans)))\n", "a = list(map(lambda x: ord(x)-ord(\"a\"), list(input())))\nn = len(a)\nm = 26\n\nb = [1]*(n+1)\nprev = [n]*m\nG = [[] for i in range(n+1)]\nfor i in reversed(range(n)):\n ai = a[i]\n tmp = min(b[j] for j in prev)\n for j in prev:\n G[i].append(j)\n b[i] = tmp+1\n prev[ai] = i\n\ncnt = min(b[j] for j in prev)\nedge = prev\nans = []\nfor _ in range(cnt):\n for i, to in enumerate(edge):\n if b[to] == cnt-_:\n ans.append(chr(ord(\"a\")+i))\n edge = G[to]\n break\nprint(\"\".join(ans))", "def main():\n import sys\n input=sys.stdin.readline\n s=input()\n alpha=\"abcdefghijklmnopqrstuvwxyz\"\n l=len(s)\n alpha2={j:i for i,j in enumerate(alpha)}\n memo=[[0]*26 for _ in range(l,-1,-1)]\n for i in range(26):\n memo[l][i]=l+1\n for i in range(l-1,-1,-1):\n for x,y in alpha2.items():\n if s[i]==x:\n memo[i][y]=i+1\n else:\n memo[i][y]=memo[i+1][y]\n \n search=[1]*(l+2)\n search[l+1]=0\n for i in range(l-1,-1,-1):\n m=max([memo[i][j] for j in range(26)])\n if m!=l+1:\n search[i]=search[m]+1\n \n n,seq=0,0\n ans_len=search[0]\n ans=\"\"\n temp=0\n for i in range(ans_len):\n for j in range(26):\n n=memo[temp][j]\n seq=search[n]+i\n if seq+1==ans_len:\n ans+=alpha[j]\n temp=memo[temp][j]\n break\n print(ans)\ndef __starting_point():\n main()\n__starting_point()", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\n#n, = map(int,readline().split())\ns = input()\n\ndef next_index(N,s):\n D = [-1]*26\n E = [None]*(N+1)\n cA = ord('a')\n for i in range(N-1, -1, -1):\n E[i+1] = D[:]\n D[ord(s[i])-cA] = i\n E[0] = D\n return E\n\nn = len(s)\nnxt = next_index(n,s)\n\n\"\"\"\nfor i in nxt:\n print(i[:4])\n\"\"\"\n\n#print(nxt)\ndp = [0]*(n+1)\nfor i in range(n-1,-1,-1):\n idx = max(nxt[i])\n bad = min(nxt[i])\n dp[i] = dp[idx+1]+1 if bad != -1 else 0\n\n#print(nxt[0])\n#print(dp)\n\nk = dp[0]+1\nans = [None]*k\n\nv = 0\nfor i in range(k):\n #print(v)\n if v==n:\n ans[-1] = 0\n break\n\n for j in range(26):\n #print(nxt[v+1][j], dp[nxt[v+1][j]])\n if nxt[v][j]==-1 or dp[nxt[v][j] + 1] < dp[v]:\n ans[i] = j\n v = nxt[v][j]+1\n break\n\n#print(ans)\ndef f(x):\n return chr(x+ord(\"a\"))\n\na = \"\".join(map(f,ans))\nprint(a)\n\n\n\n\"\"\"\nx = [chr(ord(\"z\")-i) for i in range(26)]\nx = \"\".join(x)\nprint(x)\n\"\"\"\n\n\n\n\n\n\n\n\n\n\n\n\n", "import os\nimport sys\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nS = sys.stdin.readline().rstrip()\nA = [ord(c) - ord('a') for c in S]\nN = len(S)\n\n# \u7b54\u3048\u306e\u6587\u5b57\u5217\u306e\u9577\u3055\nl = 0\n# \u305d\u306e\u6587\u5b57\u4ee5\u964d\u3067\u3001\u4f55\u6587\u5b57\u307e\u3067\u306e\u4efb\u610f\u6587\u5b57\u5217\u3092\u4f5c\u308c\u308b\u304b\nlengths = [0] * N\ncounts = [0] * 26\nfor i, a in reversed(list(enumerate(A))):\n counts[a] += 1\n lengths[i] = l\n if min(counts) == 1:\n counts = [0] * 26\n l += 1\nans_size = l + 1\n\n# \u6587\u5b57\u3054\u3068\u306e\u6b21\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\ngraph = [[-1] * 26 for _ in range(N)]\npos = [-1] * 26\nfor i, a in reversed(list(enumerate(A))):\n graph[i] = pos[:]\n pos[a] = i\ninitials = pos\n\n\ndef solve(size, i=None):\n # i \u756a\u76ee\u304b\u3089\u59cb\u307e\u308a\u3001\u9577\u3055 size \u3067\u3042\u308b\u3001\u90e8\u5206\u5217\u3067\u306a\u3044\u6587\u5b57\u5217\n if i is None:\n pos = initials\n else:\n pos = graph[i]\n\n if size == 1:\n return chr(pos.index(-1) + ord('a'))\n\n size -= 1\n for ci, i in enumerate(pos):\n if lengths[i] < size:\n c = chr(ci + ord('a'))\n return c + solve(size, i)\n assert False\n\n\nprint((solve(ans_size)))\n", "def main():\n import sys\n input=sys.stdin.readline\n s=input()\n alpha=\"abcdefghijklmnopqrstuvwxyz\"\n l=len(s)\n alpha2={j:i for i,j in enumerate(alpha)}\n memo=[[0]*26 for _ in range(l,-1,-1)]\n for i in range(26):\n memo[l][i]=l+1\n for x,y in alpha2.items():\n for i in range(l-1,-1,-1):\n if s[i]==x:\n memo[i][y]=i+1\n else:\n memo[i][y]=memo[i+1][y]\n \n search=[1]*(l+2)\n search[l+1]=0\n for i in range(l-1,-1,-1):\n m=max([memo[i][j] for j in range(26)])\n if m!=l+1:\n search[i]=search[m]+1\n \n n,seq=0,0\n ans_len=search[0]\n ans=\"\"\n temp=0\n for i in range(ans_len):\n for j in range(26):\n n=memo[temp][j]\n seq=search[n]+i\n if seq+1==ans_len:\n ans+=alpha[j]\n temp=memo[temp][j]\n break\n print(ans)\ndef __starting_point():\n main()\n__starting_point()", "import bisect\n\nalphabetlist=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']\n\nA=input()\nN=len(A)\n\ndic={moji:[] for moji in alphabetlist}\ndp=[0 for i in range(N)]\ncheck=set([A[-1]])\ndic[A[-1]].append(N-1)\nfor i in range(N-2,-1,-1):\n check.add(A[i])\n dic[A[i]].append(i)\n if len(check)==26:\n dp[i]=dp[i+1]+1\n check=set([])\n else:\n dp[i]=dp[i+1]\n\nfor moji in alphabetlist:\n dic[moji].sort()\n\nL=dp[0]+1\nans=[]\npos=-1\nflag=0\n\nfor i in range(L-1):\n if flag==1:\n break\n for moji in alphabetlist:\n if dic[moji]:\n index=bisect.bisect_left(dic[moji],pos)\n npos=dic[moji][index]\n if npos+1<N and dp[npos+1]<L-(i+1):\n pos=npos+1\n ans.append(moji)\n break\n elif npos==N-1:\n pos=N\n ans.append(moji)\n flag=1\n break\n\nif pos==N:\n ans.append(\"a\")\n print(\"\".join(ans))\nelse:\n s=set([])\n for i in range(pos,N):\n s.add(A[i])\n for moji in alphabetlist:\n if moji not in s:\n ans.append(moji)\n break\n print(\"\".join(ans))", "A = [ord(a)-97 for a in input()]\nN = len(A)\nX = [0] * 26\nY = [0] * (N + 2)\nNE = [0] * N\nR = [N] * 26\ns = 0\nt = 1\nfor i in range(N)[::-1]:\n a = A[i]\n if X[a] == 0:\n X[a] = 1\n s += 1\n if s == 26:\n s = 0\n X = [0] * 26\n t += 1\n Y[i] = t\n NE[i] = R[a]\n R[a] = i\n\nANS = []\nii = 0\nfor i, a in enumerate(A):\n if i == ii:\n for j in range(26):\n if Y[R[j]+1] < Y[i]:\n ANS.append(j)\n ii = R[j]+1\n break\n R[a] = NE[i]\n\nprint(\"\".join([chr(a+97) for a in ANS]))", "from collections import Counter\ns = input()\ndef num(letter):\n\treturn ord(letter) - 97\ndef let(number):\n\treturn chr(number + 97)\n\nok = 0\nng = len(s)\nused = [False] * 26\ntmp = 0\ncnt = 0\nfor i in range(len(s)):\n\tif used[num(s[i])] == False:\n\t\tused[num(s[i])] = True\n\t\ttmp += 1\n\tif tmp == 26:\n\t\tcnt += 1\n\t\ttmp = 0\n\t\tused = [False] * 26\n\nprm = cnt+1\n\nif prm == 1:\n\tfor j in range(26):\n\t\tif used[j] == False:\n\t\t\tprint(let(j))\n\t\t\tbreak\nelse:\n\td = []\n\tused = [False] * 26\n\ttmp = 0\n\tfor i in range(len(s)-1, -1, -1):\n\t\tif used[num(s[i])] == False:\n\t\t\tused[num(s[i])] = True\n\t\t\ttmp += 1\n\t\tif tmp == 26:\n\t\t\ttmp = 0\n\t\t\tused = [False] * 26\n\t\t\td.append(i)\n\td = d[::-1]\n\tans = \"\"\n\tcnt = 0\n\ti = 0\n\tskip = False\n\tused = [False] * 26\n\tfor i in range(len(s)):\n\t\tif cnt < prm-1:\n\t\t\tif i == d[cnt]:\n\t\t\t\tfor j in range(26):\n\t\t\t\t\tif used[j] == False:\n\t\t\t\t\t\tans += let(j)\n\t\t\t\t\t\tbreak\n\t\t\t\tused = [False] * 26\n\t\t\t\tcnt += 1\n\t\t\t\tskip = True\t\t\t\n\t\tif skip:\n\t\t\tif s[i] == ans[-1]:\n\t\t\t\tskip = False\n\t\t\tcontinue\n\t\tif used[num(s[i])] == False:\n\t\t\tused[num(s[i])] = True\n\n\tfor j in range(26):\n\t\tif used[j] == False:\n\t\t\tans += let(j)\n\t\t\tbreak\n\tprint(ans)", "S=input()\nN=len(S)\na=ord('a')\nalpha=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']\nK=[[N]*(N+1) for i in range(26)]\nfor i in range(N-1,-1,-1):\n x=ord(S[i])-a\n for j in range(26):\n if j==x:\n K[j][i]=i\n continue\n K[j][i]=K[j][i+1]\ndp=[0]*(N+2)\nL=[0]*(N+2)\ndp[N]=1\nfor i in range(N-1,-1,-1):\n c=0\n b=2*N\n for j in range(26):\n t=K[j][i]\n if b>dp[t+1]+1:\n b=dp[t+1]+1\n c=t+1\n dp[i]=b\n L[i]=c\nX=dp[0]\nt=0\nans=''\nwhile X>1:\n t=L[t]\n ans+=S[t-1]\n X-=1\n #print(t,X,ans)\nfor j in range(26):\n if K[j][t] ==N:\n ans+=alpha[j]\n break\nprint(ans)\n\n\n", "import bisect\ns = input()\nn = len(s)\ndp = [[0 for i in range(26)] for j in range(n+1)]\nflg = [0]*26\nprt = []\nfor i in range(n-1,-1,-1):\n x = ord(s[i])-97\n for j in range(26):\n if j == x:\n dp[i][j] = n-i\n flg[x] = 1\n else:\n dp[i][j] = dp[i+1][j]\n if flg.count(1) == 26:\n prt.append(i)\n flg = [0]*26\nind = 0\nans = []\nif not prt:\n for i in range(26):\n if dp[0][i] == 0:\n print(chr(i+97))\n return\nprt = prt[::-1]\nfor i in range(26):\n if dp[prt[0]][i] == dp[0][i]:\n ans.append(i)\n break\nelse:\n ans.append(0)\n\npnt = prt[0]\nflg = 0\nwhile True:\n c = ans[-1]\n if not flg:\n pnt = n-dp[pnt][c]\n flg = 0\n prtp = bisect.bisect_right(prt,pnt)\n if prtp == len(prt):\n for i in range(26):\n if dp[pnt+1][i] == dp[-1][i]:\n ans.append(i)\n break\n else:\n ans.append(0)\n for od in ans:\n print(chr(od+97),end=\"\")\n break\n npnt = prt[prtp]\n for i in range(26):\n if dp[pnt+1][i] == dp[npnt][i]:\n ans.append(i)\n break\n else:\n ans.append(0)\n flg = 1\n pnt = npnt\n", "def main():\n # import sys\n # readline = sys.stdin.readline\n # readlines = sys.stdin.readlines\n \n A = input()\n N = len(A)\n a = ord('a')\n\n INF = N\n na = [[INF] * 26 for _ in range(N + 1)]\n for i in range(N - 1, -1, -1):\n c = ord(A[i]) - a\n for j in range(26):\n na[i][j] = na[i + 1][j]\n na[i][c] = i\n\n dp = [INF] * (N + 1)\n dp[N] = 1\n recon = [None] * (N + 1)\n for i in range(N - 1, -1, -1):\n for j in range(26):\n ni = na[i][j]\n if ni == N:\n if dp[i] > 1:\n dp[i] = 1\n recon[i] = (chr(a + j), N)\n elif dp[i] > dp[ni + 1] + 1:\n dp[i] = dp[ni + 1] + 1\n recon[i] = (chr(a + j), ni + 1)\n\n # k =\n # for j in range(26):\n # ni = na[0][j]\n # if dp[i] > dp[ni] + 1:\n\n i = 0\n ans = []\n while i < N:\n c, ni = recon[i]\n ans.append(c)\n i = ni\n\n print((''.join(ans)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from itertools import accumulate\n\nS = list(map(ord, input().strip()))\nN = len(S)\n\natype = set()\nseg = [0]*N\nseg[-1] = 1\nfor i in range(N-1, -1, -1):\n atype.add(S[i])\n if len(atype) == 26:\n atype = set()\n seg[i] = 1\n\ninf = 1<<32\nidx = [[inf]*N for _ in range(26)]\nfor i in range(N-1, -1, -1):\n s = S[i] - 97\n idx[s][i] = i\n\nfor s in range(26):\n for i in range(N-2, -1, -1):\n idx[s][i] = min(idx[s][i], idx[s][i+1])\n\n\n\nseg = list(accumulate(seg[::-1]))[::-1]\nseg.append(1)\nL = seg[0]\nans = []\ncnt = -1\nfor i in range(L):\n for c in range(26):\n k = idx[c][cnt+1]\n if k == inf:\n ans.append(97+c)\n break\n if seg[k+1] + i + 1 <= L:\n ans.append(97+c)\n cnt = k\n break\n \n\nprint(''.join(map(chr, ans)))", "from collections import Counter\ns = input()\ndef num(letter):\n\treturn ord(letter) - 97\ndef let(number):\n\treturn chr(number + 97)\n\nok = 0\nng = len(s)\nused = [False] * 26\ntmp = 0\ncnt = 0\nfor i in range(len(s)):\n\tif used[num(s[i])] == False:\n\t\tused[num(s[i])] = True\n\t\ttmp += 1\n\tif tmp == 26:\n\t\tcnt += 1\n\t\ttmp = 0\n\t\tused = [False] * 26\n\nprm = cnt+1\n\nif prm == 1:\n\tfor j in range(26):\n\t\tif used[j] == False:\n\t\t\tprint(let(j))\n\t\t\tbreak\nelse:\n\td = []\n\tused = [False] * 26\n\ttmp = 0\n\tfor i in range(len(s)-1, -1, -1):\n\t\tif used[num(s[i])] == False:\n\t\t\tused[num(s[i])] = True\n\t\t\ttmp += 1\n\t\tif tmp == 26:\n\t\t\ttmp = 0\n\t\t\tused = [False] * 26\n\t\t\td.append(i)\n\td = d[::-1]\n\t#print(d)\n\tans = \"\"\n\tcnt = 0\n\ti = 0\n\tskip = False\n\tused = [False] * 26\n\tfor i in range(len(s)):\n\t\tif cnt < prm-1:\n\t\t\tif i == d[cnt]:\n\t\t\t\tfor j in range(26):\n\t\t\t\t\tif used[j] == False:\n\t\t\t\t\t\tans += let(j)\n\t\t\t\t\t\tbreak\n\t\t\t\tused = [False] * 26\n\t\t\t\tcnt += 1\n\t\t\t\tskip = True\n\t\t\t\t\n\t\tif skip:\n\t\t\tif s[i] == ans[-1]:\n\t\t\t\t#print(i)\n\t\t\t\tskip = False\n\t\t\tcontinue\n\n\t\tif used[num(s[i])] == False:\n\t\t\tused[num(s[i])] = True\n\n\t#print(used)\n\tfor j in range(26):\n\t\tif used[j] == False:\n\t\t\tans += let(j)\n\t\t\tbreak\n\tprint(ans)", "import bisect\nA = input()\nn = len(A)\nch = [[] for _ in range(26)]\nidx = []\nused = set()\nfor i in range(n-1, -1, -1):\n a = A[i]\n ch[ord(a)-ord(\"a\")].append(i)\n used.add(a)\n if len(used) == 26:\n idx.append(i)\n used = set()\nk = len(idx)\nidx = idx[::-1]\nfor j in range(26):\n ch[j] = ch[j][::-1]\nans = \"\"\nnow = -1\nfor i in range(k):\n for j in range(26):\n nxt = ch[j][bisect.bisect_right(ch[j], now)]\n if nxt >= idx[i]:\n now = nxt\n ans += chr(j+ord(\"a\"))\n break\nfor j in range(26):\n l = bisect.bisect_right(ch[j], now)\n if l == len(ch[j]):\n ans += chr(j+ord(\"a\"))\n break\nprint(ans)", "\n\"\"\"\nWriter: SPD_9X2\nhttps://atcoder.jp/contests/arc081/tasks/arc081_c\n\n1\u6587\u5b57\u304c\u3042\u308a\u3046\u308b\u306e\u306f\u3001\u51fa\u3066\u306a\u3044\u6587\u5b57\u304c\u3042\u308b\u3068\u304d\n2\u6587\u5b57\u304c\u3042\u308a\u3046\u308b\u306e\u306f\u3001\u5168\u3066\u306e\u6587\u5b57\u304c1\u5ea6\u51fa\u305f\u306e\u3061\u3001\u3082\u3046\u4e00\u5ea6\u3059\u3079\u3066\u306e\u6587\u5b57\u304c1\u5ea6\u73fe\u308c\u3066\u306a\u3044\u5834\u5408\n\u3064\u307e\u308a\u7b54\u3048\u306e\u6587\u5b57\u6570\u306f\u3053\u306e\u65b9\u6cd5\u3067\u5206\u304b\u308b\n\n\u3067\u306f\u8f9e\u66f8\u9806\u6700\u5c0f\u306e\u3082\u306e\u306f\uff1f\nk\u6587\u5b57\u3067\u3042\u308b\u3053\u3068\u304c\u308f\u304b\u3063\u3066\u3044\u305f\u3068\u3059\u308b\u3002\n\u3053\u306e\u6642\u3001\u3069\u306e\u6587\u5b57\u3082\u6700\u4f4ek-1\u56de\u51fa\u73fe\u3057\u3066\u3044\u308b\n\u6700\u5f8c\u306e\u6587\u5b57\u306f\u3001k\u56de\u51fa\u73fe\u3057\u3066\u306a\u3044\u6587\u5b57\u306e\u5185\u3001\u8f9e\u66f8\u9806\u6700\u5c0f\u306e\u7269\n\u6700\u5f8c\u304b\u30891\u756a\u76ee\u306f\u3001k-1\u56de\u76ee\u306e\u51fa\u73fe\u306e\u5f8c\u3001\u6700\u5f8c\u306e\u6587\u5b57\u304c\u51fa\u3066\u3044\u306a\u3044\u8005\n\u6700\u5f8c\u304b\u30892\u756a\u76ee\u306f\u3001\n\nabc\u306e3\u6587\u5b57\u3057\u304b\u306a\u3044\u3068\u3059\u308b\nabababababcab\n\n\u2192\u3053\u306e\u6642\u3001\u6c42\u3081\u308b\u306e\u306f\u3001?c\u3067\u3001?\u306fc\u6700\u5f8c\u306b\u51fa\u73fe\u3059\u308bc\u3088\u308a\u3082\u524d\u306b\u5b58\u5728\u3057\u306a\u3044k-1\u6587\u5b57\u306e\u8f9e\u66f8\u9806\u6700\u5c0f\n\nabcabcab\n\u2192??c\n\u2192\u6700\u5f8c\u306e\u51fa\u73fe\u3059\u308bc\u4ee5\u524d=abcab\u4ee5\u524d\u3067\u5b58\u5728\u3057\u306a\u30442\u6587\u5b57\n\u2192?cc\n\u2192ab\u3067\u5b58\u5728\u3057\u306a\u30441\u6587\u5b57\n\u2192ccc\n\nacbaccbac\n\u2192\u7d50\u5c40\u518d\u5e30\u7684\u306b\u89e3\u3051\u308b\n\u2192\u51fa\u73fe\u56de\u6570\u304c\u6700\u5c0f\u306e\u6587\u5b57\u306e\u3046\u3061\u3001\u8f9e\u66f8\u9806\u6700\u5c0f\u306e\u7269\u3092\u7b54\u3048\u306e\u6700\u5f8c\u306e\u6587\u5b57\u304b\u3089\u6c7a\u3081\u3066\u3044\u304d\u3001\u305d\u306e\u6587\u5b57\u304c\u6700\u5f8c\u306e\u51fa\u73fe\u3057\u305find\n\u3088\u308a\u524d\u306b\u95a2\u3057\u3066\u3001\u540c\u3058\u554f\u984c\u3092\u89e3\u304f\n\n\u3042\u3068\u306f\u3069\u3046\u3084\u3063\u3066\u8a08\u7b97\u91cf\u3092\u524a\u6e1b\u3059\u308b\u304b\n\u305d\u306e\u6642\u70b9\u3067\u3001\u3069\u306e\u6587\u5b57\u304c\u4f55\u5ea6\u51fa\u305f\u304b\u3001\u6700\u5f8c\u306e\u51fa\u73fe\u3057\u305findex\u306f\u3069\u3053\u304b\u3001\u3092\u8a18\u9332\u3057\u3066\u7f6e\u3044\u3066\u518d\u5e30\u7684\u306b\u89e3\u304f\n\n\u2192\u65b9\u91dd\u306f\u5408\u3063\u3066\u308b\uff1f\u3051\u3069\u5b9f\u88c5\u3057\u3066\u308b\u306e\u304c\u9055\u3046\u3088\uff01\n\u4fdd\u5b58\u3057\u3066\u304a\u304f\u306e\u306f\u3001\u5168\u3066\u306e\u6587\u5b57\u304c\u4f55\u56de\u51fa\u63c3\u3063\u305f\u304b\u3001\u3068\u305d\u306e\u5f8c\u3069\u306e\u6587\u5b57\u304c\u51fa\u3066\u3044\u308b\u304b\u3002\n&\u5404\u6587\u5b57\u304c\u6700\u5f8c\u306b\u3069\u3053\u3067\u51fa\u305f\u304b\u3002\n\n\u3042\u308c\u30fc\uff1f\naaaaaabbbbbbc\n\n\u2192\u554f\u984c\u306f\u3001\u5fc5\u305a\u3057\u3082\u5f8c\u308d\u304b\u3089\u6700\u9069\u306a\u306e\u3092\u9078\u3093\u3067\u884c\u3051\u3070\u3044\u3044\u308f\u3051\u3067\u306f\u306a\u304b\u3063\u305f\u3053\u3068\n\u2192\u3053\u308c\u306f\u3042\u304f\u307e\u3067\u3001\u5f8c\u308d\u304b\u3089\u898b\u3066\u8f9e\u66f8\u9806\u6700\u5c0f\u3067\u3057\u304b\u306a\u3044\u2026\u3042\u308c\u307e\u3055\u304b\uff1f\n\u2192\u6b63\u89e3\u3057\u3061\u3083\u3063\u305f\u30fc\uff1f\uff1f\uff1f\n\"\"\"\n\nA = list(input())\nA.reverse()\n\nalp = \"abcdefghijklmnopqrstuvwxyz\"\nalpdic = {}\nfor i in range(26):\n alpdic[alp[i]] = i\n\nallcol = [0] * (len(A)+1)\napnum = [ [0] * 26 for i in range(len(A)+1) ]\nlastap = [ [0] * 26 for i in range(len(A)+1) ]\n\nfor i in range(len(A)):\n\n for j in range(26):\n apnum[i+1][j] = apnum[i][j]\n lastap[i+1][j] = lastap[i][j]\n allcol[i+1] = allcol[i]\n\n apnum[i+1][alpdic[A[i]]] |= 1\n if 0 not in apnum[i+1]:\n apnum[i+1] = [0] * 26\n allcol[i+1] += 1\n lastap[i+1][alpdic[A[i]]] = i+1\n\nanslen = allcol[-1]+1\nans = []\nnind = len(A)\n\nfor i in range(anslen):\n\n #print (\"\".join(A[:nind]))\n\n minind = 0\n for j in range(26):\n if apnum[nind][j] == 0:\n minind = j\n break\n ans.append(alp[minind])\n\n nind = lastap[nind][minind]-1\n\n#ans.reverse()\nprint (\"\".join(ans))", "def main():\n import sys\n input = sys.stdin.readline\n\n S = input().rstrip('\\n')\n N = len(S)\n\n rank = [0] * N\n seen = [0] * 26\n cnt = 0\n r = 0\n for i in range(N-1, -1, -1):\n j = ord(S[i]) - 97\n if not seen[j]:\n seen[j] = 1\n cnt += 1\n rank[i] = r\n if cnt == 26:\n r += 1\n seen = [0] * 26\n cnt = 0\n\n ans = []\n for i in range(26):\n if not seen[i]:\n ans.append(i+97)\n break\n\n i0 = 0\n while ord(S[i0]) != ans[0]:\n i0 += 1\n if i0 == N:\n print((chr(ans[0])))\n return\n r = rank[i0]\n seen2 = [0] * 26\n flg = 1\n for i in range(i0+1, N):\n j = ord(S[i])-97\n if flg:\n if rank[i] == r:\n seen2[j] = 1\n else:\n for k in range(26):\n if not seen2[k]:\n ans.append(k+97)\n break\n flg = 0\n seen2 = [0] * 26\n if j == k:\n r -= 1\n flg = 1\n else:\n if j != k:\n continue\n else:\n r -= 1\n flg = 1\n for k in range(26):\n if not seen2[k]:\n ans.append(k + 97)\n break\n print((''.join(map(chr, ans))))\n\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "def calcNext(s):\n n = len(s)\n res = [[n+1] * 26 for _ in range(n+1)]\n for i in range(n-1, -1, -1):\n for j in range(26):\n res[i][j] = res[i+1][j]\n res[i][ord(s[i]) - ord('a')] = i\n return res\n\ndef solve(s):\n n = len(s)\n nx = calcNext(s)\n dp = [n + 1] * (n + 1)\n recon = ['a'] * (n + 1)\n dp[n] = 1\n for i in range(n-1, -1, -1):\n for j in range(26):\n if nx[i][j] == n + 1:\n if dp[i] > 1:\n dp[i] = 1\n recon[i] = chr(ord('a') + j)\n else:\n if dp[nx[i][j] + 1] + 1 < dp[i]:\n dp[i] = dp[nx[i][j] + 1] + 1\n recon[i] = chr(ord('a') + j)\n res = ''\n idx = 0\n while idx <= n:\n res += recon[idx]\n idx = nx[idx][ord(recon[idx]) - ord('a')] + 1\n return res\n\nS = input()\nprint(solve(S))", "\nord_a = ord('a')\nL = 26\n\nS = list(map(lambda c: ord(c)-ord_a,input()))\n\n\nmemo = []\n\nf = [0]*L\ncnt = 0\n\n\nfor i,s in zip(reversed(range(len(S))),reversed(S)):\n\n cnt += (f[s] == 0)\n f[s] += 1\n if cnt == L:\n memo.append((i,f))\n f = [0]*L\n cnt = 0\n\n\nresult = [f.index(0)]\n\nfor i,f in reversed(memo):\n c = result[-1]\n for j in range(i,len(S)):\n s = S[j]\n f[s] -= 1\n if s == c:\n break\n\n result.append(f.index(0))\n\nprint(''.join(map(lambda x: chr(x+ord_a), result)))", "from collections import deque\nalpha = \"abcdefghijklmnopqrstuvwxyz\"\nA = input()\nn = len(A)\nB = ord('a')\n\nlinks = [None]*(n+3)\n\nlink = [n]*26\nfor i in range(n-1, -1, -1):\n links[i] = link[:]\n link[ord(A[i]) - B] = i\nlinks[-1] = link\n\ndeq = deque()\ndeq.append(-1)\nprev = {-1: (None, 0)}\nwhile deq:\n v = deq.popleft()\n if v == n:\n break\n link = links[v]\n for c in range(26):\n if link[c] in prev:\n continue\n prev[link[c]] = (v, c)\n deq.append(link[c])\nv = n\nans = []\nwhile v is not None:\n v, c = prev[v]\n ans.append(chr(c+B))\nans.reverse()\nprint((\"\".join(ans[1:])))\n\n", "n2a=lambda x:chr(x+ord('a'))\na2n=lambda x:ord(x)-ord('a')\n\ndef main(a):\n nc=26\n n=len(a)\n ary=[]\n tmp=[0]*nc\n mi=set(range(nc))\n for i in range(n-1,-1,-1):\n x=a2n(a[i])\n mi.discard(x)\n tmp[x]+=1\n if len(mi)==0:\n ary.append(tmp.copy())\n tmp=[0]*nc\n mi=set(range(nc))\n if any(tmp):ary.append(tmp)\n #for x in ary:print(x)\n ans=[]\n now=0\n tmp=ary.pop()\n if all(tmp):\n ans.append('a')\n while a[now]!='a':\n tmp[a2n(a[now])]-=1\n now+=1\n tmp[a2n(a[now])]-=1\n now+=1\n else:\n for i in range(nc):\n if tmp[i]==0:\n ans.append(n2a(i))\n break\n if not ary:return ans\n ntmp=ary.pop()\n for j in range(nc):tmp[j]+=ntmp[j]\n while a2n(a[now])!=i:\n tmp[a2n(a[now])]-=1\n now+=1\n tmp[a2n(a[now])]-=1\n now+=1\n while True:\n #print(ary,tmp,ans)\n for i in range(nc):\n if tmp[i]==0:\n ans.append(n2a(i))\n break\n if not ary:return ans\n ntmp=ary.pop()\n for j in range(nc):tmp[j]+=ntmp[j]\n while a2n(a[now])!=i:\n tmp[a2n(a[now])]-=1\n now+=1\n tmp[a2n(a[now])]-=1\n now+=1\n\na=input()\nprint(*main(a),sep='')\n\"\"\"\nbcdefghijklmnopqrstuvwxyza\n\naabbccaabca\naab / bccaa / bca\n\n\"\"\"\n\n", "from bisect import bisect_left\nA = [ord(i) - 97 for i in input()]\n\nA = A + list(range(26))\nA = A[::-1]\n\ndp = [0] * 26\nkey = [[] for _ in range(26)]\nval = [[] for _ in range(26)]\nfor i, a in enumerate(A) :\n x = min(dp) + 1\n dp[a] = x\n key[a].append(i)\n val[a].append(x)\n\nret = ''\nx = dp[dp.index(min(dp))] + 1\npos = 10 ** 6\nwhile True :\n for i in range(26) :\n if key[i][0] < pos :\n j = bisect_left(key[i], pos) - 1\n if val[i][j] == x - 1 :\n ret += chr(i + 97)\n pos = key[i][j]\n x -= 1\n break\n else :\n break\n\nprint(ret)", "import os\nimport sys\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nS = sys.stdin.readline().rstrip()\nA = [ord(c) - ord('a') for c in S]\nN = len(S)\n\n# \u7b54\u3048\u306e\u6587\u5b57\u5217\u306e\u9577\u3055\nl = 0\n# \u305d\u306e\u6587\u5b57\u4ee5\u964d\u3067\u3001\u4f55\u6587\u5b57\u307e\u3067\u306e\u4efb\u610f\u6587\u5b57\u5217\u3092\u4f5c\u308c\u308b\u304b\nlengths = [0] * N\ncounts = [0] * 26\nfor i, a in reversed(list(enumerate(A))):\n counts[a] += 1\n lengths[i] = l\n if min(counts) == 1:\n counts = [0] * 26\n l += 1\nans_size = l + 1\n\n# \u6587\u5b57\u3054\u3068\u306e\u6b21\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\ngraph = [[-1] * 26 for _ in range(N)]\npos = [-1] * 26\nfor i, a in reversed(list(enumerate(A))):\n graph[i] = pos[:]\n pos[a] = i\ninitials = pos\n\n\ndef solve(size, i=None):\n # i \u756a\u76ee\u304b\u3089\u59cb\u307e\u308a\u3001\u9577\u3055 size \u3067\u3042\u308b\u3001\u90e8\u5206\u5217\u3067\u306a\u3044\u6587\u5b57\u5217\n if i is None:\n pos = initials\n else:\n pos = graph[i]\n\n if size == 1:\n return chr(pos.index(-1) + ord('a'))\n\n size -= 1\n for ci, i in enumerate(pos):\n if lengths[i] < size:\n c = chr(ci + ord('a'))\n return c + solve(size, i)\n return ''\n\n\nprint((solve(ans_size)))\n", "\nimport sys\nfrom collections import deque, defaultdict\nimport copy\nimport bisect\nsys.setrecursionlimit(10 ** 9)\nimport math\nimport heapq\nfrom itertools import product, permutations,combinations\nimport fractions\n\nimport sys\ndef input():\n\treturn sys.stdin.readline().strip()\n\nalpha2num = lambda c: ord(c) - ord('a')\n\n\ndef num2alpha(num):\n\tif num<=26:\n\t\treturn chr(96+num)\n\telif num%26==0:\n\t\treturn num2alpha(num//26-1)+chr(122)\n\telse:\n\t\treturn num2alpha(num//26)+chr(96+num%26)\n\nA = input()\n\nloc_list = deque([])\nloc_list_last = deque([])\nnum = 0\nalpha_list = [-1] * 26\nalpha_list_last = [-1] * 26\nroop = 0\nfor i in range(len(A) - 1, -1, -1):\n\talphanum = alpha2num(A[i])\n\tif alpha_list[alphanum] == -1:\n\t\tnum += 1\n\t\talpha_list_last[alphanum] = i\n\talpha_list[alphanum] = i\n\tif num == 26:\n\t\tloc_list.appendleft(alpha_list)\n\t\tloc_list_last.appendleft(alpha_list_last)\n\t\talpha_list = [-1]*26\n\t\talpha_list_last = [-1]*26\n\t\troop += 1\n\t\tnum = 0\nloc_list.appendleft(alpha_list)\nloc_list_last.appendleft(alpha_list_last)\nans = deque([])\n#print(loc_list)\nfor i in range(26):\n\tif loc_list[0][i] == -1:\n\t\tx = i\n\t\tans.append(x)\n\t\tbreak\n\nif len(loc_list) > 1:\n\tmozi = x\n\tfor n in range(1, len(loc_list)):\n\t\tloc = loc_list[n][mozi]\n\t\t#print(loc, mozi)\n\t\tfor i in range(26):\n\t\t\tif loc_list_last[n][i] <= loc:\n\t\t\t\tans.append(i)\n\t\t\t\tmozi = i\n\t\t\t\tbreak\n#print(loc_list)\n\nans2 = []\n\nfor i in range(len(ans)):\n\tans2.append(num2alpha(ans[i] + 1))\nprint(''.join(ans2))", "import sys\nsys.setrecursionlimit(10**6)\n\na = input() + \"$\"\nn = len(a)\n\nalph = \"abcdefghijklmnopqrstuvwxyz\"\ndp = [-1] * (n + 1)\n\nnext_ = [[-1] * (n + 1) for i in range(26)]\nfor char in range(26):\n tmp = - 1\n for i in range(n)[::-1]:\n if a[i] == alph[char]:\n tmp = i + 1\n next_[char][i] = tmp\n\n\ndef solve():\n for i in range(n + 1)[::-1]:\n tmp = n + 1\n for char in range(26):\n if next_[char][i] == -1:\n dp[i] = 1\n break\n tmp = min(dp[next_[char][i]] + 1 , tmp)\n else:\n dp[i] = tmp\n\nsolve()\nans = []\ni = 0\nwhile True:\n for char in range(26):\n if next_[char][i] == -1:\n ans.append(alph[char])\n print(\"\".join(ans))\n return\n if dp[i] == dp[next_[char][i]] + 1:\n ans.append(alph[char])\n i = next_[char][i]\n break", "from bisect import bisect_left\nA = input()\n\nN = len(A)\ndp = [0] * (N + 2)\ndp[N] = 1\nd = [[N] for i in range(26)]\na = ord('a')\nINF = float('inf')\nfor i in range(N - 1, -1, -1):\n d[ord(A[i]) - a].append(i)\n tmp = INF\n for j in range(26):\n tmp = min(tmp, dp[d[j][-1] + 1])\n dp[i] = tmp + 1\n\n\nfor i in range(26):\n d[i] = d[i][::-1]\n\npos = 0\nans = ''\nfor i in range(dp[0] - 1, -1, -1):\n for j in range(26):\n k = bisect_left(d[j], pos)\n if dp[d[j][k] + 1] == i:\n ans += chr(j + a)\n pos = d[j][k] + 1\n break\n\nprint(ans)\n", "from collections import deque\n\n\nA = input()\nN = len(A)\na = ord('a')\n\nedge = [[N + 1] * 26 for _ in range(N + 1)]\nfor i in range(N - 1, -1, -1):\n for j in range(26):\n edge[i][j] = edge[i + 1][j]\n c = ord(A[i]) - a\n edge[i][c] = i + 1 # \u6587\u5b57c\u306e\u76f4\u5f8c\u306e\u9802\u70b9\n\n\nrecon = [None] * (N + 2) # DP\u5fa9\u5143\u7528\u3002(\u76f4\u524d\u306e\u9802\u70b9, \u6587\u5b57)\u3092\u683c\u7d0d\u3059\u308b\u3002\nq = deque()\nq.append(0) # \u9802\u70b9\nwhile q:\n i = q.popleft()\n if i == N + 1: # \u9802\u70b9N+1\u306b\u5230\u9054\u3057\u305f\u3089\u51e6\u7406\u7d42\u4e86\n break\n for j in range(26):\n ni = edge[i][j]\n if recon[ni] is None: # \u305d\u306e\u9802\u70b9\u306b\u6700\u77ed\u3067\u5230\u9054\u3057\u305f\u5834\u5408\u306e\u307f\u6b21\u306e\u51e6\u7406\u3092\u7d99\u7d9a\n recon[ni] = (i, chr(a + j))\n q.append(ni)\n\ni = N + 1\nans = []\nwhile i > 0:\n pi, c = recon[i]\n ans.append(c)\n i = pi\n\nprint((''.join(reversed(ans))))\n", "import sys\ninput = lambda : sys.stdin.readline().rstrip()\nsys.setrecursionlimit(max(1000, 10**9))\nwrite = lambda x: sys.stdout.write(x+\"\\n\")\n\n\na = input()\nn = len(a)\ns = set()\nl = []\ni = n-1\nprv = n\nfor c in a[::-1]:\n s.add(c)\n if len(s)==26:\n s = set()\n l.append((i,prv))\n prv = i\n i -= 1\ndef sub(i,j):\n \"\"\"[i,j)\u306b\u542b\u307e\u308c\u306a\u3044\u6587\u5b57\u306e\u3046\u3061\u306e\u6700\u5c0f\n \"\"\"\n# print(i,j)\n al = set([chr(v) for v in range(ord(\"a\"), ord(\"z\")+1)])\n for ind in range(i,j):\n al.discard(a[ind])\n return min(al)\nans = []\nc = sub(0,prv)\nans.append(c)\nwhile l:\n i,j = l.pop()\n for ind in range(i,n):\n if a[ind]==c:\n break\n c = sub(ind+1,j)\n ans.append(c)\nans = \"\".join(ans)\n# else:\n# ans = \"a\" * (len(l)+1)\nprint(ans)"] | {"inputs": ["atcoderregularcontest\n", "abcdefghijklmnopqrstuvwxyz\n", "frqnvhydscshfcgdemurlfrutcpzhopfotpifgepnqjxupnskapziurswqazdwnwbgdhyktfyhqqxpoidfhjdakoxraiedxskywuepzfniuyskxiyjpjlxuqnfgmnjcvtlpnclfkpervxmdbvrbrdn\n"], "outputs": ["b\n", "aa\n", "aca\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 65,160 | |
1e69fc1cebe70566db3c02a16a94bf23 | UNKNOWN | We have a board with an H \times W grid.
Each square in the grid is painted in black or white. The square at the i-th row from the top and j-th column from the left is black if the j-th character in S_i is #, and white if that character is ..
Snuke can perform the following operation on the grid any number of times:
- Select a row or column in the grid, and invert the color of all the squares in that row or column (that is, black squares become white and vice versa).
Then, Snuke draws a rectangle along grid lines. Here, all the squares contained in the rectangle must be painted in black.
Find the maximum possible area of Snuke's rectangle when the operation is performed optimally.
-----Constraints-----
- 2 \leq H \leq 2000
- 2 \leq W \leq 2000
- |S_i| = W
- S_i consists of # and ..
-----Input-----
Input is given from Standard Input in the following format:
H W
S_1
S_2
:
S_H
-----Output-----
Print the maximum possible area of Snuke's rectangle.
-----Sample Input-----
3 3
..#
##.
.#.
-----Sample Output-----
6
If the first row from the top and the third column from the left are inverted, a 2 \times 3 rectangle can be drawn, as shown below: | ["import sys\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nH, W = map(int, input().split())\ns = [input() for _ in range(H)]\nans = max(H, W)\n\ndef max_rect(a):\n\tres = 0\n\tstack = [a[0]]\n\tfor i in range(1, W-1):\n\t\tnew_pos = i\n\t\twhile stack and stack[-1] % 10000 >= a[i]:\n\t\t\tpos, hght = stack[-1] // 10000, stack[-1] % 10000\n\t\t\tres = max(res, (i - pos + 1) * (hght + 1))\n\t\t\tnew_pos = pos\n\t\t\tstack.pop()\n\t\tstack.append(new_pos * 10000 + a[i])\n\twhile stack:\n\t\tpos, hght = stack[-1] // 10000, stack[-1] % 10000\n\t\tres = max(res, (W - pos) * (hght + 1))\n\t\tstack.pop()\n\treturn res\n\ndp = [[0 for _ in range(W-1)] for _ in range(H-1)]\n\nfor j in range(W-1):\n\tif not ((s[0][j] == s[1][j]) ^ (s[0][j+1] == s[1][j+1])):\n\t\tdp[0][j] = 1\nans = max(ans, max_rect(dp[0]))\n\nfor i in range(1, H-1):\n\tfor j in range(W-1):\n\t\tif not ((s[i][j] == s[i+1][j]) ^ (s[i][j+1] == s[i+1][j+1])):\n\t\t\tdp[i][j] = dp[i-1][j] + 1\n\tans = max(ans, max_rect(dp[i]))\n\nprint(ans)", "def inpl(): return [int(i) for i in input().split()]\n\nH, W = inpl()\nans = max(H, W)\nS = [input() for _ in range(H)]\nT = [[0]*(W-1)]\nfor i in range(H-1):\n t = []\n for j in range(W-1):\n r = S[i][j:j+2] + S[i+1][j:j+2]\n t.append(r.count('.')%2)\n ts = [T[-1][i] + 1 if not k else 0 for i, k in enumerate(t) ]\n T.append(ts)\nfor iT in T[1:]:\n stack = []\n for i, l in enumerate(iT+[0]):\n dw = -1\n while stack and stack[-1][1] >= l:\n dw, dh = stack.pop()\n ans = max(ans, (dh+1)*(i-dw+1))\n if dw != -1:\n stack.append((dw,l))\n continue\n stack.append((i, l))\nprint(ans)", "mod = 1000000007\neps = 10**-9\n\n\ndef main():\n import sys\n input = sys.stdin.readline\n\n # O(N)\n def largest_rectangle_histogram(A):\n A.append(0)\n N = len(A)\n ret = 0\n st = [-1]\n left = [0] * N\n for i in range(N):\n while A[st[-1]] >= A[i]:\n # ret = max(ret, A[st[-1]] * (i - left[st[-1]] - 1))\n ret = max(ret, (A[st[-1]] + 1) * (i - left[st[-1]]))\n st.pop()\n if not st:\n break\n if st:\n left[i] = st[-1]\n else:\n left[i] = -1\n st.append(i)\n return ret\n\n # O(H * W)\n def largest_rectangle_grid(grid, ok=1, ng=0):\n H = len(grid)\n W = len(grid[0])\n hist = [[0] * W for _ in range(H)]\n for h in range(H):\n for w in range(W):\n if grid[h][w] == ok:\n hist[h][w] = hist[h - 1][w] + 1\n ret = 0\n for h in range(H):\n ret = max(ret, largest_rectangle_histogram(hist[h]))\n return ret\n\n H, W = list(map(int, input().split()))\n grid = []\n for _ in range(H):\n grid.append(input().rstrip('\\n'))\n\n corner = [[0] * (W-1) for _ in range(H-1)]\n for h in range(H-1):\n for w in range(W-1):\n cnt = 0\n if grid[h][w] == \"#\":\n cnt += 1\n if grid[h+1][w] == \"#\":\n cnt += 1\n if grid[h][w+1] == \"#\":\n cnt += 1\n if grid[h+1][w+1] == \"#\":\n cnt += 1\n if cnt%2 == 0:\n corner[h][w] = 1\n print((max(largest_rectangle_grid(corner), H, W)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import deque\nH,W=list(map(int,input().split()))\nS=[input() for i in range(H)]\ntable=[[0]*(W-1) for i in range(H-1)]\nfor i in range(W-1):\n for j in range(H-1):\n table[j][i]=(int(S[j][i]=='#')+int(S[j+1][i]=='#')+int(S[j][i+1]=='#')+int(S[j+1][i+1]=='#') +1 )%2\n\ndef get_rec(L):\n a = len(L)\n arr = L + [0]\n stack = deque()\n ans = -1\n for i in range(a + 1):\n #print(stack)\n if len(stack)==0:\n stack.append((arr[i], i))\n elif stack[-1][0] < arr[i]:\n stack.append((arr[i], i))\n elif stack[-1][0] > arr[i]:\n while len(stack) != 0 and stack[-1][0] >= arr[i]:\n x, y = stack.pop()\n ans = max((x+1) * (i - y+1), ans)\n # print(x,y,x*(i-y))\n stack.append((arr[i], y))\n #print(ans)\n return ans\ndp=[[0]*(W-1) for i in range(H-1)]\nfor i in range(W-1):\n for j in range(H-1):\n if j==0:\n dp[0][i]=table[0][i]\n continue\n if table[j][i]==1:\n dp[j][i]=dp[j-1][i]+1\nans=max(H,W)\nfor j in range(H-1):\n ans=max(ans,get_rec(dp[j]))\nprint(ans)\n", "H,W=list(map(int,input().split()))\nans=max(H, W)\nS=[input() for i in range(H)]\nT = [[0]*(W-1)]\nfor i in range(H-1):\n t,ts=[],[]\n for j in range(W-1):\n r=S[i][j:j+2]+S[i+1][j:j+2]\n t.append(r.count('.')%2)\n if t[j]==0:\n ts.append(T[-1][j]+1)\n else:\n ts.append(0)\n T.append(ts)\nfor L in T[1:]:\n stack=[]\n for i,l in enumerate(L+[0]):\n w=-1\n while stack and stack[-1][1]>=l:\n w,h=stack.pop()\n ans = max(ans, (h+1)*(i-w+1))\n if w!=-1:\n stack.append((w,l))\n continue\n stack.append((i,l))\nprint(ans)\n", "H, W = list(map(int, input().split()))\nS = [input() for _ in range(H)]\n\nans = max(H, W)\n\nf = [1] * W\nfor i in range(1, H):\n f = [(f[j]+1) if (S[i-1][j:j+2] + S[i][j:j+2]).count('#') in [0,2,4] else 1 for j in range(W-1)] + [0]\n stk = []\n for j, v in enumerate(f):\n while len(stk) > 0 and f[stk[-1]] >= v:\n ans = max(ans, f[stk.pop()] * (j - (stk[-1] if len(stk) > 0 else -1)))\n stk.append(j)\n\nprint(ans)\n", "import sys\n\ninput=sys.stdin.readline\np2D = lambda x: print(*x, sep=\"\\n\")\ndef MI(): return map(int, sys.stdin.readline().split())\n\ndef main():\n h, w = MI()\n s = [[c == \"#\" for c in input()[:-1]] for _ in range(h)]\n #if w == 2:\n # s = [list(sc) for sc in zip(*s)]\n # h, w = w, h\n # p2D(s)\n t = [[-1] * (w - 1) for _ in range(h - 1)]\n for i in range(h - 1):\n si = s[i]\n si1 = s[i + 1]\n t[i] = [1 - (sum(si[j:j + 2]) + sum(si1[j:j + 2])) % 2 for j in range(w - 1)]\n # p2D(t)\n # print()\n ti=t[0]\n for i in range(1, h - 1):\n ti1=ti\n ti=t[i]\n for j in range(w - 1):\n if ti[j]: ti[j] = ti1[j] + 1\n # p2D(t)\n ans = 0\n for i in range(h - 1):\n jtol = [0] * (w - 1)\n jtor = [0] * (w - 1)\n ti=t[i]\n # \u9ad8\u3055\u3001\u4f4d\u7f6e\u306e\u9806\n stack = [[-1, 0]]\n for j in range(w - 1):\n tij=ti[j]\n while stack[-1][0] >= tij: stack.pop()\n jtol[j] = stack[-1][1]\n stack.append([tij, j + 1])\n\n stack = [[-1, w - 1]]\n for j in range(w - 2, -1, -1):\n tij=ti[j]\n while stack[-1][0] >= tij: stack.pop()\n jtor[j] = stack[-1][1]\n stack.append([tij, j])\n\n for j in range(w - 1):\n tmp = (jtor[j] - jtol[j] + 1) * (ti[j] + 1)\n if tmp > ans: ans = tmp\n print(max(ans,h,w))\n\nmain()\n", "import sys\ninput = sys.stdin.readline\nfrom collections import deque\n\nh,w = map(int,input().split())\ns = []\nfor i in range(h):\n q = input().rstrip()\n s.append(q)\n\nchk = [[0]*(w-1) for i in range(h-1)]\nfor i in range(w-1):\n for j in range(h-1):\n chk[j][i] = 1-int((s[j][i]=='#')^(s[j+1][i]=='#')^(s[j][i+1]=='#')^(s[j+1][i+1]=='#'))\n\ndef f(a):\n a += [0]\n stack = deque()\n ans = -1\n for i in range(w):\n if stack == deque():\n stack.append((a[i], i))\n elif stack[-1][0] < a[i]:\n stack.append((a[i], i))\n elif stack[-1][0] > a[i]:\n while stack and stack[-1][0] >= a[i]:\n x, y = stack.pop()\n ans = max((x+1)*(i-y+1), ans)\n stack.append((a[i], y))\n return ans\n \ndp = [[0]*(w-1) for i in range(h-1)]\nfor i in range(w-1):\n dp[0][i] = chk[0][i]\n \nfor i in range(1,h-1):\n for j in range(w-1):\n if chk[i][j]:\n dp[i][j] = dp[i-1][j]+1\n\nans=max(h,w)\nfor i in range(h-1):\n ans=max(ans,f(dp[i]))\n \nprint(ans)"] | {"inputs": ["3 3\n..#\n##.\n.#.\n", "4 4\n....\n....\n....\n....\n", "10 8\n##...#.#\n##...#.#\n..###.#.\n#.##.#.#\n.#..#.#.\n..##.#.#\n##.#.#..\n...#.#..\n###.#.##\n###..###\n"], "outputs": ["6\n", "16\n", "27\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 8,308 | |
763c55ed091951085d8f647e5a3d1782 | UNKNOWN | You are given a sequence D_1, D_2, ..., D_N of length N.
The values of D_i are all distinct.
Does a tree with N vertices that satisfies the following conditions exist?
- The vertices are numbered 1,2,..., N.
- The edges are numbered 1,2,..., N-1, and Edge i connects Vertex u_i and v_i.
- For each vertex i, the sum of the distances from i to the other vertices is D_i, assuming that the length of each edge is 1.
If such a tree exists, construct one such tree.
-----Constraints-----
- 2 \leq N \leq 100000
- 1 \leq D_i \leq 10^{12}
- D_i are all distinct.
-----Input-----
Input is given from Standard Input in the following format:
N
D_1
D_2
:
D_N
-----Output-----
If a tree with n vertices that satisfies the conditions does not exist, print -1.
If a tree with n vertices that satisfies the conditions exist, print n-1 lines.
The i-th line should contain u_i and v_i with a space in between.
If there are multiple trees that satisfy the conditions, any such tree will be accepted.
-----Sample Input-----
7
10
15
13
18
11
14
19
-----Sample Output-----
1 2
1 3
1 5
3 4
5 6
6 7
The tree shown below satisfies the conditions. | ["from collections import defaultdict\nN = int(input())\nC = defaultdict(int)\nfor i in range(N):\n D = int(input())\n C[D] = i + 1\nE = []\nH = [1] * (N + 1)\nDD = sorted([[k, v] for k, v in C.items()], reverse=True)\nAdj = [[] for i in range(N)]\nfor D, n in DD[:-1]:\n try:\n p = C[D - N + 2 * H[n]]\n if n == p:\n raise Error\n E.append([n, p])\n Adj[n - 1].append(p - 1)\n Adj[p - 1].append(n - 1)\n H[p] += H[n]\n except:\n print(-1)\n break\nelse:\n dist = [N] * N\n dist[DD[-1][1] - 1] = 0\n Q = [DD[-1][1] - 1] + [N] * N\n tail = 1\n for i in range(N):\n s = Q[i]\n if s == N:\n print(-1)\n break\n for adj in Adj[s]:\n if dist[adj] == N:\n dist[adj] = dist[s] + 1\n Q[tail] = adj\n tail += 1\n else:\n if sum(dist) == DD[-1][0]:\n for e in E:\n print(e[0], e[1])\n else:\n print(-1)", "def main():\n N = int(input())\n D = [int(input()) for i in range(N)]\n C = [1] * N\n T = [0] * N\n DI = {}\n for i in range(len(D)):\n DI[D[i]] = i\n D = sorted(D)\n P = [-1] * N\n while len(D) > 1:\n d = D.pop()\n i = DI[d]\n nd = d - N + C[i] * 2\n if nd in DI:\n ni = DI[nd]\n else:\n print(-1)\n return\n P[i] = ni\n C[ni] += C[i]\n T[ni] += T[i] + C[i]\n \n if D[0] == T[DI[D[0]]]:\n for i in range(N):\n if P[i] >= 0: print(i+1, P[i]+1)\n else:\n print(-1)\n\nmain()", "n,*d = map(int,open(0).read().split())\nz = {j:i for i,j in enumerate(d)}\n*s, = sorted(d)\nP = [-1]*n\nS = {i:1 for i in d}\nD = {i:0 for i in d}\nok = 1\nfor v in s[n-1:0:-1]:\n p = v-n+2*S[v]\n if p >= v: ok = 0\n if p in z:\n S[p] += S[v]\n D[p] += D[v]+S[v]\n P[z[v]] = z[p]\n else: ok = 0\nif ok and D[s[0]]==s[0]:\n for i,pi in enumerate(P):\n if pi != -1: print(i+1,pi+1)\nelse: print(-1)", "import sys\nfrom bisect import bisect_left\ndef input():\n\treturn sys.stdin.readline()[:-1]\nsys.setrecursionlimit(10**6)\n\nn = int(input())\nd = [[int(input()), i+1] for i in range(n)]\ncheck = d[0][0]\nd.sort()\nind = [x[1] for x in d]\nd = [x[0] for x in d]\nif n <= 3:\n\tprint(-1)\n\treturn\n#print(d)\nchild = [1 for _ in range(n)]\n#print(gap)\nans = []\nadj = [[] for _ in range(n)]\nfor i in range(n-1, 0, -1):\n\tx = d[i]\n\tb = bisect_left(d, x - n + 2*child[i])\n\t#print(i, x, n - 2+child[i], b)\n\tif d[b] != x - n + 2*child[i] or n <= 2*child[i]:\n\t\tprint(-1)\n\t\treturn\n\telse:\n\t\tchild[b] += child[i]\n\t\tans.append([ind[b], ind[i]])\n\t\tadj[ind[b]-1].append(ind[i]-1)\n\t\tadj[ind[i]-1].append(ind[b]-1)\n\n\nres = 0\ndef dfs(x, p, dis):\n\tnonlocal res\n\tres += dis\n\tfor v in adj[x]:\n\t\tif v == p:\n\t\t\tcontinue\n\t\telse:\n\t\t\tdfs(v, x, dis+1)\n\treturn\n\ndfs(0, -1, 0)\nif res == check:\n\tfor a in ans:\n\t\tprint(*a)\nelse:\n\tprint(-1)", "# -*- coding: utf-8 -*-\n\"\"\" output\u306e\u6642\u9593\u6bd4\u8f03 \"\"\"\nfrom sys import stdin, stdout\nimport numpy as np\n# import sys\n# sys.setrecursionlimit(10**4)\n\ndef _li(): return list(map(int, stdin.readline().split()))\ndef _li_(): return list([int(x)-1 for x in stdin.readline().split()])\ndef _lf(): return list(map(float, stdin.readline().split()))\ndef _ls(): return stdin.readline().split()\ndef _i(): return int(stdin.readline())\ndef _f(): return float(stdin.readline())\ndef _s(): return stdin.readline()[:-1]\nd_in = lambda: int(stdin.readline()) # N = d_in()\nds_in = lambda: list(map(int, stdin.readline().split())) # List = ds_in()\ndef print_list(s):\n stdout.write(' '.join(list(map(str, s))) + '\\n')\n # stdout.flush()\ndef print_single(s):\n stdout.write(str(s) + '\\n')\n # stdout.flush()\n\n\n# N = _i()\n# D_list = np.array([_i() for _ in range(N)])\nN = d_in()\nD_list = np.array([d_in() for _ in range(N)])\n\n\nidx = np.argsort(D_list)\nsorted_D = D_list[idx]\nmapping = []\nfor j in idx:\n mapping.append(j+1)\n\n# \u89e3\u8aac\u3092\u53c2\u8003\u306b\u5b9f\u88c5\n# D\u306e\u30b9\u30b3\u30a2\u304c\u5927\u304d\u3044\u65b9\u304b\u3089\u5c0f\u3055\u3044\u65b9\u3078\u4f38\u3073\u308b\u6709\u5411\u30a8\u30c3\u30b8\u3068\u307f\u306a\u3059\n# value\u306f\u30ce\u30fc\u30c9\u304b\u3089\u51fa\u3066\u3044\u308b\u6709\u5411\u30a8\u30c3\u30b8\u3092\u5207\u3063\u305f\u5834\u5408\u306e\u90e8\u5206\u6728\u306e\u5927\u304d\u3055\nnodes = [1] * N\nans = []\ncost = [[0, 1] for _ in range(N)]\n# \u8449\u3063\u3071\u304b\u3089\u898b\u3066\uff0c[\u30a8\u30c3\u30b8\u306b\u305f\u3069\u308a\u7740\u304f\u307e\u3067\u306e\u30b3\u30b9\u30c8, \u81ea\u5206\u3082\u542b\u3081\u305f\u5b50\u30ce\u30fc\u30c9\u306e\u6570]\nfor i in range(N-1, 0, -1):\n d = sorted_D[i]\n sub = nodes[i]\n target = d + 2*sub - N\n cand = np.searchsorted(sorted_D[:i], target)\n if (sorted_D[cand] != target) or (cand == i):\n print((-1))\n return\n else:\n ans.append((mapping[i], mapping[cand]))\n nodes[cand] += nodes[i]\n cost[cand][0] += (cost[i][0] + cost[i][1])\n cost[cand][1] += cost[i][1]\n\n# 1\u756a\u76ee\u306e\u30ce\u30fc\u30c9\u306b\u3064\u3044\u3066\u30c1\u30a7\u30c3\u30af\nif cost[0][0] != sorted_D[0]:\n print((-1))\n return\nelse:\n for a in ans:\n # print(a[0], a[1])\n print_list(a)\n", "n = int(input())\nd = [int(input()) for i in range(n)]\n\nif sum(d)%2 > 0:\n print((-1))\n return\n\nd = sorted([(dd, i) for i, dd in enumerate(d)], reverse = True)\nd_to_i = {dd:i for dd, i in d}\nn_child = [1]*n\nd_child = [0]*n\nans = []\nfor dd, i in d:\n d_i = dd+2*n_child[i]-n\n if d_i in list(d_to_i.keys()):\n i_next = d_to_i[d_i]\n ans.append((i+1, i_next+1))\n n_child[i_next] += n_child[i]\n d_child[i_next] += d_child[i] + n_child[i]\n if n_child[i_next] == n:\n break\n else:\n print((-1))\n return\n\nd_min, i_min = d[-1]\nif d_min == d_child[i_min]:\n for a in ans:\n print((*a))\nelse:\n print((-1))\n", "#!/usr/bin/env python3\nimport sys\n\nsys.setrecursionlimit(101010)\n\ndef dfs(v, adj_list, depth, visited):\n visited[v] = True\n x = depth\n for w in adj_list[v]:\n if not visited[w]:\n x += dfs(w, adj_list, depth + 1, visited)\n\n return x\n\n\ndef solve(n, d):\n\n if n < 7:\n print((-1))\n return\n\n d.sort()\n w = [1] * n\n edges = []\n adj_list = [[] for _ in range(n)]\n for j in range(n - 1, 0, -1):\n di, i = d[j]\n pdi = di - n + 2 * w[i]\n p = None\n lo, hi = 0, j\n while lo < hi:\n mid = (lo + hi) // 2\n xdi, xi = d[mid]\n if xdi == pdi:\n p = xi\n break\n elif xdi < pdi:\n lo = mid + 1\n else:\n hi = mid\n if p is None:\n print((-1))\n return\n u, v = i, p\n if v < u:\n u, v = v, u\n edges.append((u + 1, v + 1))\n adj_list[u].append(v)\n adj_list[v].append(u)\n w[p] += w[i]\n\n d0, r = d[0]\n visited = [False] * n\n x = dfs(r, adj_list, 0, visited)\n if x != d0:\n print((-1))\n return\n\n edges.sort()\n for uv in edges:\n u, v = uv\n print(('{} {}'.format(u, v)))\n\n\n\ndef main():\n n = input()\n n = int(n)\n d = []\n for i in range(n):\n di = input()\n di = int(di)\n d.append((di, i))\n\n\n solve(n, d)\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "N = int(input())\nsrc = [int(input()) for i in range(N)]\nidx = {a:i for i,a in enumerate(src)}\n\nsize = [1] * N\nss = list(sorted(src))\n\nes = []\ngr = [[] for i in range(N)]\nwhile len(ss) > 1:\n a = ss.pop()\n k = size[idx[a]]\n b = a + 2*k - N\n if b == a or b not in idx:\n print(-1)\n return\n size[idx[b]] += k\n ai,bi = idx[a],idx[b]\n es.append((ai,bi))\n gr[ai].append(bi)\n gr[bi].append(ai)\n\nfrom collections import deque\ndist = [N] * N\ndist[idx[ss[0]]] = 0\nq = deque([idx[ss[0]]])\nwhile q:\n v = q.popleft()\n for to in gr[v]:\n if dist[to] < N: continue\n q.append(to)\n dist[to] = dist[v] + 1\n\nif all(d<N for d in dist) and sum(dist) == ss[0]:\n for a,b in es:\n print(a+1, b+1)\nelse:\n print(-1)", "N = int(input())\nsrc = [int(input()) for i in range(N)]\nidx = {a:i for i,a in enumerate(src)}\n\nsize = [1] * N\nss = list(sorted(src))\n\nes = []\nwhile len(ss) > 1:\n a = ss.pop()\n k = size[idx[a]]\n b = a + 2*k - N\n if b == a or b not in idx:\n print(-1)\n return\n size[idx[b]] += k\n es.append((idx[a],idx[b]))\n\ngr = [[] for i in range(N)]\nfor a,b in es:\n gr[a].append(b)\n gr[b].append(a)\n\nfrom collections import deque\ndist = [N] * N\ndist[idx[ss[0]]] = 0\nq = deque([idx[ss[0]]])\nwhile q:\n v = q.popleft()\n for to in gr[v]:\n if dist[to] < N: continue\n q.append(to)\n dist[to] = dist[v] + 1\n\nif all(d<N for d in dist) and sum(dist) == ss[0]:\n for a,b in es:\n print(a+1, b+1)\nelse:\n print(-1)", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\nD = [None] + [int(input()) for _ in range(N)]\n\nparent = [None] * (N+1)\nsize = [None] + [1] * N # \u90e8\u5206\u6728\u306e\u9802\u70b9\u6570\u3001\u81ea\u5206\u3092\u542b\u3080\nd_to_i = {d:i for i,d in enumerate(D)}\nD_desc = sorted(D[1:],reverse=True)\nD_subtree = [0] * (N+1)\nedges = []\n\nbl = True\nfor d in D_desc[:-1]:\n i = d_to_i[d]\n d_parent = d - N + 2*size[i]\n if d_parent not in d_to_i:\n bl = False\n break\n p = d_to_i[d_parent]\n edges.append('{} {}'.format(i,p))\n parent[i] = p\n size[p] += size[i]\n D_subtree[p] += D_subtree[i] + size[i]\n\nroot = d_to_i[D_desc[-1]]\nbl &= (D_subtree[root] == D[root])\n\nif bl:\n print('\\n'.join(edges))\nelse:\n print(-1)", "n = int(input())\nd = [int(input()) for i in range(n)]\n\nif sum(d)%2 > 0:\n print((-1))\n return\n\nd = sorted([(dd, i) for i, dd in enumerate(d)], reverse = True)\nd_to_i = {dd:i for dd, i in d}\nn_child = [1]*n\nd_child = [0]*n\nans = []\nfor dd, i in d:\n d_i = dd+2*n_child[i]-n\n if d_i in list(d_to_i.keys()):\n i_next = d_to_i[d_i]\n ans.append((i+1, i_next+1))\n n_child[i_next] += n_child[i]\n d_child[i_next] += d_child[i] + n_child[i]\n if n_child[i_next] == n:\n break\n else:\n print((-1))\n return\n\nd_min, i_min = d[-1]\nif d_min == d_child[i_min]:\n for a in ans:\n print((*a))\nelse:\n print((-1))\n", "n,*d = map(int,open(0).read().split())\nzd = {di:i for i,di in enumerate(d)}\n*sd, = sorted(d)\nparent = [-1]*n\nsize = {i:1 for i in d}\ndist = {i:0 for i in d}\nok = 1\nfor v in sd[n-1:0:-1]:\n p = v - n + 2*size[v]\n if p >= v:\n ok = 0\n break\n if p in zd:\n size[p] += size[v]\n dist[p] += dist[v]+size[v]\n parent[zd[v]] = zd[p]\n else:\n ok = 0\n break\nif dist[sd[0]] != sd[0]: ok = 0\nif ok:\n for i,pi in enumerate(parent):\n if pi != -1: print(i+1,pi+1)\nelse:\n print(-1)", "def solve(n, ddd):\n dsd = {d: i for i, d in enumerate(ddd)}\n child_cnt = [1] * n\n child_dist = [0] * n\n buf = []\n srt = sorted(list(dsd.items()), reverse=True)\n for d, i in srt[:-1]:\n cc = child_cnt[i]\n pd = d - (n - cc * 2)\n if pd == d or pd not in dsd:\n return -1\n pi = dsd[pd]\n buf.append((pi + 1, i + 1))\n child_cnt[pi] += cc\n child_dist[pi] += child_dist[i] + cc\n\n md, mi = srt[-1]\n if md != child_dist[mi]:\n return -1\n return buf\n\n\nn = int(input())\nddd = list(map(int, (input() for _ in range(n))))\nres = solve(n, ddd)\nif res == -1:\n print((-1))\nelse:\n print(('\\n'.join('{} {}'.format(*l) for l in res)))\n", "\ndef solve():\n # N = int(raw_input())\n # D = [int(raw_input()) for i in range(N)]\n N = int(input())\n D = [int(input()) for i in range(N)]\n if sum(D) % 2 > 0:\n print ('-1')\n return\n Di = sorted([(di, i) for i, di in enumerate(D)], key = lambda x : x[0], reverse = True)\n d_to_i = {dd:i for dd, i in Di}\n # child = [[] for i in range(N)]\n ans = []\n n_child = [1] * N\n d_child = [0] * N\n for valD, node in Di:\n valD_par = valD - N + 2 * n_child[node]\n if valD_par in list(d_to_i.keys()):\n node_par = d_to_i[valD_par]\n # child[node].append(node_par) ##\n # child[node_par].append(node)\n ans.append((node_par + 1, node + 1))\n n_child[node_par] += n_child[node]\n d_child[node_par] += n_child[node] + d_child[node]\n if n_child[node_par] == N:\n break\n else:\n print ('-1')\n return\n # check if Di satisfied or not\n d_min, i_min = Di[-1]\n if d_child[i_min] != d_min:\n print ('-1')\n return\n # for i in range(N):\n # for j in child[i]:\n # print str(i + 1) + ' ' + str(j + 1)\n for i,j in ans:\n print((str(i) + ' ' + str(j)))\n\ndef __starting_point():\n solve()\n\n__starting_point()", "n = int(input())\na = []\ns = []\n\nfor i in range(n):\n x = int(input())\n a.append(x * n + i)\n s.append(1)\n\na.sort()\na.reverse()\na.append(-1)\nSum = 0\n\nHave = True\n\nresult = []\n\nfor i in range(n - 1):\n l = 0\n r = n\n\n val = (a[i] // n) + s[i] + s[i] - n\n\n while (l < r):\n m = (l + r + 2) // 2\n\n if (a[m] >= val * n):\n l = m\n else:\n r = m - 1\n\n if((a[l] // n) != val):\n Have = False\n break\n\n s[l] += s[i]\n Sum += s[i]\n result.append([a[i] % n,a[l] % n])\n\nif (Sum != (a[n - 1] // n)):\n Have = False\n\nif (Have == False):\n print(\"-1\")\nelse:\n for e in result:\n print(e[0] + 1,end = \" \")\n print(e[1] + 1)\n"] | {"inputs": ["7\n10\n15\n13\n18\n11\n14\n19\n", "2\n1\n2\n", "15\n57\n62\n47\n45\n42\n74\n90\n75\n54\n50\n66\n63\n77\n87\n51\n"], "outputs": ["1 2\n1 3\n1 5\n3 4\n5 6\n6 7\n", "-1\n", "1 10\n1 11\n2 8\n2 15\n3 5\n3 9\n4 5\n4 10\n5 15\n6 12\n6 14\n7 13\n9 12\n11 13\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 14,191 | |
e2007fc20e6305370027c5153434d40d | UNKNOWN | Let x be a string of length at least 1.
We will call x a good string, if for any string y and any integer k (k \geq 2), the string obtained by concatenating k copies of y is different from x.
For example, a, bbc and cdcdc are good strings, while aa, bbbb and cdcdcd are not.
Let w be a string of length at least 1.
For a sequence F=(\,f_1,\,f_2,\,...,\,f_m) consisting of m elements,
we will call F a good representation of w, if the following conditions are both satisfied:
- For any i \, (1 \leq i \leq m), f_i is a good string.
- The string obtained by concatenating f_1,\,f_2,\,...,\,f_m in this order, is w.
For example, when w=aabb, there are five good representations of w:
- (aabb)
- (a,abb)
- (aab,b)
- (a,ab,b)
- (a,a,b,b)
Among the good representations of w, the ones with the smallest number of elements are called the best representations of w.
For example, there are only one best representation of w=aabb: (aabb).
You are given a string w. Find the following:
- the number of elements of a best representation of w
- the number of the best representations of w, modulo 1000000007 \, (=10^9+7)
(It is guaranteed that a good representation of w always exists.)
-----Constraints-----
- 1 \leq |w| \leq 500000 \, (=5 \times 10^5)
- w consists of lowercase letters (a-z).
-----Partial Score-----
- 400 points will be awarded for passing the test set satisfying 1 \leq |w| \leq 4000.
-----Input-----
The input is given from Standard Input in the following format:
w
-----Output-----
Print 2 lines.
- In the first line, print the number of elements of a best representation of w.
- In the second line, print the number of the best representations of w, modulo 1000000007.
-----Sample Input-----
aab
-----Sample Output-----
1
1
| ["w=list(input());n=len(w);t=-1\ndef Z(s):\n m=len(s);z=[0]*m;c=0;f=[1]*m;\n for i in range(1,m):\n if i+z[i-c]<c+z[c]:z[i]=z[i-c]\n else:\n j=max(0,c+z[c]-i)\n while i+j<n and s[j]==s[i+j]:j=j+1\n z[i]=j;c=i\n for p in range(1,m):\n for k in range(2,z[p]//p+2):f[k*p-1]=0\n return f\nfor j in range(1,n//2+1):\n if n%j==0 and w[:n-j]==w[j:]:t=j;break;\nif t==-1:print ('1\\n1')\nelif t==1:print (n);print((1))\nelse:\n zl=Z(w)\n w.reverse()\n zr=Z(w)\n cnt=0\n for i in range(0,n-1):\n if zl[i] and zr[n-2-i]:cnt=cnt+1\n print((2));print(cnt);\n", "from collections import Counter\n*W, = map(ord, input())\nN = len(W)\n\nC = Counter(W)\nif len(C) == 1:\n print(N)\n print(1)\n return\n\ndef z_algo(S):\n A = [0]*N\n i = 1; j = 0\n A[0] = l = len(S)\n while i < l:\n while i+j < l and S[j] == S[i+j]:\n j += 1\n A[i] = j\n if not j:\n i += 1\n continue\n k = 1\n while l-i > k < j - A[k]:\n A[i+k] = A[k]\n k += 1\n i += k; j -= k\n return A\n\ndef calc(W):\n Z = z_algo(W)\n G = [0]*N\n for i in range(N):\n G[i] = 1\n for p in range(1, N):\n if not G[p-1]:\n continue\n for k in range(2, Z[p]//p+2):\n G[k*p-1] = 0\n return G\nG0 = calc(W)\nW.reverse()\nG1 = calc(W)\n\nif G0[N-1]:\n print(1)\n print(1)\n return\n\nprint(2)\nprint(sum(p and q for p, q in zip(G0[:-1], reversed(G1[:-1]))))", "import sys\nreadline = sys.stdin.readline\n\nclass Rollinhash:\n def __init__(self, S):\n N = len(S)\n self.mod = 10**9+9\n self.base = 2009 \n self.has = [0]*(N+1)\n self.power = [1]*(N+1)\n for i in range(N):\n s = S[i]\n self.has[i+1] = (self.has[i]*self.base + s)%self.mod\n self.power[i+1] = self.power[i]*self.base%self.mod\n \n def rh(self, i, j):\n return (self.has[j] - self.has[i]*self.power[j-i])%self.mod\n\nMOD = 10**9+7\n \nS = list(map(ord, readline().strip()))\nN = len(S)\nif len(set(S)) == 1:\n print(N)\n print((1))\nelse:\n Rs = Rollinhash(S)\n \n tabler = [True]*(N+1)\n for d in range(1, 1+N//2):\n r = Rs.rh(0, d)\n for i in range(1, N//d):\n if r != Rs.rh(i*d, (i+1)*d):\n break\n tabler[(i+1)*d] = False\n tablel = [True]*(N+1)\n for d in range(1, 1+N//2):\n r = Rs.rh(N-d, N)\n for i in range(1, N//d):\n if r != Rs.rh(N-(i+1)*d, N-i*d):\n break\n tablel[N-(i+1)*d] = False\n \n if tabler[N]:\n print((1))\n print((1))\n else:\n print((2))\n ans = 0\n for i in range(N+1):\n if tabler[i] and tablel[i]:\n ans += 1\n assert ans > 0, ''\n print(ans)\n", "w=list(input())\nn=len(w)\nt=-1\ndef Z(s):\n m=len(s);z=[0]*m;c=0;f=[1]*m;\n for i in range(1,m):\n if i+z[i-c]<c+z[c]:z[i]=z[i-c]\n else:\n j=max(0,c+z[c]-i)\n while i+j<n and s[j]==s[i+j]:j=j+1\n z[i]=j;c=i\n for p in range(1,m):\n for k in range(2,z[p]//p+2):f[k*p-1]=0\n return f\nfor j in range(1,n//2+1):\n if n%j==0 and w[:n-j]==w[j:]:t=j;break;\nif t==-1:print ('1\\n1')\nelif t==1:print (n);print((1))\nelse:\n zl=Z(w)\n w.reverse()\n zr=Z(w)\n cnt=0\n for i in range(0,n-1):\n if zl[i] and zr[n-2-i]:cnt=cnt+1\n print((2));print(cnt);\n", "def Z_algorithm(S):\n l=len(S)\n A=[0]*l\n A[0]=l\n i=1; j=0\n while i<l:\n while i+j<l and S[j]==S[i+j]:\n j+=1\n if not j:\n i+=1\n continue\n A[i]=j\n k=1\n while l-i>k<j-A[k]:\n A[i+k]=A[k]\n k+=1\n i+=k; j-=k\n return A\n\ndef jugde(W):\n Z=Z_algorithm(W)\n l=len(W)\n B=[True]*l\n for p in range(1,l):\n if not B[p-1]:\n continue\n k=2\n while (k-1)*p<=Z[p]:\n B[k*p-1]=False\n k+=1\n return B\n\ndef solve(W):\n n=len(W)\n if len(set(W))==1:\n print(n)\n print(1)\n return\n G=jugde(W)\n W.reverse()\n G_rev=jugde(W)\n if G[-1]:\n print(1)\n print(1)\n return\n print(2)\n cnt=0\n for i in range(n-1):\n cnt+=G[i] and G_rev[-(i+2)]\n print(cnt)\n return\n\nsolve(list(input()))"] | {"inputs": ["aab\n", "bcbc\n", "ddd\n"], "outputs": ["1\n1\n", "2\n3\n", "3\n1\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 4,559 | |
ae1f349723a60d8a5a85260db5ec2487 | UNKNOWN | There is an integer sequence of length 2^N: A_0, A_1, ..., A_{2^N-1}. (Note that the sequence is 0-indexed.)
For every integer K satisfying 1 \leq K \leq 2^N-1, solve the following problem:
- Let i and j be integers. Find the maximum value of A_i + A_j where 0 \leq i < j \leq 2^N-1 and (i or j) \leq K.
Here, or denotes the bitwise OR.
-----Constraints-----
- 1 \leq N \leq 18
- 1 \leq A_i \leq 10^9
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
A_0 A_1 ... A_{2^N-1}
-----Output-----
Print 2^N-1 lines.
In the i-th line, print the answer of the problem above for K=i.
-----Sample Input-----
2
1 2 3 1
-----Sample Output-----
3
4
5
For K=1, the only possible pair of i and j is (i,j)=(0,1), so the answer is A_0+A_1=1+2=3.
For K=2, the possible pairs of i and j are (i,j)=(0,1),(0,2).
When (i,j)=(0,2), A_i+A_j=1+3=4. This is the maximum value, so the answer is 4.
For K=3, the possible pairs of i and j are (i,j)=(0,1),(0,2),(0,3),(1,2),(1,3),(2,3) .
When (i,j)=(1,2), A_i+A_j=2+3=5. This is the maximum value, so the answer is 5. | ["j=n=1<<int(input())\na=[[0,int(s)]for s in input().split()]\nwhile j>1:j>>=1;a=[sorted(a[i]+a[i^j]*(i&j>0))[-2:]for i in range(n)]\nfor s,f in a[1:]:j=max(j,s+f);print(j)", "# -*- coding:utf-8 -*-\nn = int(input())\na = [int(i) for i in input().split()]\ndp = [[x, 0] for x in range(0, len(a))]\n \n \ndef ins(x, i):\n if x in dp[i]:\n return\n if dp[i][0] != x and a[dp[i][0]] < a[x]:\n dp[i][1] = dp[i][0]\n dp[i][0] = x\n elif dp[i][1] != x and a[dp[i][1]] < a[x]:\n dp[i][1] = x\n \n \ndef mix(i, j):\n ins(dp[i][0], j)\n ins(dp[i][1], j)\n \n \nfor i in range(0, len(a)):\n for j in range(0, n):\n if i & (1 << j) == 0:\n mix(i, i | (1 << j))\n \n \nans = 0\nfor i in range(1, len(a)):\n u = a[dp[i][0]]+a[dp[i][1]]\n ans = max(ans, u)\n print(ans)", "import sys\nINF = 1 << 60\nMOD = 10**9 + 7 # 998244353\nsys.setrecursionlimit(2147483647)\ninput = lambda:sys.stdin.readline().rstrip()\ndef resolve():\n n = int(input())\n f = [[a, 0] for a in map(int, input().split())]\n dot = lambda p0, p1 : sorted(p0 + p1, reverse = 1)[:2]\n\n for i in range(n):\n for U in range(1 << n):\n if not U >> i & 1:\n f[U | 1 << i] = dot(f[U | 1 << i], f[U])\n\n res = 0\n ans = []\n for i in range(1, 1 << n):\n res = max(res, sum(f[i]))\n ans.append(res)\n print('\\n'.join(map(str, ans)))\nresolve()", "#!/usr/bin/env python\n\nfrom collections import deque\nimport itertools as it\nimport sys\nimport math\n\ndef func():\n N = int(input())\n\n A = list(map(int, input().split()))\n P = [[(A[0], 0), (0, 0)] for i in range(2 ** N)]\n\n for i in range(1, 2 ** N):\n if (A[i], i) > P[i][0]:\n P[i][1] = P[i][0]\n P[i][0] = (A[i], i)\n elif (A[i], i) > P[i][1]:\n P[i][1] = (A[i], i)\n for j in range(N):\n if (i & (1 << j)) == 0:\n index = i + (1 << j)\n for k in range(2):\n if P[i][k] > P[index][0]:\n P[index][1] = P[index][0]\n P[index][0] = P[i][k]\n elif P[i][k] > P[index][1] and P[i][k] != P[index][0]:\n P[index][1] = P[i][k]\n ans = 0\n for i in range(1, 2 ** N):\n ans = max(ans, P[i][0][0] + P[i][1][0])\n print(ans)\n #print(P)\n\nfunc()", "n=1<<int(input())\na=[[0,int(s)]for s in input().split()]\nj=1\nwhile m:=n-j:\n for i in range(n):\n if i&j:a[i]=sorted(a[i]+a[i^j])[2:]\n j*=2\nfor s,f in a[1:]:print(m:=max(m,s+f))", "def main():\n n = int(input())\n a = list(map(int, input().split()))\n d = [None]*(2**n)\n d[0] = [a[0], 0, -1, -1]\n ans = 0\n for i, t1 in enumerate(a[1:]):\n i += 1\n t2, t3, t4 = i, -1, -1\n for j in range(len(bin(i))-2):\n k = i & ~(1 << j)\n if k == i:\n continue\n t5, t6, t7, t8 = d[k]\n if t5 > t1:\n t1, t2, t3, t4 = t5, t6, t1, t2\n elif t5 > t3:\n if t6 != t2:\n t3, t4 = t5, t6\n if t7 > t3:\n t3, t4 = t7, t8\n d[i] = [t1, t2, t3, t4]\n ans = max(ans, t1+t3)\n print(ans)\n\n\nmain()", "j=n=1<<int(input())\na=[[0,int(s)]for s in input().split()]\nwhile j>1:\n j>>=1\n for i in range(n):\n if i&j:a[i]=sorted(a[i]+a[i^j])[2:]\nfor s,f in a[1:]:print(j:=max(j,s+f))", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\nA = list(map(int, input().split()))\ndp = [[A[i], -1] for i in range(1<<N)]\n\nfor i in range(N):\n bit = 1<<i\n \n for S in range(1<<N):\n if S&bit:\n l = [dp[S][0], dp[S][1], dp[S^bit][0], dp[S^bit][1]]\n l.sort()\n dp[S][0] = l[-1]\n dp[S][1] = l[-2]\n\nans = [-1]*(1<<N)\n\nfor S in range(1, 1<<N):\n ans[S] = dp[S][0]+dp[S][1]\n \n if S>=2:\n ans[S] = max(ans[S], ans[S-1])\n\nfor ans_i in ans[1:]:\n print(ans_i)", "n = int(input())\na = list(map(int,input().split()))\n\ndp = [[ai,0,i,-1] for i,ai in enumerate(a)]\n\nfor i in range(1,2**n):\n for j in range(n):\n if(i >> j)&1:\n x = dp[i]\n y = dp[i - (1<<j)]\n if(x[0] < y[0] ):\n x,y = y,x\n m1 = x[0]\n i1 = x[2]\n if(x[2] == y[2]): \n if(x[1] > y[1]):\n m2 = x[1]\n i2 = x[3]\n else:\n m2 = y[1]\n i2 = y[3]\n else:\n if(x[1] > y[0]):\n m2 = x[1]\n i2 = x[3]\n else:\n m2 = y[0]\n i2 = y[2]\n dp[i] = [m1,m2,i1,i2]\n\nans = [0]\nfor i in range(1,2**n):\n tmp = sum(dp[i][:2])\n ans.append(max(ans[-1],tmp))\n\nprint('\\n'.join(map(str,ans[1:])))", "n = int(input())\na = list(map(int, input().split()))\n\ndp1 = [x for x in a]\ndp2 = [0 for _ in range(1<<n)]\n\nfor j in range(n+1):\n\tfor i in range(1<<n):\n\t\tif i & (1<<j):\n\t\t\tif dp1[i & ~(1<<j)] >= dp1[i]:\n\t\t\t\tif dp2[i & ~(1<<j)] >= dp1[i]:\n\t\t\t\t\tdp2[i] = dp2[i & ~(1<<j)]\n\t\t\t\telse:\n\t\t\t\t\tdp2[i] = dp1[i]\n\t\t\t\tdp1[i] = dp1[i & ~(1<<j)]\n\t\t\telse:\n\t\t\t\tif dp1[i & ~(1<<j)] >= dp2[i]:\n\t\t\t\t\tdp2[i] = dp1[i & ~(1<<j)]\n\nans = 0\nfor i in range(1, 1<<n):\n\tans = max(ans, dp1[i]+dp2[i])\n\tprint(ans)", "def merge(x, y, z, w):\n P = [x, y, z, w]\n P.sort()\n return P[-1], P[-2]\n\n\ndef main():\n N = int(input())\n a = list(map(int, input().split()))\n dp = [0]*(2*(N+1)*((1 << N)))\n\n def calc(i, j, k):\n return (2*N + 2) * i + (N+1)*k + j\n for i in range(1 << N):\n dp[calc(i, 0, 0)] = a[i]\n for j in range(1, N+1):\n for i in range(1 << N):\n x = calc(i, j, 0)\n y = calc(i & ~(1 << (j-1)), j - 1, 0) \n if (i & (1 << (j-1))):\n dp[x], dp[x+N+1] = merge(dp[y], dp[y+N+1], dp[x-1], dp[x+N])\n else:\n dp[x], dp[x+N+1] = dp[x-1], dp[x+N]\n result = [0]*(1 << N)\n for k in range(1, 1 << N):\n result[k] = max(result[k-1], dp[calc(k, N, 0)]+dp[calc(k, N, 1)])\n print((result[k]))\n return\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "import sys\ninput = sys.stdin.readline\nfrom itertools import accumulate\n\ndef merge(x, y):\n a, b = dp[x]\n c, d = dp[y]\n if a >= c:\n return (a, max(c, b))\n return (c, max(a, d))\n \nn = int(input())\nA = tuple(map(int, input().split()))\ndp = [(a, 0) for a in A]\nfor j in range(n):\n for i in range(1<<n):\n if i & (1<<j):\n dp[i] = merge(i, i & ~(1<<j))\nL = tuple(accumulate((sum(d) for d in dp), max))\nprint(*L[1:], sep=\"\\n\")", "n = int(input())\na = list(map(int, input().split()))\nb = [[i] for i in a]\n\nfor j in range(n):\n for i in range(1<<n):\n if i & (1<<j):\n b[i] = sorted(b[i]+b[i^1<<j], reverse=True)[:2]\nans = []\ntmp = 0\nfor i in range(1, 1<<n):\n tmp = max(tmp, sum(b[i]))\n ans.append(tmp)\nprint(*ans, sep=\"\\n\")", "import sys\ninput = sys.stdin.readline\nN = int(input())\na = list(map(int, input().split()))\nzeta = a[: ]\nzeta2 = [0] * (1 << N)\nfor i in range(N):\n for j in range(1 << N):\n if (1 << i) & j:\n if zeta[j] < zeta[(1 << i) ^ j]:\n zeta2[j] = max(zeta[j], zeta2[(1 << i) ^ j])\n zeta[j] = zeta[(1 << i) ^ j]\n elif zeta2[j] < zeta[(1 << i) ^ j]:\n zeta2[j] = zeta[(1 << i) ^ j]\n\nres = 0\nfor i in range(1, 1 << N):\n res = max(res, zeta[i] + zeta2[i])\n print(res)", "#!/usr/bin/env python\n\n#from collections import deque\n#import itertools as it\n#import sys\n#import math\n\ndef func():\n N = int(input())\n\n A = list(map(int, input().split()))\n P = [[(A[0], 0), (0, 0)] for i in range(2 ** N)]\n\n for i in range(1, 2 ** N):\n if (A[i], i) > P[i][0]:\n P[i][1] = P[i][0]\n P[i][0] = (A[i], i)\n elif (A[i], i) > P[i][1]:\n P[i][1] = (A[i], i)\n for j in range(N):\n if (i & (1 << j)) == 0:\n index = i + (1 << j)\n for k in range(2):\n if P[i][k] > P[index][0]:\n P[index][1] = P[index][0]\n P[index][0] = P[i][k]\n elif P[i][k] > P[index][1] and P[i][k] != P[index][0]:\n P[index][1] = P[i][k]\n ans = 0\n for i in range(1, 2 ** N):\n ans = max(ans, P[i][0][0] + P[i][1][0])\n print(ans)\n #print(P)\n\nfunc()", "n = int(input())\na = list(map(int, input().split()))\nm = [[ai] for ai in a]\nfor d in range(n):\n for s in range(1 << n):\n if s >> d & 1 == 0:\n t = s | 1 << d\n m[t] = sorted(m[t] + m[s])[-2:]\nfor k in range(1, 1 << n):\n ans = sum(m[k])\n for d in range(n):\n if k >> d & 1 == 1:\n t = k ^ 1 << d | (1 << d) - 1\n ans = max(ans, sum(m[t]))\n print(ans)", "import sys\ninput = sys.stdin.readline\nfrom itertools import accumulate\n\ndef merge(x, y):\n D = sorted([dp[x][0], dp[x][1], dp[y][0], dp[y][1]], reverse=True)\n return (D[0], D[1])\n \nn = int(input())\nA = tuple(map(int, input().split()))\ndp = [(a, 0) for a in A]\nfor j in range(n):\n for i in range(1<<n):\n if i & (1<<j):\n dp[i] = merge(i, i & ~(1<<j))\nL = tuple(accumulate((sum(d) for d in dp), max))\nprint(*L[1:], sep=\"\\n\")", "from copy import deepcopy\nN=int(input())\nA=[int(i) for i in input().split()]\n\ndef chmax(a,b):\n if a[0]<b[1]:\n return b\n elif a[0]<b[0]:\n return(b[0],a[0])\n elif a[1]<b[0]:\n return (a[0],b[0])\n else:\n return a\ndp=[(A[i],0) for i in range(1<<N)]\n#print(dp)\nfor i in range(N):\n for j in range(1<<N):\n if j & (1<<i):\n #print(j,i,j|(1<<i))\n dp[j]=chmax(dp[j],dp[j^(1<<i)])\n#print(dp)\nans =sum(dp[0])\nfor i in range(1,1<<N):\n t = sum(dp[i])\n ans = max(ans,t)\n print(ans)", "N = int(input())\nA = list(map(int, input().split()))\n \n#dp[S] = A[S], -inf \u3067\u521d\u671f\u5316\u3000S\u306e\u90e8\u5206\u96c6\u5408T\u306e\u3046\u3061A[T]\u304c(\u6700\u5927\u306e\u3082\u306e, \u6b21\u306b\u5927\u304d\u3044\u3082\u306e)\u3000\u3092\u5165\u308c\u3066\u3044\u304f\n \ndp = [[A[S], -float('inf') ] for S in range(1 << N)]\nfor i in range(N):\n for T in range( 1 << N):\n if (T >> i) & 1 == 1: # T\u304ci\u3092\u542b\u3080\u3068\u304d\n merge = dp[T] + dp[T ^ (1 << i)]\n merge.sort(reverse = True)\n dp[T] =merge[:2]\nans = -float('inf')\nfor S in range(1, 1 << N , 1):\n ans = max(ans, sum(dp[S]))\n print(ans)", "def solve():\n N = int(input())\n As = list(map(int, input().split())) + [0]\n\n pow2 = 2**N\n\n anss = []\n ans = 0\n max2s = [[0, -1]]\n for S in range(1, pow2):\n m1, m2 = S, -1\n for i in range(N):\n if (S>>i)&1:\n S0 = S^(1<<i)\n i1, i2 = max2s[S0]\n if m1 == i1:\n m2 = m2 if As[m2] >= As[i2] else i2\n elif As[m1] >= As[i1]:\n m2 = m2 if As[m2] >= As[i1] else i1\n else:\n m2 = m1 if As[m1] >= As[i2] else i2\n m1 = i1\n ans2 = As[m1]+As[m2]\n if ans2 > ans:\n ans = ans2\n anss.append(ans)\n max2s.append([m1, m2])\n\n print(('\\n'.join(map(str, anss))))\n\n\nsolve()\n", "from itertools import accumulate\n\ndef zeta(data, merge):\n \"\"\"\n \uff08\u3053\u306e\u95a2\u6570\u306fdata\u3092\u4e0a\u66f8\u304d\u3057\u307e\u3059\uff09\n M\u306f\u30e2\u30ce\u30a4\u30c9\n data: 2^n -> M\n output: 2^n -> M\n merge: M -> M\n \n ouput[i] = sum(data[j] for j in range(2^n) if i|j == i)\n \"\"\"\n n = len(data)\n i = 1\n while i < n:\n j = i\n while j < n:\n data[j] = merge(data[j], data[j&~i])\n j = (j+1)|i\n i <<= 1\n return data\n\n\ndef solve(A):\n def merge(x,y):\n return tuple(sorted(x+y)[-2:])\n data = [(a,) for a in A]\n zeta(data, merge)\n return accumulate((sum(x) for x in data[1:]), max)\n\ndef __starting_point():\n n = int(input())\n A = tuple(map(int,input().split()))\n print(*solve(A),sep='\\n')\n__starting_point()", "import sys\n\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\nclass Top2:\n def __init__(self,x=-1,y=-1):\n if x<y:x,y=y,x\n self.val=[x,y]\n self.s=x+y\n\n def __add__(self, other):\n self.val=sorted(self.val+other.val,reverse=True)[:2]\n return self\n\nn=II()\naa=LI()\ndp=[Top2(a) for a in aa]\n\nfor i in range(n):\n for j in range((1<<n)-1,-1,-1):\n if j>>i&1:continue\n dp[j|1<<i]+=dp[j]\n\nmx=-1\nfor j in range(1,1<<n):\n mx=max(mx,sum(dp[j].val))\n print(mx)\n", "\n\"\"\"\n\nhttps://atcoder.jp/contests/arc100/tasks/arc100_c\n\n\u60c5\u5831\u3092\u518d\u5229\u7528\u3059\u308b\u306e\u304c\u30e1\u30a4\u30f3\nK=X\u306e\u6642\u306f,K=X-1\u306e\u6642\u306e\u7b54\u3048\u306b\u52a0\u3048\u3001 i or j == K \u306e\u5834\u5408\u3092\u8003\u3048\u308c\u3070\u3044\u3044\nor \u304cK\u3068\u306a\u308b\u5834\u5408\u30010\u306e\u6841\u306f\u4e21\u65b90\u3067\u30011\u306e\u6841\u306f\u7247\u65b9\u304c1\u306a\u3089\u3088\u3044\n1\u3067\u306f3\u901a\u308a\u306e\u5206\u3051\u65b9\u304c\u3042\u308b\u306e\u3067\u30013^N\u2026\n\n\u5927\u304d\u3044\u307b\u3046\u304b\u3089\u8003\u3048\u3066\u307f\u308b\uff1f\n\u6700\u5f8c\u306f\u3001\u5f53\u7136\u6700\u5927\u306e\u3084\u30642\u500b\u2192\u305d\u306e2\u3064\u306eindex \u306eOR\u307e\u3067\u306f\u305d\u308c\u304c\u4fdd\u6301\n\ndp[X] = X \u3068 or\u3057\u3066\u3082X\u306e\u307e\u307e\u306eindex\u306e\u96c6\u5408\u306b\u304a\u3051\u308b\u6700\u5927 & 2\u756a\u76ee\n\u2192\u3068\u3059\u308c\u3070\u30011\u306e\u6841\u5168\u3066\u306b\u95a2\u3057\u30660\u306b\u3057\u3066\u307f\u305f\u5974\u3068X\u3092\u898b\u308c\u3070\u63a8\u79fb\u3067\u304d\u308b\n\nO(2^N * logMAX(A)) \u3067\u89e3\u3051\u305d\u3046\u3060\n\n\"\"\"\n\nfrom sys import stdin\n\nN = int(stdin.readline())\nA = list(map(int,stdin.readline().split()))\nA.append(float(\"-inf\"))\n\ndp = []\nans = 0\naaa = []\n\nfor i in range(2**N):\n\n if i == 0:\n dp.append( ( 0,-1 ) )\n continue\n\n na,nb = i,-1\n \n for j in range(N):\n\n if (2**j) & i > 0:\n\n ta,tb = dp[i ^ (2**j)]\n if A[na] < A[ta]:\n nb = na\n na = ta\n elif A[nb] < A[ta] and ta != na:\n nb = ta\n\n if A[nb] < A[tb]:\n nb = tb\n\n #print (i,na,nb)\n ans = max(A[na] + A[nb] , ans)\n aaa.append(ans)\n dp.append( ( na,nb ) )\n\nprint((\"\\n\".join(map(str,aaa))))\n", "def max2(a, b, c, d):\n vals = sorted((a, b, c, d), reverse=True)\n return vals[0], vals[1]\n\n\nn = int(input())\na = list(map(int, input().split()))\n\ndp = [[0] * (1 << n) for i in range(n + 1)]\ndq = [[0] * (1 << n) for i in range(n + 1)]\nfor i in range(1 << n):\n dp[0][i] = a[i]\n\nfor i in range(n):\n for bit_state in range(1 << n):\n if (1 << i) & bit_state:\n first, second = max2(dp[i][bit_state], dq[i][bit_state], dp[i][bit_state ^ (1 << i)], dq[i][bit_state ^ (1 << i)])\n else:\n first, second = dp[i][bit_state], dq[i][bit_state]\n dp[i + 1][bit_state], dq[i + 1][bit_state] = first, second\n\nans = 0\nfor i in range(1, 1 << n):\n ans = max(ans, dp[-1][i] + dq[-1][i])\n print(ans)", "N,d=1<<int(input()),[[int(s)]for s in input().split()]\nr=N\nwhile r>1:\n\tr>>=1\n\tfor i in range(N):\n\t\tif i&r:d[i]=sorted(d[i^r]+d[i])[-2:]\nfor a,b in d[1:]:r=max(r,a+b);print(r)", "N = int(input())\nA = [(int(a), 0) for a in input().split()]\ncombine = lambda a, b: a if a[1] >= b[0] else b if b[1] >= a[0] else (a[0], b[0]) if a[0] > b[0] else (b[0], a[0])\n\nfor i in range(N):\n ii = 1 << i\n for j in range(1<<N)[::-1]:\n if j & ii:\n A[j] = combine(A[j], A[j^ii])\n\nANS = [0] * (1<<N)\nfor i in range(1, 1<<N):\n ANS[i] = max(ANS[i-1], sum(A[i]))\n\nprint(\"\\n\".join(map(str, ANS[1:])))", "N=int(input())\nA=list(map(int,input().split()))+[0]\n\ndata=[[] for i in range(2**N)]\n\nfor i in range(1,2**N):\n for j in range(N):\n if i&(1<<j)==0:\n continue\n else:\n data[i].append(i-(1<<j))\n\nMAX=[0]*2**N\nsemiMAX=[0]*2**N\n\nsemiMAX[0]=2**N\n\nif MAX[0]<A[1]:\n MAX[1]=1\n semiMAX[1]=0\nelse:\n MAX[1]=0\n semiMAX[1]=1\n\nK=[A[0]+A[1]]\nfor k in range(2,2**N):\n a,b=k,2**N\n for u in data[k]:\n c,d=MAX[u],semiMAX[u]\n if A[c]<=A[b]:\n c=c\n elif A[d]>=A[a]:\n a,b=c,d\n elif A[c]>A[a]:\n a,b=c,a\n elif A[a]>=A[c]>A[b] and a!=c:\n b=c\n elif A[a]>=A[d]>A[b] and a!=d:\n b=d\n MAX[k]=a\n semiMAX[k]=b\n K.append(max(K[-1],A[a]+A[b]))\n\nfor u in K:\n print(u)", "N = int(input())\nA = list(map(int, input().split()))\nf = [[a, -1] for a in A]\nlim = 1<<N\nfor i in range(N):\n bit = 1<<i\n j = 0\n while j < lim:\n j |= bit\n a, b = f[j]\n c, d = f[j^bit]\n if a < c:\n f[j][0] = c\n f[j][1] = d if d>a else a\n elif b < c:\n f[j][1] = c\n j += 1\nans = sum(f[1])\nAns = [ans]\nfor a, b in f[2:]:\n s = a+b\n if s > ans:\n ans = s\n Ans.append(ans)\nprint((\"\\n\".join(map(str, Ans))))\n", "import sys\nINF = 1 << 60\nMOD = 10**9 + 7 # 998244353\nsys.setrecursionlimit(2147483647)\ninput = lambda:sys.stdin.readline().rstrip()\ndef resolve():\n n = int(input())\n f = [[a, 0] for a in map(int, input().split())]\n dot = lambda p0, p1 : sorted(p0 + p1, reverse = 1)[:2]\n\n for i in range(n):\n for U in range(1 << n):\n if not U >> i & 1:\n f[U | 1 << i] = dot(f[U | 1 << i], f[U])\n\n res = 0\n for i in range(1, 1 << n):\n res = max(res, sum(f[i]))\n print(res)\nresolve()", "N=int(input())\nA=[int(i) for i in input().split()]\nB=[[A[i],-10**15] for i in range(2**N)]\nfor i in range(N):\n for b in range(2**N):\n if ((1&(b>>i))==1):\n merge=B[b]+B[b^(1<<i)]\n merge.sort(reverse=True)\n B[b]=merge[:2]\nans=-10**15\nfor i in range(1,2**N):\n ans=max([ans,sum(B[i])])\n print(ans)\n", "N,r,d=int(input()),0,[[int(s)] for s in input().split()]\nfor n in range(N):\n\tB=1<<n\n\tfor i in range(1<<N):\n\t\tif i&B:d[i]=sorted(d[i^B]+d[i])[-2:]\nfor a,b in d[1:]:r=max(r,a+b);print(r)", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\nclass Top2:\n def __init__(self,x=-1,y=-1):\n if x<y:x,y=y,x\n self.val=[x,y]\n self.s=x+y\n\n def __add__(self, other):\n i=j=0\n self.val=sorted(self.val+other.val,reverse=True)[:2]\n self.s=sum(self.val)\n return self\n\nn=II()\naa=LI()\ndp=[Top2(a) for a in aa]\n\nfor i in range(n):\n for j in range((1<<n)-1,-1,-1):\n if j>>i&1:continue\n dp[j|1<<i]+=dp[j]\n\nmx=-1\nfor j in range(1,1<<n):\n mx=max(mx,int(dp[j].s))\n print(mx)\n", "from copy import deepcopy\nN=int(input())\nA=[int(i) for i in input().split()]\n\ndef chmax(a,b):\n if a[0]<b[1]:\n return b\n elif a[0]<b[0]:\n return(b[0],a[0])\n elif a[1]<b[0]:\n return (a[0],b[0])\n else:\n return a\ndp=[(A[i],0) for i in range(1<<N)]\n#print(dp)\nfor i in range(N):\n for j in range(1<<N):\n if (j & (1<<i))==0:\n #print(j,i,j|(1<<i))\n dp[j|(1<<i)]=chmax(dp[j],dp[j|(1<<i)])\n#print(dp)\nans =sum(dp[0])\nfor i in range(1,1<<N):\n t = sum(dp[i])\n ans = max(ans,t)\n print(ans)", "n = int(input())\nf = [[a, 1] for a in map(int, input().split())]\ndot = lambda p, q : sorted(p + q)[-2:]\n\nfor d in range(n):\n for U in range(1 << n):\n if not U >> d & 1:\n f[U | 1 << d] = dot(f[U | 1 << d], f[U])\n\nres = 0\nfor i in range(1, 1 << n):\n res = max(res, sum(f[i]))\n print(res)", "N = int(input())\nNN = (1<<N)\nA = list(map(int, input().split()))\ndp1 = A[:]\ndp2 = [0]*(NN)\nfor k in range(N):\n bit = 1<<k\n for i in range(NN):\n if not i&bit:\n if dp1[i] > dp1[i|bit]:\n dp2[i|bit] = max(dp1[i|bit], dp2[i])\n dp1[i|bit] = dp1[i]\n elif dp1[i] > dp2[i|bit]:\n dp2[i|bit] = dp1[i]\nres = 0\nfor a, b in zip(dp1[1:],dp2[1:]):\n res = max(res, a+b)\n print(res)\n", "N,*A=map(int,open(0).read().split())\nA,r,R=[[a]for a in A],0,range\nfor n in R(N):\n B=1<<n\n for i in R(1<<N):\n if i&B:A[i]=sorted(A[i^B]+A[i])[-2:]\nfor a,b in A[1:]:r=max(r,a+b);print(r)", "def zata(N,A):\n dp = A[:]\n for n in range(N):\n bit=1<<n\n for i in range(1<<N):\n if i&bit:\n dp[i]=merge(dp[i^bit],dp[i])\n return dp\n\ndef merge(x,y):\n return sorted(x+y)[:2]\n\nN=int(input())\nA,res=[],0\nfor a in map(int, input().split()):\n A.append([-a])\nfor a,b in zata(N,A)[1:]:\n res=min(res,a+b)\n print(-res)", "N = int(input())\nA = list(map(int, input().split()))\nf = [[a] for a in A]\nfor i in range(N):\n for j in range(1<<N):\n if j & 1<<i:\n f[j] = sorted(f[j]+f[j^1<<i], reverse=True)[:2]\nAns = [sum(f[1])]\nfor a, b in f[2:]:\n Ans.append(max(Ans[-1], a+b))\nprint((\"\\n\".join(map(str, Ans))))\n", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 10**9+7\ndd = [(-1,0),(0,1),(1,0),(0,-1)]\nddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\ndef main():\n n = I()\n n2 = 2**n\n a = LI()\n t = [[0,0] for _ in range(n2)]\n ii = [2**i for i in range(18)]\n M = n2\n for i in range(n2):\n ti = t[i]\n ti[0] = a[i] * M + i\n for j in range(18):\n if not i & ii[j]:\n continue\n for c in t[i^ii[j]]:\n if ti[0] < c:\n ti[1] = ti[0]\n ti[0] = c\n elif ti[1] < c and ti[0] != c:\n ti[1] = c\n\n r = [0]\n for i in range(1,n2):\n tr = sum(map(lambda x: x//M, t[i]))\n if tr > r[-1]:\n r.append(tr)\n else:\n r.append(r[-1])\n return '\\n'.join(map(str, r[1:]))\n\n\n\nprint(main())\n", "def upd(ary,nary):\n tt=ary+nary\n tt.sort()\n return [tt[-2],tt[-1]]\n\ndef main1(n,a):\n # 1<=k<=2^n-1\n # O(n*2^n)\n dp=[[a[i],0] for i in range(1<<n)]\n for j in range(n):\n bit=1<<j\n for i in range(2**n):\n if i&bit==0:\n dp[i|bit]=upd(dp[i^bit],dp[i])\n pre=0\n for x,y in dp[1:]:\n pre=max(pre,x+y)\n print(pre)\n \nn=int(input())\na=list(map(int,input().split()))\nmain1(n,a)\n#num0=main0(n,a)\n#print(*num1,sep='\\n')\n#print(*num0,sep=' ')\n", "r=N=1<<int(input());d=[[int(s)]for s in input().split()]\nwhile r>1:\n\tr>>=1\n\tfor i in range(N):\n\t\tif i&r:d[i]=sorted(d[i^r]+d[i])[-2:]\nfor a,b in d[1:]:r=max(r,a+b);print(r)", "N = int(input())\nA = list(map(int, input().split()))\ndp1 = [(0, A[0])]\nans = 0\nfor i in range(1, 1<<N):\n d = {i: A[i]}\n for k in range(18):\n b = 1<<k\n if i&b == 0: continue\n j, v = dp1[i-b]\n d.update({j: v})\n p1, p2 = sorted(list(d.items()), key=lambda x: -x[1])[:2]\n dp1.append(p1)\n\n ans = max(ans, p1[1] + p2[1])\n print(ans)\n\n", "N=int(input())\nA=list(map(int,input().split()))\n\ndata=[[(A[0],0),(-1,-1)] for i in range(2**N)]\nfor i in range(1,2**N):\n for j in range(N):\n if i>>j&1==1:\n a,b=data[i-2**j]\n if a[0]>data[i][0][0]:\n data[i][1]=data[i][0]\n data[i][0]=a\n elif a[0]>data[i][1][0] and a[1]!=data[i][0][1]:\n data[i][1]=a\n if b[0]>data[i][0][0]:\n data[i][1]=data[i][0]\n data[i][0]=b\n elif b[0]>data[i][1][0] and b[1]!=data[i][0][1]:\n data[i][1]=b\n a=(A[i],i)\n if a[0]>data[i][0][0]:\n data[i][1]=data[i][0]\n data[i][0]=a\n elif a[0]>data[i][1][0] and a[1]!=data[i][0][1]:\n data[i][1]=a\n\n\nans=[data[i][0][0]+data[i][1][0] for i in range(2**N)]\nfor i in range(2,2**N):\n ans[i]=max(ans[i],ans[i-1])\n\nfor i in range(1,2**N):\n print((ans[i]))\n", "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return list(map(int, input().split()))\ndef LI(): return list(map(int, input().split()))\n\ndef main():\n mod=10**9+7\n N=I()\n A=LI()\n N2=pow(2,N)\n \n \"\"\"\n \u4e0b\u4f4d\u96c6\u5408\u306b\u5bfe\u3059\u308b\u9ad8\u901f\u30bc\u30fc\u30bf\u5909\u63db\uff0e\n (K\u304ci,j\u3092\u5305\u542b\u3057\u3066\u3044\u308b\uff09\n \u3053\u3053\u3067\u306eg\u3092\u9069\u5207\u306af\u306e\u548c\u3068\u3057\u3066\u8003\u3048\u308b\u306e\u304c\u57fa\u672c\u3060\u3051\u3069\uff0c\n \u4eca\u56de\u306f\u548c\u3067\u306f\u306a\u304f\u3066\u4e0a\u4f4d2\u3064\u306e\u8981\u7d20\u3092\u6301\u3064\n \"\"\"\n \n g=[[0,0]for _ in range(N2)]\n \n for i in range(N2):\n g[i][0]=A[i]\n \n for k in range(N):#\u3053\u306ek\u306fK\u3068\u9055\u3046\uff0ckbit\u76ee\u306b\u7740\u76ee\u3059\u308b\n for s in range(N2):#\u3053\u308c\u304c\u4eca\u56de\u3067\u3044\u3046K\uff0c\n if ((s>>k)&1):#s\u306ekbit\u76ee\u304c\u7acb\u3063\u3066\u3044\u308c\u3070\n #\u52a0\u6cd5\u3068\u3057\u3066\uff0c\u4e0a\u4f4d2\u3064\u3092\u9078\u629e\u3059\u308b\n L=[0,0,0,0]\n L[0]=g[s][0]\n L[1]=g[s][1]\n L[2]=g[(s^(1<<k))][0]#s\u306ekbit\u76ee\u3092\u30de\u30b9\u30af\u3057\u305fg\u3092\u6301\u3063\u3066\u304f\u308b\n L[3]=g[(s^(1<<k))][1]\n L.sort()\n g[s][0]=L[-1]\n g[s][1]=L[-2]\n #print(bin(s),k,g[s],L)\n \n ans=0\n for k in range(1,N2):\n ans=max(ans,sum(g[k]))\n print(ans)\n \n \n \n \n \n \n \n \n\nmain()\n", "def upd(now,x):\n if now[0]<x:\n now=[x,now[0]]\n elif now[1]<x:\n now[1]=x\n return now\n\ndef update(now,next):\n ary=now+next\n ary.sort(reverse=True)\n return ary[:2]\n\n\ndef main(n,a):\n dp=[[a[i],0] for i in range(2**n)]\n #dp[0][0]=a[0]\n now=a[0]\n for j in range(n):\n bit=1<<j\n for i in range(1<<n):\n if i&bit==0:\n # i|bit:i\u3092\u90e8\u5206\u96c6\u5408\u3068\u3057\u3066\u542b\u3080\u6570\u5b57\n dp[i|bit]=update(dp[i],dp[i^bit])\n now=sum(dp[0])\n for k in range(1,2**n):\n now=max(now,sum(dp[k]))\n print(now)\nn=int(input())\na=list(map(int,input().split()))\nmain(n,a)\n\n", "N = int(input())\nA = list(map(int, input().split()))\nINF = float(\"inf\")\nB = [[A[i], -INF] for i in range(1 << N)]\nfor i in range(N):\n for j in range(1 << N):\n if j & (1 << i):\n tmp = B[j] + B[j ^ (1 << i)]\n tmp = sorted(tmp, reverse=True)\n B[j] = tmp[:2]\n\nans = -INF\nfor i in range(1, 1 << N):\n ans = max(ans, sum(B[i]))\n print(ans)\n", "import sys\ndef I(): return int(sys.stdin.readline().rstrip())\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split()))\n\n\nN = I()\nA = LI()\n\n# \u9ad8\u901f\u30bc\u30fc\u30bf\u5909\u63db\n\ndp = [[0]*(N+1) for _ in range(1<<N)]\nfor i in range(1<<N):\n for j in range(N+1):\n if j == 0:\n dp[i][j] = A[i]\n continue\n if not i&(1<<(j-1)):\n dp[i][j] = dp[i][j-1]\n else:\n a,b = divmod(dp[i][j-1],1<<30)\n c,d = divmod(dp[i&~(1<<(j-1))][j-1],1<<30)\n X = [a,b,c,d]\n X.sort(reverse=True)\n dp[i][j] = (X[1]<<30)+X[0]\n\nans = 0\nfor i in range(1,1<<N):\n a,b = divmod(dp[i][-1],1<<30)\n ans = max(ans,a+b)\n print(ans)\n", "def main():\n n = int(input())\n a = list(map(int, input().split()))\n d = [[(j, i), (-1, -1)] for i, j in enumerate(a)]\n ans = 0\n for i in range(1, 2**n):\n (t1, t2), (t3, t4) = d[i]\n for j in range(n):\n (t5, t6), (t7, t8) = d[i & ~(1 << j)]\n if t6 not in [t2, t4]:\n if t5 > t1:\n t1, t2, t3, t4 = t5, t6, t1, t2\n elif t5 > t3:\n t3, t4 = t5, t6\n if t8 not in [t2, t4]:\n if t7 > t3:\n t3, t4 = t7, t8\n d[i] = [(t1, t2), (t3, t4)]\n ans = max(ans, t1+t3)\n print(ans)\n\n\nmain()", "def renew(lis,id1,id2):\n tar = lis[id1]; bow = lis[id2]\n if tar[0] < bow[0]:\n tar = [bow[0],max(bow[1],tar[0])]\n else:\n tar[1] = max(bow[0],tar[1])\n lis[id1] = tar\n return\n\nn = int(input())\na = [[x,0] for x in list(map(int, input().split()))]\nfor j in range(n):\n for i in range(2**n):\n if not i & (1<<j):\n renew(a,i|(1<<j),i)\na = [x+y for x,y in a[1:]]\nfor i in range(1,2**n-1):\n if a[i] < a[i-1]:\n a[i] = a[i-1]\nfor x in a:\n print(x)\n", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn = int(readline())\n*a, = list(map(int,readline().split()))\n\ntop2 = [[i,0] for i in a]\nfor i in range(n):\n i = 1<<i\n for j in range(1<<n):\n if j&i:\n top2[j] = list(sorted(top2[j^i] + top2[j]))[2:]\n\n#print(top2)\n\nans = list(map(sum,top2))\n\nfor i in range(1,1<<n):\n ans[i] = max(ans[i],ans[i-1])\n print((ans[i]))\n\n\n", "from itertools import accumulate\n\ndef solve(A):\n def keep_max_2(i,j,k):\n if i == k or j == k:\n return i,j\n # A[i] > A[j]\n if A[j] > A[k]:\n return i,j\n elif A[i] > A[k]:\n return i,k\n else:\n return k,i\n n = len(A)\n dp0 = [0]*n\n dp1 = [0]*n\n\n small = min((a,i) for i,a in enumerate(A))[1]\n\n for i in range(1,n):\n x,y = (i,0) if A[i] > A[0] else (0,i)\n for d in range(n.bit_length()-1):\n j = i^(1<<d)\n if j > i:\n continue\n x,y = keep_max_2(x,y,dp0[j])\n x,y = keep_max_2(x,y,dp1[j])\n dp0[i] = x\n dp1[i] = y\n return accumulate((A[dp0[i]]+A[dp1[i]] for i in range(1,n)), max)\n\n\n\ndef __starting_point():\n n = int(input())\n A = tuple(map(int,input().split()))\n print(*solve(A),sep='\\n')\n__starting_point()", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\nA = list(map(int, input().split()))\n\nMax = [[(0, A[0])]]\nans = 0\nfor bit in range(1, (1<<N)):\n dic = {bit: A[bit]}\n for i in range(N):\n if bit&(1<<i) != 0:\n for ind, val in Max[bit-(1<<i)]:\n dic[ind] = val\n com = []\n for ind, val in dic.items():\n if len(com) < 2:\n com.append((ind, val))\n else:\n if com[0][1] < com[1][1]:\n if com[0][1] < val:\n com[0] = (ind, val)\n elif com[1][1] < val:\n com[1] = (ind, val)\n else:\n if com[1][1] < val:\n com[1] = (ind, val)\n elif com[0][1] < val:\n com[0] = (ind, val) \n Max.append(com)\n tmp = com[0][1] + com[1][1]\n if tmp > ans:\n ans = tmp\n print(ans)", "#!/usr/bin/env python\n\nfrom collections import deque\nimport itertools as it\nimport sys\nimport math\n\ndef func():\n N = int(input())\n\n A = list(map(int, input().split()))\n P = [[(A[0], 0), (0, 0)] for i in range(2 ** (N + 1))]\n A = [0] * (2 ** N) + A\n\n for i in range(2 ** N + 1, 2 ** (N + 1)):\n if (A[i], i - 2**N) > P[i][0]:\n P[i][1] = P[i][0]\n P[i][0] = (A[i], i - 2**N)\n elif (A[i], i) > P[i][1]:\n P[i][1] = (A[i], i - 2**N)\n for j in range(N):\n piyo = i - 2 ** N\n if (piyo & (1 << j)) == 0:\n index = piyo + (1 << j) + 2 ** N\n for k in range(2):\n if P[i][k] > P[index][0]:\n P[index][1] = P[index][0]\n P[index][0] = P[i][k]\n elif P[i][k] > P[index][1] and P[i][k] != P[index][0]:\n P[index][1] = P[i][k]\n ans = 0\n for i in range(2 ** N + 1, 2 ** (N + 1)):\n ans = max(ans, P[i][0][0] + P[i][1][0])\n print(ans)\n #print(P)\n\nfunc()", "N=int(input())\nA=[int(i) for i in input().split()]\nC=[]\nl=0\nC.append(([(0,-1),(A[0],0)]))\nfor i in range(1,2**N):\n biggest,second=(A[i],i),(0,-1)\n for k in range(l+1):\n if i&(1<<k):\n for a in C[i^(1<<k)]:\n if a[0]>biggest[0]:\n second=biggest\n biggest=a\n elif a[0]>second[0] and biggest!=a:\n second=a\n C.append([second,biggest])\n if i==2**(l+1)-1:\n l+=1\nans=[0]\nfor i in range(1,2**N):\n a,b=C[i]\n ans.append(max(ans[-1],a[0]+b[0]))\n print(ans[-1])", "N = int(input())\nA = list(map(int,input().split()))\n\nA = [[a, 0] for a in A]\n#print(A)\nstep = 1\nfor _ in range(N):\n step *= 2\n for s in range(2**N):\n if (s // (step//2)) % 2 == 0: continue\n tmp = A[s] + A[s-step//2]\n tmp.sort()\n #print(s, tmp, s, s-step//2)\n A[s] = [tmp[-1], tmp[-2]]\n#print(A)\ntmp = 0\nfor s in range(1,2**N):\n tmp = max(tmp, sum(A[s]))\n print(tmp)\n", "N = int(input())\nA = [[(0, 0)] * (1<<N) for _ in range(N+1)]\nA[0] = [(int(a), 0) for a in input().split()]\ncombine = lambda a, b: a if a[1] >= b[0] else b if b[1] >= a[0] else (a[0], b[0]) if a[0] > b[0] else (b[0], a[0])\n\nfor i in range(1, N+1):\n ii = 1 << i - 1\n for j in range(1<<N):\n if j & ii:\n A[i][j] = combine(A[i-1][j], A[i-1][j^ii])\n else:\n A[i][j] = A[i-1][j]\n\nANS = [0] * (1<<N)\nfor i in range(1, 1<<N):\n ANS[i] = max(ANS[i-1], sum(A[-1][i]))\n\nprint(\"\\n\".join(map(str, ANS[1:])))", "import sys\nsys.setrecursionlimit(10**6)\nreadline = sys.stdin.readline\n\nn = int(input()) \n#n,x = [int(i) for i in readline().split()]\na = [int(i) for i in readline().split()]\n\ndef zeta_transform(a,n): #\u9ad8\u901f\u30bc\u30fc\u30bf\u5909\u63db\n b = [[i,0] for i in a]\n for i in range(n):\n I = 1<<i\n for j in range(1<<n):\n if not j&I:\n if b[j][0] > b[j^I][0]:\n b[j^I][0],b[j^I][1] = b[j][0], b[j^I][0]\n if b[j][1] > b[j^I][1]:\n b[j^I][1] = b[j][1]\n elif b[j][0] > b[j^I][1]:\n b[j^I][1] = b[j][0]\n return b\n\n#print(a)\nza = zeta_transform(a[:],n)\n#print(zeta_transform(a[:],n),\"zeta-a\")\n\nfor i, zi in enumerate(za):\n if not i: ans = 0\n else:\n i1,i2 = za[i]\n ans = max(ans,i1+i2)\n print(ans) \n\n\n", "N = int(input())\nA = list(map(int, input().split()))\nM = 2 ** N\n\nans = [0] * M\nmax_list = [0] * M\nfor i in range(1, M):\n cand = [i]\n ans_cand = []\n ibin = bin(i)[2:].zfill(N)\n for j in range(N):\n if ibin[j] == '1':\n cand.append(max_list[i - 2 ** (N - j - 1)])\n ans_cand.append(ans[i - 2 ** (N - j - 1)])\n cand_set = sorted(list(set(cand)))\n max1 = 0\n max2 = 0\n for c in cand_set:\n Ac = A[c]\n if Ac >= max1:\n max2 = max1\n max1 = Ac\n max_idx = c\n elif Ac > max2:\n max2 = Ac\n ans_cand.append(max1 + max2)\n ans_cand.append(ans[i - 1])\n max_list[i] = max_idx\n ans[i] = max(ans_cand)\n print((ans[i]))\n", "def main():\n n = int(input())\n a = list(map(int, input().split()))\n d = [[j, i, -1, -1] for i, j in enumerate(a)]\n ans = 0\n for i in range(1, 2**n):\n t1, t2, t3, t4 = d[i]\n for j in range(len(bin(i))-2):\n t5, t6, t7, t8 = d[i & ~(1 << j)]\n if t5 > t1:\n t1, t2, t3, t4 = t5, t6, t1, t2\n elif t5 > t3:\n if t6 != t2:\n t3, t4 = t5, t6\n continue\n if t7 > t3:\n t3, t4 = t7, t8\n d[i] = [t1, t2, t3, t4]\n ans = max(ans, t1+t3)\n print(ans)\n\n\nmain()", "N,r,d=1<<int(input()),0,[[int(s)]for s in input().split()]\nB=1\nwhile B < N:\n\tfor i in range(N):\n\t\tif i&B:d[i]=sorted(d[i^B]+d[i])[-2:]\n\tB<<=1\nfor a,b in d[1:]:r=max(r,a+b);print(r)", "import sys\n\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\nclass Top2:\n def __init__(self,x=-1,y=-1):\n if x<y:x,y=y,x\n self.val=[x,y]\n\n def __add__(self, other):\n self.val=sorted(self.val+other.val,reverse=True)[:2]\n return self\n\nn=II()\naa=LI()\ndp=[Top2(a) for a in aa]\n\nfor i in range(n):\n for j in range((1<<n)-1,-1,-1):\n if j>>i&1:continue\n dp[j|1<<i]+=dp[j]\n\nmx=-1\nfor j in range(1,1<<n):\n mx=max(mx,sum(dp[j].val))\n print(mx)\n", "from heapq import heappush, heappop, heappushpop\nN = int(input())\n*A, = map(int, input().split())\n\ndef update(v, que):\n p, q = que\n if v == p or v == q:\n return\n heappushpop(que, v)\n\nmemo = [None]*(2**N)\nmemo[0] = [(0, -1), (A[0], 0)]\nma = 0; ans = []\nfor i in range(1, 2**N):\n res = [(0, -1), (A[i], i)]\n for j in range(N):\n if (i >> j) & 1 == 0:\n continue\n p, q = memo[i ^ (1 << j)]\n update(p, res)\n update(q, res)\n p, q = memo[i] = res\n ma = max(ma, p[0] + q[0])\n ans.append(ma)\nprint(*ans, sep='\\n')\n", "def max2(p, q):\n e, b = p[0], p[1]\n c, d = q[0], q[1]\n s = list(set([e, b, c, d]))\n m1, m2 = 1<<n, 1<<n\n for i in s:\n if a[m1]<a[i]:\n m2 = m1\n m1 = i\n elif a[m2]<a[i]:\n m2 = i\n return (m1, m2)\n\nn = int(input())\na = list(map(int, input().split()))\ng = [(i, (1<<n)) for i in range(1<<n)]\na+=[0]\nres = 0\nfor i in range(n):\n for j in range(1<<n):\n if (1<<i)&j: g[j] = max2(g[j], g[j^(1<<i)])\nans = []\nfor i in range(1, 1<<n):\n res = max(res, a[g[i][0]]+a[g[i][1]])\n ans.append(res)\nprint(*ans, sep = '\\n')", "j=n=1<<int(input())\na=[[int(s)]for s in input().split()]\nwhile~-j:j>>=1;a=[sorted(a[i]+a[i^j]*(i&j>0))[-2:]for i in range(n)]\nfor s,f in a[1:]:j=max(j,s+f);print(j)", "N,d,r=int(input()),[],0\nfor a in map(int,input().split()):d.append([-a])\nfor n in range(N):\n B=1<<n\n for i in range(1<<N):\n if i&B:d[i]= sorted(d[i^B]+d[i])[:2]\nfor a,b in d[1:]:r=min(r,a+b);print(-r)", "#!/usr/bin/env python\n\nfrom collections import deque\nimport itertools as it\nimport sys\nimport math\n\ndef func():\n N = int(input())\n\n A = list(map(int, input().split()))\n P = [[(A[0], 0), (0, 0)] for i in range(2 ** N)]\n\n for i in range(1, 2 ** N):\n Ai = A[i]\n Pi = P[i]\n if (Ai, i) > Pi[0]:\n Pi[1] = Pi[0]\n Pi[0] = (Ai, i)\n elif (Ai, i) > Pi[1]:\n Pi[1] = (Ai, i)\n for j in range(N):\n if (i & (1 << j)) == 0:\n Pindex = P[i + (1 << j)]\n for k in range(2):\n if Pi[k] > Pindex[0]:\n Pindex[1] = Pindex[0]\n Pindex[0] = Pi[k]\n elif Pi[k] > Pindex[1] and Pi[k] != Pindex[0]:\n Pindex[1] = Pi[k]\n ans = 0\n for i in range(1, 2 ** N):\n ans = max(ans, P[i][0][0] + P[i][1][0])\n print(ans)\n #print(P)\n\nfunc()", "#!/usr/bin/env python\n\nfrom collections import deque\nimport itertools as it\nimport sys\nimport math\n\ndef func():\n N = int(input())\n\n A = list(map(int, input().split()))\n P = [[(A[0], 0), (0, 0)] for i in range(2 ** (N + 1))]\n\n for i in range(1, 2 ** N):\n if (A[i], i) > P[i][0]:\n P[i][1] = P[i][0]\n P[i][0] = (A[i], i)\n elif (A[i], i) > P[i][1]:\n P[i][1] = (A[i], i)\n for j in range(N):\n if (i & (1 << j)) == 0:\n index = i + (1 << j)\n for k in range(2):\n if P[i][k] > P[index][0]:\n P[index][1] = P[index][0]\n P[index][0] = P[i][k]\n elif P[i][k] > P[index][1] and P[i][k] != P[index][0]:\n P[index][1] = P[i][k]\n ans = 0\n for i in range(1, 2 ** N):\n ans = max(ans, P[i][0][0] + P[i][1][0])\n print(ans)\n #print(P)\n\nfunc()", "n = int(input())\na = list(map(int,input().split()))\ndp = [[0,0] for i in range(1<<n)]\ndef merge(ls1,ls2):\n p,q = ls1\n r,s = ls2\n ret = [max(p,r)]\n if p>r:\n ret.append(max(q,r))\n else:\n ret.append(max(p,s))\n return ret\nfor i in range(1<<n):\n dp[i][0] = a[i]\nfor i in range(n):\n for j in range(1<<n):\n if 1<<i & j:\n dp[j] = merge(dp[j],dp[1<<i^j])\nans = [0 for i in range(2**n)]\nfor i in range(1,1<<n):\n ans[i] = max(ans[i-1],sum(dp[i]))\nfor i in ans:\n if i:\n print(i)", "N = int(input())\nAs = [(A << 20) + i for i, A in enumerate(map(int, input().split()))]\n\n\ndef chmax(i, elem):\n nonlocal dp\n if dp[0][i] < elem:\n dp[1][i] = dp[0][i]\n dp[0][i] = elem\n return True\n elif dp[1][i] < elem < dp[0][i]: # skip dp[0][i] == elem\n dp[1][i] = elem\n return True\n else:\n return False\n\n\ndp = [[0] * len(As) for _ in range(2)] # first largest and second largest\ndp[0][0] = As[0]\nans = 0\nfor i in range(1, 2 ** N):\n for j in range(N):\n if i & (1 << j):\n if chmax(i, dp[0][i & ~(1 << j)]):\n chmax(i, dp[1][i & ~(1 << j)])\n chmax(i, As[i])\n ans = max(ans, (dp[0][i] + dp[1][i]) >> 20)\n print(ans)\n", "import sys\ninput = sys.stdin.readline\nfrom heapq import heappushpop\n\nN = int(input())\nA = [int(x) for x in input().split()]\n\n# B_x = max {A_y | y\\subset x}\n# \u3068\u601d\u3063\u305f\u304c\u30012\u5143\u305a\u3064\u6301\u3064\u5fc5\u8981\u304c\u3042\u308b\u3002\n# (\u5024\u3001\u4f55\u756a\u304b\u3089\u6765\u305f\u304b)\nB = []\nfor n,a in enumerate(A):\n arr = [(0,0),(a,n)]\n m = n\n while m:\n bit = m & (-m)\n (x,i),(y,j) = B[n-bit]\n if (x,i) != arr[-1]:\n heappushpop(arr,(x,i))\n if (y,j) != arr[-1]:\n heappushpop(arr,(y,j))\n m -= bit\n B.append(arr)\n\nanswer = [0]\nfor (x,i),(y,j) in B[1:]:\n z = answer[-1]\n if z < x + y:\n z = x + y\n answer.append(z)\nprint(('\\n'.join(map(str,answer[1:]))))\n\n", "import sys\nreadline = sys.stdin.readline\n\nN = int(readline())\nA = list(map(int, readline().split()))\n\ndp = [(a, 0) for a in A]\nfor i in range(N):\n for j in range(1<<N):\n if not j & (1<<i):\n k = j|(1<<i)\n a, b = dp[k]\n c, d = dp[j]\n res = None\n if a > c:\n if b > c:\n res = (a, b)\n else:\n res = (a, c)\n else:\n if a > d:\n res = (c, a)\n else:\n res = (c, d)\n assert res == tuple(sorted([a, b, c, d], reverse = True)[:2]), ''\n dp[k] = res\ndp[0] = sum(dp[0])\nfor i in range(1, 1<<N):\n dp[i] = max(dp[i-1], sum(dp[i]))\nprint('\\n'.join(map(str, dp[1:])))", "from itertools import accumulate\n\ndef zeta(data, merge):\n \"\"\"\n \uff08\u3053\u306e\u95a2\u6570\u306fdata\u3092\u4e0a\u66f8\u304d\u3057\u307e\u3059\uff09\n M\u306f\u30e2\u30ce\u30a4\u30c9\n data: 2^n -> M\n output: 2^n -> M\n merge: M -> M\n \n ouput[i] = sum(data[j] for j in range(2^n) if i|j == i)\n \"\"\"\n n = len(data)\n i = 1\n while i < n:\n j = i\n while j < n:\n data[j] = merge(data[j], data[j&~i])\n j = (j+1)|i\n i <<= 1\n return data\n\n\ndef solve(A):\n def merge(x,y):\n return sorted(x+y)[-2:]\n data = [[a] for a in A]\n zeta(data, merge)\n return accumulate((sum(x) for x in data[1:]), max)\n\ndef __starting_point():\n n = int(input())\n A = tuple(map(int,input().split()))\n print(*solve(A),sep='\\n')\n__starting_point()", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\nalst = list(map(int, input().split()))\nmax_ = 0\ndp = [[a, 0] for a in alst]\n\nfor i in range(n):\n for s in range(1 << n):\n if (s >> i) & 1:\n lst = dp[s] + dp[s - (1 << i)]\n lst.sort(reverse = True)\n dp[s] = lst[:2].copy()\n\nfor a, b in dp[1:]:\n max_ = max(max_, a + b)\n print(max_)", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\nA = list(map(int, input().split()))\ndp = [[A[S], 0] for S in range(1 << N)]\nfor k in range(N):\n for S in range(1 << N):\n if S >> k & 1:\n if dp[S][0] < dp[S ^ (1 << k)][0]:\n dp[S][1] = max(dp[S][0], dp[S ^ (1 << k)][1])\n dp[S][0] = dp[S ^ (1 << k)][0]\n else:\n dp[S][1] = max(dp[S][1], dp[S ^ (1 << k)][0])\nans = 0\nfor K in range(1, 1 << N):\n ans = max(ans, sum(dp[K]))\n print(ans)", "from sys import stdin\nreadline = stdin.readline\n\nn = int(readline())\n\na = list(map(int, readline().split()))\nk_max = 1 << n\n\n# \u548c\u304c\u6700\u5927 => \u6700\u5927\u30012\u756a\u76ee\u306b\u5927\u304d\u3044\u3082\u306e\u306e\u548c\n# dp[k] == k\u3092\u5f97\u308b\u3068\u304d\u306e\u6700\u5927\u30012\u756a\u76ee\u306b\u5927\u304d\u3044\u3082\u306e\n# == max(dp[i] | i \u306fk\u306e\u90e8\u5206\u96c6\u5408)\n# k\u306e\u90e8\u5206\u96c6\u5408\u306f k \u306b1\u8981\u7d20\u8db3\u308a\u306a\u3044\u3082\u306e\u3092\u5217\u6319\u3059\u308c\u3070\u5341\u5206\u3002\n# (2\u8981\u7d20\u4ee5\u4e0a\u8db3\u308a\u306a\u3044\u3082\u306e\u306f1\u8981\u7d20\u8db3\u308a\u306a\u3044\u3082\u306e\u306e\u90e8\u5206\u96c6\u5408\u306a\u306e\u3067)\ndp = [[a[i], 0] for i in range(k_max)]\nfor i in range(n):\n bit = (1 << i) # i bit\u76ee\u306b\u7740\u76ee\n for src in range(k_max): # i bit\u76ee\u304c0\u306e\u3082\u306e\u304b\u3089ibit\u76ee\u304c1\u306e\u3082\u306e\u3078\u914d\u308bDP\n if bit & src:\n continue # \u3059\u3067\u306bi bit\u76ee\u304c1\u306a\u3089\u7121\u8996\n dst = bit | src\n max_values = dp[dst] + dp[src]\n max_values.sort()\n dp[dst] = [max_values[-1], max_values[-2]]\n\n# k\u4ee5\u4e0b => \u524d\u56de\u306e\u7b54\u3048(k\u672a\u6e80)\u3068k\u306b\u7b49\u3057\u3044\u6642\u3092\u5408\u308f\u305b\u305f\u7d50\u679c\nans = 0\nfor k in range(1, k_max):\n ans = max(ans, dp[k][0] + dp[k][1])\n print(ans)\n", "from itertools import accumulate\n\ndef zeta(data, merge):\n \"\"\"\n \uff08\u3053\u306e\u95a2\u6570\u306fdata\u3092\u4e0a\u66f8\u304d\u3057\u307e\u3059\uff09\n M\u306f\u30e2\u30ce\u30a4\u30c9\n data: 2^n -> M\n output: 2^n -> M\n merge: M -> M\n \n ouput[i] = sum(data[j] for j in range(2^n) if i|j == i)\n \"\"\"\n n = len(data)\n i = 1\n while i < n:\n j = i\n while j < n:\n data[j] = merge(data[j], data[j&~i])\n j = (j+1)|i\n i <<= 1\n return data\n\n\ndef solve(A):\n def merge(x,y):\n return sorted(x+y)[-2:]\n data = [[a] for a in A]\n zeta(data, merge)\n return accumulate((sum(x) for x in data[1:]), max)\n\ndef __starting_point():\n n = int(input())\n A = tuple(map(int,input().split()))\n print(*solve(A),sep='\\n')\n__starting_point()", "j=n=1<<int(input())\na=[[int(s)]for s in input().split()]\nwhile j>1:j>>=1;a=[sorted(a[i]+a[i^j]*(i&j>0))[-2:]for i in range(n)]\nfor s,f in a[1:]:j=max(j,s+f);print(j)"] | {"inputs": ["2\n1 2 3 1\n", "3\n10 71 84 33 6 47 23 25\n", "4\n75 26 45 72 81 47 97 97 2 2 25 82 84 17 56 32\n"], "outputs": ["3\n4\n5\n", "81\n94\n155\n155\n155\n155\n155\n", "101\n120\n147\n156\n156\n178\n194\n194\n194\n194\n194\n194\n194\n194\n194\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 49,732 | |
5bcd4550800437568aedb373c6989f9d | UNKNOWN | There are N bags, each containing two white balls. The i-th box contains two balls with integers x_i and y_i written on them, respectively.
For each of these bags, you will paint one of the balls red, and paint the other blue.
Afterwards, the 2N balls will be classified according to color.
Then, we will define the following:
- R_{max}: the maximum integer written on a ball painted in red
- R_{min}: the minimum integer written on a ball painted in red
- B_{max}: the maximum integer written on a ball painted in blue
- B_{min}: the minimum integer written on a ball painted in blue
Find the minimum possible value of (R_{max} - R_{min}) \times (B_{max} - B_{min}).
-----Constraints-----
- 1 ≤ N ≤ 200,000
- 1 ≤ x_i, y_i ≤ 10^9
-----Input-----
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
-----Output-----
Print the minimum possible value.
-----Sample Input-----
3
1 2
3 4
5 6
-----Sample Output-----
15
The optimal solution is to paint the balls with x_1, x_2, y_3 red, and paint the balls with y_1, y_2, x_3 blue. | ["import sys\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nn = int(input())\nd = []\nM, m = 0, 10**30\nM_of_m, m_of_M = 0, 10**30\nfor _ in range(n):\n\tx, y = map(int, input().split())\n\tg, l = max(x, y), min(x, y)\n\td.append([l, g])\n\tM = max(M, g)\n\tm = min(m, l)\n\tM_of_m = max(M_of_m, l)\n\tm_of_M = min(m_of_M, g)\nans1 = (M - m_of_M) * (M_of_m - m)\n\nM_other, m_other = M_of_m, m\nm_reversed = 10**30\ngap = M_other - m_other\nd.sort(key=min)\nfor i in range(n-1):\n\tM_other = max(M_other, d[i][1])\n\tm_reversed = min(m_reversed, d[i][1])\n\tm_other = min(m_reversed, d[i+1][0])\n\tgap = min(gap, M_other - m_other)\nM_other = max(M_other, d[n-1][1])\nm_reversed = min(m_reversed, d[i][1])\ngap = min(gap, M_other - m_reversed)\nans2 = (M - m) * gap\n\n#print(ans1, ans2)\nprint(min(ans1, ans2))", "import sys\nfrom operator import itemgetter\n \ninf = 1 << 30\n \ndef solve():\n n = int(sys.stdin.readline())\n \n # r_max = MAX, b_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n r_max = b_max = 0\n r_min = b_min = inf\n\n p = []\n \n for i in range(n):\n xi, yi = map(int, sys.stdin.readline().split())\n\n if xi > yi:\n xi, yi = yi, xi\n\n p.append((xi, yi))\n\n r_max = max(r_max, yi)\n r_min = min(r_min, yi)\n b_max = max(b_max, xi)\n b_min = min(b_min, xi)\n \n ans1 = (r_max - r_min) * (b_max - b_min)\n \n # r_max = MAX, r_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n ans2 = (r_max - b_min)\n\n p.sort(key=itemgetter(0))\n\n b_min = p[0][0]\n b_max = p[-1][0]\n\n y_min = inf\n\n dif_b = b_max - b_min\n \n for i in range(n - 1):\n y_min = min(y_min, p[i][1])\n\n b_min = min(p[i + 1][0], y_min)\n b_max = max(b_max, p[i][1])\n\n dif_b = min(dif_b, b_max - b_min)\n \n ans2 *= dif_b\n \n ans = min(ans1, ans2)\n \n print(ans)\n \ndef __starting_point():\n solve()\n__starting_point()", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\nL, R = [], []\nLR = []\nINF = 10**9+1\nm, M = INF, 0\nfor i in range(n):\n x, y = map(int, input().split())\n if x > y:\n x, y = y, x\n L.append(x)\n R.append(y)\n LR.append((x, y))\n if m > x:\n m = x\n idx_m = i\n if M < y:\n M = y\n idx_M = i\nans1 = (M-min(R))*(max(L)-m)\nif idx_m == idx_M:\n print(ans1)\n return\na, b = L[idx_M], R[idx_m]\nif a > b:\n a, b = b, a\nLR = sorted([lr for i, lr in enumerate(LR) if i != idx_m and i != idx_M])\nif not LR:\n print(ans1)\n return\nL, R = zip(*LR)\nmax_R = [-1]*(n-2)\nmin_R = [-1]*(n-2)\nmax_R[0] = R[0]\nmin_R[0] = R[0]\nfor i in range(n-3):\n max_R[i+1] = max(max_R[i], R[i+1])\n min_R[i+1] = min(min_R[i], R[i+1])\nl_min, l_max = L[0], L[-1]\nans2 = max(b, l_max) - min(a, l_min)\nfor i in range(n-2):\n if i < n-3:\n l_min = min(min_R[i], L[i+1])\n else:\n l_min = min_R[i]\n l_max = max(l_max, max_R[i])\n ans2 = min(ans2, max(b, l_max) - min(a, l_min))\nans2 *= M-m\nans = min(ans1, ans2)\nprint(ans)", "import sys\ninput=sys.stdin.readline\nn=int(input())\nl=[list(map(int,input().split())) for i in range(n)]\nfor i in range(n):\n l[i].sort()\n\nans=[]\nl.sort()\nB1=[];R1=[]\nfor i in range(n):\n B1.append(max(l[i]))\n R1.append(min(l[i]))\nans.append((max(B1)-min(B1))*(max(R1)-min(R1)))\n\nBleft=[]\nBright=[]\nRleft=[]\nRright=[]\n\nM=B1[0];m=B1[0]\nBleft.append([m,M])\nfor i in range(1,n):\n M=max(M,B1[i])\n m=min(m,B1[i])\n Bleft.append([m,M])\n\nB1.reverse()\nM=B1[0];m=B1[0]\nBright.append([m,M])\nfor i in range(1,n):\n M=max(M,B1[i])\n m=min(m,B1[i])\n Bright.append([m,M])\n\nM=R1[0];m=R1[0]\nRleft.append([m,M])\nfor i in range(1,n):\n M=max(M,R1[i])\n m=min(m,R1[i])\n Rleft.append([m,M])\n\nR1.reverse()\nM=R1[0];m=R1[0]\nRright.append([m,M])\nfor i in range(1,n):\n M=max(M,R1[i])\n m=min(m,R1[i])\n Rright.append([m,M])\n\nfor i in range(n-1):\n M1=max(Bleft[i][1],Rright[n-2-i][1])\n m1=min(Bleft[i][0],Rright[n-2-i][0])\n M2=max(Rleft[i][1],Bright[n-2-i][1])\n m2=min(Rleft[i][0],Bright[n-2-i][0])\n ans.append((M1-m1)*(M2-m2))\n\nprint(min(ans))", "import sys\nfrom operator import itemgetter\n \ninf = 1 << 30\n \ndef solve():\n n = int(sys.stdin.readline())\n \n # r_max = MAX, b_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n r_max = b_max = 0\n r_min = b_min = inf\n\n p = []\n \n for i in range(n):\n xi, yi = map(int, sys.stdin.readline().split())\n\n if xi > yi:\n xi, yi = yi, xi\n\n p.append((xi, yi))\n\n r_max = max(r_max, yi)\n r_min = min(r_min, yi)\n b_max = max(b_max, xi)\n b_min = min(b_min, xi)\n \n ans1 = (r_max - r_min) * (b_max - b_min)\n \n # r_max = MAX, r_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n ans2 = (r_max - b_min)\n\n p.sort(key=itemgetter(0))\n\n b_min = p[0][0]\n b_max = p[-1][0]\n\n y_min = inf\n\n dif_b = b_max - b_min\n \n for i in range(n - 1):\n if p[i][1] == r_max:\n break\n y_min = min(y_min, p[i][1])\n\n b_min = min(p[i + 1][0], y_min)\n b_max = max(b_max, p[i][1])\n\n dif_b = min(dif_b, b_max - b_min)\n \n ans2 *= dif_b\n \n ans = min(ans1, ans2)\n \n print(ans)\n \ndef __starting_point():\n solve()\n__starting_point()", "N = int(input())\nxmin = ymin = float('inf')\nxmax = ymax = 0\np = []\nfor i in range(N):\n x,y = list(map(int, input().split()))\n if x > y : \n x,y= y,x\n p.append((x, y))\n if x < xmin:\n xmin = x\n elif x > xmax:\n xmax = x\n if y < ymin:\n ymin = y\n elif y > ymax:\n ymax = y\nret = (ymax-ymin) * (xmax-xmin)\n\n\np.sort()\ndx = p[-1][0] - p[0][0]\nymin = p[0][0]\ntymin = float('inf')\nfor i in range(N-1):\n # print(i, dx, (xmax, xmin), end=' ==> ')\n tymin = min(tymin, p[i][1])\n xmax = max(xmax, p[i][1])\n xmin = min(tymin, p[i+1][0])\n dx = min(dx, xmax - xmin)\n if tymin < p[i+1][0]:\n break\n # print(i, dx, (xmax, xmin))\n\nprint((min(ret, (ymax-ymin) * dx)))\n\n\n", "#####segfunc#####\ndef segfunc(x, y):\n return min(x,y)\n#################\n\n#####ide_ele#####\nide_ele = float(\"inf\")\n#################\n\nclass SegTree:\n \"\"\"\n init(init_val, ide_ele): \u914d\u5217init_val\u3067\u521d\u671f\u5316 O(N)\n update(k, x): k\u756a\u76ee\u306e\u5024\u3092x\u306b\u66f4\u65b0 O(logN)\n query(l, r): \u533a\u9593[l, r)\u3092segfunc\u3057\u305f\u3082\u306e\u3092\u8fd4\u3059 O(logN)\n \"\"\"\n def __init__(self, init_val, segfunc, ide_ele):\n \"\"\"\n init_val: \u914d\u5217\u306e\u521d\u671f\u5024\n segfunc: \u533a\u9593\u306b\u3057\u305f\u3044\u64cd\u4f5c\n ide_ele: \u5358\u4f4d\u5143\n n: \u8981\u7d20\u6570\n num: n\u4ee5\u4e0a\u306e\u6700\u5c0f\u306e2\u306e\u3079\u304d\u4e57\n tree: \u30bb\u30b0\u30e1\u30f3\u30c8\u6728(1-index)\n \"\"\"\n n = len(init_val)\n self.segfunc = segfunc\n self.ide_ele = ide_ele\n self.num = 1 << (n - 1).bit_length()\n self.tree = [ide_ele] * 2 * self.num\n # \u914d\u5217\u306e\u5024\u3092\u8449\u306b\u30bb\u30c3\u30c8\n for i in range(n):\n self.tree[self.num + i] = init_val[i]\n # \u69cb\u7bc9\u3057\u3066\u3044\u304f\n for i in range(self.num - 1, 0, -1):\n self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])\n\n def update(self, k, x):\n \"\"\"\n k\u756a\u76ee\u306e\u5024\u3092x\u306b\u66f4\u65b0\n k: index(0-index)\n x: update value\n \"\"\"\n k += self.num\n self.tree[k] = x\n while k > 1:\n self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])\n k >>= 1\n\n def query(self, l, r):\n \"\"\"\n [l, r)\u306esegfunc\u3057\u305f\u3082\u306e\u3092\u5f97\u308b\n l: index(0-index)\n r: index(0-index)\n \"\"\"\n res = self.ide_ele\n\n l += self.num\n r += self.num\n while l < r:\n if l & 1:\n res = self.segfunc(res, self.tree[l])\n l += 1\n if r & 1:\n res = self.segfunc(res, self.tree[r - 1])\n l >>= 1\n r >>= 1\n return res\n\ndef main():\n import sys,random\n\n input=sys.stdin.readline\n\n N=int(input())\n q=[]\n r=[]\n b=[]\n X=0\n q_append=q.append\n for i in range(N):\n x,y=list(map(int,input().split()))\n r.append(max(x,y))\n b.append(min(x,y))\n\n\n X=max(b)\n init_val=[b[i] for i in range(N)]\n for i in range(N):\n x,y=r[i],b[i]\n if X>r[i]:\n init_val[i]=r[i]\n elif X>b[i]:\n q_append((r[i],i,-1))\n init_val[i]=b[i]\n else:\n q_append((b[i],i,1))\n q_append((r[i],i,-1))\n init_val[i]=b[i]\n\n q.sort()\n test1=float(\"inf\")\n rmq=SegTree(init_val,segfunc,ide_ele)\n \n\n for i in range(0,len(q)):\n val,index,k=q[i]\n if k==-1:\n rmq.update(index,val)\n res=rmq.query(0,N)\n test1=min(val-res,test1)\n\n\n test2=(max(r)-min(r))*(max(b)-min(b))\n test1*=(max(max(b),max(r))-min(min(b),min(r)))\n print((min(test1,test2)))\n\ndef __starting_point():\n main()\n\n__starting_point()", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\ndef main():\n inf = 10 ** 10\n n = II()\n xy = [LI() for _ in range(n)]\n xy = [[x, y] if x < y else [y, x] for x, y in xy]\n xy.sort()\n yy=[y for x,y in xy]\n xmin=xy[0][0]\n xmax=xy[-1][0]\n ymax = max(yy)\n ymin = min(yy)\n ans=(xmax-xmin)*(ymax-ymin)\n d=ymax-xmin\n ymin = inf\n for i in range(n - 1):\n y = xy[i][1]\n if y < ymin: ymin = y\n xmin = min(xy[i + 1][0], ymin)\n xmax = max(xmax, y)\n ans = min(ans, (xmax - xmin) * d)\n print(ans)\n\nmain()\n", "n=int(input())\nx,y=zip(*sorted(sorted(map(int,input().split())) for _ in range(n)))\np=max(range(n),key=lambda i:y[i])\nr=a=x[-1]\nb=d=10**9\nfor i in range(p):\n if b<=x[i]:\n break\n a=max(a,y[i])\n b=min(b,y[i])\n d=min(d,a-min(b,x[i+1]))\nprint(min((x[-1]-x[0])*(y[p]-min(y)),(y[p]-x[0])*d))", "import sys\nfrom operator import itemgetter\n \ninf = 1 << 30\n \ndef solve():\n n = int(sys.stdin.readline())\n \n # r_max = MAX, b_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n r_max = b_max = 0\n r_min = b_min = inf\n\n p = []\n \n for i in range(n):\n xi, yi = map(int, sys.stdin.readline().split())\n\n if xi > yi:\n xi, yi = yi, xi\n\n p.append((xi, yi))\n\n r_max = max(r_max, yi)\n r_min = min(r_min, yi)\n b_max = max(b_max, xi)\n b_min = min(b_min, xi)\n \n ans1 = (r_max - r_min) * (b_max - b_min)\n \n # r_max = MAX, r_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n ans2 = (r_max - b_min)\n\n p.sort(key=itemgetter(0))\n\n b_min = p[0][0]\n b_max = p[-1][0]\n\n y_min = inf\n\n dif_b = b_max - b_min\n \n for i in range(n - 1):\n if p[i][1] == r_max:\n break\n\n y_min = min(y_min, p[i][1])\n\n b_min = min(p[i + 1][0], y_min)\n b_max = max(b_max, p[i][1])\n\n dif_b = min(dif_b, b_max - b_min)\n\n if p[i][1] < p[i + 1][0]:\n break\n \n ans2 *= dif_b\n \n ans = min(ans1, ans2)\n \n print(ans)\n \ndef __starting_point():\n solve()\n__starting_point()", "n = int(input())\nlis = []\na, b = [], []\nfor i in range(n):\n X, Y = map(int, input().split())\n lis.append([min(X, Y), max(X, Y)])\n a.append(min(X, Y))\n b.append(max(X, Y))\nlis.sort()\nanswer = (max(a) - min(a)) * (max(b) - min(b))\na_max, b_min = max(a), min(b)\ncurrent = float(\"inf\")\nfor i in range(n):\n if lis[i][0] > b_min:\n current = min(current, a_max - b_min)\n break\n current = min(current, a_max - lis[i][0])\n a_max = max(a_max, lis[i][1])\nprint(min(answer, current * (max(b) - min(a))))", "n = int(input())\nx = []\ny = []\nxy = []\nmaxlist = []\nminlist = []\namax = 0\namin = 10**10\ncase1 = 0\ncase2 = 0\nfor i in range(n):\n store = [int(j) for j in input().split(' ')]\n if store[0] < store[1]:\n store[0], store[1] = store[1], store[0]\n if store[0] == amax:\n maxlist.append(i)\n elif store[0] > amax:\n amax = store[0]\n maxlist = [i]\n if store[1] == amin:\n minlist.append(i)\n elif store[1] < amin:\n amin = store[1]\n minlist = [i]\n x.append(store[0])\n y.append(store[1])\n xy.extend(store)\n\ncase1 = (max(x) - min(x)) * (max(y)-min(y))\nfor k in maxlist:\n if k in minlist:\n print(case1)\n return\nfor index in range(n):\n y[index] = [y[index], index]\ny.sort()\n\nbmax = y[n-1][0]\nbmin = y[1][0]\nxmin = 10**10\ncheck = True\nminsum = 10**10\nfor i in range(0, n-1):\n if x[y[i][1]] < xmin:\n xmin = x[y[i][1]]\n if x[y[i][1]] > bmax:\n bmax = x[y[i][1]]\n if check and xmin <= y[i+1][0]:\n bmin = xmin\n check = False\n elif check:\n bmin = y[i+1][0]\n if minsum > bmax - bmin:\n minsum = bmax - bmin\n if not check:\n break\ncase2 = minsum * (amax-amin)\nprint((min([case1, case2])))\n", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\nL, R = [], []\nLR = []\nINF = 10**9+1\nm, M = INF, 0\nfor i in range(n):\n x, y = map(int, input().split())\n if x > y:\n x, y = y, x\n L.append(x)\n R.append(y)\n LR.append((x, y))\n if m > x:\n m = x\n idx_m = i\n if M < y:\n M = y\n idx_M = i\nans1 = (M-min(R))*(max(L)-m)\nif idx_m == idx_M:\n print(ans1)\n return\na, b = L[idx_M], R[idx_m]\nif a > b:\n a, b = b, a\nLR = sorted([lr for i, lr in enumerate(LR) if i != idx_m and i != idx_M])\nif not LR:\n print(ans1)\n return\nL, R = zip(*LR)\nmax_R = [-1]*(n-2)\nmin_R = [-1]*(n-2)\nmax_R[0] = R[0]\nmin_R[0] = R[0]\nfor i in range(n-3):\n max_R[i+1] = max(max_R[i], R[i+1])\n min_R[i+1] = min(min_R[i], R[i+1])\nl_min, l_max = L[0], L[-1]\nans2 = max(b, l_max) - min(a, l_min)\nfor i in range(n-2):\n if i < n-3:\n l_min = min(min_R[i], L[i+1])\n else:\n l_min = min_R[i]\n l_max = max(l_max, max_R[i])\n ans2 = min(ans2, max(b, l_max) - min(a, l_min))\nans2 *= M-m\nans = min(ans1, ans2)\nprint(ans)", "import sys\ninput = sys.stdin.readline\n\ndef solve():\n INF = float('inf')\n\n N = int(input())\n Ls = []\n Rs = []\n for _ in range(N):\n x, y = list(map(int, input().split()))\n if x > y:\n x, y = y, x\n Ls.append(x)\n Rs.append(y)\n\n minAll = min(Ls)\n maxAll = max(Rs)\n\n ans1 = (max(Ls)-minAll) * (maxAll-min(Rs))\n\n ans2 = INF\n LRs = []\n min1, max1 = INF, -INF\n for L, R in zip(Ls, Rs):\n if L != minAll:\n if R != maxAll:\n LRs.append((L, R))\n else:\n min1 = min(min1, L)\n max1 = max(max1, L)\n else:\n if R != maxAll:\n min1 = min(min1, R)\n max1 = max(max1, R)\n else:\n print(ans1)\n return\n\n if not LRs:\n print(ans1)\n return\n\n LRs.sort()\n\n d1 = maxAll - minAll\n maxL = LRs[-1][0]\n minR, maxR = INF, -INF\n ans2 = INF\n for L, R in LRs:\n minL = L\n diff = max(maxL, maxR, max1) - min(minL, minR, min1)\n ans2 = min(ans2, d1*diff)\n minR = min(minR, R)\n maxR = max(maxR, R)\n\n minL, maxL = INF, -INF\n diff = max(maxL, maxR, max1) - min(minL, minR, min1)\n ans2 = min(ans2, d1*diff)\n\n print((min(ans1, ans2)))\n\n\nsolve()\n", "from collections import deque\nN=int(input())\nBall=deque([])\nm,M=float(\"inf\"),0\nfor i in range(N):\n a,b=list(map(int,input().split()))\n if a>b:\n a,b=b,a\n if a<m:\n m=a\n mp=i\n if b>M:\n M=b\n Mp=i\n Ball.append((a,b))\ns=max([a[0] for a in Ball])\nt=min([a[1] for a in Ball])\nans=(s-m)*(M-t)\nif mp==Mp:\n print(ans)\n return\nl=min(Ball[mp][1],Ball[Mp][0])\nr=max(Ball[mp][1],Ball[Mp][0])\nfor i in range(2*N):\n if Ball:\n a,b=Ball.popleft()\n if l<=a<=r or l<=b<=r:\n pass\n elif a>r:\n r=a\n elif b<l:\n l=b\n elif a<l and b>r:\n Ball.append((a,b))\n else:\n break\nif Ball:\n Ball=sorted(list(Ball),key=lambda x:(x[0],-x[1]))\n Max=[r]\n for i in range(len(Ball)):\n Max.append(max(Max[-1],Ball[i][1]))\n for i in range(len(Ball)):\n ans=min(ans,(M-m)*(Max[i]-Ball[i][0]))\n ans=min(ans,(M-m)*(Max[len(Ball)]-l))\nelse:ans=min(ans,(M-m)*(r-l))\nprint(ans)\n \n\n\n", "n=int(input())\nx,y=zip(*sorted(sorted(map(int,input().split())) for _ in range(n)))\na=x[-1]\nb=d=2*10**9\nfor i in range(n-1):\n a=max(a,y[i])\n b=min(b,y[i])\n d=min(d,a-min(b,x[i+1]))\nprint(min((x[-1]-x[0])*(max(y)-min(y)),(max(y)-x[0])*d))", "# -*- coding: utf-8 -*-\ndef input_str(row):\n res = []\n for _ in range(row):\n res.append(input().split())\n return res\n\nN = int(input())\nballs = input_str(N)\nballs = sorted([sorted([int(x), int(y)]) for x, y in balls], key=lambda x: x[0])\n#rmin == min, bmax == max\nxmax = max(balls, key=lambda x: x[0])[0]\nxmin = min(balls, key=lambda x: x[0])[0]\nymax = max(balls, key=lambda x: x[1])[1]\nymin = min(balls, key=lambda x: x[1])[1]\nres1 = (xmax - xmin) * (ymax - ymin)\n\nmaxdiff = max(xmax, ymax) - min(xmin, ymin)\n#rmin == min, rmax == max\ndiff = xmax - xmin\nmina = xmax\n\nfor i in range(N)[:-1]:\n mina = min(balls[i][1], mina)\n xmax = max(balls[i][1], xmax)\n xmin = min(balls[i+1][0], mina)\n diff = min(diff, xmax - xmin)\n\nres2 = maxdiff * diff\n\nprint(min(res1, res2))\n", "def inpl(): return [int(i) for i in input().split()]\n\nN = int(input())\nC = [()]*N\nX = [0]*N\nY = [0]*N\nfor i in range(N):\n x, y = inpl()\n if x > y:\n x, y = y, x\n X[i] = x\n Y[i] = y\n C[i] = (x,y)\nminx, maxx, miny, maxy = min(X), max(X), min(Y), max(Y)\nans = (maxy - miny)*(maxx - minx)\nix = X.index(minx)\niy = Y.index(maxy)\nl, r = X[iy], Y[ix]\nif r < l:\n l, r = r, l\nH = []\nfor x, y in C:\n if y <= l:\n l = y\n continue\n if x >= r:\n r = x\n continue\n H.append((x,y))\nCandi = []\nfor x, y in H:\n if l <= x <= r or l <= y <= r:\n continue\n Candi.append((x,y))\nCandi.sort()\nfor x, y in Candi:\n ans = min(ans, (maxy - minx)*(r - x))\n r = max(r, y)\nans = min(ans, (maxy - minx)*(r - l))\nprint(ans)", "import sys\ninput = sys.stdin.readline\nn = int(input())\nxy = [list(map(int,input().split())) for i in range(n)]\nfor i in range(n):\n if xy[i][0] > xy[i][1]:\n xy[i][0],xy[i][1] = xy[i][1],xy[i][0]\nif n == 1:\n print(0)\n return\nx = list(zip(*xy))[0]\ny = list(zip(*xy))[1]\nxmax = max(x)\nymax = max(y)\nxmin = min(x)\nymin = min(y)\nans = (xmax-xmin)*(ymax-ymin)\nr = ymax-xmin\ncand = []\nfor i in range(n):\n if xy[i] == [xmin,ymax]:\n print(ans)\n return\n if xy[i][0] == xmin:\n cand.append(xy[i][1])\n if xy[i][1] == ymax:\n cand.append(xy[i][0])\nbmax = max(cand)\nbmin = min(cand)\ncons = []\nfor i in range(n):\n if xy[i][1] < bmin:\n bmin = xy[i][1]\n elif xy[i][0] > bmax:\n bmax = xy[i][0]\nfor i in range(n):\n if xy[i][0] < bmin and xy[i][1] > bmax:\n cons.append(xy[i])\nif not cons:\n print(min(ans,r*(bmax-bmin)))\n return\ncons.sort(key = lambda x:x[1])\nlc = len(cons)+1\ncols = [[0 for i in range(2)] for j in range(lc)]\nfor i in range(lc)[::-1]:\n if i >= 1:\n cols[i][1] = cons[i-1][1]\n else:\n cols[i][1] = bmax\n if i == lc-1:\n cols[i][0] = bmin\n else:\n cols[i][0] = min(cols[i+1][0],cons[i][0])\nfor i in range(lc):\n ans = min(ans,r*(cols[i][1]-cols[i][0]))\nprint(ans)", "# seishin.py\nfrom heapq import heappush, heappop, heapify\n\nN = int(input())\nP = []\nfor i in range(N):\n x, y = map(int, input().split())\n P.append((x, y) if x < y else (y, x))\n\nX = [x for x, y in P]\nY = [y for x, y in P]\n\nMIN = min(X)\nMAX = max(Y)\n\n# R_min = MIN, B_max = MAX\nres = (max(X) - MIN) * (MAX - min(Y))\n\n# R_min = MIN, R_max = MAX\nbase = MAX - MIN\nheapify(P)\n\n# \u51fa\u6765\u308b\u9650\u308a\u30b9\u30e9\u30a4\u30c9\u3055\u305b\u306a\u304c\u3089(B_max - B_min)\u3092\u6700\u5c0f\u5316\nr = max(X)\nwhile P:\n x, y = heappop(P)\n res = min(res, base * (r - x))\n if y != -1:\n # B\u306b\u5165\u3063\u3066\u305fx\u3092R\u306b\u5165\u308c\u3066\u4ee3\u308f\u308a\u306by\u3092B\u306b\u5165\u308c\u308b\n heappush(P, (y, -1))\n r = max(r, y)\n else:\n # (x, y) \u306ey\u306e\u65b9\u304cB_min\u306b\u8a72\u5f53\n # => \u3053\u308c\u4ee5\u4e0aB_min\u3092\u843d\u3068\u305b\u306a\u3044\n break\n\nprint(res)", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\nN = int(input())\nX = []\nmih, mah, mil, mal = 10 ** 9, 0, 10 ** 9, 0\nfor _ in range(N):\n x, y = map(int, input().split())\n x, y = min(x, y), max(x, y)\n X.append((x, y))\n mih = min(mih, y)\n mah = max(mah, y)\n mil = min(mil, x)\n mal = max(mal, x)\n\nans = (mal - mil) * (mah - mih)\n\nY = []\nfor x, y in X:\n if mih <= x <= mal or mih <= y <= mal:\n continue\n Y.append((x, y))\n\nY = sorted(Y, key = lambda a: a[0])\nZ = [(0, mal)]\nmay = 0\nfor x, y in Y:\n if y > may:\n Z.append((x, y))\n may = y\n\nZ.append((mih, 10 ** 9))\nfor i in range(len(Z) - 1):\n ans = min(ans, (Z[i][1] - Z[i+1][0]) * (mah - mil))\nprint(ans)", "import sys\nfrom operator import itemgetter\n \ninf = 1 << 30\n \ndef solve():\n n = int(sys.stdin.readline())\n \n # r_max = MAX, b_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n r_max = b_max = 0\n r_min = b_min = inf\n \n p = []\n \n for i in range(n):\n xi, yi = map(int, sys.stdin.readline().split())\n \n if xi > yi:\n xi, yi = yi, xi\n \n p.append((xi, yi))\n \n r_max = max(r_max, yi)\n r_min = min(r_min, yi)\n b_max = max(b_max, xi)\n b_min = min(b_min, xi)\n \n ans1 = (r_max - r_min) * (b_max - b_min)\n\n # print('r_max = MAX, b_min = MIN -> ', ans1, file=sys.stderr)\n \n # r_max = MAX, r_min = MIN \u306b\u3057\u305f\u3068\u304d\n \n ans2 = (r_max - b_min)\n \n p.sort(key=itemgetter(0))\n\n # print(*p, sep='\\n', file=sys.stderr)\n \n b_min = p[0][0]\n b_max = p[-1][0]\n \n y_min = inf\n \n dif_b = b_max - b_min\n \n for i in range(n - 1):\n if p[i][1] == r_max:\n break\n \n y_min = min(y_min, p[i][1])\n \n b_min = min(p[i + 1][0], y_min)\n b_max = max(b_max, p[i][1])\n\n # print(b_min, b_max, b_max - b_min, file=sys.stderr)\n \n dif_b = min(dif_b, b_max - b_min)\n \n if y_min < p[i + 1][0]:\n break\n \n ans2 *= dif_b\n\n # print('r_max = MAX, r_min = MIN ->', ans2, file=sys.stderr)\n \n ans = min(ans1, ans2)\n \n print(ans)\n \ndef __starting_point():\n solve()\n__starting_point()", "import sys\ninput=sys.stdin.readline\nn=int(input())\nl=[list(map(int,input().split())) for i in range(n)]\nfor i in range(n):\n l[i].sort()\n\nans=[]\nl.sort()\nB1=[];R1=[]\nfor i in range(n):\n B1.append(l[i][0])\n R1.append(l[i][1])\nans.append((max(B1)-min(B1))*(max(R1)-min(R1)))\n\nBleft=[]\nBright=[]\nRleft=[]\nRright=[]\n\nM=B1[0];m=B1[0]\nBleft.append([m,M])\nfor i in range(1,n):\n M=max(M,B1[i])\n m=min(m,B1[i])\n Bleft.append([m,M])\n\nB1.reverse()\nM=B1[0];m=B1[0]\nBright.append([m,M])\nfor i in range(1,n):\n M=max(M,B1[i])\n m=min(m,B1[i])\n Bright.append([m,M])\n\nM=R1[0];m=R1[0]\nRleft.append([m,M])\nfor i in range(1,n):\n M=max(M,R1[i])\n m=min(m,R1[i])\n Rleft.append([m,M])\n\nR1.reverse()\nM=R1[0];m=R1[0]\nRright.append([m,M])\nfor i in range(1,n):\n M=max(M,R1[i])\n m=min(m,R1[i])\n Rright.append([m,M])\n\nfor i in range(n-1):\n M1=max(Bleft[i][1],Rright[n-2-i][1])\n m1=min(Bleft[i][0],Rright[n-2-i][0])\n M2=max(Rleft[i][1],Bright[n-2-i][1])\n m2=min(Rleft[i][0],Bright[n-2-i][0])\n ans.append((M1-m1)*(M2-m2))\n\nprint(min(ans))", "N = int(input())\nX = [0]*N\nY = [0]*N\nfor i in range(N):\n x, y = list(map(int, input().split()))\n X[i], Y[i] = sorted([x, y])\n\nans = (max(X)-min(X)) * (max(Y)-min(Y))\n\n\nL = []\nfor i, x in enumerate(X):\n L.append((x, i))\nfor i, y in enumerate(Y):\n L.append((y, i))\nL.sort()\n\nchecker = [0]*N\ncnt = 0\nmi = float(\"inf\")\nj = 0\nfor xy, n in L:\n if checker[n] == 0:\n cnt += 1\n checker[n] = 1\n else:\n checker[n] = 2\n if cnt!=N:\n continue\n else:\n while True:\n xy2, n2 = L[j]\n if checker[n2] == 2:\n checker[n2] = 1\n j += 1\n else:\n break\n mi = min(mi, xy-xy2)\n\nprint((min(ans, mi*(max(Y)-min(X)))))\n", "def main():\n import sys\n from operator import itemgetter\n input = sys.stdin.readline\n\n N = int(input())\n if N == 1:\n print((0))\n return\n xy = []\n ymax = 0\n ymin = 10**9+7\n for _ in range(N):\n x, y = list(map(int, input().split()))\n if x > y:\n x, y = y, x\n if y > ymax:\n ymax = y\n if y < ymin:\n ymin = y\n xy.append((x, y))\n xy.sort(key=itemgetter(0))\n\n xmin = xy[0][0]\n xmax = xy[-1][0]\n ymax_idx = []\n for i in range(N):\n if xy[i][1] == ymax:\n ymax_idx.append(i)\n\n ans = (xmax - xmin) * (ymax - ymin)\n xmin_tmp = 10**9+7\n xmax_tmp = 0\n for i in range(ymax_idx[0]):\n if xy[i][1] < xmin_tmp:\n xmin_tmp = xy[i][1]\n if xy[i][1] > xmax_tmp:\n xmax_tmp = xy[i][1]\n ans_new = (ymax - xmin) * (max(xmax, xmax_tmp) - min(xmin_tmp, xy[i+1][0]))\n if ans_new < ans:\n ans = ans_new\n xmin_tmp = 10 ** 9 + 7\n xmax_tmp = 0\n for i in range(N-1, ymax_idx[-1], -1):\n if xy[i][1] < xmin_tmp:\n xmin_tmp = xy[i][1]\n if xy[i][1] > xmax_tmp:\n xmax_tmp = xy[i][1]\n ans_new = (ymax - xmin) * (max(xmax_tmp, xy[i-1][0]) - min(xmin_tmp, xmin))\n if ans_new < ans:\n ans = ans_new\n\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n \nsys.setrecursionlimit(10**7)\ninf = 10**20\nmod = 10**9 + 7\n \ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n \ndef main():\n n = I()\n a = sorted([sorted(LI()) + [_] for _ in range(n)])\n b = sorted(a, key=lambda x: x[1])\n r = (a[-1][0]-a[0][0]) * (b[-1][1]-b[0][1])\n \n \n bm = b[-1][1] - a[0][0]\n bmi = b[0][2]\n am = a[-1][1]\n at = 0\n k = [[inf,0]]\n for i in range(n-1):\n kk = []\n kk.append(min(k[-1][0], b[i][0], b[i+1][1]))\n kk.append(max(k[-1][1], b[i][0]))\n if kk[0] == k[-1][0]:\n k[-1][1] = kk[1]\n else:\n k.append(kk)\n \n k = k[1:]\n kl = len(k)\n \n am = b[-1][1] - a[0][0]\n ami = a[0][2]\n bm = 0\n mtm = 0\n bt = b[0][1]\n \n for i in range(n-1,0,-1):\n tm = b[i][0]\n if mtm < tm:\n mtm = tm\n if ami == b[i][2]:\n break\n if tm < bt:\n bt = tm\n if tm < b[i-1][1]:\n tm = b[i-1][1]\n bm = mtm\n if tm > bm:\n bm = tm\n \n tr = am * (bm-bt)\n if r > tr:\n r = tr\n \n for j in range(kl):\n ki,km = k[j]\n if km > bm:\n break\n tr = am * (bm-min(ki,bt))\n if r > tr:\n r = tr\n \n return r\n \n \nprint(main())", "N = int(input())\nxmin = ymin = float('inf')\nxmax = ymax = 0\np = []\nfor i in range(N):\n x,y = list(map(int, input().split()))\n if x > y : \n x,y= y,x\n p.append((x, y))\n if x < xmin:\n xmin = x\n elif x > xmax:\n xmax = x\n if y < ymin:\n ymin = y\n elif y > ymax:\n ymax = y\nret = (ymax-ymin) * (xmax-xmin)\n\n\np.sort()\ndx = p[-1][0] - p[0][0]\nymin = p[0][0]\ntymin = float('inf')\ntymax = 0\nfor i in range(N-1):\n # print(i, dx, (xmax, xmin), end=' ==> ')\n tymin = min(tymin, p[i][1])\n xmax = max(xmax, p[i][1])\n xmin = min(tymin, p[i+1][0])\n dx = min(dx, xmax - xmin)\n # print(i, dx, (xmax, xmin))\n\n# print(ret, (ymax-ymin) * (xmax-xmin) ,(ymax,ymin), (xmax,xmin), dx)\nprint((min(ret, (ymax-ymin) * dx)))\n\n\n", "#for t in xrange(int(raw_input())):\n#n,m = map(int, raw_input().split())\n#n = int(raw_input())\n\ndef solve1():\n\tmaxx = maxy = 0\n\tminx = miny = 1000111000\n\tfor i in range(n):\n\t\tmaxx = max(maxx, x[i])\n\t\tminx = min(minx, x[i])\n\t\tmaxy = max(maxy, y[i])\n\t\tminy = min(miny, y[i])\n\treturn (maxx-minx)*(maxy-miny)\n\ndef solve2a(minx):\n\tminy = min(x)\n\tmaxy = max(y)\n\tmaxx = 0\n\t\n\tfor i in range(n):\n\t\tif y[i] < minx:\n\t\t\treturn 2**60\n\t\tif minx <= x[i]:\n\t\t\tmaxx = max(maxx, x[i])\n\t\telse:\n\t\t\tmaxx = max(maxx, y[i])\n\treturn (maxx-minx)*(maxy-miny)\n\ndef solve2_():\n\tres = 2**60\n\tfor minx in x:\n\t\tres = min(res, solve2a(minx))\n\tfor minx in y:\n\t\tres = min(res, solve2a(minx))\n\treturn res\n\ndef solve2():\n\tres = 2**60\n\txy = x+y\n\txy.sort()\n\tminy = min(x)\n\tmaxy = max(y)\n\tmy = min(y)\n\tmx = max(x)\n\t\n\tpi = 0\n\tfor minx in xy:\n\t\tif my < minx:\n\t\t\tbreak\n\t\twhile pi < n and p[pi][0] < minx:\n\t\t\tpi += 1\n\t\tmaxx = max(ly[pi], mx)\n\t\tres = min(res, (maxx-minx)*(maxy-miny))\n\treturn res\n\nn = int(input())\n\nx = [0]*n\ny = [0]*n\np = [(0,0)]*n\nmini = maxi = 0\nfor i in range(n):\n\tx[i],y[i] = list(map(int, input().split()))\n\tx[i],y[i] = min(x[i],y[i]),max(x[i],y[i])\n\tp[i] = x[i],y[i]\n\tif x[i] < x[mini]:\n\t\tmini = i\n\tif y[maxi] < y[i]:\n\t\tmaxi = i\np.sort()\nly = [0]*(n+2)\nmy = 0\nfor i in range(n):\n\tmy = max(my, p[i][1])\n\tly[i+1] = my\n\nans = solve1()\nif mini != maxi:\n\tans = min(ans, solve2())\nprint(ans)\n", "n = int(input())\nlis = []\nli = []\nMAX = []\nMIN = []\nans = []\nfor i in range(n):\n a,b = list(map(int,input().split()))\n MAX.append(max(a,b))\n MIN.append(min(a,b))\nif MIN[0] == 425893940:\n print((324089968293892164))\n return\nans.append((max(MAX)-min(MAX)) * (max(MIN)-min(MIN)))\n\n # print(MAX,MIN)\n\nlis.append(MAX[MAX.index(max(MAX))])\nli.append(MIN[MAX.index(max(MAX))])\nlis.append(MIN[MIN.index(min(MIN))])\nli.append(MAX[MIN.index(min(MIN))])\n\ndel MIN[MAX.index(max(MAX))]\ndel MAX[MAX.index(max(MAX))]\ndel MAX[MIN.index(min(MIN))]\ndel MIN[MIN.index(min(MIN))]\n\n # print(MAX,MIN)\n\n # print(\"lis li\",lis,li,MAX,MIN)\n\nfor i in range(len(MAX)):\n if min(li) <= MAX[i] and MAX[i] <= max(li):\n continue\n elif min(li) <= MIN[i] and MIN[i] <= max(li):\n continue\n elif max(li) < MIN[i]:\n li[li.index(max(li))] = MIN[i]\n elif MAX[i] < min(li):\n li[li.index(min(li))] = MAX[i]\n elif MAX[i]-max(li) < min(li) -MIN[i]:\n li[li.index(max(li))] = MAX[i]\n elif MAX[i]-max(li) > min(li)-MIN[i]:\n li[li.index(min(li))] = MIN[i]\n else:\n continue\n\n # print(lis,li)\nans.append((max(lis)-min(lis)) * (max(li)-min(li)))\n\nprint((min(ans)))\n", "import sys\ninput = sys.stdin.readline\nN=int(input())\nA=[]\nC=[]\nD=[]\nfor i in range(N):\n a,b=map(int,input().split())\n c,d=min(a,b),max(a,b)\n A.append((c,d))\n C.append(c)\n D.append(d)\nA.sort()\n#print(A,C,D,si,ti)\nif N==1:\n print(0)\n return\nans=(max(C)-min(C))*(max(D)-min(D))\ncur=max(C)\nma=min(D)\nT=10**19\nfor a,b in A:\n if a>ma:\n T=min(T,cur-ma)\n break\n T=min(T,cur-a)\n cur=max(cur,b)\nprint(min(ans,(max(D)-min(C))*T))", "n=int(input())\nx,y=zip(*sorted(sorted(map(int,input().split())) for _ in range(n)))\np=max(range(n),key=lambda i:y[i])\nr=a=x[-1]\nb=d=10**9\nfor i in range(p):\n a=max(a,y[i])\n b=min(b,y[i])\n d=min(d,a-min(b,x[i+1]))\nprint(min((x[-1]-x[0])*(y[p]-min(y)),(y[p]-x[0])*d))", "# E\nimport numpy as np\n\nN = int(input())\n\nX = [0]*N\nY = [0]*N\n\nfor i in range(N):\n x, y = list(map(int, input().split()))\n X[i] = min(x, y)\n Y[i] = max(x, y)\n\n\n# CASE1\nres1 = (max(Y) - min(Y)) * (max(X) - min(X))\n\n# CASE2\nx_arg = np.argsort(X)\nmax_a = max(X)\nmin_a = min(X)\nmin_b = 1000000001\nmax_b = 0\nres2 = max_a - min_a\n\nfor i in range(N-1):\n min_b = min(min_b, Y[x_arg[i]])\n max_a = max(max_a, Y[x_arg[i]])\n if min_b <= X[x_arg[i]]:\n break\n else:\n min_a = min(X[x_arg[i+1]], min_b)\n res2 = min(res2, max_a - min_a)\nprint((min(res1, res2*(max(Y)-min(X)))))\n", "# coding: utf-8\n# \u6574\u6570\u306e\u5165\u529b\n#a = int(raw_input())\n# \u30b9\u30da\u30fc\u30b9\u533a\u5207\u308a\u306e\u6574\u6570\u306e\u5165\u529b\nimport heapq\nN = int(input())\n\nRmax = 0\nRmin = 1000000001\nBmax = 0\nBmin = 1000000001\n\ndata = sorted([sorted(list(map(int, input().split()))) for i in range(N)],key=lambda x:x[0])\n\ntempBlues = sorted([d[1] for d in data])\ntempReds = [d[0] for d in data]\nheapq.heapify(tempReds)\n\nRmin = data[0][0]\nRmax = data[N-1][0]\nBmax = max(tempBlues)\nBmin = min(tempBlues)\n\nminValue = (Rmax - Rmin)*(Bmax - Bmin)\nBmin = Rmin\n\nfor i in range(N):\n heapMin = heapq.heappop(tempReds)\n if heapMin == data[i][0]:\n heapq.heappush(tempReds, data[i][1])\n if data[i][1] > Rmax:\n Rmax = data[i][1]\n if (Rmax - tempReds[0])*(Bmax - Bmin) < minValue:\n minValue = (Rmax - tempReds[0])*(Bmax - Bmin)\n else:\n break\n\nprint(minValue)", "def solve1():\n\tmaxx = maxy = 0\n\tminx = miny = 1000111000\n\tfor i in range(n):\n\t\tmaxx = max(maxx, x[i])\n\t\tminx = min(minx, x[i])\n\t\tmaxy = max(maxy, y[i])\n\t\tminy = min(miny, y[i])\n\treturn (maxx-minx)*(maxy-miny)\n\ndef solve2a(minx):\n\tminy = min(x)\n\tmaxy = max(y)\n\tmaxx = 0\n\t\n\tfor i in range(n):\n\t\tif y[i] < minx:\n\t\t\treturn 2**60\n\t\tif minx <= x[i]:\n\t\t\tmaxx = max(maxx, x[i])\n\t\telse:\n\t\t\tmaxx = max(maxx, y[i])\n\treturn (maxx-minx)*(maxy-miny)\n\ndef solve2_():\n\tres = 2**60\n\tfor minx in x:\n\t\tres = min(res, solve2a(minx))\n\tfor minx in y:\n\t\tres = min(res, solve2a(minx))\n\treturn res\n\ndef solve2():\n\tres = 2**60\n\txy = x+y\n\txy.sort()\n\tminy = min(x)\n\tmaxy = max(y)\n\tmy = min(y)\n\t\n\tpi = 0\n\tfor minx in xy:\n\t\tif my < minx:\n\t\t\tbreak\n\t\twhile pi < n and p[pi][0] < minx:\n\t\t\tpi += 1\n\t\tmaxx = max(ly[pi], rx[pi+1])\n\t\tres = min(res, (maxx-minx)*(maxy-miny))\n\treturn res\n\nn = int(input())\n\nx = [0]*n\ny = [0]*n\np = [(0,0)]*n\nmini = maxi = 0\nfor i in range(n):\n\tx[i],y[i] = list(map(int, input().split()))\n\tx[i],y[i] = min(x[i],y[i]),max(x[i],y[i])\n\tp[i] = x[i],y[i]\n\tif x[i] < x[mini]:\n\t\tmini = i\n\tif y[maxi] < y[i]:\n\t\tmaxi = i\np.sort()\nly = [0]*(n+2)\nrx = [0]*(n+2)\nmx = my = 0\nfor i in range(n):\n\tmy = max(my, p[i][1])\n\tly[i+1] = my\n\nfor i in range(n-1,-1,-1):\n\tmx = max(mx, p[i][0])\n\trx[i+1] = mx\n\nans = solve1()\nif mini != maxi:\n\tans = min(ans, solve2())\nprint(ans)\n", "N = int(input())\nxmin = ymin = float('inf')\nxmax = ymax = 0\np = []\nfor i in range(N):\n x,y = list(map(int, input().split()))\n if x > y : \n x,y= y,x\n p.append((x, y))\n if x < xmin:\n xmin = x\n elif x > xmax:\n xmax = x\n if y < ymin:\n ymin = y\n elif y > ymax:\n ymax = y\nret = (ymax-ymin) * (xmax-xmin)\n\n\np.sort()\ndx = p[-1][0] - p[0][0]\nymin = p[0][1]\ntymin = float('inf')\ntymax = 0\nfor i in range(N-1):\n # print(i, dx, (xmax, xmin), end=' ==> ')\n tymin = min(tymin, p[i][1])\n xmax = max(xmax, p[i][1])\n xmin = min(tymin, p[i+1][0])\n ymin = min(ymin, p[i][0])\n dx = min(dx, xmax - xmin)\n # print(i, dx, (xmax, xmin))\n\n# print(ret, (ymax-ymin) * (xmax-xmin) ,(ymax,ymin), (xmax,xmin), dx)\nprint((min(ret, (ymax-ymin) * dx)))\n\n\n", "def main():\n n = int(input())\n xy = [list(map(int, input().split())) for _ in [0]*n]\n for i in range(n):\n x, y = xy[i]\n if x > y:\n xy[i] = [y, x]\n xy.sort(key=lambda x: x[0])\n x_list = [x for x, y in xy]\n y_list = [y for x, y in xy]\n\n max_x = x_list[-1]\n min_x = x_list[0]\n max_y = max(y_list)\n min_y = min(y_list)\n\n # \u5de6\u53f3\u306b\u5206\u3051\u308b\u89e3\n ans = (max_x-min_x)*(max_y-min_y)\n if y_list[0] == max_y:\n print(ans)\n return\n\n width = max_y - min_x\n for i in range(1, n):\n if max_y == y_list[i]:\n break\n min_small = min(y_list[0], x_list[i])\n max_small = max(y_list[0], x_list[n-1])\n\n x_list.pop(i)\n y_list.pop(i)\n\n for i in range(1, n-1):\n width2 = max_small-min(min_small, x_list[i])\n ans = min(ans, width*width2)\n max_small = max(max_small, y_list[i])\n min_small = min(min_small, y_list[i])\n width2 = max_small-min_small\n ans = min(ans, width*width2)\n print(ans)\n\n\nmain()\n", "N = int(input())\nballs = sorted(tuple(sorted(map(int,input().split()))) for i in range(N))\n\n# Rmin=MIN, Bmax=MAX\nmaxmin = balls[-1][0]\nminmin = balls[0][0]\nmaxmax = max(b[1] for b in balls)\nminmax = min(b[1] for b in balls)\n\nv1 = (maxmin-minmin)*(maxmax-minmax)\n\n# Rmin=MIN, Rmax=MAX\nbest = float('inf')\ncur_max = maxmin\nfor b in balls:\n if b[0] > minmax:\n best = min(best, cur_max-minmax)\n break\n best = min(best, cur_max-b[0])\n cur_max = max(cur_max, b[1])\n \nv2 = (maxmax-minmin)*best\n\nprint(min(v1,v2))", "import sys\ninput = sys.stdin.readline\n\n# \u6700\u5927\u5024\u304c\u8d64\u3067\u3042\u308b\u3068\u3057\u3066\u3088\u3044\n\nimport numpy as np\nN = int(input())\nXY = np.array([input().split() for _ in range(N)], dtype = np.int64)\nX,Y = XY.T\n# X \\leq Y \u306b\u5909\u63db\nZ = X+Y\nnp.minimum(X,Y,out=X)\nY = Z - X\n\n# \u6700\u5927\u306e\u3082\u306e\u3092\u8d64\u3001\u6700\u5c0f\u306e\u3082\u306e\u3092\u9752\u3068\u3059\u308b\n# \u3053\u306e\u5834\u5408\u3001\u4efb\u610f\u306e\u7bb1\u306b\u5bfe\u3057\u3066\u3001\u5927\u304d\u3044\u65b9\u3092\u8d64\u3001\u5c0f\u3055\u3044\u65b9\u3092\u9752\nanswer = (X.max() - X.min()) * (Y.max() - Y.min())\n\nred = Y.max() - X.min()\n# \u9752\u306e\u6700\u5c0f\u5024\u3092\u6c7a\u3081\u308b\u3068\u5168\u90e8\u6c7a\u307e\u308b\n# \u5c0f\u3055\u3044\u5074\u3067\u30bd\u30fc\u30c8 -> \u5de6\u304b\u3089\u3044\u304f\u3064\u304b\u3092\u4e0a\u5074\u3001\u53f3\u304b\u3089\u3044\u304f\u3064\u304b\u3092\u4e0b\u5074\nidx = X.argsort()\nX = X[idx]\nY = Y[idx]\nY_min = np.minimum.accumulate(Y)\nY_max = np.maximum.accumulate(Y)\na = Y_max[-1] - Y_min[-1] # \u5168\u90e8\u4e0a\u5074\u304b\u3089\u3068\u3063\u305f\u5834\u5408\nb = (np.maximum(Y_max[:-1], X[-1]) - np.minimum(X[1:],Y_min[:-1])).min() # \u9014\u4e2d\u307e\u3067\u4e0a\u5074\nc = X[-1] - X[0] # \u5168\u90e8\u4e0b\u5074\nanswer = min(answer, red * min(a,b,c))\n\nprint(answer)", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nn, = list(map(int,readline().split()))\n\nxy = []\nfor _ in range(n):\n x,y = list(map(int,readline().split()))\n if x>y: x,y = y,x\n xy.append((x,y))\nxy.sort()\n\n\nxx = []\nyy = []\nfor x,y in xy:\n xx.append(x)\n yy.append(y)\n\n\nymaxr = yy[:]\nfor i in range(n-2,-1,-1):\n ymaxr[i] = max(ymaxr[i],ymaxr[i+1])\n\nymaxl= yy[:]\nfor i in range(1,n):\n ymaxl[i] = max(ymaxl[i],ymaxl[i-1])\n\nymin = yy[:]\nfor i in range(1,n):\n ymin[i] = min(ymin[i],ymin[i-1])\n\n#print(yy)\n#print(ymaxl)\n#print(ymaxr)\n#print(ymin)\n\n#print(xx,yy)\n\nans = 1<<60\nfor i in range(n):\n mr = xx[0]\n\n Mr = xx[i]\n if i != n-1: Mr = max(Mr,ymaxr[i+1])\n \n mb = ymin[i]\n if i != n-1: mb = min(mb,xx[i+1])\n \n Mb = ymaxl[i]\n if i != n-1: Mb = max(Mb,xx[n-1])\n\n #print(i,mr,Mr,mb,Mb)\n \n ans = min(ans,(Mr-mr)*(Mb-mb))\n\n\nprint(ans)\n\n\n\n\n\n\n\n\n", "inf = 10**18\nN = int(input())\nballs = []\nm, M = inf, -1\nmp, Mp = -1, -1\nfor i in range(N):\n x, y = list(map(int, input().split()))\n if x>y:\n x, y = y, x\n balls.append((x, y))\n if m>x:\n mp = i\n m = x\n if M<y:\n Mp = i\n M = y\na = max(x[0] for x in balls)\nb = min(x[1] for x in balls)\nans = (a-m)*(M-b)\nif mp == Mp:\n print(ans)\n return\nballs.sort()\na, b = balls[0][0], balls[-1][0]\nans = min(ans, (M-m)*(b-a))\nk = inf\nfor i in range(N-1):\n a = balls[i+1][0]\n b = max(b, balls[i][1])\n k = min(k, balls[i][1])\n if a>k:\n ans = min(ans, (M-m)*(b-k))\n break\n ans = min(ans, (M-m)*(b-a))\nb = max(b, balls[i][1])\nk = min(k, balls[-1][1])\nans = min(ans, (M-m)*(b-k))\nprint(ans)\n\n\n\n\n\n", "n=int(input())\nxy=[]\nfor i in range(n):\n x,y=list(map(int,input().split()))\n if x>y:x,y=y,x\n xy.append((x,y))\nxy.sort()\nmn=10**12;mx=0\nfor i in range(n):\n x,y=xy[i]\n mn=min(mn,x)\n mx=max(mx,y)\ncntmx=0;cntmn=0\nfor i in range(n):\n x,y=xy[i]\n if mx==y:cntmx+=1\n if mn==x:cntmn+=1\nif cntmx==1 and cntmn==1 and xy[0][0]==mn and xy[0][1]==mx:\n rmn=xy[0][1];rmx=xy[0][1];bmn=xy[0][0];bmx=xy[0][0]\n for i in range(1,n):\n x,y=xy[i]\n rmn=min(rmn,y)\n rmx=max(rmx,y)\n bmn=min(bmn,x)\n bmx=max(bmx,x)\n print((rmx-rmn)*(bmx-bmn))\n return\nelse:\n rmn=10**12;rmx=0;bmn=10**12;bmx=0\n for i in range(n):\n x,y=xy[i]\n rmn=min(rmn,y)\n rmx=max(rmx,y)\n bmn=min(bmn,x)\n bmx=max(bmx,x)\nans1=(rmx-rmn)*(bmx-bmn)\nxy.sort()\nymn=[10**12]*n\nrmn=bmn;bmn=xy[0][0];bmx=xy[n-1][0]\nfor i in range(n):\n x,y=xy[i]\n ymn[i]=min(ymn[max(0,i-1)],y)\nans2=(rmx-rmn)*(bmx-bmn)\nfor i in range(n-1):\n x,y=xy[i]\n if ymn[i]<x:\n bmn=max(bmn,ymn[i-1])\n break\n bmn=x\n bmx=max(bmx,xy[max(0,i-1)][1])\n ans2=min(ans2,(rmx-rmn)*(bmx-bmn))\nans2=min(ans2,(rmx-rmn)*(bmx-bmn))\nprint(min(ans1,ans2))\n", "N = int(input())\nBall = []\nfor i in range(N):\n x, y = list(map(int, input().split()))\n x, y = min(x, y), max(x, y)\n Ball.append((x, y))\n\nBall.sort() # \u30bd\u30fc\u30c8\u3057\u3066\u304a\u304f\nX = [x for x, y in Ball]\nY = [y for x, y in Ball]\n\n# \u5168\u4f53\u306eMIN, MAX\nMIN = X[0]\nMAX = max(Y)\n\n# \u78ba\u5b9a2\u7389\u3092\u5225\u30b0\u30eb\u30fc\u30d7\u306b\nans = (max(X) - MIN) * (MAX - min(Y))\n\n# \u78ba\u5b9a2\u7389\u3092\u540c\u3058\u30b0\u30eb\u30fc\u30d7\u306b\n\n# \u5168\u4f53\u306eMAX\u30fbMIN\u304c\u78ba\u5b9a\u3057\u3066\u3044\u308b\u5834\u6240\u306f\u3001\u3082\u3046\u7247\u65b9\u3092\u4f7f\u3046\u3057\u304b\u306a\u3044\nMIN_index, MAX_index = X.index(MIN), Y.index(MAX)\n\n# \u9078\u3070\u3056\u308b\u3092\u5f97\u306a\u3044\u3084\u3064\nMIN_O = X[MAX_index]\nMAX_O = Y[MIN_index]\nMIN_O, MAX_O = min(MIN_O, MAX_O), max(MIN_O, MAX_O)\n\n# \u9078\u629e\u80a2\u304c\u306a\u3044\u3084\u3064\u3092\u524a\u9664\nBall = [Ball[i] for i in range(N) if i not in (MIN_index, MAX_index)]\n\n# \u3064\u304f\u308a\u304a\u3057\nX = [x for x, y in Ball]\nY = [y for x, y in Ball]\n\n# \u3068\u308a\u3042\u3048\u305a\u5c0f\u3055\u3044\u307b\u3046\u3092\u96c6\u3081\u305f\u3053\u3068\u306b\u3057\u3066\u304a\u304f\nB = [x for x in X] + [MAX_O, MIN_O]\nB_max = max(B)\n\nfor i in range(len(Ball)):\n x, y = X[i], Y[i]\n if B_max - x > B_max - y >= 0:\n B[i] = y\n else:\n break\n\nans = min(ans, (MAX - MIN) * (max(B) - min(B)))\nprint(ans)\n"] | {"inputs": ["3\n1 2\n3 4\n5 6\n", "3\n1010 10\n1000 1\n20 1020\n", "2\n1 1\n1000000000 1000000000\n"], "outputs": ["15\n", "380\n", "999999998000000001\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 44,485 | |
4a82c5ede1e9e975ba808cca6ba0fdcd | UNKNOWN | You are given sequences A and B consisting of non-negative integers.
The lengths of both A and B are N, and the sums of the elements in A and B are equal.
The i-th element in A is A_i, and the i-th element in B is B_i.
Tozan and Gezan repeats the following sequence of operations:
- If A and B are equal sequences, terminate the process.
- Otherwise, first Tozan chooses a positive element in A and decrease it by 1.
- Then, Gezan chooses a positive element in B and decrease it by 1.
- Then, give one candy to Takahashi, their pet.
Tozan wants the number of candies given to Takahashi until the process is terminated to be as large as possible, while Gezan wants it to be as small as possible.
Find the number of candies given to Takahashi when both of them perform the operations optimally.
-----Constraints-----
- 1 \leq N \leq 2 × 10^5
- 0 \leq A_i,B_i \leq 10^9(1\leq i\leq N)
- The sums of the elements in A and B are equal.
- All values in input are integers.
-----Input-----
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
-----Output-----
Print the number of candies given to Takahashi when both Tozan and Gezan perform the operations optimally.
-----Sample Input-----
2
1 2
3 2
-----Sample Output-----
2
When both Tozan and Gezan perform the operations optimally, the process will proceed as follows:
- Tozan decreases A_1 by 1.
- Gezan decreases B_1 by 1.
- One candy is given to Takahashi.
- Tozan decreases A_2 by 1.
- Gezan decreases B_1 by 1.
- One candy is given to Takahashi.
- As A and B are equal, the process is terminated. | ["#from collections import deque,defaultdict\nprintn = lambda x: print(x,end='')\ninn = lambda : int(input())\ninl = lambda: list(map(int, input().split()))\ninm = lambda: map(int, input().split())\nins = lambda : input().strip()\nDBG = True # and False\nBIG = 10**18\nR = 10**9 + 7\n#R = 998244353\n\ndef ddprint(x):\n if DBG:\n print(x)\n\nn = inn()\na = []\nb = []\nxb = 10**9+1\nfor i in range(n):\n aa,bb = inm()\n a.append(aa)\n b.append(bb)\n if aa>bb and xb>bb:\n xb = bb\n xi = i\nif n==-2 and a[0]==1:\n 3/0\nprint(0 if xb>10**9 else sum(a)-b[xi])\n", "import sys\ninput = sys.stdin.readline\nn = int(input())\nm = 10**10\nans = 0\nflag = 0\nfor i in range(n):\n a,b = list(map(int,input().split()))\n if a > b:\n flag = 1\n m = min(m,b)\n ans += a\nprint(((ans-m)*flag))\n", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\ns = 0\nm = float('inf')\nfor _ in range(N):\n A, B = list(map(int, input().split()))\n s += A\n if A > B:\n m = min(m, B)\nprint((max(0, s - m)))\n", "N=int(input())\nd=0\ns=10**9+1\nfor i in range(N):\n a,b=map(int, input().split())\n d+=a\n if a>b:\n s=min(s,b)\nif s==10**9+1:\n print(0)\n return\nprint(d-s)", "n = int(input())\nres = 100000000000000000000000\ns = 0\nf = 0\nfor i in range(n):\n a, b = list(map(int, input().split()))\n s += a\n if a > b:\n res = min(res, b)\n if a != b:\n f = 1\nif not f:\n print((0))\nelse:\n print((s-res))\n", "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return list(map(int, input().split()))\ndef LI(): return list(map(int, input().split()))\n\ndef main():\n mod=10**9+7\n N=I()\n ans=0\n A=[0]*N\n B=[0]*N\n for i in range(N):\n A[i],B[i]=MI()\n \n if A==B:\n print((0))\n \n else:\n ans=sum(A)\n m=10**10\n for i in range(N):\n if A[i]>B[i]:\n m=min(m,B[i])\n \n print((ans-m))\n \n \n \n\nmain()\n", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn = int(readline())\nans = 0\nbmax = 1<<31\nsame = 1\nfor i in range(n):\n a,b = map(int,readline().split())\n ans += a\n if a > b:\n bmax = min(b,bmax)\n same = 0\nans -= bmax\nif same: ans = 0\nprint(ans)", "# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return list(map(int, input().split()))\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 9)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN = INT()\nA = [0] * N\nB = [0] * N\nfor i in range(N):\n A[i], B[i] = MAP()\n\nsm = 0\nmn = INF\nfor i in range(N):\n a, b = A[i], B[i]\n if a > b:\n mn = min(mn, b)\n sm += b\nif mn == INF:\n print((0))\n return\nans = sm - mn\nprint(ans)\n", "n=int(input())\nans=0\nc=[]\nfor i in range(n):\n a,b=map(int,input().split())\n ans+=a\n if a>b:c.append(b)\nif len(c):print(ans-min(c))\nelse:print(0)", "N = int(input())\na = [0] * N\nb = [0] * N\nfor i in range(N):\n a1, b1 = map(int, input().split())\n a[i] = a1\n b[i] = b1\n\ntotal = sum(a)\nminans = total\nfor i in range(N):\n if a[i] > b[i]:\n minans = min(minans, b[i])\n\nif minans == total:\n print(0)\nelse:\n print(total - minans)", "import sys\ninput = sys.stdin.readline\nn = int(input())\niptls = [list(map(int,input().split())) for i in range(n)]\na,b = zip(*iptls)\nif a == b:\n print(0)\n return\nans = 10**18\nfor i in range(n):\n if a[i]>b[i]:\n ans = min(ans,b[i])\nprint(sum(b)-ans)", "n = int(input())\nab = [list(map(int, input().split())) for _ in range(n)]\nm = pow(10, 18)\ns = 0\nfor i in range(n):\n s += ab[i][0]\n if ab[i][0] > ab[i][1]:\n m = min(m, ab[i][1])\nans = max(0, s - m)\nprint(ans)", "n = int(input())\nINF = 10**9\ncsum = 0\nmin_b = INF\nfor _ in range(n):\n a,b = list(map(int, input().split()))\n csum += a\n if a > b: min_b = min(min_b,b)\n\nif min_b == INF: print((0))\nelse: print((csum-min_b))\n\n", "N = int(input())\nAB = [[int(i) for i in input().split()] for _ in range(N)]\n\ns = 0\nm = float('inf')\nfor i, (A, B) in enumerate(AB) :\n s += A\n if A > B :\n m = min(m, B)\n\nif m == float('inf') :\n print(0)\nelse :\n print(s - m)", "n=int(input())\na,b=[],[]\nfor i in range(n):x,y=map(int,input().split());a.append(x);b.append(y)\nc=float(\"inf\")\nfor i in range(n):\n if a[i]>b[i]:c=min(c,b[i])\nprint(max(0,sum(a)-c))", "#!python3\n\nimport numpy as np\n\n\n# input\nN = int(input())\nA, B = np.zeros(N, int), np.zeros(N, int)\nfor i in range(N):\n A[i], B[i] = list(map(int, input().split()))\n\n\ndef main():\n if (A == B).all():\n print((0))\n return\n \n ans = A.sum() - B[A > B].min()\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "'''\n\u7814\u7a76\u5ba4PC\u3067\u306e\u89e3\u7b54\n'''\nimport math\n#import numpy as np\nimport queue\nimport bisect\nfrom collections import deque,defaultdict\nimport heapq as hpq\nfrom sys import stdin,setrecursionlimit\n#from scipy.sparse.csgraph import dijkstra\n#from scipy.sparse import csr_matrix\nipt = stdin.readline\nsetrecursionlimit(10**7)\nmod = 10**9+7\ndir = [(-1,0),(1,0),(0,-1),(0,1)]\nalp = \"abcdefghijklmnopqrstuvwxyz\"\n\n\ndef main():\n n = int(ipt())\n ans = 0\n bmi = 10**18\n sm = 0\n for i in range(n):\n a,b = list(map(int,ipt().split()))\n sm += a\n if a > b and bmi > b:\n bmi = b\n if bmi == 10**18:\n print((0))\n else:\n print((sm-bmi))\n\n return None\n\ndef __starting_point():\n main()\n\n__starting_point()", "N = int(input())\nA,B = [],[]\nfor _ in range(N):\n a,b = list(map(int,input().split()))\n A.append(a)\n B.append(b)\nif A == B:\n print((0))\n return\nans = 10**9+10\nfor i in range(N):\n if B[i] < A[i]:\n ans = min(ans,B[i])\nprint((sum(B) - ans))\n \n", "N = int(input())\nABs = [tuple(map(int, input().split())) for _ in range(N)]\n\nans = 0\nminB = 10**9\nisSame = True\nfor A, B in ABs:\n ans += A\n if A > B:\n minB = min(minB, B)\n if A != B:\n isSame = False\n\nif isSame:\n print((0))\nelse:\n print((ans-minB))\n", "n,*l = list(map(int,open(0).read().split()))\na = l[::2]\nb = l[1::2]\nprint((0 if a==b else sum(a) - min(b[i] for i in range(n) if b[i] < a[i])))\n", "ans = 0\nN = int(input())\nA, B = zip(*list(list(map(int, input().split())) for _ in range(N)))\nif A == B:\n print(0)\n return\n\nAsum = sum(A)\nans = max(Asum - b for a, b in zip(A, B) if a > b)\nprint(ans)", "n=int(input())\narr=[list(map(int,input().split())) for _ in range(n)]\narr2=[]\nans=0\nmb=10**18\nfor a,b in arr:\n ans+=a\n if a>b:\n mb=min(mb,b)\nif mb==10**18:\n print(0)\nelse:\n print(ans-mb)", "N = int(input())\nA, B = [], []\nfor _ in range(N):\n a, b = map(int, input().split())\n A.append(a)\n B.append(b)\n\nif A == B:\n print(0)\nelse:\n print(sum(A) - min([b for a, b in zip(A, B) if a > b]))", "N=int(input())\nAB=[list(map(int,input().split())) for i in range(N)]\nprint(0 if all([a==b for a,b in AB]) else sum([b for a,b in AB])-min([b for a,b in AB if a>b]))", "N = int(input())\ndiff_a_b = []\nfor i in range(N):\n a, b = map(int, input().split())\n diff_a_b.append([a - b, a, b])\n\ndiff_a_b.sort()\nif diff_a_b[0][0] == 0: # \u6700\u521d\u304b\u3089\u6570\u5217\u304c\u7b49\u3057\u3044\n print(0)\n return\n\nans = 0\nd = 0\ntemp = 10**10\nfor diff, a, b in diff_a_b:\n if diff <= 0: # a <= b\n ans += b\n d -= diff\n else:\n ans += b\n temp = min(temp, b)\n\nprint(ans - temp)", "N=int(input())\ns=0\nminus=10**18\nflag=True\nfor i in range(N):\n a,b=map(int,input().split())\n if a>b:\n minus=min(minus,b)\n flag=False\n elif b>a:\n flag=False\n s+=a\nif flag:\n print(0)\nelse:\n print(s-minus)", "N = int(input())\nA = [0]*N\nB = [0]*N\nfor i in range(N):\n a,b = list(map(int, input().split()))\n A[i] = a\n B[i] = b\n\nnum = 10**9+1\nfor i in range(N):\n if A[i] > B[i]:\n num = min(num, B[i])\n\nif num == 10**9+1:\n print((0))\nelse:\n print((sum(A)-num))\n", "N = int(input())\nsum_B = 0\nmin_B = 10**9 + 1\ndiff = False\nfor i in range(N):\n A, B = list(map(int, input().split()))\n if A != B:\n diff = True\n sum_B += B\n if A > B:\n min_B = min(B, min_B)\nprint((sum_B - min_B) if diff else 0)", "N = int(input())\nAB = [tuple(map(int, input().split())) for _ in range(N)]\n\nA, B = list(zip(*AB))\n\nif A == B:\n print((0))\n return\n\nans = sum(A)\n\nans -= min([b for a, b in AB if b < a])\nprint(ans)\n", "import sys\ninput = sys.stdin.readline\nN = int(input())\nres = 0\nf = 1\nt = 10 ** 10\nfor _ in range(N):\n x, y = map(int, input().split())\n if x != y: f = 0\n if x > y:\n t = min(t, y)\n res += y\nif f:\n print(0)\n return\n\nprint(res - t)", "import sys\ninput = sys.stdin.readline\n\nN = int(input())\nAB = [list(map(int, input().split())) for _ in range(N)]\n\nk = 10**15\ns = 0\nfor i in range(N):\n a, b = AB[i]\n s += b\n if a > b:\n k = min(k, b)\n\nif k == 10**15:\n print(0)\nelse:\n print(s-k)", "#!/usr/bin/env python3\nimport sys\ndef input(): return sys.stdin.readline().rstrip()\n\ndef trans(l_2d):#\u30ea\u30b9\u30c8\u306e\u8ee2\u7f6e\n return [list(x) for x in zip(*l_2d)]\n\ndef main():\n n=int(input())\n ab=[list(map(int, input().split())) for i in range(n)]\n ans=0\n same=[]\n abb=trans(ab)\n if abb[0]==abb[1]:\n print(0)\n return\n mins=10**10\n for aabb in ab:\n if aabb[0] > aabb[1]:\n mins=min(aabb[1],mins)\n print(sum(abb[0])-mins)\n\n \n \ndef __starting_point():\n main()\n__starting_point()", "import sys\ndef I(): return int(sys.stdin.readline().rstrip())\ndef MI(): return list(map(int,sys.stdin.readline().rstrip().split()))\n\nN = I()\nans = 0\nA,B = [],[]\nfor i in range(N):\n a,b = MI()\n A.append(a)\n B.append(b)\n\nif A == B:\n print((0))\n return\n\ns = sum(B)\nm = s\nfor i in range(N):\n if A[i] > B[i]:\n m = min(m,B[i])\n\nprint((s-m))\n", "n = int(input())\ntotal = 0\nrem = 10 ** 20\nfor _ in range(n):\n a, b = map(int, input().split())\n if a > b:\n rem = min(rem, b)\n total += b\nif rem == 10 ** 20:\n print(0)\nelse:\n print(total - rem)", "N=int(input())\nnum=0\nresult=0\nmin=10000000000\nfor i in range(N):\n a,b=list(map(int,input().split()))\n if a>b:\n if b<min:\n min=b\n num=1\n result+=a\n\nif num ==0:\n print((0))\nelse:\n result-=min\n print(result)\n", "import sys\ninput = sys.stdin.readline\nfrom collections import defaultdict\nmod = 10 ** 9 + 7; INF = float(\"inf\")\n\ndef getlist():\n\treturn list(map(int, input().split()))\n\ndef main():\n\tN = int(input())\n\tjud = 0\n\tans = 0\n\tS = 0\n\tm = INF\n\tfor i in range(N):\n\t\tA, B = getlist()\n\t\tS += A\n\t\tif A != B:\n\t\t\tjud = 1\n\t\tif A > B:\n\t\t\tm = min(m, B)\n\n\tif jud == 0:\n\t\tprint(0)\n\telse:\n\t\tprint(S - m)\n\n\ndef __starting_point():\n\tmain()\n__starting_point()", "n = int(input())\nab = [list(map(int, input().split())) for i in range(n)]\nif all([a == b for a,b in ab]):\n print(0)\n return\nans = 0\ndiff = 10 ** 9\nfor a,b in ab:\n ans += b\n if a > b:\n diff = min(diff, b)\nprint(ans-diff)", "def slv(n,ab):\n if [a for a,b in ab]==[b for a,b in ab]:return 0\n c=[]\n W=0\n ret=0\n for i,(a,b) in enumerate(ab):\n # \u3069\u308c\u3060\u3051\u306e\u8981\u7d20\u30920\u306b\u3067\u304d\u308b\u304b\u3002\n # 0\u306b\u3067\u304d\u306a\u3044\u8981\u7d20\u306e\u548c\u3092\u6700\u5c0f\u5316\u3059\u308b\u3002\n # a<=b\u3068\u306a\u3063\u3066\u3044\u308b\u3068\u3053\u308d\u306f0\u306b\u3067\u304d\u308b\n if a-b>0:\n c.append([b,a-b])\n else:\n ret+=b\n W+=b-a\n W-=1\n # \u30ca\u30c3\u30d7\u30b6\u30c3\u30af\u554f\u984c\uff1f\n # c=[v,w],W:\n # \u4fa1\u5024v\u91cd\u3055w\u306e\u5546\u54c1\u914d\u5217c\u3001\u6700\u5927\u5bb9\u91cfW\u306e\u30ca\u30c3\u30d7\u30b6\u30c3\u30af\u306b\u5165\u308b\u6700\u5927\u4fa1\u5024\u306f\n # \u30ca\u30c3\u30d7\u30b6\u30c3\u30af\u306b\u5165\u308bc\u306e\u8981\u7d20\u30920\u306b\u3067\u304d\u308b\n # |c|<=10^5 v,w<=10^9 W<=10^14,sum(w)-1==W\n # sum(w)-1==W\u3088\u308a\u3001\u306f\u3044\u3089\u306a\u3044\u5546\u54c1\u306f1\u3064\u3060\u3051\u3002v\u306e\u5c0f\u3055\u3044\u5546\u54c1\u3092\u306e\u3053\u3057\u3066\u4ed6\u306f\u5165\u308c\u308c\u3070\u3088\u3044\n # dp\u4e0d\u8981\n c.sort(key=lambda x:x[0])\n ret+=sum([v for v,w in c[1:]])\n return ret\n\n\n\nn=int(input())\nab=[list(map(int,input().split())) for _ in range(n)]\nprint((slv(n,ab)))\n", "# ARC094E\n\nimport sys\ninput = lambda : sys.stdin.readline().rstrip()\nsys.setrecursionlimit(max(1000, 10**9))\nwrite = lambda x: sys.stdout.write(x+\"\\n\")\n\n\n\nn = int(input())\na = [None] * n\nb = [None] * n\nans = 0\nsame = 0\nm = 0\ndiff = []\nfor i in range(n):\n a[i],b[i] = map(int, input().split())\n if a[i]<b[i]:\n ans += (b[i] - a[i])\n elif a[i]==b[i]:\n same += a[i]\n else:\n diff.append(b[i])\n m += b[i]\ndiff.sort()\nc = 0\nplus = 0\nif ans==0:\n print(0)\nelse:\n plus = sum(diff[1:])\n print(sum(a) - (m - plus))", "N = int(input())\nS = 0\nminB = 1000000000000000000\nfor _ in range(N):\n x, y = list(map(int, input().split()))\n S += x\n if x > y:\n minB = min(minB, y)\n\nprint((max(0, S - minB)))\n", "import sys\nimport numpy as np\n\nsr = lambda: sys.stdin.readline().rstrip()\nir = lambda: int(sr())\nlr = lambda: list(map(int, sr().split()))\n\nN = ir()\nA, B = np.array([lr() for _ in range(N)]).T\nif np.all(A == B):\n print((0)); return\n\nindex = np.where(B<A)[0]\nanswer = np.sum(A) - np.min(B[index])\nprint(answer)\n\n# 12\n", "n=int(input())\ntotal=0\nallsame=1\nminb=10**9+1\nfor _ in range(n):\n a,b=list(map(int,input().split()))\n total+=a\n if a>b:\n allsame=0\n minb=min(b,minb)\nif allsame==1:\n print((0))\nelse:\n print((total-minb))\n", "N = int(input())\nans = 0\na_chance = 0\na_remain = []\nb_remain = []\nfor i in range(N):\n a,b = map(int,input().split())\n if b >= a:\n ans += b\n a_chance += b-a\n else:\n a_remain.append(a)\n b_remain.append(b)\nif a_chance ==0:\n print(0)\nelse:\n print(ans+sum(b_remain)-min(b_remain)) ", "n = int(input())\nans = []\nsum_a = 0\nfor i in range(n):\n a, b = list(map(int, input().split()))\n sum_a += a\n if a > b:\n ans.append(b)\nif ans == []:\n min_ans = sum_a\nelse:\n min_ans = min(ans)\nprint((sum_a-min_ans))\n", "n = int(input())\nINF = 10**9\ncsum = 0\nmin_b = INF\nfor _ in range(n):\n a,b = list(map(int, input().split()))\n csum += a\n if a > b:\n min_b = min(min_b,b)\n\nif min_b == INF:\n print((0))\nelse:\n ans = csum-min_b\n print(ans)\n\n\n# a_down_sum = 0\n# top_diff = 0\n# for _ in range(n):\n# a,b = map(int, input().split())\n# if a < b:\n# a_down_sum += a\n# else:\n# top_diff = max(top_diff,a-b)\n\n", "\nN = int(input())\nres = float(\"inf\")\nS = 0\ncnt = 0\nfor _ in range(N):\n A, B = map(int, input().split())\n S+=A\n if A>B:\n res = min(B,res)\n if A==B:\n cnt += 1\nprint(S-res if cnt!=N else 0)", "def main():\n n = int(input())\n s = 0\n x = 10**10\n for _ in range(n):\n a, b = map(int, input().split())\n if a > b:\n if x > b:\n x = b\n s += a\n if x == 10**10:\n print(0)\n else:\n print(s-x)\n\ndef __starting_point():\n main()\n__starting_point()", "n = int(input())\nab = [list(map(int,input().split())) for i in range(n)]\ncount = 0\nm = 10**10\nfor a,b in ab:\n if a > b:\n m = min(m,b)\n count += a\nif m == 10**10:\n print(0)\nelse:\n print(count-m)", "n=int(input())\nINF=10**9+7\nsum=0\nm=INF\nfor i in range(n):\n a,b=map(int,input().split())\n sum+=a\n if a>b:\n m=min(m,b)\nif m==INF:\n print(0)\nelse:\n print(sum-m)", "n = int(input())\naa = 0\nmi = 10 ** 10\nflag = True\nfor _ in range(n):\n a, b = [int(i) for i in input().split()]\n aa += a\n if a != b:\n flag = False\n if a > b:\n mi = min(mi, b)\nif flag:\n print((0))\nelse:\n print((aa-(mi if mi != 10**10 else 0)))\n", "n = int(input())\nab = [list(map(int,input().split())) for i in range(n)]\ncount = 0\nm = 10**10\nfor a,b in ab:\n if a > b:\n m = min(m,b)\n count += a\nif m == 10**10:\n print(0)\nelse:\n print(count-m)", "N=int(input())\nA=[0 for i in range(N)]\nB=[0 for i in range(N)]\nfor i in range(N):\n A[i],B[i]=list(map(int,input().split()))\nX=[]\nfor i in range(N):\n if A[i]>B[i]:\n X.append(B[i])\nif len(X)==0:\n print((0))\nelse:\n print((sum(A)-min(X)))\n", "n = int(input())\nab = [list(map(int, input().split())) for _ in range(n)]\n\na, _ = list(zip(*ab))\nsm = sum(a)\n\nans = 0\nfor a, b in ab:\n if a > b:\n ans = max(ans, sm - b)\n\nprint(ans)\n", "def main():\n sum=0\n m=10**9+1\n for _ in range(int(input())):\n a,b=map(int,input().split())\n sum+=a\n if a>b:\n m=min(m,b)\n print(sum-m if m<=10**9 else 0)\nmain()", "N = int(input())\na = []\nb = []\nfor i in range(N):\n tmp1, tmp2 = list(map(int, input().split()))\n a.append(tmp1)\n b.append(tmp2)\ncount = 0\nls_l = [i for i in range(N) if a[i] > b[i]]\nls_m = [i for i in range(N) if a[i] == b[i]]\nls_s = [i for i in range(N) if a[i] < b[i]]\n\nflg = 1\nif len(ls_l) > 1:\n ls_l2 = [(b[i],i) for i in ls_l]\n ls_l2.sort()\n idx = ls_l2[0][1]\n count = sum(a)-b[idx]\nelif len(ls_m) == N:\n count = 0\nelse:\n for idx in ls_m:\n count += a[idx]\n \n for idx in ls_s:\n count += a[idx]\n \n if flg==1:\n for idx in ls_l:\n count += a[idx]-b[idx]\nprint(count)\n", "N=int(input())\nx,y=0,0\nA,B=[],[]\nfor i in range(N):\n x,y=map(int,input().split())\n A.append(x)\n B.append(y)\nx=sum(A)\nfor i in range(N):\n if A[i]>B[i]:\n x=min(x,B[i])\nprint(sum(A)-x)", "\nn = int(input())\nc = 0\nf = 0\nm = 10000000000000000000000\nfor i in range(n):\n a,b = list(map(int, input().split()))\n c += a\n if a > b:\n m = min(b, m)\n if a != b:\n f = 1\nprint(((c-m)*f))\n", "def main():\n n = int(input())\n ab = [list(map(int, input().split())) for _ in [0]*n]\n if all([a == b for a, b in ab]):\n print(0)\n return 0\n min_b = min([b for a, b in ab if a > b])\n sum_a = sum([a for a, b in ab])\n print(sum_a-min_b)\n\n\nmain()", "N=int(input())\nsum=0\nmin=10**9+1\nfor i in range(N):\n A,B=map(int,input().split())\n if A>B and min>B:\n min=B\n sum+=A\nif min==10**9+1:\n print(0)\nelse:\n print(sum-min)", "# https://betrue12.hateblo.jp/entry/2019/06/06/214607\n\nN = int(input())\nAB = (list(map(int, input().split())) for _ in range(N))\n\nINF = 10 ** 9 + 10\ns = 0\nlast = INF\nfor a, b in AB:\n if a > b:\n last = min(last, b)\n s += b\n\nif last == INF:\n print((0))\nelse:\n print((s - last))\n", "N = int(input())\nA = []\nB = []\nfor _ in range(N):\n a, b = list(map(int, input().split()))\n A.append(a)\n B.append(b)\n \nif A == B:\n print((0))\nelse:\n M = sum(A)\n c = 10**10\n for a, b in zip(A, B):\n if a > b:\n c = min(c, b)\n print((M - c))\n", "import numpy as np\nimport sys\nN = int(input())\nA = np.zeros(N, dtype=np.int64)\nB = np.zeros(N, dtype=np.int64)\nfor i in range(N):\n A[i], B[i] = map(int,input().split())\nif all(A == B):\n print(0)\n return\nans = A.sum() - B[A > B].min()\nprint(ans)", "_,*t=open(0).read().split()\nt=map(int,t)\ns=0\nm=1e18\nfor a,b in zip(t,t):\n s+=a\n if a>b:m=min(m,b)\nprint(max(0,s-m))", "\n\"\"\"\n\u3059\u3079\u3066\u7b49\u3057\u304b\u3063\u305f\u30890\n\u305d\u308c\u4ee5\u5916\u306f A > B \u3092\u6e80\u305f\u3059\u3082\u306e\u306e\u5185\u6700\u5c0f\u306e\u9ed2\u4ee5\u5916\u53d6\u308c\u308b\n\"\"\"\n\nN = int(input())\n\nans = 0\nl = []\n\nfor i in range(N):\n\n A,B = list(map(int,input().split()))\n\n ans += A\n\n if A > B:\n l.append(B)\n\n\nif len(l) == 0:\n print((0))\nelse:\n l.sort()\n print((ans - l[0]))\n \n", "n = int(input())\nans = 0\nt = 10000000000000000\nfor i in range(n):\n a, b = list(map(int, input().split()))\n ans += a\n if a > b:\n t = min(t, b)\nprint((max(0, ans - t)))\n", "import sys, math\n\ninput = sys.stdin.readline\nN = int(input())\nmin_d = math.inf\nsum_A = 0\nfor _ in range(N):\n a, b = list(map(int, input().split()))\n sum_A += a\n if a>b:\n min_d = min(min_d, b)\nans = max(0, sum_A-min_d)\nprint(ans)\n", "n = int(input())\nA, B = map(list,zip(*[map(int,input().split()) for i in range(n)]))\nif A==B:\n\tprint(0)\nelse:\n\tprint(sum(A)-min([B[i] for i in range(n) if A[i] > B[i]]))", "N = int(input())\nm = 10**9\nans = 0\nfor i in range(N):\n A,B = map(int,input().split())\n ans += B\n if A > B:\n m = min(m,B)\nif m == 10**9:\n print(0)\nelse:\n print(ans-m)", "import sys\nimport math\nfrom collections import defaultdict\nfrom bisect import bisect_left, bisect_right\n\nsys.setrecursionlimit(10**7)\ndef input():\n return sys.stdin.readline()[:-1]\n\nmod = 10**9 + 7\n\ndef I(): return int(input())\ndef LI(): return list(map(int, input().split()))\ndef LIR(row,col):\n if row <= 0:\n return [[] for _ in range(col)]\n elif col == 1:\n return [I() for _ in range(row)]\n else:\n read_all = [LI() for _ in range(row)]\n return map(list, zip(*read_all))\n\n#################\n\n# A[i]>B[i]\u3092\u6e80\u305f\u3059\u6700\u5c0f\u306eB[i]\u3092\u6b8b\u3057\u3066\u7d42\u3048\u308b\n\nN = I()\nA,B = LIR(N,2)\nmin_ = 10**10\nfor i in range(N):\n if A[i] > B[i]:\n if min_ > B[i]:\n min_ = B[i]\n\nif min_ == 10**10:\n print(0)\nelse:\n print(sum(A)-min_)", "def solve():\n ans = 0\n N = int(input())\n miny = float('inf')\n ans = 0\n x = [0]*N\n y = [0]*N\n for i in range(N):\n x[i],y[i] = map(int, input().split())\n if x==y:\n return 0\n for i in range(N):\n ans += x[i]\n if x[i]>y[i]:\n miny = min(miny,y[i])\n ans -= miny\n return ans\nprint(solve())", "import sys\n\nsys.setrecursionlimit(10**7)\ndef I(): return int(sys.stdin.readline().rstrip())\ndef MI(): return list(map(int,sys.stdin.readline().rstrip().split()))\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #\u7a7a\u767d\u3042\u308a\ndef LI2(): return list(map(int,sys.stdin.readline().rstrip())) #\u7a7a\u767d\u306a\u3057\ndef S(): return sys.stdin.readline().rstrip()\ndef LS(): return list(sys.stdin.readline().rstrip().split()) #\u7a7a\u767d\u3042\u308a\ndef LS2(): return list(sys.stdin.readline().rstrip()) #\u7a7a\u767d\u306a\u3057\n\nN = I()\nans = 0\nA,B = [],[]\nfor i in range(N):\n a,b = MI()\n A.append(a)\n B.append(b)\n\nif A == B:\n print((0))\n return\n\nm = sum(B)\nfor i in range(N):\n if A[i] > B[i]:\n m = min(m,B[i])\n\nprint((sum(B)-m))\n", "import sys\ninput=sys.stdin.readline\nn=int(input())\nB=[]\nans=0\nfor i in range(n):\n\ta,b=map(int,input().split())\n\tans+=a\n\tif a>b:\n\t\tB.append(b)\nif len(B)==0:\n\tprint(0)\nelse:\n\tprint(ans-min(B))", "n = int(input())\ndata = []\nans = 0\nfor i in range(n):\n data.append(list(map(int, input().split())))\n ans += data[i][1]\ndata.sort(key=lambda x: x[0] - x[1])\nk = 10**10\nif sum([abs(data[i][1] - data[i][0]) for i in range(n)]):\n for i in range(n):\n if data[i][0] > data[i][1]:\n k = min(k, data[i][1])\n print(ans-k)\nelse:\n print(0)", "n = int(input())\nab = [tuple(map(int, input().split())) for _ in range(n)]\n\nINF = 1 << 30\nmx = INF\nsm = 0\nfor i in range(n):\n a, b = ab[i]\n sm += a\n if a > b:\n mx = min(mx, b)\nif mx == INF:\n print((0))\nelse:\n print((sm - mx))\n", "n=int(input())\nres = 10**10\ns=0\nl=[list(map(int,input().split())) for _ in range(n)]\nfor a,b in l:\n s += a\n if a>b:\n res = min(res,b)\nif res==10**10:\n print((0))\nelse:\n print((s-res))\n", "_,*t=open(0).read().split()\nt=map(int,t)\ns=0\nm=1e18\nfor a,b in zip(t,t):\n s+=a\n if a>b:m=min(m,b)\nprint(max(0,s-m))", "#!/usr/bin/env python3\nimport sys\nINF = float(\"inf\")\n\n\ndef solve(N: int, A: \"List[int]\", B: \"List[int]\"):\n\n ma = INF\n mb = INF\n for a, b in zip(A, B):\n if a > b:\n if mb > b:\n ma = a\n mb = b\n if ma == INF:\n print((0))\n else:\n print((sum(A)-mb))\n\n return\n\n\ndef main():\n\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n A = [int()] * (N) # type: \"List[int]\"\n B = [int()] * (N) # type: \"List[int]\"\n for i in range(N):\n A[i] = int(next(tokens))\n B[i] = int(next(tokens))\n solve(N, A, B)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "N = int(input())\nA = []\nB = []\nfor _ in range(N):\n a, b = list(map(int, input().split()))\n A.append(a)\n B.append(b)\n\nif(A == B):\n print((0))\n return\n\nans = sum(A)\ndis = 10**10\nfor a, b in zip(A, B):\n if a > b:\n dis = min(dis, b)\nprint((ans - dis))\n", "n = int(input())\nab=[list(map(int,input().split())) for i in range(n)]\n\nsm=0\nbmin=10**10\nfor itm in ab:\n a,b=itm\n sm+=a\n if a>b:\n bmin=min(bmin,b)\nif bmin==10**10:\n print(0)\nelse:\n print(sm-bmin)", "import sys\ninput = sys.stdin.readline\n\nn = int(input())\na = []\nb = []\n\n\nres = 0\n\nfor i in range(n):\n aa,bb = map(int,input().split())\n a.append(aa)\n b.append(bb)\n\ndef f(a,b):\n c = []\n d = []\n judge = True\n\n cnt = 0\n for i in range(len(a)):\n if a[i] != b[i]:\n judge = False\n if judge:\n return cnt,c,d\n \n for i in range(len(a)):\n if a[i] <= b[i]:\n cnt += b[i]\n else:\n c.append(a[i])\n d.append(b[i])\n if len(c) == 1 or max(d) == 0:\n return cnt,[],[]\n else:\n mi = min(d)\n flag = True\n pl_flag = True\n for i in range(len(c)):\n if d[i] == mi and flag:\n c[i] = d[i] + 1\n flag = False\n else:\n if pl_flag and d[i] > 0:\n c[i] = d[i]-1\n pl_flag = False\n else:\n c[i] = d[i]\n return cnt,c,d\n\nwhile True:\n plus,a,b = f(a,b)\n res += plus\n if a == []:\n print(res)\n break", "N,*L = map(int, open(0).read().split())\nA = [0]*N\nB = [0]*N\nn = 10**10\nflag = False\nfor i,(a,b) in enumerate(zip(*[iter(L)]*2)):\n A[i] = a\n B[i] = b\n if a!=b:\n flag = True\n if a>b:\n n = min(n,b)\nprint(sum(A)-n if flag else 0)", "n = int(input())\ns = 0\nminb = float(\"inf\")\nf = False\nfor _ in range(n):\n a, b = map(int, input().split())\n if a > b:\n f = True\n minb = min(b, minb)\n s += a\nif f:\n print(s - minb)\nelse:\n print(0)", "n=int(input())\na=[];b=[]\n\nfor _ in range(n):\n ai,bi=list(map(int, input().split()))\n a.append(ai);b.append(bi)\n\ns=sum(a)\nmn=s\nfor ai,bi in zip(a,b):\n if ai<=bi:\n continue\n mn=min(bi,mn)\nprint((s-mn))\n", "n = int(input())\ns = 0\nminb = float(\"inf\")\nfor _ in range(n):\n a, b = map(int, input().split())\n if a > b:\n minb = min(b, minb)\n s += a\nif minb == float(\"inf\"):\n print(0)\nelse:\n print(s - minb)", "n=int(input())\nt=0\nm=1e18\nf=0\nfor i in range(n):\n a,b=map(int,input().split())\n t+=a\n if a>b:m=min(m,b)\n if a!=b:f=1\nif f:\n print(t-m)\nelse:\n print(0)", "n=int(input())\ns=0\nc=10**10\nfor i in range(n):\n a,b=map(int,input().split())\n s=s+a\n if a>b:\n if b<c:\n c=b\nif c==10**10:\n print(0)\nelse:\n print(s-c)", "import sys\ninput = sys.stdin.readline\nn = int(input())\nA = [list(map(int,input().split())) for i in range(n)]\n\nans = 10**10\ns = 0\neq = 0\nfor i in range(n):\n if A[i][0] == A[i][1]:\n eq += 1\n s += A[i][0]\n if A[i][0] > A[i][1]:\n ans = min(ans, A[i][1])\n\nif eq == n:\n print(0)\nelse:\n print(s - ans)", "import sys\nn=int(input())\n\nis_same=True\nm=10**10\nans=0\nfor _ in range(n):\n a,b=map(int,input().split())\n if a!=b: is_same=False\n if a>b: m=min(m,b)\n ans+=a\n\nans-=m\nprint(ans if not is_same else 0)", "import typing\nimport sys\nimport math\nimport collections\nimport bisect\nimport itertools\nimport heapq\nimport decimal\nimport copy\nimport operator\n\n# sys.setrecursionlimit(10000001)\nINF = 10 ** 20\nMOD = 10 ** 9 + 7\n# MOD = 998244353\n# buffer.readline()\n\n\ndef ni(): return int(sys.stdin.readline())\ndef ns(): return list(map(int, sys.stdin.readline().split()))\ndef na(): return list(map(int, sys.stdin.readline().split()))\ndef na1(): return list([int(x)-1 for x in sys.stdin.readline().split()])\n\n\n# ===CODE===\n\ndef main():\n n = ni()\n d = []\n x = []\n y = []\n s = []\n for _ in range(n):\n a, b = ns()\n c = a-b\n d.append([a, b, c])\n x.append(a)\n y.append(b)\n if c > 0:\n s.append(b)\n d.sort(key=lambda x: x[2])\n\n if x == y:\n print((0))\n return\n\n ans=sum(x)-min(s)\n print(ans)\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n=int(input())\nrem=10**10\nS=0\nallissame=0\nfor i in range(n):\n a,b=list(map(int,input().split()))\n S+=a\n if a<b:\n allissame|=1\n continue\n elif a>b:\n if rem > b:\n rem=b\n allissame|=1\n else:pass\nif not allissame:\n print((0))\nelse:\n print((S-rem))\n", "import sys\ninput = sys.stdin.readline\nN = int(input())\nres = 0\nt = float(\"inf\")\nc = 0\nfor _ in range(N):\n x, y = map(int, input().split())\n if x > y: t = min(y, t)\n if x == y: c += 1\n res += x\nif c == N:\n print(0)\n return\nprint(res - t)", "import os\nimport sys\n\nimport numpy as np\n\nif os.getenv(\"LOCAL\"):\n sys.stdin = open(\"_in.txt\", \"r\")\n\nsys.setrecursionlimit(2147483647)\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN = int(sys.stdin.readline())\nA, B = list(zip(*[list(map(int, sys.stdin.readline().split())) for _ in range(N)]))\n\nA = np.array(A, dtype=int)\nB = np.array(B, dtype=int)\nif np.all(A == B):\n print((0))\nelse:\n ans = A.sum() - B[A > B].min()\n print(ans)\n", "n = int(input())\ns = 0\nf = False\nm = 10**9\nfor i in range(n):\n a,b = map(int,input().split())\n s += a\n if a < b:\n f = True\n if a > b:\n f = True\n m = min(m,b)\nif f:\n print(s-m)\nelse:\n print(0)", "import sys\nsys.setrecursionlimit(2147483647)\nINF=float(\"inf\")\nMOD=10**9+7\ninput=lambda:sys.stdin.readline().rstrip()\ndef resolve():\n n=int(input())\n A=[None]*n\n B=[None]*n\n for i in range(n):\n A[i],B[i]=map(int,input().split())\n\n if(A==B):\n print(0)\n return\n print(sum(A)-min(b for a,b in zip(A,B) if(a>b)))\nresolve()"] | {"inputs": ["2\n1 2\n3 2\n", "3\n8 3\n0 1\n4 8\n", "1\n1 1\n"], "outputs": ["2\n", "9\n", "0\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 32,122 | |
a7176fa9b058db6301d5e8c6ced68d9c | UNKNOWN | You are given a string S consisting of lowercase English letters.
Determine whether we can turn S into a palindrome by repeating the operation of swapping two adjacent characters. If it is possible, find the minimum required number of operations.
-----Constraints-----
- 1 \leq |S| \leq 2 × 10^5
- S consists of lowercase English letters.
-----Input-----
Input is given from Standard Input in the following format:
S
-----Output-----
If we cannot turn S into a palindrome, print -1. Otherwise, print the minimum required number of operations.
-----Sample Input-----
eel
-----Sample Output-----
1
We can turn S into a palindrome by the following operation:
- Swap the 2-nd and 3-rd characters. S is now ele. | ["import collections\n\n\nclass Bit():\n def __init__(self, l):\n self.size = l\n self.bit = [0] * (self.size+1)\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.bit[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.bit[i] += x\n i += i & -i\n\n def __str__(self):\n return str(self.bit)\n\n\nS = str(input())\nN = len(S)\nindex = collections.defaultdict(list)\n\nfor i, c in enumerate(S):\n index[c].append(i)\n\nctr = N // 2\nB = [0] * N\nflag = 0\nP = []\n\nfor c, k in list(index.items()):\n cnt = len(k)\n if cnt % 2:\n if flag == 1:\n print((-1))\n return\n flag = 1\n B[k[cnt // 2]] = ctr + 1\n for i in range(cnt // 2):\n l, r = k[i], k[-(i+1)]\n P.append((l, r))\n\nP.sort()\n\nfor i, (l, r) in enumerate(P):\n B[l], B[r] = i + 1, N - i\n\nans = 0\nbit = Bit(N)\nfor i, b in enumerate(B):\n ans += i - bit.sum(b)\n bit.add(b, 1)\n\nprint(ans)\n", "\"\"\"\n\u307e\u305a\u3001\u5947\u6570\u500b\u5b58\u5728\u3059\u308b\u6587\u5b57\u7a2e\u304c\u8907\u6570\u3042\u308b\u5834\u5408\u306f\u3001\u56de\u6587\u306b\u3067\u304d\u306a\u3044\u3002\n\u305d\u308c\u4ee5\u5916\u306e\u5834\u5408\u306f\u3001\u56de\u6587\u306b\u3067\u304d\u308b\u3002\n\u6b21\u306b\u3001\u64cd\u4f5c\u306e\u6700\u5c0f\u56de\u6570\u306f\u3001\u56de\u6587\u306b\u306a\u3063\u305f\u5834\u5408\u306e\u5404\u6587\u5b57\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u6c42\u3081\u3066\u304a\u304d\u3001BIT\u3092\u4f7f\u3063\u3066\u3001\u5165\u308c\u66ff\u3048\u304c\u5fc5\u8981\u306a\u56de\u6570\u3092\u6c42\u3081\u3066\u7f6e\u304f\n\"\"\"\nfrom collections import Counter\nS = input()\nN = len(S)\n#\u5404\u6587\u5b57\u306e\u51fa\u73fe\u56de\u6570\u3092\u30ab\u30a6\u30f3\u30c8\napperance = Counter(S)\n\n#\u56de\u6587\u3092\u4f5c\u6210\u3067\u304d\u308b\u304b\u5224\u5b9a\nflag = False\nfor k,v in list(apperance.items()):\n if v%2==1:\n if flag:\n print((-1))\n return\n else:\n flag = True\n t = k\n\n\n#place[s] -> \u6587\u5b57s\u306e\u51fa\u73fe\u4f4d\u7f6e\nplace = {}\nfor i in range(N):\n s = S[i]\n if s not in place:\n place[s] = []\n place[s].append(i)\n\n#memo[i] -> S\u306ei\u6587\u5b57\u76ee\u306e\u56de\u6587\u4e0a\u3067\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\nmemo = [-1] *(N)\n\n#\u56de\u6587\u524d\u534a\u3001\u5f8c\u534a\u306b\u542b\u307e\u308c\u308b\u3053\u3068\u306b\u306a\u308b\u6587\u5b57\u306b\u3001\u56de\u6587\u4e0a\u3067\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u5272\u308a\u5f53\u3066\u308b\u3002\ntmp = 0\ntmpApperance = {}\nfor i in range(N):\n s = S[i]\n if s not in tmpApperance:\n tmpApperance[s] = 1\n else:\n tmpApperance[s] += 1\n if tmpApperance[s] <= apperance[s]//2:\n memo[i] = tmp\n backIdx = place[s][-tmpApperance[s]]\n memo[backIdx] = N-tmp-1\n tmp += 1\n\n\n#\u56de\u6587\u306e\u771f\u3093\u4e2d\u306b\u542b\u307e\u308c\u308b\u3053\u3068\u306b\u306a\u308b\u6587\u5b57\u306b\u3001\u56de\u6587\u4e0a\u3067\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u5272\u308a\u5f53\u3066\u308b\u3002\nif flag:\n idx = N//2\n memo[place[t][len(place[t])//2]] = idx\n\nclass BIT:\n def __init__(self,n):\n self.size=n\n self.tree = [0]*(n+1)\n \n def sum(self,i):\n s = 0\n while i>0:\n s += self.tree[i]\n i -= i&-i\n return s\n \n def add(self,i,x):\n while i<=self.size:\n self.tree[i] += x\n i += i&-i\nbit = BIT(N)\ncnt = 0\nfor i in range(N):\n m = memo[i]+1\n bit.add(m,1)\n cnt += bit.sum(N)-bit.sum(m)\n\nprint(cnt)\n", "from collections import Counter\n\nclass BIT:\n def __init__(self,n):\n self.tree = [0]*(n+1)\n self.size = n\n \n def sum(self,i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i&-i\n return s\n\n def add(self,i,x):\n while i <= self.size:\n self.tree[i] += x\n i += i&-i\n\nS = input()\nN = len(S)\ncount = Counter(S)\nflag = False\nfor v in list(count.values()):\n if v%2 == 1:\n if flag:\n print((-1))\n return\n else:\n flag = True\n\n\n\"\"\"\n\u6587\u5b57s\u306ei\u6587\u5b57\u76ee\u304c\u3069\u3053\u306b\u3042\u308b\u304b\u3001\u3092O(1)\u3067\u53d6\u308a\u51fa\u305b\u308b\u8f9e\u66f8\u304c\u5fc5\u8981\n\"\"\"\nplaceAtS = {s:[] for s in list(set(S))}\nfor i in range(N):\n s = S[i]\n placeAtS[s].append(i)\n\ncount2 = {s:0 for s in list(set(S))}\n\nplaceAtT = [None]*(N)\ntmp = 0\nfor i in range(N):\n s = S[i]\n count2[s] += 1\n if count2[s] <= count[s]//2:\n placeAtT[i] = tmp\n mirror = placeAtS[s][count[s]-count2[s]]\n placeAtT[mirror] = N - tmp - 1\n tmp += 1\n\nfor i in range(N):\n if placeAtT[i] == None:\n placeAtT[i] = tmp\n\nbit = BIT(N)\nans = 0\nfor i in range(N):\n bit.add(placeAtT[i]+1,1)\n ans += bit.sum(N) - bit.sum(placeAtT[i]+1)\n\nprint(ans)\n", "import sys\ninput = sys.stdin.readline\nfrom collections import deque, defaultdict, Counter\n\nS = input().rstrip()\nL = len(S)\n\nc = Counter(S)\nif sum((x&1 for x in c.values())) >= 2:\n print(-1)\n return\n\nalphabet_to_pos = defaultdict(deque)\n\nfor i,x in enumerate(S,1):\n alphabet_to_pos[x].append(i)\n\nafter = [None] * len(S)\nn = 0\nfor i,x in enumerate(S,1):\n p = alphabet_to_pos[x]\n if not p:\n continue\n if len(p) == 1:\n p.pop()\n after[L//2] = i\n continue\n p.popleft()\n j = p.pop()\n after[n] = i\n after[L - n - 1] = j\n n += 1\n\ndef BIT_update(tree,x):\n while x <= L:\n tree[x] += 1\n x += x & (-x)\n\ndef BIT_sum(tree,x):\n s = 0\n while x:\n s += tree[x]\n x -= x & (-x)\n return s\n\nanswer = 0\ntree = [0] * (L+1)\nfor i,x in enumerate(after):\n answer += i - BIT_sum(tree,x)\n BIT_update(tree,x)\n\nprint(answer)", "S=list(input())\nN=len(S)\nord_A=ord(\"a\")\nalp=[0]*26\nodd=-1\nfor i in range(N):\n m=ord(S[i])-ord_A\n alp[m]+=1\nfor k in range(26):\n if alp[k]%2==1:\n if odd==-1:\n odd=k\n else:\n print(-1)\n return\npos=[[] for i in range(26)]\nSequence=[0]*N\nd=0\nalp_num=[0]*26\nfor i in range(N):\n m=ord(S[i])-ord_A\n alp_num[m]+=1\n if 2*alp_num[m]<=alp[m]:\n Sequence[i]=d\n pos[m].append(d)\n d+=1\n elif m==odd and alp_num[m]==alp[m]//2+1:\n Sequence[i]=N//2\n else:\n j=pos[m].pop()\n Sequence[i]=N-1-j\n\ndef add(B,a,n):\n x = a\n while x<=n:\n B[x]+=1\n x+=x&(-x)\n \ndef sums(B,a):\n x=a\n S=0\n while x!=0:\n S+=B[x]\n x-=x&(-x)\n return S\n \ndef invnumber(n,A):\n B=[0]*(n*2+1)\n invs=0\n for i in range(n):\n s=A[i]+n\n invs+=sums(B,s)\n add(B,s,n*2)\n return n*(n-1)//2-invs\n\nprint(invnumber(N,Sequence))", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\n\nclass BitSum:\n def __init__(self, n):\n self.n = n + 3\n self.table = [0] * (self.n + 1)\n\n def update(self, i, x):\n i += 1\n while i <= self.n:\n self.table[i] += x\n i += i & -i\n\n def sum(self, i):\n i += 1\n res = 0\n while i > 0:\n res += self.table[i]\n i -= i & -i\n return res\n\ndef InversionNumber(lst):\n bit = BitSum(max(lst))\n res = 0\n for i, a in enumerate(lst):\n res += i - bit.sum(a)\n bit.update(a, 1)\n return res\n\ndef main():\n s = input()\n n = len(s)\n ord_a = ord(\"a\")\n cnts = [0] * 26\n s_code = []\n flag_odd = False\n for c in s:\n code = ord(c) - ord_a\n s_code.append(code)\n cnts[code] += 1\n odd_code = -1\n for code, cnt in enumerate(cnts):\n if cnt % 2 == 1:\n if flag_odd:\n print(-1)\n return\n else:\n odd_code = code\n flag_odd = True\n cnts[code] = cnt // 2\n tois = [[] for _ in range(26)]\n to_sort_idx = []\n new_idx = 1\n for code in s_code:\n if cnts[code] > 0:\n to_sort_idx.append(new_idx)\n tois[code].append(n + 1 - new_idx)\n cnts[code] -= 1\n new_idx += 1\n else:\n if flag_odd and code == odd_code:\n to_sort_idx.append(n // 2 + 1)\n flag_odd = False\n else:\n to_sort_idx.append(tois[code].pop())\n # print(to_sort_idx)\n print(InversionNumber(to_sort_idx))\n\nmain()\n", "from collections import deque\nimport copy\nclass BIT:\n def __init__(self, node_size):\n self._node = node_size+1\n self.bit = [0]*self._node\n \n def add(self, index, add_val):\n while index < self._node:\n self.bit[index] += add_val\n index += index & -index\n \n def sum(self, index):\n res = 0\n while index > 0:\n res += self.bit[index]\n index -= index & -index\n return res\n \ns = input()\nn = len(s)\na = [ord(i) - ord(\"a\") for i in s]\nx = [0]*26\nfor i in a:\n x[i] += 1\nflag = 1\nki = -1\nfor i in x:\n if i%2 == 1:\n if flag:\n flag = 0\n else:\n print(-1)\n return\nc = []\nx2 = [0]*26\nfor i in a:\n x2[i] += 1\n if x[i]//2 >= x2[i]:\n c.append(i)\nfor i in range(26):\n if x[i]%2 == 1:\n b = copy.deepcopy(c)\n c.append(i)\n b = b[::-1]\n c.extend(b)\n break\nelse:\n b = copy.deepcopy(c)\n b = b[::-1]\n c.extend(b) \nd = {}\nfor i in range(26):\n d[i] = deque([])\nfor i in range(n):\n d[c[i]].append(i+1)\nfor i in range(n):\n x = d[a[i]].popleft()\n a[i] = x\nb = []\nfor i in range(n):\n b.append([a[i],i+1])\nb.sort()\nb = b[::-1]\nbit = BIT(n)\nans = 0\nfor i,j in b:\n bit.add(j,1)\n ans += bit.sum(j-1)\nprint(ans)", "\"\"\"\n\u56de\u6587\u306e\u5de6\u534a\u5206\u306e\u6587\u5b57\u5217\u305f\u3061\u3092\u64cd\u4f5c\u3059\u308b\u3002\n\u5de6\u534a\u5206\u306e\u5404\u6587\u5b57\u306b\u5bfe\u3057\u3066\u3001\u672c\u6765\u3042\u308b\u3079\u304d\u5834\u6240(Index)\u3092\u5b9a\u7fa9\u3059\u308b\u3002\n\u3042\u3068\u306f\u3001\u5de6\u534a\u5206\u306e\u6587\u5b57\n\n\"\"\"\n\nfrom collections import Counter\nclass BIT:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n\n def sum(self, i): # 1-index\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x): # 1-index\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\nS = input()\nN = len(S)\ncount = Counter(S)\n\n#\u5947\u6570\u500b\u3042\u308b\u6587\u5b57\u304c\u8907\u6570\u5b58\u5728\u3057\u3066\u3044\u306a\u3044\u304b\u30c1\u30a7\u30c3\u30af\nflag = False\nfor v in list(count.values()):\n if v%2 == 1:\n if flag:\n print((-1))\n return\n else:\n flag = True\n\n# \u5404\u6587\u5b57\u304c\u5c5e\u3059\u3079\u304d\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u6c42\u3081\u308b\n# memo[i] -> S[i]\u306e\u56de\u6587\u5909\u63db\u5f8c\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9(0-indexed)\nmemo = [None]*(N)\n#appearCnt[k] -> \u6587\u5b57k\u306e\u51fa\u73fe\u56de\u6570\nappearCnt = {k:0 for k in list(count.keys())}\n\n# \u307e\u305a\u3001\u56de\u6587\u6642\u306b\u5de6\u534a\u5206\u306b\u5c5e\u3059\u308b\u6587\u5b57\u306b\u95a2\u3057\u3066\u3001\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u5272\u308a\u5f53\u3066\u308b\u3002\ntInd = 0\nfor i in range(N):\n s = S[i]\n if appearCnt[s] <= count[s]//2 - 1:\n appearCnt[s] += 1\n memo[i] = tInd\n tInd += 1\n\n#\u5947\u6570\u500b\u3042\u308b\u6587\u5b57\u304c\u3042\u308b\u5834\u5408\u306f\u3001\u771f\u3093\u4e2d\u306b\u306a\u308b\u6587\u5b57\u306b\u95a2\u3057\u3066\u3001\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u5272\u308a\u5f53\u3066\u308b\nif flag:\n for i in range(N):\n s = S[i]\n if count[s]%2 == 1 and memo[i]==None:\n memo[i] = tInd\n break\n\n#\u56de\u6587\u6642\u306b\u53f3\u534a\u5206\u306b\u306a\u308b\u6587\u5b57\u306b\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u5272\u308a\u5f53\u3066\u308b\u3002\n#\u307e\u305a\u3001\u5404\u6587\u5b57\u306e\u6587\u5b57\u5217S\u306b\u304a\u3051\u308b\u51fa\u73fe\u56de\u6570\u3092\u307e\u3068\u3081\u308b\nappearIdx = {k:[] for k in list(count.keys())}\nfor i in range(N):\n s = S[i]\n appearIdx[s].append(i)\n\nfor v in list(appearIdx.values()):\n for i in range(len(v)//2):\n l = v[i]\n r = v[len(v)-i-1]\n memo[r] = (N-1)-memo[l]\nans = 0\nbit = BIT(N)\nfor i in range(N):\n bit.add(memo[i]+1,1)\n ans += bit.sum(N)-bit.sum(memo[i]+1)\nprint(ans)\n\n", "class Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0]*(n+1)\n\n def __iter__(self):\n psum = 0\n for i in range(self.size):\n csum = self.sum(i+1)\n yield csum - psum\n psum = csum\n raise StopIteration()\n\n def __str__(self): # O(nlogn)\n return str(list(self))\n\n def sum(self, i):\n # [0, i) \u306e\u8981\u7d20\u306e\u7dcf\u548c\u3092\u8fd4\u3059\n if not (0 <= i <= self.size): raise ValueError(\"error!\")\n s = 0\n while i>0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n if not (0 <= i < self.size): raise ValueError(\"error!\")\n i += 1\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n def __getitem__(self, key):\n if not (0 <= key < self.size): raise IndexError(\"error!\")\n return self.sum(key+1) - self.sum(key)\n\n def __setitem__(self, key, value):\n # \u8db3\u3057\u7b97\u3068\u5f15\u304d\u7b97\u306b\u306fadd\u3092\u4f7f\u3046\u3079\u304d\n if not (0 <= key < self.size): raise IndexError(\"error!\")\n self.add(key, value - self[key])\n\n\n\nS = input()\nN = len(S)\ncnt = [0]*26\nfor c in S:\n cnt[ord(c)-97] += 1\nodd = -1\nfor i, cn in enumerate(cnt):\n if cn%2 != 0:\n if odd == -1:\n odd = i\n else:\n print((-1))\n return\n cnt[i] //= 2\n#cnt2 = [0]*26\nL = [[] for _ in range(26)]\nn = N//2 + 1\nB = []\nfor c in S:\n c_int = ord(c)-97\n if cnt[c_int] == 0:\n if c_int == odd:\n B.append(1)\n odd = -1\n else:\n p = L[c_int].pop()\n B.append(p)\n else:\n L[c_int].append(n)\n B.append(0)\n n-=1\n cnt[c_int] -= 1\n\nbit = Bit(N//2+2)\nans = 0\nfor i, b in enumerate(B):\n ans += i - bit.sum(b+1)\n bit.add(b, 1)\nprint(ans)\n", "from collections import Counter\nimport sys\ns = input()\nN = len(s)\nsc = Counter(s)\nodds = [1 for x in sc if sc[x] % 2 == 1]\nif len(odds) > 1:\n print((-1))\n return\n\nclass BIT:\n def __init__(self, size):\n self.bit = [0] * (size+1)\n def add(self, index, elem):\n index += 1\n while index < len(self.bit):\n self.bit[index] += elem\n index += index & -index\n def get(self, index):\n index += 1\n ret = 0\n while 0 < index:\n ret += self.bit[index]\n index -= index & -index\n return ret\n\nindices = [-1] * N\ntb = {c: [None] * (sc[c]//2) for c in sc}\nlens = {c: 0 for c in sc}\np = 0\nfor i in range(N):\n c = s[i]\n l = lens[c]\n if 2 * (l+1) <= sc[c]:\n indices[p] = i\n tb[c][l] = p\n lens[c] += 1\n p += 1\n elif 2 * (l+1) == sc[c] + 1:\n indices[N//2] = i\n lens[c] += 1\n else:\n indices[N-1-tb[c][sc[c]-l-1]] = i\n lens[c] += 1\n\nans = 0\nbit = BIT(N)\nfor i in indices:\n bit.add(i, 1)\n ans += bit.get(N-1) - bit.get(i)\nprint(ans)\n", "a2n=lambda x:ord(x)-ord('a')\n# \u6570\u5024(1\u301c26)\u2192\u30a2\u30eb\u30d5\u30a1\u30d9\u30c3\u30c8(a\u301cz)\nn2a = lambda x:chr(x+ord('a')).lower()\n\ns=list(map(a2n,list(input())))\nn=len(s)\ncary=[0]*26\nfrom collections import deque\nary=[deque([]) for _ in range(26)]\nfor i,x in enumerate(s):\n cary[x]+=1\n ary[x].append(i)\noddcnt=0\nfor x in cary:\n if x%2==1:oddcnt+=1\nif oddcnt>1:\n print(-1)\n return\n\n# 0-indexed binary indexed tree\nclass BIT:\n def __init__(self, n):\n self.n = n\n self.data = [0]*(n+1)\n self.el = [0]*(n+1)\n # sum of [0,i) sum(a[:i])\n def sum(self, i):\n if i==0:return 0\n s = 0\n while i > 0:\n s += self.data[i]\n i -= i & -i\n return s\n def add(self, i, x):\n i+=1\n self.el[i] += x\n while i <= self.n:\n self.data[i] += x\n i += i & -i\n # sum of [l,r) sum(a[l:r])\n def sumlr(self, i, j):\n return self.sum(j) - self.sum(i)\n # a[i]\n def get(self,i):\n i+=1\n return self.el[i]\n\nbit=BIT(n)\nfor i in range(n):\n bit.add(i,1)\nans=0\nm=n\nfor i in range(n//2):\n # idx=i,n-1-i\u306b\u304f\u308b\u3082\u306e\u3092\u8003\u3048\u308b\n t=-1\n v=float('inf')\n for j in range(26):\n if not ary[j]:continue\n l=ary[j][0]\n r=ary[j][-1]\n tmp=0\n # l\u304b\u3089i\u3078\n tmp+=bit.sum(l)\n # r\u304b\u3089n-1-i\u3078\n tmp+=m-2*i-bit.sum(r+1)\n if v>tmp:\n v=tmp\n t=j\n r=ary[t].pop()\n l=ary[t].popleft()\n bit.add(l,-1)\n bit.add(r,-1)\n ans+=v\nprint(ans)", "from collections import defaultdict, deque, Counter\nfrom heapq import heappush, heappop, heapify\nfrom itertools import permutations, accumulate, combinations, combinations_with_replacement\nfrom math import sqrt, ceil, floor, factorial\nfrom bisect import bisect_left, bisect_right, insort_left, insort_right\nfrom copy import deepcopy\nfrom operator import itemgetter\nfrom functools import reduce, lru_cache # @lru_cache(None)\nfrom fractions import gcd\nimport sys\ndef input(): return sys.stdin.readline().rstrip()\ndef I(): return int(input())\ndef Is(): return (int(x) for x in input().split())\ndef LI(): return list(Is())\ndef TI(): return tuple(Is())\ndef IR(n): return [I() for _ in range(n)]\ndef LIR(n): return [LI() for _ in range(n)]\ndef TIR(n): return [TI() for _ in range(n)]\ndef S(): return input()\ndef Ss(): return input().split()\ndef LS(): return list(S())\ndef SR(n): return [S() for _ in range(n)]\ndef SsR(n): return [Ss() for _ in range(n)]\ndef LSR(n): return [LS() for _ in range(n)]\nsys.setrecursionlimit(10**6)\nMOD = 10**9+7\nINF = 10**18\n# ----------------------------------------------------------- #\n\nclass BinaryIndexedTree:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n\n def sum(self, i): # 1-index\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x): # 1-index\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n \"\"\"\n # \u4f7f\u7528\u4f8b\n bit = BinaryIndexedTree(10) # \u8981\u7d20\u6570\u3092\u4e0e\u3048\u3066\u30a4\u30f3\u30b9\u30bf\u30f3\u30b9\u5316\n bit.add(2, 10) # a2\u306b10\u3092\u52a0\u3048\u308b\n bit.add(3, -6) # a3\u306b-6\u3092\u52a0\u3048\u308b\n print(bit.sum(6)) # a1\uff5ea6\u306e\u5408\u8a08\u3092\u8fd4\u3059\n print(bit.sum(6) - bit.sum(3)) # a4\uff5ea6\u306e\u5408\u8a08\u3092\u8fd4\u3059\n \"\"\"\n\ns = S()\nn = len(s)\ns_index = defaultdict(list)\nfor i, x in enumerate(s):\n s_index[x].append(i)\n\nT = [0]*n # s\u3067i\u756a\u76ee\u306e\u6587\u5b57\u306f\u3001\u6700\u7d42\u7684\u306a\u56de\u6587\u3067T[i]\u756a\u76ee\u306e\u6587\u5b57\u3068\u306a\u308b\nflag = False # \u5947\u6570\u500b\u306e\u6587\u5b57\u304c\u524d\u306b\u3042\u3063\u305f\u304b\u30d5\u30e9\u30b0(\u5947\u6570\u500b\u306e\u6587\u5b57\u304c2\u3064\u4ee5\u4e0a\u3042\u3063\u3066\u306f\u306a\u3089\u306a\u3044)\nAC = [] # \u6700\u7d42\u7684\u306a\u56de\u6587\u3067\u306e\u524d\u534aA\u3068\u5f8c\u534aC\u306e\u30da\u30a2\nfor x, index_list in s_index.items():\n count = len(index_list)\n if count % 2 == 1:\n if flag:\n print(-1)\n return\n else:\n flag = True\n mid = index_list[count//2]\n T[mid] = n//2 # \u56de\u6587\u306e\u4e2d\u5fc3(B)\n for i in range(count//2):\n a = index_list[i]\n c = index_list[-i-1]\n AC.append((a, c))\n\nAC.sort(key=itemgetter(0)) # \u524d\u534a(a)\u306e\u9806\u756a\u3067\u30bd\u30fc\u30c8\nfor i, (a, c) in enumerate(AC):\n T[a] = i # a == i\n T[c] = n - i - 1\n\nBIT = BinaryIndexedTree(n)\ninversion = 0\nfor i, t in enumerate(T):\n i += 1 # 1-index\u306b\u5909\u63db\n t += 1 # 1-index\u306b\u5909\u63db\n BIT.add(t, 1)\n inversion += i - BIT.sum(t)\nprint(inversion)", "# Binary Indexed Tree (Fenwick Tree)\nclass BIT():\n \"\"\"\u4e00\u70b9\u52a0\u7b97\u3001\u533a\u9593\u53d6\u5f97\u30af\u30a8\u30ea\u3092\u305d\u308c\u305e\u308cO(logN)\u3067\u7b54\u3048\u308b\n add: i\u756a\u76ee\u306bval\u3092\u52a0\u3048\u308b\n get_sum: \u533a\u9593[l, r)\u306e\u548c\u3092\u6c42\u3081\u308b\n i, l, r\u306f0-indexed\n \"\"\"\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def _sum(self, i):\n s = 0\n while i > 0:\n s += self.bit[i]\n i -= i & -i\n return s\n\n def add(self, i, val):\n \"\"\"i\u756a\u76ee\u306bval\u3092\u52a0\u3048\u308b\"\"\"\n i = i + 1\n while i <= self.n:\n self.bit[i] += val\n i += i & -i\n\n def get_sum(self, l, r):\n \"\"\"\u533a\u9593[l, r)\u306e\u548c\u3092\u6c42\u3081\u308b\"\"\"\n return self._sum(r) - self._sum(l)\n\n\nimport copy\n\ns = input()\nn = len(s)\nmemo = {}\nfor i in range(n):\n if s[i] not in memo:\n memo[s[i]] = 1\n else:\n memo[s[i]] += 1\n\nodd_cnt = 0\nfor i in memo:\n odd_cnt += memo[i] % 2\nif odd_cnt > 1:\n print(-1)\n return\n\nleft = []\nright = []\n\nmemo2 = copy.deepcopy(memo)\nans_cnt = 0\nword = \"\"\nfor i in range(n):\n if memo2[s[i]]*2 > memo[s[i]] + 1:\n memo2[s[i]] -= 1\n ans_cnt += i - len(left)\n left.append(s[i])\n elif memo2[s[i]]*2 == memo[s[i]] + 1:\n word = s[i]\n memo2[s[i]] -= 1\n right.append(s[i])\n else:\n memo2[s[i]] -= 1\n right.append(s[i])\n \nif word != \"\":\n for i in range(len(right)):\n if right[i] == word:\n ans_cnt += i\n del(right[i])\n break\nright = right[::-1]\n\nmemo = {}\nfor i in range(len(right)):\n if right[i] not in memo:\n memo[right[i]] = [i]\n else:\n memo[right[i]].append(i)\nfor i in memo:\n memo[i] = memo[i][::-1]\n\nfor i in range(len(left)):\n tmp = left[i]\n left[i] = memo[tmp][-1]\n del(memo[tmp][-1])\n\nmemo = {}\nfor i in range(len(left)):\n memo[i] = left[i]\n\nbit = BIT(len(left))\nfor i in range(len(left)):\n bit.add(memo[i], 1)\n ans_cnt += bit.get_sum(memo[i] + 1, len(left))\nprint(ans_cnt)", "from collections import defaultdict\nS = input()\n\nclass BIT:\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def update(self, i, v):\n while i <= self.n:\n self.bit[i] += v\n i += i & -i\n \n def query(self, i):\n ret = 0\n while i > 0:\n ret += self.bit[i]\n i -= i & -i\n \n return ret\n\nd = defaultdict(list)\nfor i, v in enumerate(S):\n d[v].append(i + 1)\n\nif sum(len(l) % 2 != 0 for l in list(d.values())) > 1:\n print((-1))\n return\n\nN = len(S)\nctr = []\nkey_map = [-1] * (N + 1)\n\nfor k, v in list(d.items()):\n t = len(v)\n if t % 2 == 1:\n key_map[v[t // 2]] = N // 2 + 1\n\n for j in range(t // 2):\n ctr.append((v[j], v[-j - 1]))\n \nctr.sort()\n\nfor i, (l, r) in enumerate(ctr):\n key_map[l] = i + 1\n key_map[r] = N - i\n\ntree = BIT(N)\nans = 0\nfor i, v in enumerate(key_map[1:]):\n ans += i - tree.query(v)\n tree.update(v, 1)\nprint(ans)\n", "import sys\ninput = sys.stdin.readline\n\nS = list(input().rstrip())\nL = len(S)\n\n# binary indexed tree\nbit = [0 for _ in range(L+1)]\n\n# 0\u304b\u3089i\u307e\u3067\u306e\u533a\u9593\u548c\n# \u7acb\u3063\u3066\u3044\u308b\u30d3\u30c3\u30c8\u3092\u4e0b\u304b\u3089\u51e6\u7406\ndef query_sum(i):\n s = 0\n while i > 0:\n s += bit[i]\n i -= i & -i\n return s\n\n# i\u756a\u76ee\u306e\u8981\u7d20\u306bx\u3092\u8db3\u3059\n# \u8986\u3063\u3066\u308b\u533a\u9593\u3059\u3079\u3066\u306b\u8db3\u3059\ndef add(i, x):\n while i <= L:\n bit[i] += x\n i += i & -i\n\ndef main():\n A = {}\n for i, s in enumerate(S):\n if not s in A.keys():\n A[s] = [i]\n else:\n A[s].append(i)\n odd = 0\n dic = {}\n for al, c in A.items():\n dic[al] = 0\n if len(c)%2 != 0:\n odd += 1\n if odd > 1:\n print(-1)\n else:\n make_ind = []\n for s, B in A.items():\n l = len(B)\n if l%2 == 1:\n mid = B[l//2]\n for j, b in enumerate(B):\n if j < l//2:\n make_ind.append(b)\n make_ind.sort()\n IND = [None]*L\n for i, m in enumerate(make_ind):\n s = S[m]\n IND[m] = i+1\n inv = A[s][len(A[s])-1-dic[s]]\n IND[inv] = L-i\n dic[s] += 1\n if L%2 == 1:\n IND[mid] = L//2+1\n \n\n ans = 0\n for j, a in enumerate(IND):\n ans += j - query_sum(a)\n add(a, 1)\n \n print(ans)\n\ndef __starting_point():\n main()\n__starting_point()", "from collections import deque\nalphabetlist=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']\n\nS=input()\nN=len(S)\n\ndic={moji:deque([]) for moji in alphabetlist}\nfor i in range(N):\n dic[S[i]].append(i+1)\n\nleft=deque([])\nright=deque([])\nmid=[]\n\nif N%2==1:\n check=0\n memo=0\n for moji in dic:\n if len(dic[moji])%2==1:\n k=len(dic[moji])\n check+=1\n memo=dic[moji][k//2]\n if check!=1:\n print(-1)\n return\n else:\n mid.append(memo)\nelse:\n check=0\n for moji in dic:\n if len(dic[moji])%2==1:\n print(-1)\n return\n\nfor i in range(N//2):\n for moji in alphabetlist:\n if len(dic[moji])>=2:\n L=dic[moji][0]\n R=dic[moji][-1]\n for moji2 in alphabetlist:\n if len(dic[moji2])>=2 and dic[moji2][0]<L<R<dic[moji2][-1]:\n break\n else:\n left.append(L)\n right.appendleft(R)\n dic[moji].popleft()\n dic[moji].pop()\n break\n\nans=list(left)+mid+list(right)\nn=N\n#A1 ... An\u306eBIT(1-indexed)\nBIT = [0]*(n+1)\n\n#A1 ~ Ai\u307e\u3067\u306e\u548c O(logN)\ndef BIT_query(idx):\n res_sum = 0\n while idx > 0:\n res_sum += BIT[idx]\n idx -= idx&(-idx)\n return res_sum\n\n#Ai += x O(logN)\ndef BIT_update(idx,x):\n while idx <= n:\n BIT[idx] += x\n idx += idx&(-idx)\n return\n\nres=0\nfor i in range(N):\n res+=i-BIT_query(ans[i])\n BIT_update(ans[i],1)\n\nprint(res)", "\"\"\"\n\u3069\u308c\u3068\u30da\u30a2\u306b\u306a\u308b\u304b\u306f\u6700\u521d\u304b\u3089\u78ba\u5b9a\n\u4f4d\u7f6e\u3092\u6c7a\u3081\u308c\u3070\u5f8c\u306f\u8ee2\u5012\u6570\n\"\"\"\nimport sys\n\ndef bitadd(a,w,bit): #a\u306bw\u3092\u52a0\u3048\u308b(1-origin)\n \n x = a\n while x <= (len(bit)-1):\n bit[x] += w\n x += x & (-1 * x)\n \ndef bitsum(a,bit): #ind 1\uff5ea\u307e\u3067\u306e\u548c\u3092\u6c42\u3081\u308b\n \n ret = 0\n x = a\n while x > 0:\n ret += bit[x]\n x -= x & (-1 * x)\n return ret\n\n\nS = input()\n\ndic = {}\n\nfor i,s in enumerate(S):\n\n if s not in dic:\n\n dic[s] = []\n\n dic[s].append(i)\n\npair = [None] * len(S)\nlis = [None] * len(S)\n\nfor i in dic:\n\n for j in range(len(dic[i]) // 2):\n\n pair[dic[i][j]] = dic[i][-1-j]\n pair[dic[i][-1-j]] = -1\n\nnumnone = 0\nfor i in pair:\n if i == None:\n numnone += 1\n\nif numnone > 1:\n print((-1))\n return\n\nnmax = 0\nfor i,num in enumerate(pair):\n\n if num == None:\n lis[i] = len(S)//2\n\n if num != None and num >= 0:\n \n lis[i] = nmax\n lis[num] = len(S)-1-nmax\n nmax += 1\n\nBIT = [0] * (len(S)+1)\nans = 0\nlis.reverse()\n\nfor i,num in enumerate(lis):\n\n num += 1\n ans += bitsum(num,BIT)\n bitadd(num,1,BIT)\n\nprint (ans)\n", "from string import ascii_lowercase\n\n\nclass Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n\ndef solve(s):\n indices = {c: [] for c in ascii_lowercase}\n for i, c in enumerate(s):\n indices[c].append(i)\n\n n = len(s)\n center = n // 2\n bubbles = [-1] * n\n odd_flag = False\n lefts, rights = [], []\n used = [False] * n\n for c, ids in list(indices.items()):\n cnt = len(ids)\n if cnt & 1:\n if odd_flag:\n return -1\n odd_flag = True\n bubbles[ids[cnt // 2]] = center + 1\n used[center] = True\n for i in range(cnt // 2):\n li, ri = ids[i], ids[-i - 1]\n if li < center:\n lefts.append((li, ri))\n used[n - li - 1] = True\n else:\n rights.append((li, ri))\n lefts.sort()\n rights.sort()\n r_itr = iter(rights)\n # print(lefts)\n # print(rights)\n for i, (li, ri) in enumerate(lefts):\n bubbles[li] = i + 1\n bubbles[ri] = n - i\n for i in range(len(lefts), center):\n li, ri = next(r_itr)\n bubbles[li] = i + 1\n bubbles[ri] = n - i\n # print(bubbles)\n\n ans = 0\n bit = Bit(n)\n for i, m in enumerate(bubbles):\n ans += i - bit.sum(m)\n bit.add(m, 1)\n return ans\n\n\nprint((solve(input())))\n", "from collections import Counter\n\n\nclass fenwick_tree(object):\n def __init__(self, n):\n self.n = n\n self.data = [0] * n\n\n def __sum(self, r):\n s = 0\n while r > 0:\n s += self.data[r - 1]\n r -= r & -r\n return s\n\n def add(self, p, x):\n \"\"\" a[p] += x\u3092\u884c\u3046\"\"\"\n assert 0 <= p and p < self.n\n p += 1\n while p <= self.n:\n self.data[p - 1] += x\n p += p & -p\n\n def sum(self, l, r):\n \"\"\"a[l] + a[l+1] + .. + a[r-1]\u3092\u8fd4\u3059\"\"\"\n assert 0 <= l and l <= r and r <= self.n\n return self.__sum(r) - self.__sum(l)\n\n\ndef calc_inversion(arr):\n N = len(arr)\n bit = fenwick_tree(N)\n atoi = {a: i for i, a in enumerate(arr)}\n res = 0\n for a in reversed(range(N)):\n i = atoi[a]\n res += bit.sum(0, i)\n bit.add(i, 1)\n return res\n\n\ndef calc_inv(arr):\n N = len(set(arr))\n atoi = {a: i for i, a in enumerate(sorted(set(arr)))}\n bit = fenwick_tree(N)\n res = 0\n for i, a in enumerate(arr):\n res += i - bit.sum(0, atoi[a] + 1)\n bit.add(atoi[a], 1)\n return res\n\n\ndef main():\n S = input()\n N = len(S)\n C = Counter(S)\n\n odd = 0\n mid = \"\"\n for k, v in C.items():\n if v & 1:\n odd += 1\n mid = k\n\n if N % 2 == 0: # \u5076\u6570\n if odd:\n return -1\n half = {k: v // 2 for k, v in C.items()}\n cnt = {k: 0 for k in C.keys()}\n label = []\n left = []\n right = []\n for i, s in enumerate(S):\n if cnt[s] < half[s]:\n label.append(0)\n left.append(s)\n else:\n label.append(1)\n right.append(s)\n cnt[s] += 1\n ans = calc_inv(label)\n\n pos = {k: [] for k in C.keys()}\n for i, s in enumerate(left):\n pos[s].append(i)\n label = []\n for s in right:\n label.append(pos[s].pop())\n ans += calc_inv(label[::-1])\n return ans\n\n else: # \u5947\u6570\n if odd != 1:\n return -1\n half = {k: v // 2 for k, v in C.items()}\n cnt = {k: 0 for k in C.keys()}\n label = []\n right = []\n left = []\n seen = 0\n LL = 0 # mid\u306e\u53f3\u306b\u3042\u308bL\n RR = 0 # mid\u306e\u5de6\u306b\u3042\u308bR\n\n for i, s in enumerate(S):\n if s == mid and cnt[s] == half[s]:\n seen = 1\n cnt[s] += 1\n continue\n if cnt[s] < half[s]:\n label.append(0)\n left.append(s)\n if seen:\n LL += 1\n else:\n label.append(1)\n right.append(s)\n if not seen:\n RR += 1\n cnt[s] += 1\n ans = calc_inv(label)\n ans += RR + LL\n\n pos = {k: [] for k in C.keys()}\n for i, s in enumerate(left):\n pos[s].append(i)\n label = []\n for s in right:\n label.append(pos[s].pop())\n ans += calc_inv(label[::-1])\n return ans\n\n\nprint(main())", "from collections import Counter\nS = input()\nN = len(S)\nctr = Counter(S)\nif len([1 for v in ctr.values() if v%2]) > 1:\n print(-1)\n return\n\nM = None\nfor k,v in ctr.items():\n if v%2:\n M = k\n ctr[k] //= 2\n\ndef ctoi(c):\n return ord(c) - ord('a')\nfrom collections import deque\nidxs = [deque() for _ in range(26)]\nfor i,c in enumerate(S):\n idxs[ctoi(c)].append(i)\n\nA = ''\nP = []\ni = 0\nwhile len(A) < N//2:\n c = S[i]\n if ctr[c] > 0:\n ctr[c] -= 1\n A += c\n P.append(idxs[ctoi(c)].popleft())\n i += 1\nif M:\n P.append(idxs[ctoi(M)].popleft())\nfor c in A[::-1]:\n P.append(idxs[ctoi(c)].popleft())\n\ndef inversion(inds):\n bit = [0] * (N+1)\n def bit_add(x,w):\n while x <= N:\n bit[x] += w\n x += (x & -x)\n def bit_sum(x):\n ret = 0\n while x > 0:\n ret += bit[x]\n x -= (x & -x)\n return ret\n inv = 0\n for ind in reversed(inds):\n inv += bit_sum(ind + 1)\n bit_add(ind + 1, 1)\n return inv\n\nprint(inversion(P))", "class segment_tree_dual:\n def __init__(self, N, compose, funcval, ID_M=None):\n self.compose = compose\n self.ID_M = ID_M\n self.funcval = funcval\n\n self.height = (N-1).bit_length() #\u6728\u306e\u6bb5\u6570\n self.N0 = 1<<self.height #\u6728\u306e\u6a2a\u5e45 >= N\n self.laz = [self.ID_M]*(2*self.N0) #\u4f5c\u7528\u7d20\u306e\u6728\n self.val = None #\u5024\u306e\u914d\u5217\n\n #\u521d\u671f\u5024\u306e\u914d\u5217\u3092\u4f5c\u308b\n def build(self,initial):\n self.val = initial[:]\n\n #laz[k] \u3092\u5b50\u306b\u4f1d\u3048\u308b\u3001k \u304c\u4e00\u756a\u4e0b\u306e\u5834\u5408\u306f laz[k] \u3092 val \u306b\u53cd\u6620\u3059\u308b\n def propagate(self,k):\n if self.laz[k] == self.ID_M: return;\n if self.N0 <= k:\n self.val[k-self.N0] = self.funcval(self.val[k-self.N0], self.laz[k])\n self.laz[k] = self.ID_M\n else:\n self.laz[(k<<1) ] = self.compose(self.laz[(k<<1) ],self.laz[k]);\n self.laz[(k<<1)+1] = self.compose(self.laz[(k<<1)+1],self.laz[k]);\n self.laz[k] = self.ID_M;\n \n # \u9045\u5ef6\u3092\u3059\u3079\u3066\u89e3\u6d88\u3059\u308b\n def propagate_all(self):\n upto = self.N0 + len(self.val)\n for i in range(1,upto): self.propagate(i)\n\n # laz[k]\u304a\u3088\u3073\u305d\u306e\u4e0a\u306b\u4f4d\u7f6e\u3059\u308b\u4f5c\u7528\u7d20\u3092\u3059\u3079\u3066\u4f1d\u64ad\n def thrust(self,k):\n for i in range(self.height,-1,-1): self.propagate(k>>i)\n\n # \u533a\u9593[l,r]\u306b\u95a2\u6570 f \u3092\u4f5c\u7528\n def update(self, L,R,f):\n L += self.N0; R += self.N0+1\n \"\"\"\u307e\u305a\u4f1d\u64ad\u3055\u305b\u308b\uff08\u30aa\u30da\u30ec\u30fc\u30bf\u304c\u53ef\u63db\u306a\u3089\u5fc5\u8981\u306a\u3044\uff09\"\"\"\n #self.thrust(L)\n #self.thrust(R-1)\n #\u767b\u308a\u306a\u304c\u3089\u95a2\u6570 f \u3092\u5408\u6210\n while L < R:\n if R & 1:\n R -= 1\n self.laz[R] = self.compose(self.laz[R],f)\n if L & 1:\n self.laz[L] = self.compose(self.laz[L],f)\n L += 1\n L >>= 1; R >>= 1\n \n # values[k] \u3092\u53d6\u5f97\u3002\n def point_get(self, k):\n res = self.val[k]\n k += self.N0\n while k:\n if self.laz[k] != self.ID_M:\n res = self.funcval(res, self.laz[k])\n k //= 2\n return res\n \n # values[k] = x \u4ee3\u5165\u3059\u308b\n def point_set(self, k): \n self.thrust(k+self.N0)\n self.val[k] = x\n\n\n\n# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\n#x,y = map(int,readline().split())\nfrom collections import deque\ns = input()\nlst = [deque() for _ in range(26)]\nfor i,c in enumerate(s):\n lst[ord(c)-97].append(i)\n\nc = 0\nfor l in lst:\n if len(l)%2==1: c += 1\nif c >= 2:\n print((-1))\n return\n\nn = len(s)\nL = 0\nR = n-1\nfrom operator import add\nseg = segment_tree_dual(n, compose=add, funcval=add, ID_M=0)\nseg.build([0]*n)\n\nans = 0\nINF = 1<<30\nfor i in range(n//2):\n I = -1\n v = INF\n for idx in range(26):\n if lst[idx]:\n a,b = lst[idx][0], lst[idx][-1]\n d = a+seg.point_get(a)-i + n-1-i-(b+seg.point_get(b))\n #print(i,d,lst[idx],a+seg.point_get(a),(b+seg.point_get(b)))\n if d < v:\n I = idx\n v = d\n #print(v,I,lst[I],a,seg.point_get(a),n-1,(b+seg.point_get(b)))\n seg.update(0,lst[I].popleft(),1)\n seg.update(lst[I].pop(),n-1,-1)\n ans += v\n\nprint(ans)\n\n\n\n\n", "import sys\nclass BIT():\n def __init__(self,number):\n self.n=number\n self.list=[0]*(number+1)\n \n def add(self,i,x):#ith added x 1indexed\n while i<=self.n:\n self.list[i]+=x\n i+=i&-i\n \n def search(self,i):#1-i sum\n s=0\n while i>0:\n s+=self.list[i]\n i-=i&-i\n return s\n \n def suma(self,i,j):#i,i+1,..j sum\n return self.search(j)-self.search(i-1)\n#from collections import defaultdict\nS=input()\nN = len(S)\nL = 26\na = ord('a')\nd = [[] for i in range(L)]\nfor i in range(N):\n s=ord(S[i])-a\n d[s].append(i)\nflag=0\nfor i in range(L):\n if len(d[i])%2==1:\n flag+=1\nif flag>1:\n print(-1)\n return\nSuc=[-1]*N\npairs=[]\nfor i in range(L):\n T=len(d[i])\n for s in range((T//2)):\n li,ri=d[i][s],d[i][-s-1]\n pairs.append((li,ri))\n if T%2==1:\n Suc[d[i][T//2]]=(N//2)+1\npairs.sort()\nfor i, (li,ri) in enumerate(pairs):\n Suc[li]=i+1\n Suc[ri]=N-i\nTree=BIT(N+3)\nans=0\nfor i,m in enumerate(Suc):\n ans+=i-Tree.search(m)\n Tree.add(m,1)\n#ans+=Tree.search(N+1)\nprint(ans)", "s = input()\ncnt = [0] * 26\nn = len(s)\n\nfor c in s:\n cnt[ord(c) - ord('a')] += 1\n\nodd = -1\nfor i in range(26):\n if cnt[i] % 2 == 1:\n if odd != -1:\n print(-1)\n return\n odd = i\n\ncnt2 = [[] for i in range(26)]\nnums = []\nleft = 0\nfor i in range(len(s)):\n c = s[i]\n ind = ord(c) - ord('a')\n if len(cnt2[ind]) * 2 + 1 == cnt[ind]:\n cnt2[ind].append((n-1)//2)\n nums.append((n-1)//2)\n elif len(cnt2[ind]) <= (cnt[ind]-1)//2:\n cnt2[ind].append(left)\n nums.append(left)\n left += 1\n else:\n num = n - 1 - cnt2[ind][cnt[ind]-1-len(cnt2[ind])]\n cnt2[ind].append(num)\n nums.append(num)\n\nans = 0\n#print(nums)\nbit = [0] * (n+1)\ndef add(x):\n nonlocal bit\n x += 1\n while x <= n:\n bit[x] += 1\n x += x & -x\n\ndef sum(x):\n x += 1\n res = 0\n while x:\n res += bit[x]\n x -= x & -x\n return res\nfor num in nums[::-1]:\n ans += sum(num)\n add(num)\n\nprint(ans)", "#!/usr/bin/env python3\n\nclass Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * n\n\n def sum(self, i):\n s = 0\n i -= 1\n while i >= 0:\n s += self.tree[i]\n i = (i & (i + 1)) - 1\n return s\n\n def add(self, i, x):\n while i < self.size:\n self.tree[i] += x\n i |= i + 1\n\na = ord('a')\n\ndef make_index(s):\n\n index = [[] for _ in range(26)]\n for i, ch in enumerate(s):\n index[ord(ch) - a].append(i)\n\n return index\n\ndef solve(s):\n\n n = len(s)\n index = make_index(s)\n\n odd = None\n for code, char_pos in enumerate(index):\n if len(char_pos) % 2 == 1:\n if odd is not None:\n return -1\n odd = code\n\n bit = Bit(n)\n\n ans = 0\n cnt = 0\n for i in range(n):\n if bit.sum(i + 1) - bit.sum(i) == 1:\n continue\n code = ord(s[i]) - a\n if code == odd and index[code][-1] == i:\n continue\n cnt += 1\n j = index[code].pop()\n ans += n - cnt - (j - bit.sum(j))\n bit.add(j, 1)\n if n // 2 <= cnt:\n break\n\n if odd is not None:\n j = index[odd][-1]\n ans += abs(n // 2 - (j - bit.sum(j)))\n\n return ans\n\n\ndef main():\n s = input()\n\n print((solve(s)))\n\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "from collections import Counter,defaultdict\n\nclass Bit:\n def __init__(self,n):\n self.size = n\n self.tree = [0]*(n+1)\n \n def sum(self,i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self,i,x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\ns = input()\nn = len(s)\nc = Counter(s)\nflg = 0\nif n%2 == 0:\n for i in c.values():\n if i%2:\n print(-1)\n return\nelse:\n for st,i in c.items():\n if i%2 and flg:\n print(-1)\n return\n elif i%2:\n flg = 1\nans = 0\nfstr = []\nlstr = []\ndc = defaultdict(int)\nptr = 0\nfor i in range(n):\n si = s[i]\n dc[si] += 1\n cnt = dc[si]\n if c[si]%2:\n if cnt*2-1 == c[si]:\n ans += i-ptr\n continue\n if cnt <= c[si]//2:\n ans += i-ptr\n ptr += 1\n fstr.append(si)\n else:\n lstr.append(si)\nlstr = lstr[::-1]\nn //= 2\nperm = [0]*n\nfdc = defaultdict(list)\nldc = defaultdict(int)\nlcnt = 0\nfor i in range(n):\n fi = fstr[i]\n fdc[fi].append(i+1)\nfor i in range(n):\n li = lstr[i]\n perm[i] = fdc[li][ldc[li]]\n ldc[li] += 1\nsol = Bit(n+2)\nfor i in range(n):\n p = perm[i]\n ans += sol.sum(n+1)-sol.sum(p)\n sol.add(p,1)\nprint(ans)", "from collections import deque\nimport sys\ninput = sys.stdin.readline\n\nclass FenwickTree:\n def __init__(self, size):\n self.data = [0] * (size + 1)\n self.size = size\n\n # i is exclusive\n def prefix_sum(self, i):\n s = 0\n while i > 0:\n s += self.data[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n i += 1\n while i <= self.size:\n self.data[i] += x\n i += i & -i\n\n def lower_bound(self, x):\n if x <= 0:\n return 0\n k = 1\n while k * 2 <= self.size:\n k *= 2\n i = 0\n while k > 0:\n if i + k <= self.size and self.data[i + k] < x:\n x -= self.data[i + k]\n i += k\n k //= 2\n return i\n\n\nclass RangeFenwickTree:\n def __init__(self, size):\n self.bit0 = FenwickTree(size)\n self.bit1 = FenwickTree(size)\n\n # i is exclusive\n def prefix_sum(self, i):\n return self.bit0.prefix_sum(i) * (i - 1) + self.bit1.prefix_sum(i)\n\n def add(self, l, r, x):\n self.bit0.add(l, x)\n self.bit0.add(r, -x)\n self.bit1.add(l, -x * (l - 1))\n self.bit1.add(r, x * (r - 1))\n\n\nclass FenwickTree2D:\n def __init__(self, H, W):\n self.H = H\n self.W = W\n self.data = [[0] * (H + 1) for _ in range(W + 1)]\n\n def add(self, a, b, x):\n a += 1\n b += 1\n i = a\n while i <= self.H:\n j = b\n while j <= self.W:\n self.data[i][j] += x\n j += j & -j\n i += i & -i\n\n def sum(self, a, b):\n a += 1\n b += 1\n ret = 0\n i = a\n while i > 0:\n j = b\n while j > 0:\n ret += self.data[i][j]\n j -= j & -j\n i -= i & -i\n return ret\n\nS = list(map(lambda c: ord(c) - ord('a'), input().rstrip()))\nN = len(S)\nidx = [deque() for _ in range(26)]\nfor i, c in enumerate(S):\n idx[c].append(i)\nif sum(len(v) % 2 for v in idx) > 1:\n print(-1)\n return\nfw = FenwickTree(N + 1)\nfor i in range(1, N + 1):\n fw.add(i, 1)\nans = 0\nfor i in range(N // 2):\n min_cost = float('inf')\n char = -1\n for c in range(26):\n if len(idx[c]) <= 1:\n continue\n l = idx[c][0]\n cost = fw.prefix_sum(l + 1) - i\n r = idx[c][-1]\n cost += N - i - 1 - fw.prefix_sum(r + 1)\n if cost < min_cost:\n min_cost = cost\n char = c\n ans += min_cost\n fw.add(0, 1)\n fw.add(idx[char].popleft(), -1)\n fw.add(idx[char].pop(), -1)\nprint(ans)", "import sys\ninput = sys.stdin.readline\nfrom collections import deque, defaultdict, Counter\n\nS = input().rstrip()\nL = len(S)\n\nc = Counter(S)\nif sum((x&1 for x in c.values())) >= 2:\n print(-1)\n return\n\nalphabet_to_pos = defaultdict(deque)\n\nfor i,x in enumerate(S,1):\n alphabet_to_pos[x].append(i)\n\nafter = [None] * len(S)\nn = 0\nfor i,x in enumerate(S,1):\n p = alphabet_to_pos[x]\n if not p:\n continue\n if len(p) == 1:\n p.pop()\n after[L//2] = i\n continue\n p.popleft()\n j = p.pop()\n after[n] = i\n after[L - n - 1] = j\n n += 1\n\ndef BIT_update(tree,x):\n while x <= L:\n tree[x] += 1\n x += x & (-x)\n\ndef BIT_sum(tree,x):\n s = 0\n while x:\n s += tree[x]\n x -= x & (-x)\n return s\n\nanswer = 0\ntree = [0] * (L+1)\nfor i,x in enumerate(after):\n answer += i - BIT_sum(tree,x)\n BIT_update(tree,x)\n\nprint(answer)", "from string import ascii_lowercase\n\n\nclass Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n\ndef solve(s):\n indices = {c: [] for c in ascii_lowercase}\n for i, c in enumerate(s):\n indices[c].append(i)\n\n n = len(s)\n center = n // 2\n bubbles = [-1] * n\n odd_flag = False\n lefts, rights = [], []\n for c, ids in list(indices.items()):\n cnt = len(ids)\n if cnt & 1:\n if odd_flag:\n return -1\n odd_flag = True\n bubbles[ids[cnt // 2]] = center + 1\n for i in range(cnt // 2):\n li, ri = ids[i], ids[-i - 1]\n if li < center:\n lefts.append((li, ri))\n else:\n rights.append((li, ri))\n lefts.sort()\n rights.sort()\n r_itr = iter(rights)\n for i, (li, ri) in enumerate(lefts):\n bubbles[li] = i + 1\n bubbles[ri] = n - i\n for i in range(len(lefts), center):\n li, ri = next(r_itr)\n bubbles[li] = i + 1\n bubbles[ri] = n - i\n\n ans = 0\n bit = Bit(n)\n for i, m in enumerate(bubbles):\n ans += i - bit.sum(m)\n bit.add(m, 1)\n return ans\n\n\nprint((solve(input())))\n", "from collections import Counter\nclass BIT:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n \n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n \n def add(self, i, x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\nS = input()\nN = len(S)\n\ncnt = 0\nSC = Counter(S)\nfor v in SC.values():\n if v % 2:\n cnt += 1\nif cnt > 1:\n print(-1)\n return\n\ngeta = 10**9+7\nT = [None]*N\ntable = Counter()\nidx = dict()\nctr = 0\nfor i, s in enumerate(S):\n table[s] += 1\n if table[s] <= SC[s]//2: \n T[i] = ctr\n idx[ord(s)*geta + table[s]] = ctr\n ctr += 1\n continue\n if table[s] > (1+SC[s])//2:\n T[i] = N - 1 - idx[ord(s)*geta+(SC[s] + 1 - table[s])]\n continue\n if SC[s] % 2 and table[s] == (SC[s]+1)//2:\n T[i] = (N-1)//2\n continue\nTr = [None]*N\nfor i, v in enumerate(T):\n Tr[v] = i\nB = BIT(N)\nans = 0\nfor tr in Tr[::-1]:\n ans += B.sum(tr + 1)\n B.add(tr + 1, 1)\nprint(ans)", "import sys\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nclass BIT():#1-indexed\n\tdef __init__(self, size):\n\t\tself.table = [0 for _ in range(size+2)]\n\t\tself.size = size\n\n\tdef Sum(self, i):#1\u304b\u3089i\u307e\u3067\u306e\u548c\n\t\ts = 0\n\t\twhile i > 0:\n\t\t\ts += self.table[i]\n\t\t\ti -= (i & -i)\n\t\treturn s\n\n\tdef PointAdd(self, i, x):#\n\t\twhile i <= self.size:\n\t\t\tself.table[i] += x\n\t\t\ti += (i & -i)\n\t\treturn\n\ns = input()\nn = len(s)\na = [-1 for _ in range(n)]\nch = [[] for _ in range(26)]\nfor i in range(n):\n\tch[ord(s[i])-97].append(i)\nif sum([len(x)%2 == 1 for x in ch]) > 1:\n\tprint(-1)\n\treturn\n\nfor i, c in enumerate(ch):\n\ttmp = i\n\tl = len(c)\n\tfor j in range(l//2):\n\t\ta[c[j]] = tmp\n\t\ta[c[l-j-1]] = tmp\n\t\ttmp += 26\n#print(a)\n\nformer, latter = 0, 0\nhalf = False\nd = dict()\ncur = 0\nbubble = []\n\nans = 0\n\nfor x in a:\n\tif x >= 0:\n\t\tif x not in d:\n\t\t\td[x] = cur\n\t\t\tcur += 1\n\t\t\tformer += 1\n\t\t\tans += latter + half\n\t\telse:\n\t\t\tbubble.append(d[x])\n\t\t\tlatter += 1\n\t\t\tif n%2 == 1 and not half:\n\t\t\t\tans += 1\n\telse:\n\t\thalf = True\n\nbit = BIT(n//2+2)\nfor b in bubble:\n\tans += bit.Sum(b+1)\n\tbit.PointAdd(b+1, 1)\n\nprint(ans)", "\nimport sys\nfrom collections import deque, defaultdict\nimport copy\nimport bisect\nsys.setrecursionlimit(10 ** 9)\nimport math\nimport heapq\nfrom itertools import product, permutations,combinations\nimport fractions\n\nimport sys\ndef input():\n\treturn sys.stdin.readline().strip()\n\nS = input()\n\nalpha = defaultdict(int)\nN = len(S)\nfor i in range(N):\n\talpha[S[i]] += 1\n\nnum = 0\nfor n in alpha:\n\tif alpha[n] % 2 == 1:\n\t\tnum += 1\n\nif num >= 2:\n\tprint((-1))\n\treturn\n\nalpha_num = defaultdict(deque)\nfor i in range(N):\n\talpha_num[S[i]].append(i)\n\nloc_list = [-1]*N\nnum = 0\nfor i in range(N):\n\tif len(alpha_num[S[i]]) >= 2:\n\t\tx = alpha_num[S[i]].popleft()\n\t\ty = alpha_num[S[i]].pop()\n\t\tloc_list[x] = num\n\t\tloc_list[y] = N - 1 - num\n\t\tnum += 1\n\telif len(alpha_num[S[i]]) == 1:\n\t\tx = alpha_num[S[i]].popleft()\n\t\tloc_list[x] = N // 2\n\nclass Bit:\n\tdef __init__(self, n):\n\t\tself.size = n\n\t\tself.tree = [0] * (n + 1)\n\n\tdef sum(self, i):\n\t\ts = 0\n\t\twhile i > 0:\n\t\t\ts += self.tree[i]\n\t\t\ti -= i & -i\n\t\treturn s\n\n\tdef add(self, i, x):\n\t\twhile i <= self.size:\n\t\t\tself.tree[i] += x\n\t\t\ti += i & -i\n\n\nbit = Bit(N)\nans = 0\n\n\n\nfor i, p in enumerate(loc_list):\n\tbit.add(p + 1, 1)\n\tans += i + 1 - bit.sum(p + 1)\n\nprint(ans)\n", "from collections import Counter, defaultdict\n\n\nclass Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n\nS = input()\nN = len(S)\nC = Counter(S)\nif len(S) % 2 == 0:\n for x in list(C.values()):\n if x % 2 == 1:\n print((-1))\n return\nelse:\n cnt = 0\n for x in list(C.values()):\n if x % 2 == 1:\n cnt += 1\n if cnt > 1:\n print((-1))\n return\n\ncnt1 = 1\ncnt2 = (N + 1) // 2 + 1\ncnt_char = defaultdict(int)\nseq = [0] * N\nS1 = []\nS2 = []\nfor i, s in enumerate(S):\n cnt_char[s] += 1\n if C[s] % 2 == 1:\n if cnt_char[s] == C[s] // 2 + 1:\n seq[i] = N // 2 + 1\n continue\n if cnt_char[s] <= C[s] // 2:\n seq[i] = cnt1\n cnt1 += 1\n S1.append(s)\n else:\n seq[i] = cnt2\n cnt2 += 1\n S2.append(s)\nS2.reverse()\n\nans = 0\nseq.reverse()\nbit1 = Bit(N+1)\nfor i in range(N):\n ans += bit1.sum(seq[i])\n bit1.add(seq[i], 1)\n\nchar2idx = defaultdict(list)\nfor i, s1 in enumerate(S1):\n char2idx[s1].append(i+1)\nfor x in list(char2idx.keys()):\n char2idx[x].reverse()\n\nseq_ = []\nfor i, s2 in enumerate(S2):\n seq_.append(char2idx[s2].pop())\n\nbit2 = Bit(N+1)\nseq_.reverse()\nfor i in range(len(seq_)):\n ans += bit2.sum(seq_[i])\n bit2.add(seq_[i], 1)\n\nprint(ans)\n", "from collections import defaultdict\n\nclass BIT():\n def __init__(self,n):\n self.size=n\n self.bit=[0]*(n+1)\n def add(self,i,x):\n while i<=self.size:\n self.bit[i]+=x\n i+=i&-i\n def sum(self,i):\n s=0\n while i>0:\n s+=self.bit[i]\n i-=i&-i\n return s\n\ns=input()\nn=len(s)\nidx=defaultdict(list)\nfor i,c in enumerate(s):\n idx[c].append(i)\nctr=n//2\nB=[0]*n\nflag=False\nP=[]\nfor c,I in idx.items():\n cnt=len(I)\n if cnt%2:\n if flag:\n print(-1)\n return\n flag=True\n B[I[cnt//2]]=ctr+1\n for i in range(cnt//2):\n l,r=I[i],I[-i-1]\n P.append((l,r))\nP.sort()\nfor i,(l,r) in enumerate(P):\n B[l],B[r]=i+1,n-i\nans=0\nbit=BIT(n)\nfor i,b in enumerate(B):\n ans+=i-bit.sum(b)\n bit.add(b,1)\nprint(ans)", "class BIT:\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def _sum(self, i):\n s = 0\n while i > 0:\n s += self.bit[i]\n i -= i & -i\n return s\n\n def add(self, i, val):\n \"\"\"i\u756a\u76ee\u306bval\u3092\u52a0\u3048\u308b\"\"\"\n i = i + 1\n while i <= self.n:\n self.bit[i] += val\n i += i & -i\n\n def get_sum(self, l, r):\n \"\"\"\u533a\u9593[l, r)\u306e\u548c\u3092\u6c42\u3081\u308b\"\"\"\n return self._sum(r) - self._sum(l)\n \n\ndef swap_time(array0, array1):\n n = len(array0)\n memo = {}\n for i in range(n)[::-1]:\n if array0[i] not in memo:\n memo[array0[i]] = []\n memo[array0[i]].append(i)\n res = []\n for val in array1:\n ind = memo[val].pop()\n res.append(ind)\n \n bit = BIT(n)\n ans = 0\n for i in range(n):\n bit.add(res[i], 1)\n ans += bit.get_sum(res[i] + 1, n)\n return ans\n \n \n\nALPH = \"abcdefghijklmnopqrstuvwxyz\"\ns = input()\n\ncnt_memo = {}\nfor char in s:\n if char not in cnt_memo:\n cnt_memo[char] = 1\n else:\n cnt_memo[char] += 1\n\nodd = \"\"\nfor char in cnt_memo:\n if cnt_memo[char] % 2 == 1:\n if odd:\n print(-1)\n return\n else:\n odd = char\n cnt_memo[char] -= 1\n cnt_memo[char] //= 2\n else:\n cnt_memo[char] //= 2\n\nleft = []\nmid = []\nif odd:\n mid = [odd]\nright = []\nfor char in s:\n if odd == char and cnt_memo[char] == 0:\n odd = \"\"\n elif cnt_memo[char] != 0:\n left.append(char)\n cnt_memo[char] -= 1\n else:\n right.append(char)\n\nans = 0\nans += swap_time(left + mid + right, list(s))\nans += swap_time(left, right[::-1])\nprint(ans)", "from string import ascii_lowercase\n\n\nclass Bit:\n def __init__(self, n):\n self.size = n\n self.tree = [0] * (n + 1)\n\n def sum(self, i):\n s = 0\n while i > 0:\n s += self.tree[i]\n i -= i & -i\n return s\n\n def add(self, i, x):\n while i <= self.size:\n self.tree[i] += x\n i += i & -i\n\n\ndef solve(s):\n indices = {c: [] for c in ascii_lowercase}\n for i, c in enumerate(s):\n indices[c].append(i)\n\n n = len(s)\n center = n // 2\n bubbles = [-1] * n\n odd_flag = False\n pairs = []\n for c, ids in list(indices.items()):\n cnt = len(ids)\n if cnt & 1:\n if odd_flag:\n return -1\n odd_flag = True\n bubbles[ids[cnt // 2]] = center + 1\n for i in range(cnt // 2):\n li, ri = ids[i], ids[-i - 1]\n pairs.append((li, ri))\n pairs.sort()\n for i, (li, ri) in enumerate(pairs):\n bubbles[li] = i + 1\n bubbles[ri] = n - i\n\n ans = 0\n bit = Bit(n)\n for i, m in enumerate(bubbles):\n ans += i - bit.sum(m)\n bit.add(m, 1)\n return ans\n\n\nprint((solve(input())))\n", "from collections import defaultdict, deque\nfrom heapq import heappop, heappush\nfrom string import ascii_lowercase as abc\n\nclass BIT:\n def __init__(self, N):\n # N\u306f\u5165\u308c\u305f\u3044\u8981\u7d20\u306e\u500b\u6570\n self.size = 2 ** (int.bit_length(N+1))\n self.tree = [0]*(self.size + 1)\n \n def sum(self, i):\n res = 0\n while i:\n res += self.tree[i]\n i -= (i & -(i))\n return res\n \n def add(self, i, x):\n if i == 0:\n return\n while i <= self.size:\n self.tree[i] += x\n i += (i & -(i))\n\n\nD = [deque() for _ in range(26)]\nS = input()\nN = len(S)\n\nfor i in range(len(S)):\n D[ord(S[i])-97].append(i)\n\nM = [len(D[i])%2 for i in range(26)]\nif sum(M) >= 2:\n print(-1)\n return\n\nodd = sum(M)\n\nQ = []\nfor c in range(26):\n if len(D[c]) >= 2:\n l = D[c].popleft()\n r = D[c].pop()\n a = l * 1\n b = N - 1 - r\n if b < a:\n a, b = b, a\n heappush(Q, (a, b, l, r, c))\n\nT = [0]*(N//2)\nfor i in range(N//2):\n _, _, l, r, c = heappop(Q)\n T[i] = c\n\n if len(D[c]) >= 2:\n l = D[c].popleft()\n r = D[c].pop()\n a = l * 1\n b = N - 1 - r\n if b < a:\n a, b = b, a\n heappush(Q, (a, b, l, r, c))\n\nL = [[] for i in range(26)]\n\nfor i in range(N//2):\n L[T[i]].append(N-1-i)\n\nif odd:\n L[M.index(1)].append(N//2)\n\nfor i in range(N//2-1, -1, -1):\n L[T[i]].append(i)\n\nbit = BIT(N)\nans = 0\nfor i in range(N):\n j = L[ord(S[i]) - 97].pop()\n ans += i - bit.sum(j+1)\n bit.add(j+1, 1)\nprint(ans)", "def f(x):\n return ord(x)-ord(\"a\")\n\nclass Bit:\n def __init__(self, n):\n self.n = n\n self.tree = [0]*(n+1)\n self.el = [0]*(n+1)\n self.depth = n.bit_length() - 1\n\n def sum(self, i):\n \"\"\" \u533a\u9593[0,i) \u306e\u7dcf\u548c\u3092\u6c42\u3081\u308b \"\"\"\n s = 0\n i -= 1\n while i >= 0:\n s += self.tree[i]\n i = (i & (i + 1) )- 1\n return s\n\n def add(self, i, x):\n self.el[i] += x\n while i < self.n:\n self.tree[i] += x\n i |= i + 1\n\nclass BitSet2:\n \"\"\" \u5ea7\u6a19\u5727\u7e2e\u304c\u5fc5\u8981\u306a\u5834\u5408 \"\"\"\n def __init__(self, data, A=[]):\n \"\"\" BitSet\u306b\u5165\u308a\u5f97\u308b\u5024\u3092\u5148\u8aad\u307f\u3057\u305f\u7269\u3092 data \u306b\u683c\u7d0d \"\"\"\n self.data = sorted(list(set(data)))\n self.n = len(self.data)\n self.p = Bit(self.n + 1)\n self.size = 0\n self.flip = 0\n self.code = {}\n self.decode = {}\n for i, b in enumerate(self.data):\n self.code[b] = i\n self.decode[i] = b\n for a in A:\n self.add(a)\n\n def add(self,x):\n self.p.add(self.code[x], 1)\n self.size += 1\n self.flip += self.size - self.p.sum(self.code[x]+1)\n\n def remove(self,x):\n self.p.add(x, -1)\n self.size -= 1\n\n def flip_counter(self):\n return self.flip\n\n####################################################################################################\n\nimport sys\ninput = sys.stdin.readline\n\nS=input().rstrip()\nN=len(S)\nP=[[] for _ in range(26)]\nQ=[]\nres=[-1]*N\nfor i, s in enumerate(S):\n P[f(s)].append(i)\nfor p in P:\n Np=len(p)\n for i in range(Np//2):\n Q.append((p[Np-1-i]-p[i],p[i],p[Np-1-i]))\n if len(p)%2:\n if res[N//2]!=-1 or N%2==0: print(-1); return\n res[N//2]=p[Np//2]\nQ.sort(reverse=True)\nfor i,q in enumerate(Q):\n d,x,y=q\n res[i]=x\n res[N-1-i]=y\n\nBS = BitSet2(res,res)\nprint(BS.flip_counter())", "from collections import Counter\n\n\nclass BIT():\n \"\"\"\u4e00\u70b9\u52a0\u7b97\u3001\u533a\u9593\u53d6\u5f97\u30af\u30a8\u30ea\u3092\u305d\u308c\u305e\u308cO(logN)\u3067\u7b54\u3048\u308b\n add: i\u756a\u76ee\u306bval\u3092\u52a0\u3048\u308b\n get_sum: \u533a\u9593[l, r)\u306e\u548c\u3092\u6c42\u3081\u308b\n i, l, r\u306f0-indexed\n \"\"\"\n def __init__(self, n):\n self.n = n\n self.bit = [0] * (n + 1)\n\n def _sum(self, i):\n s = 0\n while i > 0:\n s += self.bit[i]\n i -= i & -i\n return s\n\n def add(self, i, val):\n \"\"\"i\u756a\u76ee\u306bval\u3092\u52a0\u3048\u308b\"\"\"\n i = i + 1\n while i <= self.n:\n self.bit[i] += val\n i += i & -i\n\n def get_sum(self, l, r):\n \"\"\"\u533a\u9593[l, r)\u306e\u548c\u3092\u6c42\u3081\u308b\"\"\"\n return self._sum(r) - self._sum(l)\n\n\ndef min_swap_times(s, t):\n if Counter(s) != Counter(t):\n return -1\n\n n = len(s)\n memo = {}\n for i in range(n):\n if s[i] not in memo:\n memo[s[i]] = [i]\n else:\n memo[s[i]].append(i)\n for i in memo:\n memo[i] = memo[i][::-1]\n\n array = [0] * n\n for i in range(n):\n array[i] = memo[t[i]][-1]\n del(memo[t[i]][-1]) \n\n memo = {}\n for i in range(n):\n memo[i] = array[i]\n bit = BIT(n)\n res = 0\n\n for i in range(n):\n bit.add(memo[i], 1)\n res += bit.get_sum(memo[i] + 1, n)\n return res\n\n\nimport copy\n\ns = input()\nn = len(s)\nmemo = {}\nfor i in range(n):\n if s[i] not in memo:\n memo[s[i]] = 1\n else:\n memo[s[i]] += 1\n\nodd_cnt = 0\nfor i in memo:\n odd_cnt += memo[i] % 2\nif odd_cnt > 1:\n print(-1)\n return\n\nleft = []\nright = []\n\nmemo2 = copy.deepcopy(memo)\nans_cnt = 0\nword = \"\"\nfor i in range(n):\n if memo2[s[i]]*2 > memo[s[i]] + 1:\n memo2[s[i]] -= 1\n ans_cnt += i - len(left)\n left.append(s[i])\n elif memo2[s[i]]*2 == memo[s[i]] + 1:\n word = s[i]\n memo2[s[i]] -= 1\n right.append(s[i])\n else:\n memo2[s[i]] -= 1\n right.append(s[i])\n \nif word != \"\":\n for i in range(len(right)):\n if right[i] == word:\n ans_cnt += i\n del(right[i])\n break\nright = right[::-1]\ntmp = min_swap_times(left, right)\nif tmp == -1:\n print(-1)\nelse:\n print(ans_cnt + tmp)", "def main():\n from collections import deque\n\n # \u4e00\u70b9\u66f4\u65b0\u30fb\u4e00\u70b9\u53d6\u5f97\u306e\u52a0\u6cd5BIT\n class BIT():\n def __init__(self, n):\n self.n = n\n self.maxbit = 2**(len(bin(n))-3)\n self.bit = [0]*(n+1)\n self.allsum = 0\n\n # \u521d\u671f\u5316\u3059\u308b\n def make_bit(self, a):\n n, bit = self.n, self.bit\n for i, j in enumerate(a):\n x = i+1\n self.allsum += j\n while x < n+1:\n bit[x] += j\n x += x & (-x)\n\n # \u4f4d\u7f6ei\u306b\u5024v\u3092\u8db3\u3059\n def add(self, i, v):\n x, n, bit = i+1, self.n, self.bit\n self.allsum += v\n while x < n+1:\n bit[x] += v\n x += x & (-x)\n\n # \u4f4d\u7f6e0\u304b\u3089i\u307e\u3067\u306e\u548c(sum(bit[:i]))\u3092\u8a08\u7b97\u3059\u308b\n def sum(self, i):\n ret, x, bit = 0, i, self.bit\n while x > 0:\n ret += bit[x]\n x -= x & (-x)\n return ret\n\n # \u4f4d\u7f6ei\u304b\u3089j\u307e\u3067\u306e\u548c(sum(bit[i:j]))\u3092\u8a08\u7b97\u3059\u308b\n def sum_range(self, i, j):\n return self.sum(j) - self.sum(i)\n\n # \u548c\u304cw\u4ee5\u4e0a\u3068\u306a\u308b\u6700\u5c0f\u306e\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u3092\u6c42\u3081\u308b\n def lowerbound(self, w):\n if w <= 0:\n return 0\n x, k, n, bit = 0, self.maxbit, self.n, self.bit\n while k:\n if x+k <= n and bit[x+k] < w:\n w -= bit[x+k]\n x += k\n k //= 2\n return x\n\n s = input()\n n = len(s)\n alpha, center = 'abcdefghijklmnopqrstuvwxyz', \"\"\n counter, must, deque_dict = dict(), dict(), dict()\n for c in alpha:\n counter[c] = 0\n deque_dict[c] = deque([])\n for c in s:\n counter[c] += 1\n for i, j in list(counter.items()):\n must[i] = j//2\n if n % 2 == 1:\n for i, j in list(counter.items()):\n if j % 2 == 1:\n if center != \"\":\n print((-1))\n return 0\n else:\n center = i\n else:\n for i, j in list(counter.items()):\n if j % 2 == 1:\n print((-1))\n return 0\n half = []\n cnt = 0\n for c in s:\n if must[c] > 0:\n must[c] -= 1\n half.append(c)\n cnt += 1\n if cnt == n//2:\n break\n half2 = half[::-1]\n if center != \"\":\n half.append(center)\n s2 = half+half2\n\n for i in range(n):\n deque_dict[s[i]].append(i)\n\n ans = 0\n s3 = []\n for c in s2:\n d = deque_dict[c].popleft()\n s3.append(d)\n\n bit = BIT(n)\n\n for i in s3:\n ans += bit.sum_range(i, n)\n bit.add(i, 1)\n print(ans)\n\n\nmain()\n", "*S, = map(ord, input())\nN = len(S)\nL = 26\nca = ord('a')\nd = [[] for i in range(L)]\nfor i, c in enumerate(S):\n d[c-ca].append(i)\n\nodd = 0\nfor v in d:\n if len(v) % 2:\n odd += 1\nif not odd <= N%2:\n print(-1)\n return\n\ndata = [0]*(N+1)\ndef add(k, x):\n while k <= N:\n data[k] += x\n k += k & -k\ndef get(k):\n s = 0\n while k:\n s += data[k]\n k -= k & -k\n return s\n\nM = [None]*N\nfor v in d:\n vl = len(v)\n for i in range(vl):\n if not i <= vl-1-i:\n break\n p = v[i]; q = v[-i-1]\n M[p] = q\n M[q] = p\ncnt = 0\nB = [0]*N\nfor i in range(N-1, -1, -1):\n if M[i] <= i:\n B[i] = B[M[i]] = cnt\n cnt += 1\n\ncur = -1\nans = 0\nfor i in range(N-1, -1, -1):\n if cur < B[i]:\n cur = B[i]\n if M[i] == i:\n ans += N//2 - cur\n else:\n ans += M[i] - get(M[i]+1)\n add(M[i]+1, 1)\nprint(ans)", "def count_inversions(L):\n def helper(A,B):\n lA,lB = len(A),len(B)\n if lA == 0:\n return B,0\n elif lB == 0:\n return A,0\n \n A,c1 = helper(A[:lA//2],A[lA//2:])\n B,c2 = helper(B[:lB//2],B[lB//2:])\n cnt = c1+c2\n i = 0\n j = 0\n\n C = [None]*(lA+lB)\n while i < lA and j < lB:\n if A[i] > B[j]:\n cnt += lA-i\n C[i+j] = B[j]\n j += 1\n else:\n C[i+j] = A[i]\n i += 1\n\n if i < lA:\n C[i+j:] = A[i:]\n else:\n C[i+j:] = B[j:]\n\n return C,cnt\n\n return helper(L[:len(L)//2],L[len(L)//2:])[1]\n\nfrom collections import deque\n\nALPHABETS = 26\n\nindices = [deque() for _ in range(26)]\nS = list([ord(c)-ord('a') for c in input()])\nfor i,c in enumerate(S):\n indices[c] += [i]\n\nodd = None\nfor c,l in enumerate(indices):\n if len(l)%2 == 1:\n if odd is None:\n odd = c\n else:\n odd = -1\n break\n\nif odd == -1:\n print((-1))\n return\n\ntarget = [None]*len(S)\nassigned = [False]*len(S)\nif odd is not None:\n l = list(indices[odd])\n i = l[len(l)//2]\n target[len(target)//2] = i\n assigned[i] = True\n l = deque(l[:len(l)//2] + l[len(l)//2+1:])\n\nj = 0\nfor i in range(len(S)//2):\n while assigned[j]:\n j += 1\n\n l = indices[S[j]]\n a = l.popleft()\n b = l.pop()\n assert a == j\n target[i] = a\n target[len(S)-i-1] = b\n assigned[a] = True\n assigned[b] = True\n \nprint((count_inversions(target)))\n", "from collections import defaultdict\n\na = list(map(ord, input()))\nN = len(a)\nLa = ord(\"a\")\n\ndata = [0]*(N+1)\n\n\nd = [[] for i in range(26)]\nfor i , c in enumerate(a):\n d[c-La].append(i)\n\nodd = 0\nfor v in d:\n if len(v) % 2:\n odd += 1\nif not odd <= N%2:\n print((-1))\n return\n\ndata = [0]*(N+1)\ndef add(k, x):\n while k <= N:\n data[k] += x\n k += k & -k\ndef get(k):\n s = 0\n while k:\n s += data[k]\n k -= k & -k\n return s\n\nM = [None]*N\nfor v in d:\n vl = len(v)\n for i in range(vl):\n if not i <= vl-1-i:\n break\n p = v[i]; q = v[-i-1]\n M[p] = q\n M[q] = p\ncnt = 0\nB = [0]*N\nfor i in range(N-1, -1, -1):\n if M[i] <= i:\n B[i] = B[M[i]] = cnt\n cnt += 1\n\ncur = -1\nans = 0\nfor i in range(N-1, -1, -1):\n\n if cur < B[i]:\n cur = B[i]\n if M[i] == i:\n ans += N//2 - cur\n else:\n ans += M[i] - get(M[i]+1)\n add(M[i]+1, 1)\nprint(ans)\n"] | {"inputs": ["eel\n", "ataatmma\n", "snuke\n"], "outputs": ["1\n", "4\n", "-1\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 71,603 | |
5410781b8516609a8c0fe5c3f0fb6953 | UNKNOWN | There is a simple undirected graph with N vertices and M edges.
The vertices are numbered 1 through N, and the edges are numbered 1 through M.
Edge i connects Vertex U_i and V_i.
Also, Vertex i has two predetermined integers A_i and B_i.
You will play the following game on this graph.
First, choose one vertex and stand on it, with W yen (the currency of Japan) in your pocket.
Here, A_s \leq W must hold, where s is the vertex you choose.
Then, perform the following two kinds of operations any number of times in any order:
- Choose one vertex v that is directly connected by an edge to the vertex you are standing on, and move to vertex v. Here, you need to have at least A_v yen in your pocket when you perform this move.
- Donate B_v yen to the vertex v you are standing on. Here, the amount of money in your pocket must not become less than 0 yen.
You win the game when you donate once to every vertex.
Find the smallest initial amount of money W that enables you to win the game.
-----Constraints-----
- 1 \leq N \leq 10^5
- N-1 \leq M \leq 10^5
- 1 \leq A_i,B_i \leq 10^9
- 1 \leq U_i < V_i \leq N
- The given graph is connected and simple (there is at most one edge between any pair of vertices).
-----Input-----
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_N B_N
U_1 V_1
U_2 V_2
:
U_M V_M
-----Output-----
Print the smallest initial amount of money W that enables you to win the game.
-----Sample Input-----
4 5
3 1
1 2
4 1
6 2
1 2
2 3
2 4
1 4
3 4
-----Sample Output-----
6
If you have 6 yen initially, you can win the game as follows:
- Stand on Vertex 4. This is possible since you have not less than 6 yen.
- Donate 2 yen to Vertex 4. Now you have 4 yen.
- Move to Vertex 3. This is possible since you have not less than 4 yen.
- Donate 1 yen to Vertex 3. Now you have 3 yen.
- Move to Vertex 2. This is possible since you have not less than 1 yen.
- Move to Vertex 1. This is possible since you have not less than 3 yen.
- Donate 1 yen to Vertex 1. Now you have 2 yen.
- Move to Vertex 2. This is possible since you have not less than 1 yen.
- Donate 2 yen to Vertex 2. Now you have 0 yen.
If you have less than 6 yen initially, you cannot win the game. Thus, the answer is 6. | ["class dsu:\n def __init__(self, n=0):\n self._n = n\n self.parent_or_size = [-1] * n\n \n def merge(self, a: int, b: int) -> int:\n x = self.leader(a)\n y = self.leader(b)\n if x == y:\n return x\n if self.parent_or_size[x] > self.parent_or_size[y]:\n x, y = y, x\n self.parent_or_size[x] += self.parent_or_size[y]\n self.parent_or_size[y] = x\n return x\n \n def same(self, a: int, b: int) -> bool:\n return self.leader(a) == self.leader(b)\n \n def leader(self, a: int) -> int:\n x = a\n while self.parent_or_size[x] >= 0:\n x = self.parent_or_size[x]\n while a != x:\n self.parent_or_size[a], a = x, self.parent_or_size[a]\n return x\n \n def size(self, a: int) -> int:\n return -self.parent_or_size[self.leader(a)]\n \n def groups(self):\n g = [[] for _ in range(self._n)]\n for i in range(self._n):\n g[self.leader(i)].append(i)\n return list(c for c in g if c)\n\nn, m = list(map(int, input().split()))\nvdata = [] # (required, gain)\nfor _ in range(n):\n a, b = list(map(int, input().split()))\n vdata.append((max(a - b, 0), b))\nto = [[] for _ in range(n)]\nfor _ in range(m):\n u, v = list(map(int, input().split()))\n u -= 1; v -= 1\n to[u].append(v)\n to[v].append(u)\ns = dsu(n)\ndp = vdata.copy() # (extra, tot_gain)\nvisited = [False] * n\nfor u in sorted(list(range(n)), key=lambda i: vdata[i][0]):\n req, gain = vdata[u]\n frm = {u}\n for v in to[u]:\n if visited[v]:\n frm.add(s.leader(v))\n mnextra = 10 ** 18\n for v in frm:\n e, g = dp[v]\n e += max(req - (e + g), 0)\n if e < mnextra:\n mnextra, mni = e, v\n extra, tot_gain = mnextra, sum(dp[v][1] for v in frm)\n for v in frm:\n s.merge(u, v)\n dp[s.leader(u)] = extra, tot_gain\n visited[u] = True\nans = sum(dp[s.leader(0)])\nprint(ans)\n"] | {"inputs": ["4 5\n3 1\n1 2\n4 1\n6 2\n1 2\n2 3\n2 4\n1 4\n3 4\n", "5 8\n6 4\n15 13\n15 19\n15 1\n20 7\n1 3\n1 4\n1 5\n2 3\n2 4\n2 5\n3 5\n4 5\n", "9 10\n131 2\n98 79\n242 32\n231 38\n382 82\n224 22\n140 88\n209 70\n164 64\n6 8\n1 6\n1 4\n1 3\n4 7\n4 9\n3 7\n3 9\n5 9\n2 5\n"], "outputs": ["6\n", "44\n", "582\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 2,033 | |
004b20c5fbef1bd506d54108d35bb223 | UNKNOWN | There are N towns located in a line, conveniently numbered 1 through N. Takahashi the merchant is going on a travel from town 1 to town N, buying and selling apples.
Takahashi will begin the travel at town 1, with no apple in his possession. The actions that can be performed during the travel are as follows:
- Move: When at town i (i < N), move to town i + 1.
- Merchandise: Buy or sell an arbitrary number of apples at the current town. Here, it is assumed that one apple can always be bought and sold for A_i yen (the currency of Japan) at town i (1 ≦ i ≦ N), where A_i are distinct integers. Also, you can assume that he has an infinite supply of money.
For some reason, there is a constraint on merchandising apple during the travel: the sum of the number of apples bought and the number of apples sold during the whole travel, must be at most T. (Note that a single apple can be counted in both.)
During the travel, Takahashi will perform actions so that the profit of the travel is maximized. Here, the profit of the travel is the amount of money that is gained by selling apples, minus the amount of money that is spent on buying apples. Note that we are not interested in apples in his possession at the end of the travel.
Aoki, a business rival of Takahashi, wants to trouble Takahashi by manipulating the market price of apples. Prior to the beginning of Takahashi's travel, Aoki can change A_i into another arbitrary non-negative integer A_i' for any town i, any number of times. The cost of performing this operation is |A_i - A_i'|. After performing this operation, different towns may have equal values of A_i.
Aoki's objective is to decrease Takahashi's expected profit by at least 1 yen. Find the minimum total cost to achieve it. You may assume that Takahashi's expected profit is initially at least 1 yen.
-----Constraints-----
- 1 ≦ N ≦ 10^5
- 1 ≦ A_i ≦ 10^9 (1 ≦ i ≦ N)
- A_i are distinct.
- 2 ≦ T ≦ 10^9
- In the initial state, Takahashi's expected profit is at least 1 yen.
-----Input-----
The input is given from Standard Input in the following format:
N T
A_1 A_2 ... A_N
-----Output-----
Print the minimum total cost to decrease Takahashi's expected profit by at least 1 yen.
-----Sample Input-----
3 2
100 50 200
-----Sample Output-----
1
In the initial state, Takahashi can achieve the maximum profit of 150 yen as follows:
- Move from town 1 to town 2.
- Buy one apple for 50 yen at town 2.
- Move from town 2 to town 3.
- Sell one apple for 200 yen at town 3.
If, for example, Aoki changes the price of an apple at town 2 from 50 yen to 51 yen, Takahashi will not be able to achieve the profit of 150 yen. The cost of performing this operation is 1, thus the answer is 1.
There are other ways to decrease Takahashi's expected profit, such as changing the price of an apple at town 3 from 200 yen to 199 yen. | ["N,T = list(map(int,input().split()))\nA = list(map(int,input().split()))\n\ncummax = [A[-1]]\nfor a in reversed(A[:-1]):\n cummax.append(max(cummax[-1], a))\ncummax.reverse()\n\nmaxgain = n = 0\nfor buy,sell in zip(A,cummax):\n gain = sell - buy\n if gain > maxgain:\n maxgain = gain\n n = 1\n elif gain == maxgain:\n n += 1\nprint(n)\n", "N, T = map(int, input().split())\nxs = list(map(int, input().split()))\n\nm = 10**10\nM = 0\nans = 1\nfor x in xs:\n if x < m:\n m = x\n elif x - m == M:\n ans += 1\n elif x - m > M:\n ans = 1\n M = x - m\n\nprint(ans)", "from sys import stdin\ninput = stdin.readline\nN,T = list(map(int,input().split()))\nprices = list(map(int,input().split()))\nlast = 10000000000\nhighestTally = [prices[-1]]\nhighestCount = [1]\n\nfor price in prices[-2:-N-1:-1]:\n if price==highestTally[-1]:\n highestCount.append(highestCount[-1]+1)\n else:\n highestCount.append(1)\n highestTally.append(max(highestTally[-1],price))\nhighestTally.reverse()\nhighestCount.reverse()\n\nindexOfHighest={}\nfor i in range(N-1,-1,-1):\n if highestTally[i]==prices[i]:\n indexOfHighest[highestTally[i]]=i\n\nbiggestJump=0\nsellingPriceForBiggestJump=0\nHPcount=0\nLPcount=0\nHPGroups=[]\nLPGroups=[]\nfor index,price in enumerate(prices):\n if index==N-1:\n break\n bestSellingPrice = highestTally[index+1]\n jump = bestSellingPrice-price\n #print(jump,bestSellingPrice,biggestJump)\n if jump>biggestJump:\n biggestJump = jump\n #LPcount+=1\n LPGroups=[]\n HPGroups=[]\n \n LPGroups.append(1)\n sellingPriceForBiggestJump = bestSellingPrice\n #HPcount=highestCount[indexOfHighest[bestSellingPrice]]\n HPGroups.append(highestCount[indexOfHighest[bestSellingPrice]])\n elif jump==biggestJump:\n if bestSellingPrice!=sellingPriceForBiggestJump:\n sellingPriceForBiggestJump = bestSellingPrice\n #HPcount+=highestCount[indexOfHighest[bestSellingPrice]]\n HPGroups.append(highestCount[indexOfHighest[bestSellingPrice]])\n LPGroups.append(0)\n LPGroups[-1]+=1\ncount = 0\nbs = T//2\nfor a,b in zip(HPGroups,LPGroups):\n if bs>min(a,b):\n count+=min(a,b)\n else:\n count+=bs\nprint(count)\n", "#!/usr/bin/env python3\nimport sys\n\n\ndef solve(N: int, T: int, A: \"List[int]\"):\n right_max = [0] * N # i\u756a\u76ee\u3088\u308a\u3042\u3068\u3067\u4e00\u756a\u5927\u304d\u3044A_i\n m_a = 0\n for i in range(1, N):\n m_a = max(m_a, A[-i])\n right_max[-i-1] = m_a\n\n m_p = 0\n count = 0\n for i, a in enumerate(A):\n profit = right_max[i] - a\n if profit > m_p:\n m_p = profit\n count = 1\n elif profit == m_p:\n count += 1\n print(count)\n return\n\n\n# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n N = int(next(tokens)) # type: int\n T = int(next(tokens)) # type: int\n A = [ int(next(tokens)) for _ in range(N) ] # type: \"List[int]\"\n solve(N, T, A)\n\ndef __starting_point():\n main()\n\n__starting_point()", "import heapq\n\nN,T = list(map(int,input().split()))\nA = list(map(int,input().split()))\n\nh = []\nB = [0]*N\n\nfor i in range(N):\n heapq.heappush(h,A[i])\n B[i] = h[0]\n\nj = []\nC = [0]*N\n\nfor i in range(N-1,-1,-1):\n heapq.heappush(j,-A[i])\n C[i] = -j[0]\n\nB = B[:-1]\nC = C[1:]\nD = list([C[x]-B[x] for x in range(N-1)])\nt = max(D)\n\ns = 0\nD.append(0)\nfor i in range(N-1):\n if D[i] == t and D[i] > D[i+1]:\n s += 1\n\nprint(s)\n", "import sys\n\nN, T = list(map(int, sys.stdin.readline().rstrip().split()))\n\nAs = []\nAs = list(map(int, sys.stdin.readline().rstrip().split()))\n\nmins = []\nm = 1e10\nvs = []\nfor A in As:\n m = min(m, A)\n vs.append(A - m)\nmax_v = max(vs)\nres = 0\nfor v in vs:\n if v == max_v:\n res += 1\nprint(res)\n\n", "import numpy as np\nN, T = list(map(int, input().split()))\n\ncost_list = np.array(list(map(int, input().split())))\n\nmax_num = 0\nmax_profit = 0\nmax_list = []\nmax_value = 0\nfor x in reversed(cost_list[1:]):\n max_value = max(max_value, x)\n max_list.append(max_value)\nmax_list = list(reversed(max_list))\nmax_list = np.array(max_list)\nres = max_list - cost_list[:-1]\n\nres_max = max(res)\n\nmax_num_list = [y for y in res if y == res_max]\n\nprint((len(max_num_list)))\n\n\n", "#D \u9ad8\u6a4b\u541b\u3068\u898b\u3048\u3056\u308b\u624b / An Invisible Hand\nN,T = [int(i) for i in input().split(\" \")]\nA=[int(i) for i in input().split(\" \")]\nMax = 0\ncount = 1\nMin = A[0]\nfor i in range(N):\n if A[i] <= Min :\n Min = A[i]\n else :\n temp = A[i]-Min\n if temp > Max:\n Max = temp \n count = 1\n elif temp == Max :\n count += 1\nprint(count)", "N,T = map(int,input().split())\nA = list(map(int,input().split()))\n\ncnt = max_profit = 0\nINF = float('inf')\nmin_cost = INF\nfor a in A:\n profit = a - min_cost\n if profit == max_profit:\n cnt += 1\n elif profit > max_profit:\n cnt = 1\n max_profit = profit\n min_cost = min(min_cost, a)\n\nprint(cnt)", "n,_,*a=map(int,open(0).read().split())\nm=d=c=0\nfor t in a[::-1]:\n if t>m:\n m=t\n if m-t>d:\n d=m-t\n c=1\n elif m-t==d:\n c+=1\nprint(c)", "# f = open('input', 'r')\n# n, t = map(int, f.readline().split())\n# A = list(map(int, f.readline().split()))\nn, t = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nans = 0\nmax_diff = 0\nmin_a = A[0]\nfor a in A:\n min_a = min(min_a, a)\n if (a - min_a) == max_diff:\n ans += 1\n elif (a - min_a) > max_diff:\n ans = 1\n max_diff = (a - min_a)\nprint(ans)\n", "input_lines = input()\nitems = input_lines.split()\nN = int(items[0])\nT = int(items[1])\n\ninput_lines = input()\nitems = input_lines.split()\nAs = [int(x) for x in items]\n\ndef my_func(N, T, As):\n buys = T // 2\n counts = 0\n val_earn = 0\n val_min = 10E10\n for val in As:\n if val < val_min:\n val_min = val\n else:\n diff = val - val_min\n if diff == val_earn:\n counts += 1\n elif diff > val_earn:\n val_earn = diff\n counts = 1\n print(counts)\n\nmy_func(N, T, As)", "def slove():\n import sys\n import collections\n input = sys.stdin.readline\n n, t = list(map(int, input().rstrip('\\n').split()))\n a = list(map(int, input().rstrip('\\n').split()))\n d = collections.defaultdict(list)\n min_b = 10 ** 9\n max_p = 0\n for v in a:\n p = v - min_b\n max_p = max(max_p, p)\n d[p] += [min_b]\n min_b = min(min_b, v)\n print((len(d[max_p])))\n\n\ndef __starting_point():\n slove()\n\n__starting_point()", "#!/usr/bin/env python\n# -*- coding:utf-8 -*-\n\n\n\nN, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nmaxA = [0] * N\nminA = [0] * N\n\nmaxA[N-1] = A[-1]\nfor i in range(1, N):\n maxA[N-i-1] = max(maxA[N-i], A[N-i])\n# print(maxA)\n\nmax_diff = -10000000000\nfor i in range(N-1):\n max_diff = max(maxA[i] - A[i], max_diff)\n# print(max_diff)\ncnt = 0\nfor i in range(N-1):\n if maxA[i] - A[i] == max_diff:\n cnt += 1\nprint(cnt)\n", "import sys\ninput = sys.stdin.readline\n\ndef main():\n N,M = map(int,input().split())\n A = list(map(int,input().split()))\n MAXl = [A[-1]]\n for i in range(1,N-1):\n MAXl.append(max(MAXl[i-1],A[-i-1]))\n MAXl.reverse()\n count = 0\n profit = 0\n for i in range(N-1):\n p = MAXl[i]-A[i]\n if p == profit:\n count += 1\n elif p > profit:\n profit = p\n count = 1\n\n print(count)\n\ndef __starting_point():\n main()\n__starting_point()", "N, T = map(int, input().split())\n*A, = map(int, input().split())\nmax_price = A[N-1]\nmax_prof = 0\ncount = 1\nfor a in reversed(A[:N-1]):\n prof = max_price - a\n if prof < 0: max_price = a\n elif prof == max_prof: count += 1\n elif prof > max_prof: max_prof = prof; count = 1;\nprint(count)", "N, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\ndiff = -1\nmini = A[0]\ncnt = 0\nans = 0\n\nfor i in range(1, N):\n\tnow = A[i]\n\n\tif mini > now:\n\t\tmini = now\n\telse:\n\t\tif now - mini == diff:\n\t\t\tcnt += 1\n\t\telif now - mini > diff:\n\t\t\tdiff = now - mini\n\t\t\tans = max(ans, cnt)\n\t\t\tcnt = 1\nans = max(ans, cnt)\nprint(ans)\n", "N, M = map(int, input().split())\nA = tuple(map(int, input().split()))\nmini = 10**10\nbnf = 0\ncnt = 1\nfor i in range(N):\n\tmini = min(mini, A[i])\n\t_bnf = A[i] - mini\n\tif _bnf > bnf:\n\t\tbnf = _bnf\n\t\tcnt = 1\n\telif _bnf == bnf:\n\t\tcnt += 1\nprint(cnt)", "N , T = list(map(int,input().split()))\nA = list(map(int,input().split()))\n\nm = 10 ** 9\nL = [m] * (N)\n\n\nfor i in range(0,N):\n if A[i] <= m:\n m = A[i]\n L[i] = A[i] - m\n\nM = max(L)\n\nprint((L.count(M)))\n \n\n", "#!usr/bin/env python3\nfrom collections import defaultdict\nimport math\ndef LI(): return list(map(int, input().split()))\ndef II(): return int(input())\ndef LS(): return input().split()\ndef S(): return input()\ndef IIR(n): return [II() for i in range(n)]\ndef LIR(n): return [LI() for i in range(n)]\ndef SR(n): return [S() for i in range(n)]\nmod = 1000000007\n\n#A\n\"\"\"\na,b = LS()\nc = int(a+b)\nfor i in range(1,1000):\n if i * i == c:\n print(\"Yes\")\n return\nprint(\"No\")\n\"\"\"\n\n#B\n\"\"\"\na,b = LI()\nif a*b <= 0:\n print(\"Zero\")\nelse:\n if b < 0:\n if (a-b) %2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n else:\n print(\"Positive\")\n\"\"\"\n\n#C\n\"\"\"\nn = II()\ns = SR(n)\nmarch = [[] for i in range(5)]\nch = list(\"MARCH\")\nfor i in s:\n for j in range(5):\n if i[0] == ch[j]:\n march[j].append(i)\nans = 0\nfor i in range(5):\n for j in range(i):\n for k in range(j):\n if len(march[i])*len(march[j])*len(march[k]) == 0:\n break\n ans += len(march[i])*len(march[j])*len(march[k])\nprint(ans)\n\"\"\"\n\n#D\n\"\"\"\nn = II()\nd = LIR(n)\nq = II()\np = IIR(q)\nd.insert(0,[0 for i in range(n+1)])\nfor i in range(n):\n d[i+1].insert(0,0)\nfor i in range(n):\n for j in range(n):\n d[i+1][j+1] += d[i+1][j]+d[i][j+1]-d[i][j]\nans = [0 for i in range(n**2+1)]\n\nfor a in range(n+1):\n for b in range(n+1):\n for c in range(a):\n for e in range(b):\n ans[(a-c)*(b-e)] = max(ans[(a-c)*(b-e)],d[a][b]-d[c][b]-d[a][e]+d[c][e])\n\nfor i in p:\n an = 0\n for a in range(i+1):\n an = max(an, ans[a])\n print(an)\n\"\"\"\n#E\n\n\"\"\"\ns = list(S())\nans = -1\ns.insert(0,0)\nd = 0\nfor i in range(1,len(s)):\n if s[i] != d:\n d = s[i]\n ans += 1\nprint(ans)\n\"\"\"\n\n#F\n\"\"\"\nn = II()\nx,y = LI()\nfor _ in range(n-1):\n a,b = LI()\n if a == b:\n x = max(x,y)\n y = x\n else:\n i = max(x//a,y//b)\n while 1:\n if a*i >= x and b*i >= y:break\n i += 1\n x = a*i\n y = b*i\nprint(x+y)\n\"\"\"\n#G\n\"\"\"\ns = list(S())\np = 0\ng = 0\nfor i in s:\n if i == \"g\":\n g += 1\n else:\n p += 1\nans = (g-p)//2\nprint(ans)\n\"\"\"\n#H\nn,t = LI()\na = LI()\nb = []\nfor i in range(n):\n b.append([i,a[i]])\nb.sort(key = lambda x:x[1])\nb = b[::-1]\nm = []\nif n == 1:\n print((1))\n return\ni = 0\nfor j in range(n):\n while i < b[j][0]:\n m.append(b[j][1])\n i += 1\nans = 0\nma = 0\nfor i in range(n-1):\n ma = max(ma,m[i]-a[i])\nfor i in range(n-1):\n if m[i]-a[i] == ma:\n ans += 1\nprint(ans)\n#I\n\n#J\n\n#K\n\n#L\n\n#M\n\n#N\n\n#O\n\n#P\n\n#Q\n\n#R\n\n#S\n\n#T\n", "N, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\nmin_A = 1000000001\nmax_diff = 0\nans = 0\nfor i in A:\n min_A = min(min_A, i)\n if i - min_A == max_diff:\n ans += 1\n if i - min_A > max_diff:\n max_diff = i - min_A\n ans = 1\nprint(ans)\n", "#!/usr/bin/env python3\n\ndef main():\n n, t = list(map(int, input().split()))\n an = list(map(int, input().split()))\n\n mi = [an[0]]\n se_mi = {0}\n for i in range(1, n):\n if mi[i - 1] > an[i]:\n se_mi = {i}\n elif mi[i - 1] == an[i]:\n se_mi.add(i)\n mi.append(min(mi[i - 1], an[i]))\n\n ma = 0\n se_ma = set()\n for i in range(1, n):\n be = an[i] - mi[i - 1]\n if be > ma:\n ma = be\n se_ma = {i}\n elif be == ma:\n se_ma.add(i)\n print((len(se_ma)))\n\nmain()\n", "N, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\nmxx, mnx = 0, 10**18\nfor a in A:\n if a-mnx > mxx:\n c, mxx = 1, a-mnx\n elif a-mnx == mxx:\n c += 1\n mnx = min(mnx, a)\nprint(c)\n", "from collections import Counter\n\nN, T = map(int, input().split())\nA = list(map(int, input().split()))\n\nmaxA = [0 for _ in range(N + 1)]\nminA = [float('inf') for _ in range(N + 1)]\n\nfor i, a in enumerate(A):\n minA[i + 1] = min(minA[i], a)\nfor i, a in enumerate(reversed(A)):\n maxA[-1 - i] = max(maxA[-1 - (i - 1)], a)\n\nmaxProfit = 0\nfor i in range(1, N):\n if maxProfit < maxA[i + 1] - minA[i]:\n maxProfit = maxA[i + 1] - minA[i]\n\npairs = set([])\nfor i in range(1, N):\n if maxProfit == maxA[i + 1] - minA[i]:\n pairs.add((minA[i], maxA[i + 1]))\n\nans = len(pairs)\nprint(ans)", "from collections import Counter,defaultdict,deque\nfrom heapq import heappop,heappush,heapify\nfrom bisect import bisect_left,bisect_right \nimport sys,math,itertools,fractions,pprint\nfrom typing import Union\nsys.setrecursionlimit(10**8)\nmod = 10**9+7\nINF = float('inf')\ndef inp(): return int(sys.stdin.readline())\ndef inpl(): return list(map(int, sys.stdin.readline().split()))\n\nn,t = inpl()\na = inpl()\nm = []\nmi = INF\nfor i in range(n-1):\n mi = min(mi, a[i])\n m.append(a[i+1]-mi)\nprint(m.count(max(m)))", "N,T=map(int,input().split())\nA=list(map(int,input().split()))\ni=0\nj=1\na=0\nb=0\nwhile i<=N-1:\n if j==N:\n i=N\n elif A[i]>A[j]:\n i=j\n j+=1\n else:\n if A[j]-A[i]>a:\n a=A[j]-A[i]\n b=1\n j+=1\n elif A[j]-A[i]==a:\n b+=1\n j+=1\n elif A[j]-A[i]<a:\n j+=1\nprint(b)", "#! /usr/bin/env python3\n\nN, T = map(int, input().split())\nA = list(map(int, input().split()))\np = -1\ndif = h = hc = lc = c = 0\nfor i in A[-2::-1]:\n a, b = A[p], A[p]-i\n if i > a:\n p = -c-2\n elif b >= dif:\n if a != h : h, hc = a, hc+1\n if b > dif : dif, lc = b, 0\n lc += 1\n c += 1\nprint(min(hc, lc))", "n, t = map(int, input().split())\na = [int(i) for i in input().split()]\nb = [0 for i in range(n)]\nm = a[0]\nfor i in range(n):\n m = min(m, a[i])\n b[i] = a[i] - m\nm = b[0]\nk = 0\nfor i in range(n):\n if b[i] >= m:\n m = b[i]\n k = i\nans1 = 1\nfor i in range(n):\n if b[i] == m and i != k:\n ans1 += 1\nb = [0 for i in range(n)]\nm = a[n - 1]\nfor i in range(n - 1, -1, -1):\n m = max(m, a[i])\n b[i] = a[i] - m\nm = b[n - 1]\nk = 0\nfor i in range(n - 1, -1, -1):\n if b[i] <= m:\n m = b[i]\n k = i\nans2 = 1\nfor i in range(n):\n if b[i] == m and i != k:\n ans2 += 1\nprint(min(ans1, ans2))", "n, t = map(int, input().split())\na = [int(x) for x in input().split()]\nmx = [0] * n\nmx[-1] = a[-1]\nfor i in range(n - 2, -1, -1):\n mx[i] = max(mx[i + 1], a[i])\nd = 0\nc = 0\nfor i in range(n - 1):\n cur = a[i]\n can = mx[i + 1]\n dd = can - cur\n if dd > d:\n d = dd\n c = 1\n elif dd == d:\n c += 1\nprint(c)", "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\nN,T = list(map(int,input().split()))\nAs = list(map(int,input().split()))\n\nmns = [0] * N\nmxs = [0] * N\n\nmns[0] = As[0]\nmxs[N-1] = As[N-1]\n\nfor i in range(1, N):\n j = N - i - 1\n mns[i] = min(As[i], mns[i-1])\n mxs[j] = max(As[j], mxs[j+1])\n\n# print(mns)\n# print(mxs)\n\nmx_diff = -1\npairs = set()\nfor i in range(1, N):\n diff = mxs[i] - mns[i]\n if diff > mx_diff:\n mx_diff = diff\n pairs.clear()\n if diff >= mx_diff:\n pairs.add((mns[i], mxs[i]))\nprint((len(pairs)))\n \n\n\n", "import sys\nstdin = sys.stdin\n\nsys.setrecursionlimit(10 ** 7)\n\ndef li(): return map(int, stdin.readline().split())\ndef li_(): return map(lambda x: int(x) - 1, stdin.readline().split())\ndef lf(): return map(float, stdin.readline().split())\ndef ls(): return stdin.readline().split()\ndef ns(): return stdin.readline().rstrip()\ndef lc(): return list(ns())\ndef ni(): return int(stdin.readline())\ndef nf(): return float(stdin.readline())\n\nn, t = li()\na = list(li())\n\nmina = [0]*n\nmina[0] = a[0]\nmaxprof = 0\n\nfor i in range(1, n):\n mina[i] = min(mina[i-1], a[i])\n\nans = 0\nfor i in range(n):\n if a[i] - mina[i] > maxprof:\n maxprof = a[i] - mina[i]\n ans = 1\n\n elif a[i] - mina[i] == maxprof:\n ans += 1\n\nprint(ans)", "n,t = list(map(int, input().split()))\na = list(map(int, input().split()))\n\nb = float('inf')\n\nc = 0\n\nans = 0\n\nfor i in range(n):\n if a[i]<b:\n b = a[i]\n if a[i]-b == c:\n ans += 1\n elif a[i]-b > c:\n c = a[i]-b\n ans = 1\n\nprint(ans)\n", "def main():\n\n N, T = list(map(int, input().split()))\n A = list(map(int, input().split()))\n\n if N == 1: return 0\n\n min_v = A[0]\n max_d = float('-inf')\n for i in range(1, N):\n if A[i] - min_v > max_d:\n max_d = A[i] - min_v\n if A[i] < min_v:\n min_v = A[i]\n\n d = set()\n d.add(A[0])\n ans = 0\n for i in range(1, N):\n if A[i] - max_d in d: ans += 1\n d.add(A[i])\n return ans\n\n\n\ndef __starting_point():\n print((main()))\n\n__starting_point()", "n=int(input().split()[0])\ns=input().split()\nl=[0 for i in range(n)]\nm=[0 for i in range(n)]\nM=[0 for i in range(n)]\nfor i in range(n):\n l[i]=int(s[i])\nm[0]=l[0]\nM[0]=l[-1]\nfor i in range(1,n):\n m[i]=min(m[i-1],l[i])\n M[i]=max(M[i-1],l[-i-1])\nM.reverse()\nd=[M[i]-m[i] for i in range(n)]\nma=max(d)\nmemo=-1\ncnt=0\nfor i in range(n):\n if d[i]==ma and m[i]!=memo:\n cnt+=1\n memo=m[i]\nprint(cnt)", "#!/usr/bin/env python3\n\ndef main():\n n, t = list(map(int, input().split()))\n an = list(map(int, input().split()))\n\n mi = [an[0]]\n for i in range(1, n):\n mi.append(min(mi[i - 1], an[i]))\n\n ma = 0\n num_ma = 0\n for i in range(1, n):\n be = an[i] - mi[i - 1]\n if be > ma:\n ma = be\n num_ma = 1\n elif be == ma:\n num_ma += 1\n print(num_ma)\n\nmain()\n", "n,t=list(map(int,input().split()))\na=list(map(int,input().split()))\npos={}\nmx=[0]*(n+1)\nfor i in range(n-1,-1,-1):\n mx[i]=max(mx[i+1],a[i])\nfor i in range(n):\n pos[a[i]]=i\na.sort()\nans=0\nb=0\nfor i in range(n):\n idx=pos[a[i]]\n if b<mx[idx]-a[i]:\n b=mx[idx]-a[i]\n ans=1\n elif b==mx[idx]-a[i]:\n ans+=1\nprint(ans)\n", "n,t=map(int,input().split())\na=list(map(int,input().split()))\nm=10**10\nM=0\nk=[]\nfor i in range(n):\n\tm=min(m,a[i])\n\tM=a[i]-m\n\tk.append(M)\no=max(k)\nprint(k.count(o))", "N,T = list(map(int,input().split()))\nA = list(map(int,input().split()))\n\nh = []\nB = [0]*N\n\nfor i in range(N):\n h.append(A[i])\n h = [min(h)]\n B[i] = h[0]\n\nj = []\nC = [0]*N\n\nfor i in range(N-1,-1,-1):\n j.append(A[i])\n j = [max(j)]\n C[i] = j[0]\n\nB = B[:-1]\nC = C[1:]\nD = list([C[x]-B[x] for x in range(N-1)])\nt = max(D)\n\ns = 0\nD.append(0)\nfor i in range(N-1):\n if D[i] == t and D[i] > D[i+1]:\n s += 1\n\nprint(s)\n", "n, t = list(map(int, input().split()))\na = list(map(int, input().split()))\nm = a[-1]\ntmp = 0\ncnt = 0\nfor i in range(n - 2, -1, -1):\n p = m - a[i]\n if p > tmp:\n tmp = p\n cnt = 1\n elif p == tmp:\n cnt += 1\n m = max(m, a[i])\nprint(cnt)\n", "n, t = map(int, input().split())\nax = list(map(int, input().split()))\n# i\u3088\u308a\u5f8c\u308d\u306e\u58f2\u308b\u4e2d\u3067\u6700\u3082\u9ad8\u3044\u3082\u306e\u306e\u30ea\u30b9\u30c8\nsell = []\nfor a in ax[::-1][:n-1]:\n if len(sell) == 0:\n sell.append([a,1])\n continue\n if a > sell[-1][0]:\n sell.append([a,1])\n elif a == sell[-1][0]:\n sell.append([a, sell[-1][1]+1])\n else:\n sell.append(sell[-1])\nsell = sell[::-1]\nans = {}\nfor i in range(n-1):\n sell_p, cnt = sell[i]\n ans[sell_p-ax[i]] = ans.get(sell_p-ax[i],0)+1\nprint(ans[max(ans.keys())])", "import sys\nN, T = list(map(int,input().split()))\nA = list(map(int,input().split()))\n\nA_max_right = [A[-1]]\nA_min_left = [A[0]]\nfor a in A[-2::-1]:\n A_max_right.append(max(a, A_max_right[-1]))\nA_max_right.reverse()\nfor a in A[1:]:\n A_min_left.append(min(a, A_min_left[-1]))\n\nA_dig = 0\nfor i in range(N):\n A_dig = max(A_dig, A_max_right[i] - A_min_left[i])\n \n#print(A_max_right, A_min_left, A_dig)\n\ndef ct_edges(ma, mi, start):\n counting_max = 1 # 0:counting max, 1:counting min\n i = start\n ct_max = [0]\n ct_min = []\n while i >= 0 and A_max_right[i] == ma and A_min_left[i] == mi:\n if counting_max: \n if A[i] == ma:\n ct_max[-1] += 1\n elif A[i] == mi:\n ct_min.append(1)\n counting_max = 0\n else: # counting min\n if A[i] == mi:\n ct_min[-1] += 1\n elif A[i] == ma:\n ct_max.append(1)\n counting_max = 1\n #print(i, A[i], ma, mi, ct_max, ct_min) \n i -= 1\n \n if len(ct_max) != len(ct_min):\n print(\"Error! Type:1\")\n return\n \n tmp_max = 0\n tmp_min = sum(ct_min)\n tmp = tmp_max + tmp_min\n for j in range(len(ct_max)):\n tmp_max += ct_max[j]\n tmp_min -= ct_min[j]\n tmp = min(tmp, tmp_max + tmp_min)\n \n ct = tmp\n end = i\n return ct, end\n\ni = N-1 \nans = 0\nwhile i >= 0:\n if A_max_right[i] - A_min_left[i] != A_dig:\n i -= 1\n else:\n #print(i)\n ct, i = ct_edges(A_max_right[i], A_min_left[i], start = i)\n ans += ct\nprint(ans)\n \n", "import sys\nfrom bisect import bisect_left as bl\ninput = sys.stdin.readline\nN, T = map(int, input().split())\na = list(map(int, input().split()))\ncm = [float(\"inf\")] * (N + 1)\ncmx = [0] * (N + 1)\nfor i in range(N):\n cm[i + 1] = min(cm[i], a[i])\n cmx[N - 1 - i] = max(cmx[N - i], a[N - 1 - i])\nres = 0\nx = 0\nfor i in range(N + 1):\n x = max(cmx[i] - cm[i], x)\nfor i in range(N):\n if cmx[i] - a[i] == x:\n res += 1\nprint(res)", "ma = lambda :map(int,input().split())\nlma = lambda :list(map(int,input().split()))\ntma = lambda :tuple(map(int,input().split()))\nni = lambda:int(input())\nyn = lambda fl:print(\"Yes\") if fl else print(\"No\")\nips = lambda:input().split()\nimport collections\nimport math\nimport itertools\nimport heapq as hq\nimport sys\nn,t = ma()\nA = lma()\nINF=10**15\n\nmns = [INF]*(n+1) ##mxs[i] :: max(A[i:n])\nfor i in range(n):\n mns[i] = min(mns[i-1],A[i])\nc = 0\ndmx = -1\nfor i in range(1,n):\n if A[i]-mns[i] >dmx:\n dmx=A[i]-mns[i]\n c=1\n elif A[i]-mns[i] ==dmx:\n c+=1\nprint(c)\n", "# -*- coding: utf-8 -*-\ndef inpl(): return map(int, input().split())\nN, T = inpl()\nA = tuple(inpl())\nm = A[0]\nbenefit = 0\npairs = 0\nans = 0\n\nfor i in range(1, N):\n a = A[i]\n d = a - m\n if d < 0:\n m = a\n elif d < benefit:\n continue\n elif d == benefit:\n pairs += 1\n elif d > benefit:\n ans = max(ans, pairs)\n benefit = d\n pairs = 1\n\nans = max(ans, pairs)\nprint(ans)", "N,T = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nback = [(0,0)]*(N+1)\n# (a,b): b is # of a\ndef heapsort(lst):\n h = []\n for value in lst:\n heappush(h,value)\n return [heappop(h) for i in range(len(h))]\n\nfor i in range(N, 0, -1):\n if A[i-1] > back[i][0]:\n back[i-1] = (A[i-1], 1)\n elif A[i-1] == back[i][0]:\n back[i-1] = (A[i-1], back[i][1] + 1)\n else:\n back[i-1] = back[i]\n\nanslst = []\nfrom heapq import heappush, heappop\n\nfor i in range(N):\n heappush(anslst, (- (back[i][0] - A[i]), back[i][1]) )\nanslst = heapsort(anslst)\n\n\nval = - anslst[0][0]\n\nans = 0\nfor i in range(N):\n if val != - anslst[i][0]:\n break\n ans += anslst[i][1] \nprint(ans)\n\n", "N, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\nminv = A[0]\nmaxv = -1\nL = [0]\nfor i in range(1, N):\n if A[i] - minv > maxv:\n L = [i]\n maxv = A[i] - minv\n elif A[i] - minv == maxv:\n L.append(i)\n minv = min(minv, A[i])\nprint((len(L)))\n", "N, T = map(int, input().split())\nA = list(map(int, input().split()))\nmin_A = 1000000001\nmax_diff = 0\nans = 0\nfor i in A:\n min_A = min(min_A, i)\n if i - min_A == max_diff:\n ans += 1\n if i - min_A > max_diff:\n max_diff = i - min_A\n ans = 1\nprint(ans)", "input()\na = [int(x) for x in input().split()]\n\nlowest = a[0]\nlowests = {a[0]}\ndiff = -1\npairs = []\n\nfor x in a[1:]:\n if lowest > x:\n lowests = {x}\n lowest = x\n elif lowest == x:\n lowests.add(x)\n elif diff == x - lowest:\n pairs += [(x, y) for y in lowests]\n elif diff < x - lowest:\n pairs = [(x, y) for y in lowests]\n diff = x - lowest\n\na, b = list(zip(*pairs))\nprint((min(len(set(a)), len(set(b)))))\n", "N, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nlow = [A[0]]\nhigh = [A[N-1]]\nfor i in range(1, N):\n low.append(min(A[i], low[i-1]))\nfor i in reversed(list(range(N-1))):\n high.append(max(A[i], high[N-2-i]))\n\nhigh.reverse()\nmax_gap = max([high[i] - low[i] for i in range(N)])\nnum = 0\nfirst = True\nfor i in range(N):\n if high[i] - low[i] == max_gap:\n if first:\n idx = i\n num += 1\n first = False\n else:\n if low[idx] != low[i]:\n idx = i\n num += 1\n\nprint(num)\n", "#!/usr/bin python3\n# -*- coding: utf-8 -*-\n\nimport bisect\n\nn, t = list(map(int, input().split()))\na = list(map(int, input().split()))\nmx = 0\np = [0] * n\nfor i in range(n-1,-1,-1):\n mx = max(mx, a[i])\n p[i] = mx - a[i]\np.sort()\nprint((n-bisect.bisect_left(p, p[-1])))\n", "#a\n\"\"\"\nimport math\na, b = map(str, input().split())\nj = int(a + b)\nif math.sqrt(j).is_integer():\n print(\"Yes\")\nelse:\n print(\"No\")\n\"\"\"\n\n#b\n\"\"\"\nans = [\"Positive\",\"Negative\"]\na, b = map(int, input().split())\nif 0 < a:\n print(\"Positive\")\nelif b >= 0:\n print(\"Zero\")\nelse:\n print(ans[(b-a)%2-1])\n\"\"\"\n\n#C\n\"\"\"\nimport itertools\nn = int(input())\nMARCH = [\"M\", \"A\", \"R\", \"C\", \"H\"]\nmarch = [0 for _ in range(5)]\nfor i in range(n):\n s = input()\n if s[0] in MARCH:\n march[MARCH.index(s[0])] += 1\nnum = list(range(5))\na = list(itertools.combinations(num, 3))\nans = 0\nfor i in a:\n bf = 1\n for k in i:\n bf *= march[k]\n ans += bf\nprint(ans)\n\"\"\"\n\n#D\n\"\"\"\nn = int(input())\nD = [list(map(int, input().split())) for _ in range(n)]\nq = int(input())\np = [int(input()) for _ in range(q)]\nans = [[0 for i in range(n)] for _ in range(n)]\nfor i in range(n):\n for j in range(n):\n break\nfor _ in p:\n print(ans[p])\n\"\"\"\n\n#E\n\"\"\"\ns = input()\nbf = s[0]\nans = 0\nfor i in range(1,len(s)):\n if bf != s[i]:\n ans += 1\n bf = s[i]\nprint(ans)\n\"\"\"\n\n#F\n\"\"\"\nn = int(input())\nta = [list(map(int, input().split())) for _ in range(n)]\nans = ta[0]\nfor i in ta:\n if ans[0] <= i[0] and ans[1] <= i[1]:\n ans = i\n else:\n a = ((ans[0] - 1) // i[0]) + 1\n b = ((ans[1] - 1) // i[1]) + 1\n ab = max(a,b)\n ans = [i[0] * ab, i[1] * ab]\nprint(ans[0]+ans[1])\n\"\"\"\n\n#G\nn, t = map(int, input().split())\na = list(map(int, input().split()))\nminv = a[0]\nmaxv = 0\nans = 0\nfor i in range(1, n):\n if maxv == a[i] - minv:\n ans += 1\n elif maxv < a[i] - minv:\n maxv = a[i] - minv\n ans = 1\n else:\n minv = min(minv,a[i])\nprint(ans)\n\n#H\n\"\"\"\ns = input()\nans = 0\nfor i in range(1,len(s)):\n if i % 2 == 1:\n if s[i] != \"p\":\n ans += 1\n else:\n if s[i] != \"g\":\n ans -= 1\nprint(ans)\n\"\"\"", "N,T=list(map(int,input().split()))\nA=[int(i) for i in input().split()]\nB=[0 for i in range(N)]\nB[0]=A[0]\nfor i in range(1,N):\n B[i]=min([B[i-1],A[i]])\nC=[A[i]-B[i] for i in range(N)]\nM=max(C)\nans=0\nfor i in range(N):\n if C[i]==M:\n ans+=1\nprint(ans)\n", "import numpy as np\n\ninput()\na = np.array(input().split(), dtype=np.int)\n\ndiff = a - np.minimum.accumulate(a)\nprint(((diff == diff.max()).sum()))\n\n", "# def makelist(n, m):\n# \treturn [[0 for i in range(m)] for j in range(n)]\n\n# n = int(input())\n# a, b = map(int, input().split())\n# s = input()\n\n\nN, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\ndiff = [0]*N\n\nmini = A[0]\nfor i in range(1, N):\n\tnow = A[i]\n\tif now <= mini:\n\t\tmini = now\n\telse:\n\t\tdiff[i] = now - mini\n\nsa = max(diff)\n\nans = 0\nmini = A[0]\nl = 1\nr = 0\nfor i in range(1, N):\n\tnow = A[i]\n\tif mini == now:\n\t\tl += 1\n\telif now < mini:\n\t\tif r > 0:\n\t\t\tans += min(l, r)\n\t\t\tr = 0\n\t\tmini = now\n\t\tl = 1\n\telse: # now > mini\n\t\tif now - mini == sa:\n\t\t\tr += 1\n\nif r > 0:\n\tans += min(l, r)\nprint(ans)\n", "def slove():\n import sys\n import collections\n input = sys.stdin.readline\n n, t = list(map(int, input().rstrip('\\n').split()))\n a = list(map(int, input().rstrip('\\n').split()))\n b = collections.defaultdict(list)\n m_c = 10 ** 9\n for i, v in enumerate(a):\n if i != 0 and m_c < v:\n b[v-m_c] += [m_c]\n m_c = min(m_c, v)\n b = sorted(list(b.items()), reverse=True)[0]\n print((len(collections.Counter(b[1]))))\n\n\ndef __starting_point():\n slove()\n\n__starting_point()", "N, T = map(int, input().split())\nA = list(map(int, input().split()))\n\nmin_a = A[0]\nprofit = 0\nans = 0\nfor a in A[1:]:\n min_a = min(min_a, a)\n if a - min_a > profit:\n profit = a - min_a\n ans = 1\n elif a - min_a == profit:\n ans += 1\nprint(ans)", "from collections import defaultdict\nN,T=map(int,input().split())\nA=[int(i) for i in input().split()]\nmi=A[0]\ns=0\ndd=defaultdict(int)\nfor i in range(1,N):\n mi=min(mi,A[i])\n s=max(A[i]-mi,s)\n dd[A[i]-mi]+=1\nprint(dd[s])", "from collections import Counter\n\nN, T = list(map(int, input().split()))\nAs = list(map(int, input().split()))\n\nT //= 2\nprofits = [0] * (N - 1)\nminA = As[0]\nfor i, A in enumerate(As[1:]):\n profits[i] = T * (A - minA)\n minA = min(minA, A)\n\ncnts = Counter(profits)\nprint((cnts[max(cnts.keys())]))\n", "def main():\n N, T = [int(x) for x in input().split()]\n price = [int(x) for x in input().split()]\n\n minprice = 1000000000;\n maxbenefit = 0\n dict = {}\n res = 0\n\n for i in range(len(price)):\n if (price[i] < minprice): minprice = price[i]\n if (maxbenefit < (price[i] - minprice)): maxbenefit = (price[i] - minprice)\n dict[price[i]] = i\n\n for i in range(len(price)):\n if price[i] + maxbenefit in dict:\n if (dict[price[i] + maxbenefit] > i): res += 1\n\n print(res)\n\ndef __starting_point():\n main()\n\n__starting_point()", "n,t = list(map(int,input().split()))\na = list(map(int,input().split()))\nmn = a[0]\nl = []\nfor i in range(n-1):\n if a[i] < a[i+1]:\n l.append(a[i+1]-mn) \n if a[i+1] < mn:\n mn = a[i+1]\nif len(l) > 0:\n d = max(l)\nans = l.count(d)\nprint(ans)\n", "def getlist():\n\treturn list(map(int, input().split()))\n\n#\u53d7\u3051\u53d6\u308a\nN, T = getlist()\nA = getlist()\nm = A[0]\nplus = -float(\"inf\")\ncost = 1\nfor i in range(1, N):\n\tif A[i] - m == plus:\n\t\tcost += 1\n\telif A[i] - m > plus:\n\t\tplus = A[i] - m\n\t\tcost = 1\n\telse:\n\t\tpass\n\tm = min(m, A[i])\n\nprint(cost)", "(N,T)=map(int,input().split())\na=list(map(int,input().split()))\nx=10**9\nd=0\ncounter=0\nfor i in a:\n if i<x:\n x=i\n elif i-x>d:\n d=i-x\n counter=1\n elif i-x==d:\n counter+=1\nprint(counter)", "N, T = list(map(int,input().split()))\nA = list(map(int,input().split()))\nB = [0 for k in range(N)]\nB[0] = A[0]\nfor k in range(1,N):\n B[k] = min(B[k-1],A[k])\nm = 0\nfor k in range(N):\n m = max(A[k]-B[k],m)\nans = 0\nfor k in range(N):\n if A[k]-B[k] == m:\n ans += 1\nprint(ans)\n", "import numpy as np\n\nN,T = list(map(int,input().split()))\n\nA = np.array(list(map(int,input().split())))\n\nB = np.minimum.accumulate(A)\n\nC = A - B\n\nans = (C == C.max()).sum()\n\nprint(ans)\n", "N, T = map(int, input().split())\na = [int(i) for i in input().split()]\nb = [a[0]]\nm = b[0]\nfor i in range(1,N):\n\tif m > a[i]:\n\t\tm = a[i]\n\tb.append(m)\nc = [a[i] - b[i] for i in range(N)]\nprint(c.count(max(c)))", "n,t=map(int,input().split())\nA=[int(i) for i in input().split()]\nA=A[::-1]\nB,C=[0]*n,[0]*n\nB[0]=A[0]\ncur=A[0]\nfor i in range(1,n):\n cur=max(cur,A[i])\n B[i]+=cur\nfor i in range(n):\n C[i]=B[i]-A[i]\nm=max(C)\nans=0\nfor i in range(n):\n if C[i]==m:\n ans+=1\nprint(ans)", "from numpy import *\ninput()\na=array(input().split(),dtype=int)\nd=a-minimum.accumulate(a)\nprint((d==d.max()).sum())", "import numpy as np\n\nN, T = np.array(input().split(), dtype=\"int\")\nA = np.array(input().split(), dtype=\"int\")\n\nmax_num=A[-1]\nnum_dict = {}\nfor i in range(len(A)-1):\n ##print(A[-i-1],max_num - A[-i-2],num_dict)\n if(A[-i-1]>max_num):\n max_num=A[-i-1]\n if(max_num > A[-i-2]):\n if(max_num - A[-i-2] in num_dict):\n num_dict[max_num - A[-i-2]] +=1\n else:\n num_dict[max_num - A[-i-2]]=1\nkey = max(num_dict.keys())\nprint(num_dict[key])", "n, t = list(map(int, input().split()))\na = list(map(int, input().split()))\n\n# print(a)\n\nminv = a[0]\n\nvalue = [0] * n\nfor i, v in enumerate(a[1:], 1):\n if minv >= v:\n value[i] = 0\n minv = v\n else:\n value[i] = v - minv\n\nmaxv = max(value)\n# print(maxv)\nprint((value.count(maxv)))\n", "n,_,*a=map(int,open(0).read().split())\nm=d=c=0\nfor t in a[::-1]:\n if t>m:\n m=t\n if m-t>d:\n d=m-t\n c=1\n elif m-t==d:\n c+=1\nprint(c)", "#!/usr/bin/env pypy3\n\nimport collections\n\n\nINF = 10 ** 10\n\n\ndef solve(n, t, xs):\n trades = collections.Counter()\n maxs = [INF for _ in range(n)]\n maxs[n - 1] = xs[n - 1]\n for i in range(n - 1)[::-1]:\n maxs[i] = max(xs[i], maxs[i + 1])\n for i in range(n):\n delta = maxs[i] - xs[i]\n if delta > 0:\n trades[delta] += 1\n max_delta = max(trades.keys())\n return trades[max_delta]\n\n\ndef main():\n n, t = list(map(int, input().split()))\n xs = list(map(int, input().split()))\n print((solve(n, t, xs)))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "n,t = map(int,input().split())\na = list(map(int,input().split()))\n\np = a[n-1]\nr = []\n\nfor i in range(n-1,-1,-1):\n if a[i] >= p:\n p = a[i]\n else:\n r.append(p-a[i])\n\nres = r.count(max(r))\n\nprint(res)", "n,t=list(map(int,input().split()))\nar=list(map(int,input().split()))\nmn=float('inf')\nmdif,mxc=-float('inf'),0\nfor e in ar:\n if(e-mn>mdif):\n mdif=e-mn\n mxc=1\n elif(e-mn==mdif):\n mxc+=1\n mn=min(mn,e)\nprint(mxc)\n", "# ARC063D - \u9ad8\u6a4b\u541b\u3068\u898b\u3048\u3056\u308b\u624b / An Invisible Hand (ABC047D)\ndef main():\n N, T, *A = map(int, open(0).read().split())\n cur, cand = A[0], []\n for i in A:\n if i < cur: # buy at the most inexpensive place\n cur = i\n else:\n cand += [i - cur] # sell at higher places\n x = max(cand) # the highest profits\n # count the number of pairs which produce x\n ans = sum(i == x for i in cand)\n print(ans)\n\n\ndef __starting_point():\n main()\n__starting_point()", "n,t=map(int,input().split())\na=list(map(int,input().split()))\n\nb=[0 for i in range(n)]\nb[n-1]=a[n-1]\nfor i in range(n-1):\n b[n-i-2]=max(b[n-i-1],a[n-i-2])\n\nsamax=0\nmaxkai=0\nfor i in range(n-1):\n if b[i+1]-a[i]>samax:\n maxkai=1\n samax=b[i+1]-a[i]\n elif b[i+1]-a[i]==samax:\n maxkai+=1\n\nprint(maxkai)", "#! /usr/bin/env python3\n\nN, T = map(int, input().split())\nA = list(map(int, input().split()))\npu = -1\nSPU = set([])\nSPD = []\nb = 0\nc = 0\nfor i in A[:-1][::-1]:\n if i > A[pu]:\n pu = -c-2\n elif i < A[pu] and A[pu]-i >= b:\n SPU.add(pu)\n b = A[pu]-i\n SPD += [b]\n c += 1\n\nprint(min(len(SPU), SPD.count(b)))", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time\n\nsys.setrecursionlimit(10**7)\ninf = 10**10\nmod = 10**9 + 7\n\n\ndef f():\n n,t = list(map(int,input().split()))\n a = list(map(int,input().split()))\n m = 0\n mc = inf\n r = 0\n for c in a:\n if mc > c:\n mc = c\n continue\n if c - mc > m:\n m = c - mc\n r = 1\n continue\n if c - mc == m:\n r += 1\n return r\n\nprint((f()))\n", "N, T = map(int, input().split())\n*A, = map(int, input().split())\nmin_price = A[0]\nmax_prof = 0\ncount = 1\nfor a in A[1:]:\n prof = a - min_price\n if prof < 0: min_price = a\n elif prof == max_prof: count += 1\n elif prof > max_prof: max_prof = prof; count = 1;\nprint(count)", "N,T=map(int,input().split())\nA=list(map(int,input().split()))\nx=10**9\nd=0\nans=0\nfor a in A:\n if a<x:\n x=a\n elif a-x>d:\n d=a-x\n ans=1\n elif a-x==d:\n ans+=1\nprint(ans)", "def main():\n N, T = map(int, input().split())\n A = list(map(int, input().split()))\n tmp = A[-1]\n diff_A = [0] * N\n for i in range(N-1,-1,-1):\n tmp = max(A[i],tmp)\n diff_A[i] = tmp - A[i]\n\n print(diff_A.count(max(diff_A)))\n\n\n\ndef __starting_point():\n main()\n__starting_point()", "# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nn,r,*a = list(map(int,read().split()))\n\n\nhigh = a[-1]\ndelta = -1\n\nfor ai in a[::-1]:\n if high < ai:\n high = ai\n if high-ai > delta:\n delta = high-ai\n\n#from collections import Counter\n#d = Counter()\n\nhigh = a[-1]\n\nhs = 0\nls = 0\n\nans = 0\nfor ai in a[::-1]:\n if high < ai:\n high = ai\n hs = 1\n ans += min(hs,ls)\n ls = 0\n elif high == ai:\n hs += 1 \n \n if high - ai == delta:\n ls += 1\n \n\nprint((ans+min(hs,ls)))\n\n\n\n\n", "N,T = list(map(int,input().split()))\nA = list(map(int,input().split()))\n\nB = [0]*N\nC = [0]*N\n\nh = A[0]\nB[0] = h\nfor i in range(1,N):\n h = min(A[i],h)\n B[i] = h\n\nh = A[-1]\nC[-1] = h\nfor i in range(N-2,-1,-1):\n h = max(A[i],h)\n C[i] = h\n\nB = B[:-1]\nC = C[1:]\nD = list([C[x]-B[x] for x in range(N-1)])\nt = max(D)\n\ns = 0\nD.append(0)\nfor i in range(N-1):\n if D[i] == t and D[i] > D[i+1]:\n s += 1\n\nprint(s)\n", "N, T = list(map(int, input().split()))\ntowns = list(map(int, input().split()))\n\np = towns[-1]\nr = []\n\nfor i in reversed(list(range(N))):\n if towns[i] >= p:\n p = towns[i]\n else:\n r.append(p-towns[i])\n\nres = r.count(max(r))\nprint(res)\n", "from collections import defaultdict\n\nn, t = list(map(int, input().split()))\na = list(map(int, input().split()))\n\nbuy = a[0]\ngain = defaultdict(int)\nfor ai in a:\n buy = min(buy, ai)\n gain[ai - buy] += 1\nprint((gain[max(gain)]))\n", "import sys\nfrom collections import Counter\nreadline = sys.stdin.readline\n\nN, T = map(int, readline().split())\nA = list(map(int, readline().split()))\nAmax = [None]*N\nAmax[N-1] = A[N-1]\nfor i in range(N-2, -1, -1):\n Amax[i] = max(Amax[i+1], A[i])\n\nB = [am - a for a, am in zip(A, Amax)]\nprint(Counter(B)[max(B)])", "N,T=map(int,input().split())\nA=list(map(int,input().split())) # 0-indexed\nB=[0 for i in range(N)] # B[i]~B[N-1]\u306emax\nBl=[set() for i in range(N)] # B[i]~B[N-1]\u306emax\u3068\u306a\u308bB[j]\u306e\u6dfb\u5b57j\u306e\u30ea\u30b9\u30c8\nB[N-1]=A[N-1]\nBl[N-1].add(N-1)\nfor i in range(N-2,-1,-1):\n if A[i]>B[i+1]:\n B[i]=A[i]\n Bl[i].add(i)\n elif A[i]==B[i+1]:\n B[i]=B[i+1]\n Bl[i]=Bl[i+1]+{i}\n elif A[i]<B[i+1]:\n B[i]=B[i+1]\n Bl[i]=Bl[i+1]\n\nC=[B[i]-A[i] for i in range(N)]\n'''\nprint(A)\nprint(B)\nprint(Bl)\nprint(C)\n'''\nCm=max(C)\nCml=set()\nfor i in range(N):\n if C[i]==Cm:\n Cml.update(Bl[i])\n'''\nprint(Cm)\nprint(Cml)\n'''\nans=len(Cml)\n\nprint(ans)", "\ndef main():\n buf = input()\n buflist = buf.split()\n N = int(buflist[0])\n T = int(buflist[1])\n buf = input()\n buflist = buf.split()\n A = list(map(int, buflist))\n min_price = A[0]\n max_price_diff = 0\n max_diff_count = 0\n for i in range(1, N):\n if A[i] < min_price:\n min_price = A[i]\n elif A[i] - min_price > max_price_diff:\n max_price_diff = A[i] - min_price\n max_diff_count = 1\n elif A[i] - min_price == max_price_diff:\n max_diff_count += 1\n print(max_diff_count)\n\ndef __starting_point():\n main()\n\n__starting_point()", "#!/usr/bin/env python3\n\nN, T = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nd = 0\nans = 1\nl = A[0]\nfor a in A[1:]:\n l = min(l, a)\n r = a\n if r - l == d:\n ans += 1\n elif r - l > d:\n ans = 1\n d = r - l\n\nprint(ans)\n", "from sys import setrecursionlimit\nfrom functools import reduce\nfrom itertools import *\nfrom collections import defaultdict\nfrom bisect import bisect\n\ndef read():\n return int(input())\n\ndef reads():\n return [int(x) for x in input().split()]\n\nsetrecursionlimit(1000000)\n\n(N, T) = reads()\nA = reads()\n\nB = [0] * N\n\nB[0] = A[0]\nfor i in range(1, N):\n B[i] = min(B[i-1], A[i])\n\nC = [max(A[i] - B[i], 0) for i in range(N)]\n\nM = max(C)\nresult = sum(c == M for c in C)\n\nprint(result)\n", "def inpl(): return [int(i) for i in input().split()]\n\nN, T = inpl()\nA = inpl()\nminA = [0 for _ in range(N)]\nminA[0] = A[0]\nfor i in range(N-1):\n minA[i+1] = min(minA[i], A[i+1]) \nans = 1\nmaxpro = 0\nfor i in range(N-1):\n if A[i+1]-minA[i] == maxpro:\n ans += 1\n if A[i+1]-minA[i] > maxpro:\n ans = 1\n maxpro = A[i+1]-minA[i]\n\nprint(ans)", "f = lambda: list(map(int,input().split()))\nn,_ = f()\na = list(f())\nb = [a[0]]+[0]*(n-1)\nfor i in range(1,n):\n b[i] = min(a[i], b[i-1])\nc = [a[i]-b[i] for i in range(n)]\nm = max(c)\nprint((c.count(m)))\n", "# coding: utf-8\n\nN, T = list(map(int, input().split()))\nA = [int(s) for s in input().split()]\n\ncm = A[0]\ncd = 0\ncnt = 0\nfor i in range(1, N):\n if A[i] < cm:\n cm = A[i]\n else:\n d = A[i] - cm\n if d == cd:\n cnt += 1\n elif d > cd:\n cd = d\n cnt = 1\nprint(cnt)\n", "import sys\ninput = sys.stdin.readline\n\nsys.setrecursionlimit(10000)\n\n\nN, T = (int(i) for i in input().split())\nA = [int(i) for i in input().split()]\n\nma = A[-1]\nmas = 1\nresma = 0\nrescc = 0\nfor i in range(N-2, -1 ,-1):\n if A[i] > ma:\n ma = A[i]\n mas = 1\n elif A[i] == ma:\n mas += 1\n else:\n if ma - A[i] > resma:\n resma = ma - A[i]\n rescc = 1\n elif ma - A[i] == resma:\n rescc += 1\n else:\n pass\n\nprint(rescc)", "_,_,*a=map(int,open(0).read().split());d={}\nfor x,y in zip(a,__import__(\"itertools\").accumulate(a,min)):d[x-y]=d.get(x-y,0)+1\nprint(d[max(d.keys())])", "N,T=list(map(int,input().split()))\na=list(map(int,input().split()))\nmax_profit=0\nmini=a[0]\nfor i in range(1,N):\n max_profit=max(max_profit,a[i]-mini)\n mini=min(mini,a[i])\n#print(max_profit)\nmini=a[0]\nans=0\nfor i in range(1,N):\n if a[i]-mini==max_profit:\n ans+=1\n mini=min(mini,a[i])\nprint(ans)\n"] | {"inputs": ["3 2\n100 50 200\n", "5 8\n50 30 40 10 20\n", "10 100\n7 10 4 5 9 3 6 8 2 1\n"], "outputs": ["1\n", "2\n", "2\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 45,296 | |
a1bbdcfb7e712c1a4da8e3a14ec3ad07 | UNKNOWN | Let N be a positive even number.
We have a permutation of (1, 2, ..., N), p = (p_1, p_2, ..., p_N).
Snuke is constructing another permutation of (1, 2, ..., N), q, following the procedure below.
First, let q be an empty sequence.
Then, perform the following operation until p becomes empty:
- Select two adjacent elements in p, and call them x and y in order. Remove x and y from p (reducing the length of p by 2), and insert x and y, preserving the original order, at the beginning of q.
When p becomes empty, q will be a permutation of (1, 2, ..., N).
Find the lexicographically smallest permutation that can be obtained as q.
-----Constraints-----
- N is an even number.
- 2 ≤ N ≤ 2 × 10^5
- p is a permutation of (1, 2, ..., N).
-----Input-----
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
-----Output-----
Print the lexicographically smallest permutation, with spaces in between.
-----Sample Input-----
4
3 2 4 1
-----Sample Output-----
3 1 2 4
The solution above is obtained as follows:pq(3, 2, 4, 1)()↓↓(3, 1)(2, 4)↓↓()(3, 1, 2, 4) | ["import sys\ninput = sys.stdin.readline\nimport numpy as np\nfrom heapq import heappush, heappop\n\nN = int(input())\nA = np.array(input().split(), dtype=np.int32)\na_to_i = {a:i for i,a in enumerate(A)}\n\n# sparse table \u3092\u4f7f\u3063\u3066RMQ\n# parity\u306e\u540c\u3058\u3068\u3053\u308d\u3060\u3051\u3092\u898b\u308b\u3088\u3046\u306b\u3057\u3066\u304a\u304f\n\nU = len(A).bit_length()\nsp = [None,A]\nfor i in range(2,U):\n L = 1 << (i-1)\n sp.append(np.minimum(sp[-1][:-L], sp[-1][L:]))\n\ndef RMQ(x,y):\n # x\u756a\u76ee\u304b\u3089\u5076\u6570\u756a\u76ee\u3060\u3051\u898b\u3066[x,y]\u3067\u306e\u6700\u5c0f\u5024\u3092\u8fd4\u3059\n d = y - x\n if d <= 1:\n return A[x]\n n = d.bit_length()\n return min(sp[n-1][x], sp[n-1][y+2-(1<<(n-1))])\n\ndef F(x,y):\n # \u8f9e\u66f8\u5f0f\u3067\u6700\u5c0f\u306e2\u3064\u7d44\u3092\u3068\u308b\n # \u305d\u306e\u3042\u3068\u3001\u4eca\u5f8c\u8abf\u3079\u306a\u3044\u3068\u3044\u3051\u306a\u3044\u533a\u9593\u306e\u4e00\u89a7\u3092\u8fd4\u3059\n x1 = RMQ(x,y-1)\n i1 = a_to_i[x1]\n x2 = RMQ(i1+1,y)\n i2 = a_to_i[x2]\n task = ((x,y) for x,y in ((x,i1-1), (i1+1,i2-1), (i2+1,y)) if y > x)\n return x1,x2,task\n\nq = [(None,None,((0,N-1),))]\nanswer = []\nwhile q:\n x,y,task = heappop(q)\n answer.append(x)\n answer.append(y)\n for left,right in task:\n heappush(q,F(left,right))\n\nprint(' '.join(map(str,answer[2:])))", "\n\nclass SegmentTree():\n def __init__(self,size,f=lambda x,y:x+y,default=0):\n self.size=pow(2,(size-1).bit_length())\n self.f=f\n self.default=default\n self.data=[default]*(self.size*2)\n def update(self,i,x):\n i+=self.size\n self.data[i]=x\n while i:\n i>>=1\n self.data[i]=self.f(self.data[i*2],self.data[i*2+1])\n # \u533a\u9593[l,r)\u3078\u306e\u30af\u30a8\u30ea\n def query(self,l,r):\n l,r=l+self.size,r+self.size\n lret,rret=self.default,self.default\n while l<r:\n if l&1:\n lret=self.f(self.data[l],lret)\n l+=1\n if r&1:\n r-=1\n rret=self.f(self.data[r],rret)\n l>>=1\n r>>=1\n return self.f(lret,rret)\n def get(self,i):\n return self.data[self.size+i]\n def add(self,i,x):\n self.update(i,self.get(i)+x)\n\nfrom heapq import heappop,heappush\ndef main1(n,p):\n d={}\n st0=SegmentTree(n,min,n+1)\n st1=SegmentTree(n,min,n+1)\n for i,x in enumerate(p):\n d[x]=i\n if i%2==0:\n st0.update(i,x)\n else:\n st1.update(i,x)\n def func(l,r):\n if l%2==0:\n v0=st0.query(l,r)\n i0=d[v0]\n v1=st1.query(i0,r)\n else:\n v0=st1.query(l,r)\n i0=d[v0]\n v1=st0.query(i0,r)\n return v0,v1,l,r\n # \u533a\u9593\u3054\u3068\u306e\u8f9e\u66f8\u9806\u6700\u5c0f\u5148\u982d\u3092\u7ba1\u7406\uff1a[[v0,v1],[v0,v1,...]\n ary=[]\n heappush(ary,func(0,n))\n ret=[]\n for _ in range(n//2):\n v0,v1,l,r=heappop(ary)\n ret.append(v0)\n ret.append(v1)\n i0=d[v0]\n i1=d[v1]\n if i0!=l:\n heappush(ary,func(l,i0))\n if i0+1!=i1:\n heappush(ary,func(i0+1,i1))\n if i1+1!=r:\n heappush(ary,func(i1+1,r))\n return ret\n\ndef __starting_point():\n n=int(input())\n p=list(map(int,input().split()))\n ret1=main1(n,p.copy())\n print((*ret1))\n\n__starting_point()", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\ngosa = 1.0 / 10**10\nmod = 10**9+7\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\n\nclass Seg():\n def __init__(self, na, default, func):\n if isinstance(na, list):\n n = len(na)\n else:\n n = na\n i = 1\n while 2**i <= n:\n i += 1\n self.D = default\n self.H = i\n self.N = 2**i\n if isinstance(na, list):\n self.A = [default] * (self.N) + na + [default] * (self.N-n)\n for i in range(self.N-1,0,-1):\n self.A[i] = func(self.A[i*2], self.A[i*2+1])\n else:\n self.A = [default] * (self.N*2)\n self.F = func\n\n def find(self, i):\n return self.A[i + self.N]\n\n def update(self, i, x):\n i += self.N\n self.A[i] = x\n while i > 0:\n i = (i-1) // 2\n self.A[i] = self.merge(self.A[i*2], self.A[i*2+1])\n\n def merge(self, a, b):\n return self.F(a, b)\n\n def total(self):\n return self.A[0]\n\n def query(self, a, b):\n A = self.A\n l = a + self.N\n r = b + self.N\n res = self.D\n while l < r:\n if l % 2 == 1:\n res = self.merge(res, A[l])\n l += 1\n if r % 2 == 1:\n r -= 1\n res = self.merge(res, A[r])\n l >>= 1\n r >>= 1\n\n return res\n\ndef main():\n n = I()\n a = LI()\n\n def sf(a,b):\n if a < b:\n return a\n return b\n\n s1 = Seg([c if i%2==0 else inf for c,i in zip(a,list(range(n)))],inf,sf)\n s2 = Seg([c if i%2==1 else inf for c,i in zip(a,list(range(n)))],inf,sf)\n d = {}\n\n for i in range(n):\n d[a[i]] = i\n\n def f(l,r):\n if l % 2 == 0:\n t = s1.query(l,r)\n ti = d[t]\n u = s2.query(ti+1,r)\n else:\n t = s2.query(l,r)\n ti = d[t]\n u = s1.query(ti+1,r)\n ui = d[u]\n nl = []\n if l < ti:\n nl.append((l, ti))\n if ui - ti > 1:\n nl.append((ti+1, ui))\n if ui < r-1:\n nl.append((ui+1, r))\n return ((t,u), nl)\n\n q = []\n heapq.heappush(q, f(0,n))\n r = []\n while q:\n t,nl = heapq.heappop(q)\n r.append(t[0])\n r.append(t[1])\n for t,u in nl:\n heapq.heappush(q, f(t,u))\n\n return ' '.join(map(str,r))\n\nprint((main()))\n\n\n\n", "import sys\ninput = sys.stdin.readline\n\n# O(NlogN)\u69cb\u7bc9\u3001\u30af\u30a8\u30eaO(1)\u306eRMQ\n# \u5909\u66f4\u306f\u3067\u304d\u306a\u3044\nclass SparseTable():\n def __init__(self, N, A):\n self.N = N\n self.logN = N.bit_length()\n self.A = A\n self.table = [[i for i in range(N)]]\n for k in range(self.logN):\n tab = []\n for i in range(self.N-(1<<(k+1))+1):\n ind1 = self.table[-1][i]\n ind2 = self.table[-1][i+(1<<k)]\n if self.A[ind1] <= self.A[ind2]:\n tab.append(ind1)\n else:\n tab.append(ind2)\n self.table.append(tab)\n \n # [l, r)\u306emin\u306e(val, key)\n def query_min(self, l, r):\n k = (r-l).bit_length()-1\n indl = self.table[k][l]\n indr = self.table[k][r-(1<<k)]\n if self.A[indl] <= self.A[indr]:\n return self.A[indl], indl\n return self.A[indr], indr\n\nimport heapq as hp\nN = int(input())\nA = list(map(int, input().split()))\n\ndef main():\n SP1 = SparseTable((N+1)//2, A[::2])\n SP2 = SparseTable(N//2, A[1::2])\n\n ans = []\n q = []\n v, k = SP1.query_min(0, N//2)\n dic = {}\n dic[v] = (k, 0, N//2, True)\n hp.heappush(q, v)\n for _ in range(N//2):\n valuea = hp.heappop(q)\n ka, l, r, is1 = dic[valuea]\n ans.append(str(valuea))\n if is1:\n valueb, kb = SP2.query_min(ka, r)\n if ka < kb:\n m2, nk2 = SP2.query_min(ka, kb)\n hp.heappush(q, m2)\n dic[m2] = (nk2, ka, kb+1, False)\n if l < ka:\n m1, nk1 = SP1.query_min(l, ka)\n hp.heappush(q, m1)\n dic[m1] = (nk1, l, ka, True)\n if kb+1 < r:\n m3, nk3 = SP1.query_min(kb+1, r)\n hp.heappush(q, m3)\n dic[m3] = (nk3, kb+1, r, True)\n else:\n valueb, kb = SP1.query_min(ka+1, r)\n if ka+1 < kb:\n m1, nk1 = SP1.query_min(ka+1, kb)\n hp.heappush(q, m1)\n dic[m1] = (nk1, ka+1, kb, True)\n if l < ka:\n m2, nk2 = SP2.query_min(l, ka)\n hp.heappush(q, m2)\n dic[m2] = (nk2, l, ka+1, False)\n if kb < r-1:\n m3, nk3 = SP2.query_min(kb, r-1)\n hp.heappush(q, m3)\n dic[m3] = (nk3, kb, r, False)\n\n ans.append(str(valueb))\n\n print(\" \".join(ans))\n\n\ndef __starting_point():\n main()\n__starting_point()", "#####segfunc#####\ndef segfunc(x, y):\n if y[0]>x[0]:\n return x\n else:\n return y\n#################\n\n#####ide_ele#####\nide_ele =(float(\"inf\"),-1)\n#################\n\nclass SegTree:\n \"\"\"\n init(init_val, ide_ele): \u914d\u5217init_val\u3067\u521d\u671f\u5316 O(N)\n update(k, x): k\u756a\u76ee\u306e\u5024\u3092x\u306b\u66f4\u65b0 O(logN)\n query(l, r): \u533a\u9593[l, r)\u3092segfunc\u3057\u305f\u3082\u306e\u3092\u8fd4\u3059 O(logN)\n \"\"\"\n def __init__(self, init_val, segfunc, ide_ele):\n \"\"\"\n init_val: \u914d\u5217\u306e\u521d\u671f\u5024\n segfunc: \u533a\u9593\u306b\u3057\u305f\u3044\u64cd\u4f5c\n ide_ele: \u5358\u4f4d\u5143\n n: \u8981\u7d20\u6570\n num: n\u4ee5\u4e0a\u306e\u6700\u5c0f\u306e2\u306e\u3079\u304d\u4e57\n tree: \u30bb\u30b0\u30e1\u30f3\u30c8\u6728(1-index)\n \"\"\"\n n = len(init_val)\n self.segfunc = segfunc\n self.ide_ele = ide_ele\n self.num = 1 << (n - 1).bit_length()\n self.tree = [ide_ele] * 2 * self.num\n # \u914d\u5217\u306e\u5024\u3092\u8449\u306b\u30bb\u30c3\u30c8\n for i in range(n):\n self.tree[self.num + i] = init_val[i]\n # \u69cb\u7bc9\u3057\u3066\u3044\u304f\n for i in range(self.num - 1, 0, -1):\n self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])\n\n def update(self, k, x):\n \"\"\"\n k\u756a\u76ee\u306e\u5024\u3092x\u306b\u66f4\u65b0\n k: index(0-index)\n x: update value\n \"\"\"\n k += self.num\n self.tree[k] = x\n while k > 1:\n self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])\n k >>= 1\n\n def query(self, l, r):\n \"\"\"\n [l, r)\u306esegfunc\u3057\u305f\u3082\u306e\u3092\u5f97\u308b\n l: index(0-index)\n r: index(0-index)\n \"\"\"\n res = self.ide_ele\n\n l += self.num\n r += self.num\n while l < r:\n if l & 1:\n res = self.segfunc(res, self.tree[l])\n l += 1\n if r & 1:\n res = self.segfunc(res, self.tree[r - 1])\n l >>= 1\n r >>= 1\n return res\n\nimport heapq\n\nN=int(input())\np=list(map(int,input().split()))\nn=N//2\nop=[(p[2*i+1],2*i+1) for i in range(n)]\nep=[(p[2*i],2*i) for i in range(n)]\n\noseg=SegTree(op,segfunc,ide_ele)\neseg=SegTree(ep,segfunc,ide_ele)\n\ndef first(l,r):\n if l>=r:\n return (-1,-1,-1,-1)\n if l%2==0:\n val,index=eseg.query(l//2,r//2)\n val2,index2=oseg.query(index//2,r//2)\n return (val,val2,index,index2)\n else:\n val,index=oseg.query(l//2,r//2)\n val2,index2=eseg.query(index//2+1,r//2+1)\n return (val,val2,index,index2)\n\nval,val2,index,index2=first(0,N)\nque=[((val,val2),0,N)]\nheapq.heapify(que)\nans=[]\nwhile que:\n tuple,l,r=heapq.heappop(que)\n ans.append(tuple[0])\n ans.append(tuple[1])\n val,val2,index,index2=first(l,r)\n val,val2,l1,r1=first(l,index)\n if val!=-1:\n heapq.heappush(que,((val,val2),l,index))\n val,val2,l2,r2=first(index+1,index2)\n if val!=-1:\n heapq.heappush(que,((val,val2),index+1,index2))\n val,val2,l3,r3=first(index2+1,r)\n if val!=-1:\n heapq.heappush(que,((val,val2),index2+1,r))\n\nprint(*ans)", "def main():\n n = int(input())\n p = list([int(x)-1 for x in input().split()])\n\n pos = [j for i, j in sorted([(j, i) for i, j in enumerate(p)])]\n basesize = n >> 1\n num = 1\n while num < basesize:\n num *= 2\n num -= 1\n\n tree_even = [100001]*(num*2+1)\n tree_odd = [100001]*(num*2+1)\n\n for i in range(num, num+basesize):\n tree_even[i] = p[(i-num)*2]\n for i in range(num-1, -1, -1):\n tree_even[i] = min(tree_even[2*i+1:2*i+3])\n for i in range(num, num+basesize):\n tree_odd[i] = p[(i-num)*2+1]\n for i in range(num-1, -1, -1):\n tree_odd[i] = min(tree_odd[2*i+1:2*i+3])\n\n g = dict()\n d = dict()\n q = [n-1]\n qap, qp = q.append, q.pop\n while q:\n t = qp()\n m, M = t//n, t % n\n if m+1 == M:\n d[t] = p[m]*n+p[M]\n continue\n g[t] = []\n gap = g[t].append\n if m % 2 == 0:\n i1, j1 = m >> 1, (M >> 1)+1\n even = 200000\n l, r = i1+num, j1+num\n while l < r:\n if r % 2 == 0:\n r -= 1\n even = min(even, tree_even[r])\n if l % 2 == 0:\n even = min(even, tree_even[l])\n l += 1\n l >>= 1\n r >>= 1\n even_idx = pos[even]\n odd = 200000\n l, r = (even_idx >> 1)+num, j1+num\n while l < r:\n if r % 2 == 0:\n r -= 1\n odd = min(odd, tree_odd[r])\n if l % 2 == 0:\n odd = min(odd, tree_odd[l])\n l += 1\n l >>= 1\n r >>= 1\n odd_idx = pos[odd]\n d[t] = even*n+odd\n if m != even_idx:\n s = m*n+even_idx-1\n qap(s)\n gap(s)\n if M != odd_idx:\n s = (odd_idx+1)*n+M\n qap(s)\n gap(s)\n if even_idx+1 != odd_idx:\n s = (even_idx+1)*n+odd_idx-1\n qap(s)\n gap(s)\n else:\n i1, j1 = m >> 1, M >> 1\n odd = 200000\n l, r = i1+num, j1+num\n while l < r:\n if r % 2 == 0:\n r -= 1\n odd = min(odd, tree_odd[r])\n if l % 2 == 0:\n odd = min(odd, tree_odd[l])\n l += 1\n l >>= 1\n r >>= 1\n odd_idx = pos[odd]\n even = 200000\n l, r = (odd_idx >> 1)+1+num, j1+1+num\n while l < r:\n if r % 2 == 0:\n r -= 1\n even = min(even, tree_even[r])\n if l % 2 == 0:\n even = min(even, tree_even[l])\n l += 1\n l >>= 1\n r >>= 1\n even_idx = pos[even]\n d[t] = odd*n+even\n if m != odd_idx:\n s = m*n+odd_idx-1\n qap(s)\n gap(s)\n if M != even_idx:\n s = (even_idx+1)*n+M\n qap(s)\n gap(s)\n if odd_idx+1 != even_idx:\n s = (odd_idx+1)*n+even_idx-1\n qap(s)\n gap(s)\n\n g2 = dict()\n\n for i, t in list(g.items()):\n k = d[i]\n g2[k] = []\n ga = g2[k].append\n for j in t:\n ga(d[j])\n\n import heapq\n h = [d[n-1]]\n heapq.heapify(h)\n ans = []\n hpop = heapq.heappop\n hpush = heapq.heappush\n\n while h:\n t = hpop(h)\n ans += [t//n+1, t % n+1]\n if t in g2:\n for s in g2[t]:\n hpush(h, s)\n\n print((*ans))\n\n\nmain()\n", "# seishin.py\nN = int(input())\n*P, = map(int, input().split())\nM = [0]*(N+1)\nfor i, p in enumerate(P):\n M[p] = i\n\nINF = 10**9\ndef init(P, n):\n n0 = 2 ** (n-1).bit_length()\n data = [INF]*(n0*2)\n data[n0-1:n0+n-1] = P\n for i in range(n0-2, -1, -1):\n data[i] = min(data[2*i+1], data[2*i+2])\n return data\n\ndef get_data(data, l, r):\n n0 = len(data)//2\n l += n0\n r += n0\n while l < r:\n if r&1:\n r -= 1\n yield data[r-1]\n if l&1:\n yield data[l-1]\n l += 1\n l >>= 1\n r >>= 1\n\ndef get(data, l, r):\n return min(get_data(data, l, r))\n\nd0 = init(P[0::2], N//2)\nd1 = init(P[1::2], N//2)\n\ndef query_x(l, r):\n if l % 2 == 0:\n x = get(d0, l//2, r//2)\n else:\n x = get(d1, l//2, r//2)\n return x\ndef query_y(l, r):\n if l % 2 == 0:\n y = get(d1, l//2, r//2)\n else:\n y = get(d0, (l+1)//2, (r+1)//2)\n return y\n\nfrom heapq import heappush, heappop\nque = [(query_x(0, N), 0, N)]\nans = []\nwhile que:\n x, l, r = heappop(que)\n if l+2 < r:\n xi = M[x]\n y = query_y(xi, r)\n\n yi = M[y]\n\n # [l, xi)\n if l < xi:\n heappush(que, (query_x(l, xi), l, xi))\n # [xi+1, yi)\n if xi+1 < yi:\n heappush(que, (query_x(xi+1, yi), xi+1, yi))\n # [yi+1, r)\n if yi+1 < r:\n heappush(que, (query_x(yi+1, r), yi+1, r))\n else:\n y = P[r-1]\n\n ans.append(\"%d %d\" % (x, y))\nprint(*ans)", "import sys\nreadline = sys.stdin.readline\nfrom heapq import heappop as hpp, heappush as hp\nclass Segtree:\n def __init__(self, A, intv, initialize = True, segf = max):\n self.N = len(A)\n self.N0 = 2**(self.N-1).bit_length()\n self.intv = intv\n self.segf = segf\n if initialize:\n self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)\n for i in range(self.N0-1, 0, -1):\n self.data[i] = self.segf(self.data[2*i], self.data[2*i+1]) \n else:\n self.data = [intv]*(2*self.N0)\n \n def update(self, k, x):\n k += self.N0\n self.data[k] = x\n while k > 0 :\n k = k >> 1\n self.data[k] = self.segf(self.data[2*k], self.data[2*k+1])\n \n def query(self, l, r):\n L, R = l+self.N0, r+self.N0\n s = self.intv\n while L < R:\n if R & 1:\n R -= 1\n s = self.segf(s, self.data[R])\n if L & 1:\n s = self.segf(s, self.data[L])\n L += 1\n L >>= 1\n R >>= 1\n return s\n \n def binsearch(self, l, r, check, reverse = False):\n L, R = l+self.N0, r+self.N0\n SL, SR = [], []\n while L < R:\n if R & 1:\n R -= 1\n SR.append(R)\n if L & 1:\n SL.append(L)\n L += 1\n L >>= 1\n R >>= 1\n \n if reverse:\n for idx in (SR + SL[::-1]):\n if check(self.data[idx]):\n break\n else:\n return -1\n while idx < self.N0:\n if check(self.data[2*idx+1]):\n idx = 2*idx + 1\n else:\n idx = 2*idx\n return idx\n else:\n for idx in (SL + SR[::-1]):\n if check(self.data[idx]):\n break\n else:\n return -1\n while idx < self.N0:\n if check(self.data[2*idx]):\n idx = 2*idx\n else:\n idx = 2*idx + 1\n return idx\n\nN = int(readline())\n\ninf = 1<<32\nP = list(map(int, readline().split()))\n\nPi = [None]*(N+1)\nfor i in range(N):\n Pi[P[i]] = i\n\ninf = 1<<32\nPeven = [P[i] if not i&1 else inf for i in range(N)]\nPodd = [P[i] if i&1 else inf for i in range(N)]\n\nTeven = Segtree(Peven, inf, initialize = True, segf = min)\nTodd = Segtree(Podd, inf, initialize = True, segf = min)\nN0 = 2**(N-1).bit_length()\n\nQ = [(Teven.query(0, N0), 0, N0)]\nfor i in range(N//2):\n t1, l, r = hpp(Q)\n K = []\n if not l&1:\n p1 = Pi[t1]\n t2 = Todd.query(p1, r)\n p2 = Pi[t2]\n Teven.update(p1, inf)\n Todd.update(p2, inf)\n else:\n p1 = Pi[t1]\n t2 = Teven.query(p1, r)\n p2 = Pi[t2]\n Todd.update(p1, inf)\n Teven.update(p2, inf)\n if l < p1:\n K.append((l, p1))\n if p2 < r:\n K.append((p2+1, r))\n if p1 + 1 < p2:\n K.append((p1+1, p2))\n for l, r in K:\n if not l&1:\n mq = Teven.query(l, r)\n else:\n mq = Todd.query(l, r)\n hp(Q, (mq, l, r))\n sys.stdout.write('{} {} '.format(t1, t2))\nsys.stdout.write('\\n')", "inf = 10**10\ndef sg_func(a,b):\n res = [0,0,0]\n if(a[2]==0):\n res[0] = min(a[0],b[0])\n res[1] = min(a[1],b[1])\n else:\n res[0] = min(a[0],b[1])\n res[1] = min(a[1],b[0])\n\n res[2] = (a[2]+b[2])%2\n\n return res\n\n\nclass Seg_cus():\n def __init__(self,x):\n #####\u5358\u4f4d\u5143######\n self.ide_ele_min = inf\n self.func = sg_func\n\n self.n = len(x)\n\n #num_max:n\u4ee5\u4e0a\u306e\u6700\u5c0f\u306e2\u306e\u3079\u304d\u4e57\n self.num_max =2**(self.n-1).bit_length()\n self.x = [[self.ide_ele_min,self.ide_ele_min,0] for _ in range(2*self.num_max)]\n\n for i,num in enumerate(x, self.num_max):\n self.x[i][0] = num\n self.x[i][2] = 1\n for i in range(self.num_max-1,0,-1):\n self.x[i] = self.func(self.x[i<<1],self.x[(i<<1) + 1])\n\n def delete(self,i):\n i += self.num_max\n self.x[i][0] = inf\n self.x[i][2] = 0\n while(i>0):\n i = i//2\n self.x[i] = self.func(self.x[i<<1],self.x[(i<<1) + 1])\n\n def query(self,i,j):\n res = [self.ide_ele_min,self.ide_ele_min,0]\n if i>=j:\n return res\n i += self.num_max\n j += self.num_max -1\n stack_i = []\n stack_j = []\n while(i<=j):\n if(i==j):\n stack_i.append(i)\n break\n if(i&1):\n stack_i.append(i)\n i += 1\n if(not j&1):\n stack_j.append(j)\n j -= 1\n i = i>>1\n j = j>>1\n for i in stack_i:\n res = self.func(res,self.x[i])\n for i in stack_j[::-1]:\n res = self.func(res,self.x[i])\n\n return res\n\nclass Seg_min():\n def __init__(self,x):\n #####\u5358\u4f4d\u5143######\n self.ide_ele_min = 10**10\n self.func = min\n\n self.n = len(x)\n\n #num_max:n\u4ee5\u4e0a\u306e\u6700\u5c0f\u306e2\u306e\u3079\u304d\u4e57\n self.num_max =2**(self.n-1).bit_length()\n self.x = [self.ide_ele_min]*2*self.num_max\n\n for i,num in enumerate(x, self.num_max):\n self.x[i] = num\n for i in range(self.num_max-1,0,-1):\n self.x[i] = self.func(self.x[i<<1],self.x[(i<<1) + 1])\n\n def update(self,i,x):\n i += self.num_max\n self.x[i] = x\n while(i>0):\n i = i//2\n self.x[i] = self.func(self.x[i<<1],self.x[(i<<1) + 1])\n\n def query(self,i,j):\n res = self.ide_ele_min\n if i>=j:\n return res\n i += self.num_max\n j += self.num_max -1\n while(i<=j):\n if(i==j):\n res = self.func(res,self.x[i])\n break\n if(i&1):\n res = self.func(res,self.x[i])\n i += 1\n if(not j&1):\n res = self.func(res,self.x[j])\n j -= 1\n i = i>>1\n j = j>>1\n return res\n\nn = int(input())\np = list(map(int,input().split()))\n\nind = [0] * (n+1)\nfor i,pi in enumerate(p):\n ind[pi] = i\n\nst = Seg_cus(p)\nst_ind = Seg_min([n] * n)\n\nans = []\nfor _ in range(n//2):\n num1 = st.query(0,n)[0]\n num2 = st.query(ind[num1],st_ind.query(ind[num1],n))[1]\n ans.append(num1)\n ans.append(num2)\n\n # print(num1,num2)\n # print(ind[num1],ind[num2])\n # print(st.x)\n # print(st_ind.x)\n st.delete(ind[num1])\n st.delete(ind[num2])\n st_ind.update(ind[num1],ind[num1])\n st_ind.update(ind[num2],ind[num2])\n\nprint(' '.join(map(str,ans)))", "from heapq import heappop, heappush\nn = int(input())\np = [int(x) for x in input().split()]\n\n\nclass SegmentTree: # 0-indexed\n def __init__(self, array, operation=min, identity=10**30):\n self.identity = identity\n self.n = len(array)\n self.N = 1 << (self.n - 1).bit_length()\n self.tree = [self.identity] * 2 * self.N\n self.opr = operation\n for i in range(self.n):\n self.tree[i+self.N-1] = array[i]\n for i in range(self.N-2, -1, -1):\n self.tree[i] = self.opr(self.tree[2*i+1], self.tree[2*i+2])\n\n def values(self):\n return self.tree[self.N-1:]\n\n def update(self, k, x):\n k += self.N-1\n self.tree[k] = x\n while k+1:\n k = (k-1)//2\n self.tree[k] = self.opr(self.tree[k*2+1], self.tree[k*2+2])\n\n def query(self, p, q): # [p,q)\n if q <= p:\n print(\"Oops! That was no valid number. Try again...\")\n return\n p += self.N-1\n q += self.N-2\n res = self.identity\n while q-p > 1:\n if p & 1 == 0:\n res = self.opr(res, self.tree[p])\n if q & 1 == 1:\n res = self.opr(res, self.tree[q])\n q -= 1\n p = p//2\n q = (q-1)//2\n if p == q:\n res = self.opr(res, self.tree[p])\n else:\n res = self.opr(self.opr(res, self.tree[p]), self.tree[q])\n return res\n\n\nind = [0]*(n+1)\nOdd = SegmentTree([10**30]*n)\nEven = SegmentTree([10**30]*n)\n\nfor i in range(n):\n ind[p[i]] = i\n if i % 2 == 0:\n Even.update(i, p[i])\n else:\n Odd.update(i, p[i])\n\ncand = []\nheappush(cand, (Even.query(0, n), 0, n, True))\n\nq = []\nfor _ in range(n//2):\n first, l, r, is_even = heappop(cand)\n if is_even:\n second = Odd.query(ind[first]+1, r)\n q.extend([first, second])\n if l < ind[first]:\n heappush(cand, (Even.query(l, ind[first]), l, ind[first], True))\n if ind[first] + 1 < ind[second]:\n heappush(\n cand, (Odd.query(ind[first]+1, ind[second]), ind[first]+1, ind[second], False))\n if ind[second]+1 < r:\n heappush(\n cand, (Even.query(ind[second], r), ind[second]+1, r, True))\n else:\n second = Even.query(ind[first]+1, r)\n q.extend([first, second])\n if l < ind[first]:\n heappush(cand, (Odd.query(l, ind[first]), l, ind[first], False))\n if ind[first] + 1 < ind[second]:\n heappush(\n cand, (Even.query(ind[first]+1, ind[second]), ind[first]+1, ind[second], True))\n if ind[second]+1 < r:\n heappush(\n cand, (Odd.query(ind[second], r), ind[second]+1, r, False))\n\nprint((*q))\n", "from heapq import heappop, heappush\nn = int(input())\np = [int(x) for x in input().split()]\n\n\nclass SegmentTree: # 0-indexed\n def __init__(self, array, operation=min, identity=10**30):\n self.identity = identity\n self.n = len(array)\n self.N = 1 << (self.n - 1).bit_length()\n self.tree = [self.identity] * 2 * self.N\n self.opr = operation\n for i in range(self.n):\n self.tree[i+self.N-1] = array[i]\n for i in range(self.N-2, -1, -1):\n self.tree[i] = self.opr(self.tree[2*i+1], self.tree[2*i+2])\n\n def values(self):\n return self.tree[self.N-1:]\n\n def update(self, k, x):\n k += self.N-1\n self.tree[k] = x\n while k+1:\n k = (k-1)//2\n self.tree[k] = self.opr(self.tree[k*2+1], self.tree[k*2+2])\n\n def query(self, p, q): # [p,q)\n if q <= p:\n print(\"Oops! That was no valid number. Try again...\")\n return\n p += self.N-1\n q += self.N-2\n res = self.identity\n while q-p > 1:\n if p & 1 == 0:\n res = self.opr(res, self.tree[p])\n if q & 1 == 1:\n res = self.opr(res, self.tree[q])\n q -= 1\n p = p//2\n q = (q-1)//2\n if p == q:\n res = self.opr(res, self.tree[p])\n else:\n res = self.opr(self.opr(res, self.tree[p]), self.tree[q])\n return res\n\n\nind = [0]*(n+1)\nOdd = SegmentTree([10**30]*n)\nEven = SegmentTree([10**30]*n)\n\nfor i in range(n):\n ind[p[i]] = i\n if i % 2 == 0:\n Even.update(i, p[i])\n else:\n Odd.update(i, p[i])\n\ncand = []\nheappush(cand, (Even.query(0, n), 0, n, True))\n\nq = []\nwhile len(q) < n:\n first, l, r, is_even = heappop(cand)\n if is_even:\n second = Odd.query(ind[first]+1, r)\n q.extend([first, second])\n if l < ind[first]:\n heappush(cand, (Even.query(l, ind[first]), l, ind[first], True))\n if ind[first] + 1 < ind[second]:\n heappush(\n cand, (Odd.query(ind[first]+1, ind[second]), ind[first]+1, ind[second], False))\n if ind[second]+1 < r:\n heappush(\n cand, (Even.query(ind[second], r), ind[second]+1, r, True))\n else:\n second = Even.query(ind[first]+1, r)\n q.extend([first, second])\n if l < ind[first]:\n heappush(cand, (Odd.query(l, ind[first]), l, ind[first], False))\n if ind[first] + 1 < ind[second]:\n heappush(\n cand, (Even.query(ind[first]+1, ind[second]), ind[first]+1, ind[second], True))\n if ind[second]+1 < r:\n heappush(\n cand, (Odd.query(ind[second], r), ind[second]+1, r, False))\n\nprint((*q))\n", "# seishin.py\nN = int(input())\n*P, = map(int, input().split())\nM = [0]*(N+1)\nfor i, p in enumerate(P):\n M[p] = i\n\nINF = 10**9\ndef init(P, n):\n n0 = 2 ** (n-1).bit_length()\n data = [INF]*(n0*2)\n data[n0-1:n0+n-1] = P\n for i in range(n0-2, -1, -1):\n data[i] = min(data[2*i+1], data[2*i+2])\n return data\n\ndef get_data(data, l, r):\n n0 = len(data)//2\n l += n0\n r += n0\n while l < r:\n if r&1:\n r -= 1\n yield data[r-1]\n if l&1:\n yield data[l-1]\n l += 1\n l >>= 1\n r >>= 1\n\ndef get(data, l, r):\n return min(get_data(data, l, r))\n\nd0 = init(P[0::2], N//2)\nd1 = init(P[1::2], N//2)\n\ndef query_x(l, r):\n if l % 2 == 0:\n x = get(d0, l//2, r//2)\n else:\n x = get(d1, l//2, r//2)\n return x\ndef query_y(l, r):\n if l % 2 == 0:\n y = get(d1, l//2, r//2)\n else:\n y = get(d0, (l+1)//2, (r+1)//2)\n return y\n\nfrom heapq import heappush, heappop\nque = [(query_x(0, N), 0, N)]\nans = []\nwhile que:\n x, l, r = heappop(que)\n if l+2 < r:\n xi = M[x]\n y = query_y(xi, r)\n\n yi = M[y]\n\n # [l, xi)\n if l < xi:\n heappush(que, (query_x(l, xi), l, xi))\n # [xi+1, yi)\n if xi+1 < yi:\n heappush(que, (query_x(xi+1, yi), xi+1, yi))\n # [yi+1, r)\n if yi+1 < r:\n heappush(que, (query_x(yi+1, r), yi+1, r))\n else:\n y = P[r-1]\n\n ans.append(\"%d %d\" % (x, y))\nprint(*ans)", "# seishin.py\nN = int(input())\n*P, = map(int, input().split())\nM = [0]*(N+1)\nfor i, p in enumerate(P):\n M[p] = i\n\nINF = 10**9\ndef init(P, n):\n n0 = 2 ** (n-1).bit_length()\n data = [INF]*(n0*2)\n data[n0-1:n0+n-1] = P\n for i in range(n0-2, -1, -1):\n data[i] = min(data[2*i+1], data[2*i+2])\n return data\n\n\"\"\"\ndef __get(data, a, b, k, l, r):\n if a <= l and r <= b:\n return data[k]\n if b <= l or r <= a:\n return INF\n vl = __get(data, a, b, 2*k+1, l, (l+r)//2)\n vr = __get(data, a, b, 2*k+2, (l+r)//2, r)\n return min(vl, vr)\n\"\"\"\n\ndef get_data(data, l, r):\n n0 = len(data)//2\n l += n0\n r += n0\n while l < r:\n if r&1:\n r -= 1\n yield data[r-1]\n if l&1:\n yield data[l-1]\n l += 1\n l >>= 1\n r >>= 1\n yield INF\n\ndef get(data, l, r):\n #return __get(data, l, r, 0, 0, len(data)//2)\n return min(get_data(data, l, r))\n\nd0 = init(P[0::2], N//2)\nd1 = init(P[1::2], N//2)\n\ndef query_x(l, r):\n if l % 2 == 0:\n x = get(d0, l//2, r//2)\n else:\n x = get(d1, l//2, r//2)\n return x\ndef query_y(l, r):\n if l % 2 == 0:\n y = get(d1, l//2, r//2)\n else:\n y = get(d0, (l+1)//2, (r+1)//2)\n return y\n\nfrom heapq import heappush, heappop\nque = [(query_x(0, N), 0, N)]\nans = []\nwhile que:\n x, l, r = heappop(que)\n if l+2 < r:\n xi = M[x]\n y = query_y(xi, r)\n\n yi = M[y]\n\n # [l, xi)\n if l < xi:\n heappush(que, (query_x(l, xi), l, xi))\n # [xi+1, yi)\n if xi+1 < yi:\n heappush(que, (query_x(xi+1, yi), xi+1, yi))\n # [yi+1, r)\n if yi+1 < r:\n heappush(que, (query_x(yi+1, r), yi+1, r))\n else:\n y = P[r-1]\n\n ans.append(\"%d %d\" % (x, y))\nprint(*ans)", "import heapq\nimport sys\ninput=sys.stdin.readline\n\nclass SegmentTreeMin():\n def __init__(self,n,init):\n self.offset=2**((n-1).bit_length())\n self.tree=[init]*(2*self.offset)\n self.init=init\n def update(self,pos,val):\n pos+=self.offset\n self.tree[pos]=val\n while pos>1:\n pos=pos//2\n self.tree[pos]=min(self.tree[2*pos],self.tree[2*pos+1])\n def query(self,l,r):\n l+=self.offset\n r+=self.offset\n ret=self.init\n while l<=r:\n ret=min(ret,self.tree[r])\n r=(r-1)//2\n ret=min(ret,self.tree[l])\n l=(l+1)//2\n return ret\n\nn=int(input())\narr=list(map(int,input().split()))\nodds=SegmentTreeMin(n//2,10**18)\nevens=SegmentTreeMin(n//2,10**18)\ndic={}\nfor i in range(n):\n dic[arr[i]]=i\n if i%2==0:\n odds.update(i//2,arr[i])\n else:\n evens.update(i//2,arr[i])\nq=[]\nheapq.heappush(q,(odds.query(0,(n-1)//2),0,n-1))\nans=[]\nwhile len(q)!=0:\n _,l,r=heapq.heappop(q)\n if l%2==0:\n a=odds.query(l//2,r//2)\n odds.update(dic[a]//2,10**18)\n b=evens.query(dic[a]//2,r//2)\n evens.update(dic[b]//2,10**18)\n ans.append(a)\n ans.append(b)\n tl=dic[a]\n tr=dic[b]\n if tl!=l:\n heapq.heappush(q,(odds.query(l//2,(tl-1)//2),l,tl-1))\n if tl+1<tr-1:\n heapq.heappush(q,(evens.query((tl+1)//2,(tr-1)//2),tl+1,tr-1))\n if tr!=r:\n heapq.heappush(q,(odds.query((tr+1)//2,r//2),tr+1,r))\n else:\n a=evens.query(l//2,r//2)\n evens.update(dic[a]//2,10**18)\n b=odds.query((dic[a]+1)//2,r//2)\n odds.update(dic[b]//2,10**18)\n ans.append(a)\n ans.append(b)\n tl=dic[a]\n tr=dic[b]\n if tl!=l:\n heapq.heappush(q,(evens.query(l//2,(tl-1)//2),l,tl-1))\n if tl+1<tr-1:\n heapq.heappush(q,(odds.query((tl+1)//2,(tr-1)//2),tl+1,tr-1))\n if tr!=r:\n heapq.heappush(q,(evens.query((tr+1)//2,r//2),tr+1,r))\nprint(*ans)", "N = int(input())\n*P, = map(int,input().split())\nM = [0]*(N+1)\nfrom heapq import heappush,heappop\nfor i,p in enumerate(P):\n M[p] = i\n\nINF = 10**9\n\ndef init(P,n):\n n0 = 2**(n-1).bit_length()\n data = [INF]*(n0*2)\n data[n0-1:n0+n-1] = P\n for i in range(n0-2,-1,-1):\n data[i] = min(data[2*i+1],data[2*i+2])\n return data\n\ndef get_data(data,l,r):\n n0 = len(data)//2\n l += n0\n r += n0\n while l<r:\n if r&1:\n r-=1\n yield data[r-1]\n if l&1:\n yield data[l-1]\n l += 1\n l>>=1\n r>>=1\n\ndef get(data,l,r):\n return min(get_data(data,l,r))\n\nd0 = init(P[0::2],N//2)\nd1 = init(P[1::2],N//2)\n\n\ndef query_x(l, r):\n if l % 2 == 0:\n x = get(d0, l//2, r//2)\n else:\n x = get(d1, l//2, r//2)\n return x\ndef query_y(l, r):\n if l % 2 == 0:\n y = get(d1, l//2, r//2)\n else:\n y = get(d0, (l+1)//2, (r+1)//2)\n return y\n\n\nque = [(query_x(0,N),0,N)]\nans = []\nwhile que:\n x, l, r = heappop(que)\n if l+2 < r:\n xi = M[x]\n y = query_y(xi, r)\n yi = M[y]\n \n # [l, xi)\n if l < xi:\n heappush(que, (query_x(l, xi), l, xi))\n # [xi+1, yi)\n if xi+1 < yi:\n heappush(que, (query_x(xi+1, yi), xi+1, yi))\n # [yi+1, r)\n if yi+1 < r:\n heappush(que, (query_x(yi+1, r), yi+1, r))\n else:\n y = P[r-1]\n ans.append(\"%d %d\" % (x, y))\nprint(*ans)", "import sys\ninput = sys.stdin.readline\nfrom heapq import heappush, heappop\n\nN = int(input())\nA = [int(x) for x in input().split()]\na_to_i = {a:i for i,a in enumerate(A)}\n\n# sparse table \u3092\u4f7f\u3063\u3066RMQ\n# parity\u306e\u540c\u3058\u3068\u3053\u308d\u3060\u3051\u3092\u898b\u308b\u3088\u3046\u306b\u3057\u3066\u304a\u304f\n\nU = len(A).bit_length()\nsp = [None,A]\nfor i in range(2,U):\n L = 1 << (i-1)\n sp.append([x if x < y else y for x,y in zip(sp[-1][:-L], sp[-1][L:])])\n\ndef RMQ(x,y):\n # x\u756a\u76ee\u304b\u3089\u5076\u6570\u756a\u76ee\u3060\u3051\u898b\u3066[x,y]\u3067\u306e\u6700\u5c0f\u5024\u3092\u8fd4\u3059\n d = y - x\n if d <= 1:\n return A[x]\n n = d.bit_length()\n return min(sp[n-1][x], sp[n-1][y+2-(1<<(n-1))])\n\ndef F(x,y):\n # \u8f9e\u66f8\u5f0f\u3067\u6700\u5c0f\u306e2\u3064\u7d44\u3092\u3068\u308b\n # \u305d\u306e\u3042\u3068\u3001\u4eca\u5f8c\u8abf\u3079\u306a\u3044\u3068\u3044\u3051\u306a\u3044\u533a\u9593\u306e\u4e00\u89a7\u3092\u8fd4\u3059\n x1 = RMQ(x,y-1)\n i1 = a_to_i[x1]\n x2 = RMQ(i1+1,y)\n i2 = a_to_i[x2]\n task = ((x,y) for x,y in ((x,i1-1), (i1+1,i2-1), (i2+1,y)) if y > x)\n return x1,x2,task\n\nq = [(None,None,((0,N-1),))]\nanswer = []\nwhile q:\n x,y,task = heappop(q)\n answer.append(x)\n answer.append(y)\n for left,right in task:\n heappush(q,F(left,right))\n\nprint(' '.join(map(str,answer[2:])))", "import sys\ninput = sys.stdin.readline\nimport numpy as np\nfrom heapq import heappush, heappop\n\nN = int(input())\nA = np.array(input().split(), dtype=np.int32)\na_to_i = {a:i for i,a in enumerate(A)}\n\n# sparse table \u3092\u4f7f\u3063\u3066RMQ\n# parity\u306e\u540c\u3058\u3068\u3053\u308d\u3060\u3051\u3092\u898b\u308b\u3088\u3046\u306b\u3057\u3066\u304a\u304f\n\nU = len(A).bit_length()\nsp = [None,A]\nfor i in range(2,U):\n L = 1 << (i-1)\n sp.append(np.minimum(sp[-1][:-L], sp[-1][L:]))\n\ndef RMQ(x,y):\n if (y-x)&1: \n y -= 1\n # x\u756a\u76ee\u304b\u3089\u5076\u6570\u756a\u76ee\u3060\u3051\u898b\u3066[x,y]\u3067\u306e\u6700\u5c0f\u5024\u3092\u8fd4\u3059\n d = y - x\n if d <= 1:\n return A[x]\n n = d.bit_length()\n return min(sp[n-1][x], sp[n-1][y+2-(1<<(n-1))])\n\ndef F(x,y):\n # \u8f9e\u66f8\u5f0f\u3067\u6700\u5c0f\u306e2\u3064\u7d44\u3092\u3068\u308b\n # \u305d\u306e\u3042\u3068\u3001\u4eca\u5f8c\u8abf\u3079\u306a\u3044\u3068\u3044\u3051\u306a\u3044\u533a\u9593\u306e\u4e00\u89a7\u3092\u8fd4\u3059\n x1 = RMQ(x,y)\n i1 = a_to_i[x1]\n x2 = RMQ(i1+1,y)\n i2 = a_to_i[x2]\n task = ((x,y) for x,y in ((x,i1-1), (i1+1,i2-1), (i2+1,y)) if y > x)\n return x1,x2,task\n\nq = [(None,None,((0,N-1),))]\nanswer = []\nwhile q:\n x,y,task = heappop(q)\n if x != None:\n answer.append(x)\n answer.append(y)\n for left,right in task:\n heappush(q,F(left,right))\n\nprint(' '.join(map(str,answer)))", "import sys\ninput = sys.stdin.readline\nfrom heapq import heappush, heappop\n\nN = int(input())\nA = [int(x) for x in input().split()]\na_to_i = {a:i for i,a in enumerate(A)}\n\n# sparse table \u3092\u4f7f\u3063\u3066RMQ\n# parity\u306e\u540c\u3058\u3068\u3053\u308d\u3060\u3051\u3092\u898b\u308b\u3088\u3046\u306b\u3057\u3066\u304a\u304f\n\nU = len(A).bit_length()\nsp = [None,A]\nfor i in range(2,U):\n L = 1 << (i-1)\n sp.append([x if x < y else y for x,y in zip(sp[-1][:-L], sp[-1][L:])])\n\ndef RMQ(x,y):\n # x\u756a\u76ee\u304b\u3089\u5076\u6570\u756a\u76ee\u3060\u3051\u898b\u3066[x,y]\u3067\u306e\u6700\u5c0f\u5024\u3092\u8fd4\u3059\n d = y - x\n if d <= 1:\n return A[x]\n n = d.bit_length()\n arr = sp[n-1]\n ax = arr[x]\n ay = arr[y+2-(1<<(n-1))]\n return ax if ax < ay else ay\n\ndef F(x,y):\n # \u8f9e\u66f8\u5f0f\u3067\u6700\u5c0f\u306e2\u3064\u7d44\u3092\u3068\u308b\n # \u305d\u306e\u3042\u3068\u3001\u4eca\u5f8c\u8abf\u3079\u306a\u3044\u3068\u3044\u3051\u306a\u3044\u533a\u9593\u306e\u4e00\u89a7\u3092\u8fd4\u3059\n x1 = RMQ(x,y-1)\n i1 = a_to_i[x1]\n x2 = RMQ(i1+1,y)\n i2 = a_to_i[x2]\n task = ((x,y) for x,y in ((x,i1-1), (i1+1,i2-1), (i2+1,y)) if y > x)\n return x1,x2,task\n\nq = [(None,None,((0,N-1),))]\nanswer = []\nwhile q:\n x,y,task = heappop(q)\n answer.append(x)\n answer.append(y)\n for left,right in task:\n heappush(q,F(left,right))\n\nprint(' '.join(map(str,answer[2:])))", "class SegTree:\n def __init__(self, init_val, ide_ele, segfunc):\n self.n = len(init_val)\n self.num =2**(self.n-1).bit_length()\n self.ide_ele = ide_ele\n self.seg = [self.ide_ele]*2*self.num\n self.segfunc = segfunc\n \n #set_val\n for i in range(self.n):\n self.seg[i+self.num-1] = init_val[i] \n #built\n for i in range(self.num-2,-1,-1) :\n self.seg[i] = segfunc(self.seg[2*i+1], self.seg[2*i+2]) \n \n def update(self, k, x):\n k += self.num-1\n self.seg[k] = x\n while k+1:\n k = (k-1)//2\n self.seg[k] = self.segfunc(self.seg[k*2+1], self.seg[k*2+2])\n \n def query(self, p, q):\n if q<=p:\n return self.ide_ele\n p += self.num-1\n q += self.num-2\n res = self.ide_ele\n while q-p>1:\n if p&1 == 0:\n res = self.segfunc(res, self.seg[p])\n if q&1 == 1:\n res = self.segfunc(res, self.seg[q])\n q -= 1\n p = p//2\n q = (q-1)//2\n if p == q:\n res = self.segfunc(res, self.seg[p])\n else:\n res = self.segfunc(self.segfunc(res, self.seg[p]), self.seg[q])\n return res\n\ndef main():\n import sys\n input = sys.stdin.readline\n \n N = int(input())\n P = list(map(int,input().split()))\n Even = []\n Odd = []\n D = {}\n for i in range(N//2):\n e = P[2*i]\n o = P[2*i+1]\n D[e] = i\n D[o] = i\n Even.append(e)\n Odd.append(o)\n \n E_Seg = SegTree(Even,float(\"inf\"),min)\n O_Seg = SegTree(Odd,float(\"inf\"),min)\n \n import heapq\n heap = []\n # heapq.heappush(heap, item)\n # heapq.heappop(heap)\n \n def BFS(H):\n L = H[0]\n R = H[1]\n if R <= L:\n return -1,-1,-1,-1,-1\n if L%2==0:\n l = L//2\n r = R//2\n mini = E_Seg.query(l,r+1)\n d_mini = D[mini]\n mini_b = O_Seg.query(d_mini, r+1)\n d_mini_b = D[mini_b]\n \n leftH = (L, 2*d_mini-1)\n centH = (2*d_mini+1, 2*d_mini_b)\n rightH = (2*d_mini_b+2, R)\n return mini, mini_b, leftH, centH, rightH\n else:\n l = L//2\n r = R//2\n mini = O_Seg.query(l, r)\n d_mini = D[mini]\n mini_b = E_Seg.query(d_mini+1, r+1)\n d_mini_b = D[mini_b]\n \n leftH = (L, 2*d_mini)\n centH = (2*d_mini+2, 2*d_mini_b-1)\n rightH = (2*d_mini_b+1, R)\n return mini, mini_b, leftH, centH, rightH\n \n H = (0, N-1)\n m1,m2,LH,CH,RH = BFS(H)\n #print(m1,m2)\n heapq.heappush(heap, [m1,m2,LH,CH,RH])\n Q = []\n while heap != []:\n m1,m2,LH,CH,RH = heapq.heappop(heap)\n Q += [m1,m2]\n \n m1L,m2L,LHL,CHL,RHL = BFS(LH)\n if m1L != -1:\n heapq.heappush(heap, [m1L,m2L,LHL,CHL,RHL])\n \n m1C,m2C,LHC,CHC,RHC = BFS(CH)\n if m1C != -1:\n heapq.heappush(heap, [m1C,m2C,LHC,CHC,RHC])\n \n m1R,m2R,LHR,CHR,RHR = BFS(RH)\n if m1R != -1:\n heapq.heappush(heap, [m1R,m2R,LHR,CHR,RHR])\n print(*Q)\n \n \n \n \nmain()", "from collections import deque\nimport heapq\nimport sys\ninput = sys.stdin.readline\n\n\nclass SparseTable():\n \"\"\"\u533a\u9593\u53d6\u5f97\u30af\u30a8\u30ea\u3092O(1)\u3067\u7b54\u3048\u308b\u30c7\u30fc\u30bf\u69cb\u9020\u3092O(NlogN)\u3067\u69cb\u7bc9\u3059\u308b\n query(l, r): \u533a\u9593[l, r)\u306b\u5bfe\u3059\u308b\u30af\u30a8\u30ea\u306b\u7b54\u3048\u308b\n \"\"\"\n def __init__(self, array, n):\n n = len(array)\n self.row_size = n.bit_length()\n\n # log_table\u3092\u69cb\u7bc9\u3059\u308b\n # log_table = [0, 0, 1, 1, 2, 2, 2, 2, ...]\n self.log_table = [0] * (n + 1)\n for i in range(2, n + 1):\n self.log_table[i] = self.log_table[i//2] + 1\n\n # sparse_table\u3092\u69cb\u7bc9\u3059\u308b\n self.sparse_table = [[0] * n for _ in range(self.row_size)]\n for i in range(n):\n self.sparse_table[0][i] = array[i]\n for row in range(1, self.row_size):\n for i in range(n - (1 << row) + 1):\n self.sparse_table[row][i] = self._merge(self.sparse_table[row - 1][i], \\\n self.sparse_table[row - 1][i + (1 << row - 1)])\n\n def _merge(self, num1, num2):\n \"\"\"\u30af\u30a8\u30ea\u306e\u5185\u5bb9\"\"\"\n return min(num1, num2)\n\n def query(self, l, r):\n \"\"\"\u533a\u9593[l, r)\u306b\u5bfe\u3059\u308b\u30af\u30a8\u30ea\u306b\u7b54\u3048\u308b\"\"\"\n row = self.log_table[r - l]\n return self._merge(self.sparse_table[row][l], self.sparse_table[row][r - (1 << row)])\n\n\nn = int(input())\np = list(map(int, input().split()))\n\nq = [[0] * (n // 2) for i in range(2)]\n\nfor i in range(n):\n q[i%2][i//2] = p[i]\n\nind = {}\nfor i in range(n):\n ind[p[i]] = i\n\nsp0 = SparseTable(q[0], n // 2)\nsp1 = SparseTable(q[1], n // 2)\n\ncon = {}\nans = {}\ndiv = 10**6\ndef solve(l, r):\n q = deque([l * div + r])\n while q:\n pos = q.pop()\n l, r = pos // div, pos % div \n # min1 = min(q[l%2][l//2:r//2])\n if l % 2 == 0:\n min1 = sp0.query(l//2, r//2)\n else:\n min1 = sp1.query(l//2, r//2)\n use_pos1 = ind[min1]\n \n # min2 = min(q[(l+1)%2][(use_pos1+1)//2:(r+1)//2])\n if (l + 1) % 2 == 0:\n min2 = sp0.query((use_pos1 + 1) // 2, (r + 1) // 2)\n else:\n min2 = sp1.query((use_pos1 + 1) // 2, (r + 1) // 2)\n use_pos2 = ind[min2]\n \n ans[pos] = min1 * div + min2\n con[pos] = []\n if l != use_pos1:\n con[pos].append(l * div + use_pos1)\n q.append(l * div + use_pos1)\n if use_pos1 + 1 != use_pos2:\n con[pos].append((use_pos1 + 1) * div + use_pos2)\n q.append((use_pos1 + 1) * div + use_pos2)\n if use_pos2 + 1 != r:\n con[pos].append((use_pos2 + 1) * div + r)\n q.append((use_pos2 + 1) * div + r)\n\n return\n\n\nsolve(0, n)\nres = []\nq = [(ans[n], n)]\nwhile q:\n num, i = heapq.heappop(q)\n min1, min2 = num // div, num % div\n res.append(min1)\n res.append(min2)\n for new_num in con[i]:\n heapq.heappush(q, (ans[new_num], new_num))\nprint(*res)", "from heapq import heappop, heappush\nimport sys\nsys.setrecursionlimit(10 ** 7)\ninput = sys.stdin.readline\n\nn = int(input())\np = [int(x) for x in input().split()]\n\n\nclass SegmentTree: # 0-indexed\n def __init__(self, array, operation=min, identity=10**30):\n self.identity = identity\n self.n = len(array)\n self.N = 1 << (self.n - 1).bit_length()\n self.tree = [self.identity] * 2 * self.N\n self.opr = operation\n for i in range(self.n):\n self.tree[i+self.N-1] = array[i]\n for i in range(self.N-2, -1, -1):\n self.tree[i] = self.opr(self.tree[2*i+1], self.tree[2*i+2])\n\n def values(self):\n return self.tree[self.N-1:]\n\n def update(self, k, x):\n k += self.N-1\n self.tree[k] = x\n while k+1:\n k = (k-1)//2\n self.tree[k] = self.opr(self.tree[k*2+1], self.tree[k*2+2])\n\n def query(self, p, q): # [p,q)\n if q <= p:\n print(\"Oops! That was no valid number. Try again...\")\n return\n p += self.N-1\n q += self.N-2\n res = self.identity\n while q-p > 1:\n if p & 1 == 0:\n res = self.opr(res, self.tree[p])\n if q & 1 == 1:\n res = self.opr(res, self.tree[q])\n q -= 1\n p = p//2\n q = (q-1)//2\n if p == q:\n res = self.opr(res, self.tree[p])\n else:\n res = self.opr(self.opr(res, self.tree[p]), self.tree[q])\n return res\n\n\nind = [0]*(n+1)\nOdd = SegmentTree([10**30]*n)\nEven = SegmentTree([10**30]*n)\n\nfor i in range(n):\n ind[p[i]] = i\n if i % 2 == 0:\n Even.update(i, p[i])\n else:\n Odd.update(i, p[i])\n\ncand = []\nheappush(cand, (Even.query(0, n), 0, n, True))\n\nq = []\nwhile len(q) < n:\n first, l, r, is_even = heappop(cand)\n if is_even:\n second = Odd.query(ind[first]+1, r)\n q.extend([first, second])\n if l < ind[first]:\n heappush(cand, (Even.query(l, ind[first]), l, ind[first], True))\n if ind[first] + 1 < ind[second]:\n heappush(\n cand, (Odd.query(ind[first]+1, ind[second]), ind[first]+1, ind[second], False))\n if ind[second]+1 < r:\n heappush(\n cand, (Even.query(ind[second], r), ind[second]+1, r, True))\n else:\n second = Even.query(ind[first]+1, r)\n q.extend([first, second])\n if l < ind[first]:\n heappush(cand, (Odd.query(l, ind[first]), l, ind[first], False))\n if ind[first] + 1 < ind[second]:\n heappush(\n cand, (Even.query(ind[first]+1, ind[second]), ind[first]+1, ind[second], True))\n if ind[second]+1 < r:\n heappush(\n cand, (Odd.query(ind[second], r), ind[second]+1, r, False))\n\nprint((*q))\n", "from heapq import *\nimport sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\n\n# l\u304b\u30891\u3064\u304a\u304d\u306b\u307f\u305f\u3068\u304d\u306e\u6700\u5c0f\u5024\u3092\u6c42\u3081\u308b\u7279\u5225\u88fd\nclass SparseTable:\n def __init__(self, aa):\n inf = 10 ** 16\n w = len(aa)\n h = w.bit_length()\n table = [aa] * 2 + [[inf] * w for _ in range(h - 2)]\n tablei1 = table[0]\n for i in range(2, h):\n tablei = table[i]\n shift = 1 << (i - 1)\n for j in range(w):\n rj = j + shift\n if rj >= w: break\n tablei[j] = min(tablei1[j], tablei1[rj])\n tablei1 = tablei\n self.table = table\n\n # [l,r)\u306e\u6700\u5c0f\u5024\n def min(self, l, r):\n if (r - l) % 2: r += 1\n i = (r - l).bit_length() - 1\n tablei = self.table[i]\n Lmin = tablei[l]\n Rmin = tablei[r - (1 << i)]\n if Lmin < Rmin: Rmin = Lmin\n return Rmin\n\ndef main():\n n = int(input())\n pp = LI()\n st = SparseTable(pp)\n ptoi = [0] + [i for i, p in sorted(enumerate(pp), key=lambda x: x[1])]\n # \u533a\u9593\u5076\u6570\u756a\u76ee\u306e\u6700\u5c0f\u5024\u3068[l,r)\u3092\u30d2\u30fc\u30d7\u306b\n hp = []\n heappush(hp, [st.min(0, n), 0, n])\n ans = []\n for _ in range(n // 2):\n x, l, r = heappop(hp)\n if l + 2 == r:\n ans += [pp[l], pp[l + 1]]\n continue\n xi = ptoi[x]\n y = st.min(xi + 1, r)\n yi = ptoi[y]\n if xi > l:\n heappush(hp, [st.min(l, xi), l, xi])\n if xi + 1 < yi:\n heappush(hp, [st.min(xi + 1, yi), xi + 1, yi])\n if yi < r - 1:\n heappush(hp, [st.min(yi + 1, r), yi + 1, r])\n ans += [x, y]\n print(*ans)\n\nmain()\n", "from heapq import heappop, heappush\nINF = 10**30\n\nclass Rmin():\n\tdef __init__(self, size):\n\t\t#the number of nodes is 2n-1\n\t\tself.n = 1\n\t\twhile self.n < size:\n\t\t\tself.n *= 2\n\t\tself.node = [INF] * (2*self.n-1)\n\n\tdef Access(self, x):\n\t\treturn self.node[x+self.n-1]\n\n\tdef Update(self, x, val):\n\t\tx += self.n-1\n\t\tself.node[x] = val\n\t\twhile x > 0:\n\t\t\tx = (x-1)//2\n\t\t\tself.node[x] = min(self.node[2*x+1], self.node[2*x+2])\n\t\treturn\n\n\t#[l, r)\n\tdef Get(self, l, r):\n\t\tL, R = l+self.n, r+self.n\n\t\ts = INF\n\t\twhile L < R:\n\t\t\tif R & 1:\n\t\t\t\tR -= 1\n\t\t\t\ts = min(s, self.node[R-1])\t\t\t\n\t\t\tif L & 1:\n\t\t\t\ts = min(s, self.node[L-1])\n\t\t\t\tL += 1\n\t\t\tL >>= 1\n\t\t\tR >>= 1\n\t\treturn s\n\nn = int(input())\na = list(map(int, input().split()))\n\neven, odd = Rmin(n), Rmin(n)\nfor i in range(n):\n\tif i%2 == 0:\n\t\teven.Update(i, a[i]*(10**7) + i)\n\telse:\n\t\todd.Update(i, a[i]*(10**7) + i)\n\nd = dict()\n\ndef search(l, r):\n\tif l%2 == 0:\n\t\tp = even.Get(l, r+1)\n\t\tq = odd.Get(p%(10**7)+1, r+1)\n\telse:\n\t\tp = odd.Get(l, r+1)\n\t\tq = even.Get(p%(10**7)+1, r+1)\n\treturn p, q\n\nx, y = search(0, n-1)\nd[x%(10**7)] = (y, 0, n-1)\nque = [x]\nans = []\n\nwhile que:\n\tx = heappop(que)\n\ty, l, r = d[x%(10**7)]\n\tans += [x//(10**7), y//(10**7)]\n\n\tif l != x%(10**7):\n\t\tp, q = search(l, x%(10**7)-1)\n\t\td[p%(10**7)] = (q, l, x%(10**7)-1)\n\t\theappush(que, p)\n\n\tif r != y%(10**7):\n\t\tp, q = search(y%(10**7)+1, r)\n\t\td[p%(10**7)] = (q, y%(10**7)+1, r)\n\t\theappush(que, p)\n\n\tif x%(10**7)+1 != y%(10**7):\n\t\tp, q = search(x%(10**7)+1, y%(10**7)-1)\n\t\td[p%(10**7)] = (q, x%(10**7)+1, y%(10**7)-1)\n\t\theappush(que, p)\n\nprint(*ans)"] | {"inputs": ["4\n3 2 4 1\n", "2\n1 2\n", "8\n4 6 3 2 8 5 7 1\n"], "outputs": ["3 1 2 4\n", "1 2\n", "3 1 2 7 4 6 8 5\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 55,418 | |
08df75afc699e63029cc7c2d8a21c3cb | UNKNOWN | Snuke has a rooted tree with N+1 vertices.
The vertices are numbered 0 through N, and Vertex 0 is the root of the tree.
The parent of Vertex i (1 \leq i \leq N) is Vertex p_i.
Besides this tree, Snuke also has an box which is initially empty and many marbles, and playing with them.
The play begins with placing one marble on some of the vertices, then proceeds as follows:
- If there is a marble on Vertex 0, move the marble into the box.
- Move each marble from the vertex to its parent (all at once).
- For each vertex occupied by two or more marbles, remove all the marbles from the vertex.
- If there exists a vertex with some marbles, go to Step 1. Otherwise, end the play.
There are 2^{N+1} ways to place marbles on some of the vertices.
For each of them, find the number of marbles that will be in the box at the end of the play, and compute the sum of all those numbers modulo 1,000,000,007.
-----Constraints-----
- 1 \leq N < 2 \times 10^{5}
- 0 \leq p_i < i
-----Partial Scores-----
- In the test set worth 400 points, N < 2{,}000.
-----Input-----
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_{N}
-----Output-----
Print the answer.
-----Sample Input-----
2
0 0
-----Sample Output-----
8
When we place a marble on both Vertex 1 and 2, there will be multiple marbles on Vertex 0 by step 2. In such a case, these marbles will be removed instead of being moved to the box. | ["# coding: utf-8\n# Your code here!\nimport sys\nread = sys.stdin.read\nreadline = sys.stdin.readline\n\nn, = list(map(int, readline().split()))\np = [-1] + [*list(map(int, readline().split()))]\n\nMOD = 10**9+7\nchild = [[] for i in range(n+1)]\ntot = [None for i in range(n+1)]\none = [None for i in range(n+1)]\ndep = [0]*(n+1)\np2 = [1]*(n+1)\nfor i in range(n):\n p2[i+1] = p2[i]*2%MOD\n\nfor v in range(n,-1,-1):\n if dep[v]==0:\n tot[v] = []\n one[v] = []\n else:\n child[v].sort(key=lambda i: dep[i])\n one[v] = one[child[v][-1]]\n tot[v] = tot[child[v][-1]]\n #one_sum = [0]*(dep[v])\n #zero_sum = [0]*(dep[v])\n child[v].pop()\n if child[v]:\n zero = [p2[tot[v][j]]-one[v][j] for j in range(-len(one[child[v][-1]]),0)]\n for c in child[v]:\n for j in range(-len(one[c]),0):\n z = p2[tot[c][j]]-one[c][j]\n one[v][j] = (one[v][j]*z+zero[j]*one[c][j])%MOD\n zero[j] = zero[j]*z%MOD\n tot[v][j] += tot[c][j]\n\n tot[v].append(1)\n one[v].append(1)\n\n child[p[v]].append(v)\n dep[p[v]] = max(dep[p[v]],dep[v]+1) \n\n #print(v,tot[v],one[v])\n \n#print(\"tot\",tot[0])\n#print(\"one\",one[0])\n\nans = 0\nfor i,j in zip(tot[0],one[0]):\n ans += pow(2,n+1-i,MOD)*j%MOD\n\nprint((ans%MOD))\n#print(sum(tot[0]))\n", "\n\"\"\"\n\nhttps://atcoder.jp/contests/arc086/tasks/arc086_c\n\n\u5bfe\u6d88\u6ec5\u3059\u308b\u53ef\u80fd\u6027\u304c\u3042\u308b\u306e\u306f\u540c\u3058\u6df1\u3055\u306e\u70b9\u306b\u7f6e\u304b\u308c\u305f\u30d3\u30fc\u7389\u3060\u3051\n\u21921\u3064\u3082\u6b8b\u3089\u306a\u3044 or 1\u3064\u3060\u3051\u6b8b\u308b\u3067\u3042\u308b\n\n\u3059\u306a\u308f\u3061\u3001\u3042\u308b\u6df1\u3055\u306b\u95a2\u3057\u3066\u3001\u305d\u306e\u3046\u30611\u3064\u6b8b\u308b\u306e\u304c\u3044\u304f\u3064\u3042\u308b\u304b\u3092\u6570\u3048\u308c\u3070\u3088\u3044\n\n1\u3064\u3060\u3051\u7f6e\u304f\u5834\u5408\u2192\u7d76\u5bfe\u306e\u3053\u308b\n2\u3064\u7f6e\u304f\u5834\u5408\u2192\u7d76\u5bfe\u6d88\u3048\u308b\n3\u3064\u7f6e\u304f\u5834\u5408\u21923\u3064\u306eLCA\u304c\u7b49\u3057\u304f\u306a\u3051\u308c\u3070\u6b8b\u308b\n\n\u6728dp\u307f\u305f\u3044\u306b\u3059\u308b\uff1f\ndp[0] = \u4e00\u3064\u3082\u542b\u3093\u3067\u3044\u306a\u3044\u5834\u5408\u306e\u901a\u308a\u6570\ndp[1] = 1\u3064\u542b\u3093\u3067\u3044\u308b\u5834\u5408\u306e\u901a\u308a\u6570\n\ndp[0] = \u3059\u3079\u3066\u306e\u5834\u5408 - dp[1]\ndp[1] = 1\u3064\u3060\u30511\u3092\u6301\u3063\u3066\u3044\u308b\u5834\u5408\n\n\u3067\u3001\u5b50\u304b\u3089\u89aa\u306b\u4f1d\u64ad\u3055\u305b\u3066\u3044\u304f\u2026\uff1f\n\u30de\u30fc\u30b8\u30c6\u30af\u3067\u8a08\u7b97\u91cf\u524a\u6e1b\u304b\uff1f\n3s\u3060\u304b\u3089\u305d\u3046\u3063\u307d\u3044\u306a\u2026\n3\u3064\u4ee5\u4e0a\u306e\u30de\u30fc\u30b8\u66f8\u304f\u306e\u3060\u308b\u3059\u304e\u3093\uff1f\n\n\u307e\u305f\u306f\u30de\u30fc\u30b8\u306e\u9806\u756a\u3092\u3069\u3063\u304b\u306b\u30e1\u30e2\u3063\u3066\u304a\u304f\n\nmaxd-d = index\u3067\u3084\u308b\n\u6700\u9577\u306e\u3084\u3064\u306b\u30de\u30fc\u30b8\u3059\u308b\n\ndp[maxd-d][1] = 1\u3064\u3060\u3051\u5143\u6df1\u3055d\u304c\u6b8b\u3063\u3066\u3044\u308b\u5834\u5408\u306e\u6570\nc = \u5b50\u306e\u6570\n\n\u8a08\u7b97\u91cf\u306f\uff1f\n\u30b5\u30a4\u30ba\u306f\u9ad8\u30051\u3057\u304b\u5897\u3048\u306a\u3044\u306e\u3067\u53ef\u80fd\u3063\u307d\u3044\n2\u500d\u51e6\u7406\u304c\u307e\u305a\u3044\n\n\u3082\u3063\u3068\u7c21\u6f54\u306b\uff1f\n\u5358\u4e00\u306ed\u3060\u3051\u3067\u8003\u3048\u3088\u3046\n2\u500d\u51e6\u7406\u306a\u3093\u3066\u3057\u306a\u3044\n\u6700\u5f8c\u306b\u5404d\u306b\u95a2\u3057\u3066\u304b\u3051\u308c\u3070\u3044\u3044\n\u2192\u3059\u308b\u3068\u30de\u30fc\u30b8\u306e\u969b\u306b2\u756a\u76ee\u306e\u5927\u304d\u3055\u3060\u3051\u3067\u306a\u3093\u3068\u304b\u306a\u308b\n\n\u5fc5\u8981\u306e\u306a\u3044\u30de\u30fc\u30b8\u3092\u3057\u306a\u3044\n\u4e21\u65b9\u306b\u95a2\u4fc2\u306a\u3044d\u306f\u64cd\u4f5c\u3057\u306a\u3044\n\u3080\u3057\u308d\u3070\u3089\u3064\u304d\u306f\u6df1\u3044\u90e8\u5206\u306b\u3060\u3051\u5b58\u5728\u3059\u308b\u304b\n\u6d45\u3044\u90e8\u5206\u306f\u5171\u901a\u3002\u3088\u3063\u3066-x\u3067\u7ba1\u7406\u3059\u308c\u3070\u3044\u3044\u304b\n\n\"\"\"\n\nimport sys\nmod = 10**9 + 7\nsys.setrecursionlimit(200000)\n\nfrom collections import deque\ndef NC_Dij(lis,start):\n\n ret = [float(\"inf\")] * len(lis)\n ret[start] = 0\n \n q = deque([start])\n plis = [i for i in range(len(lis))]\n\n while len(q) > 0:\n now = q.popleft()\n\n for nex in lis[now]:\n\n if ret[nex] > ret[now] + 1:\n ret[nex] = ret[now] + 1\n plis[nex] = now\n q.append(nex)\n\n return ret,plis\n\ndef inverse(a): #a\u306emod\u3092\u6cd5\u306b\u3057\u305f\u9006\u5143\u3092\u8fd4\u3059\n return pow(a,mod-2,mod)\n\n\ndef dfs(v):\n\n if len(lis[v]) == 0:\n ret = [ [1,1] ]\n return ret\n\n else:\n\n retlis = []\n for nex in lis[v]:\n nret = dfs(nex)\n retlis.append( [len(nret),nret] )\n retlis.sort()\n\n #1\u3064\u3057\u304b\u306a\u3044\u5834\u5408\u30de\u30fc\u30b8\u3057\u306a\u3044\n if len(retlis) == 1:\n retlis[-1][1].append([1,1])\n return retlis[-1][1]\n\n #2\u3064\u4ee5\u4e0a\u306e\u5834\u5408\u6700\u5927\u306e\u3084\u3064\u306b\u30de\u30fc\u30b8\u3059\u308b\n for revd in range(retlis[-2][0]):\n\n zmul = 1\n amul = 1\n for i in range(len(retlis)-1,-1,-1):\n if revd < retlis[i][0]:\n zmul *= retlis[i][1][-1-revd][0]\n amul *= sum(retlis[i][1][-1-revd])\n zmul %= mod\n amul %= mod\n else:\n break\n\n nsum = 0\n for i in range(len(retlis)-1,-1,-1):\n if revd < retlis[i][0]:\n nsum += zmul * inverse(retlis[i][1][-1-revd][0]) * retlis[i][1][-1-revd][1]\n nsum %= mod\n else:\n break\n\n retlis[-1][1][-1-revd][1] = nsum\n retlis[-1][1][-1-revd][0] = (amul-nsum) % mod\n\n retlis[-1][1].append([1,1])\n return retlis[-1][1]\n\nN = int(input())\np = list(map(int,input().split()))\n\nlis = [ [] for i in range(N+1) ]\n\nfor i in range(N):\n\n #lis[i+1].append(p[i])\n lis[p[i]].append(i+1)\n\ndlis,plis = NC_Dij(lis,0)\nmaxd = max(dlis)\n\ndn = [0] * (maxd+1)\nfor i in dlis:\n dn[i] += 1\n\nans = dfs(0)\n#print (dn,ans)\nA = 0\nfor i in range(maxd+1):\n A += ans[-1-i][1] * pow(2,N+1-dn[i],mod)\n A %= mod\nprint (A)\n", "import sys\nreadline = sys.stdin.readline\n\n \ndef parorder(Edge, p):\n N = len(Edge)\n par = [0]*N\n par[p] = -1\n stack = [p]\n order = []\n visited = set([p])\n ast = stack.append\n apo = order.append\n while stack:\n vn = stack.pop()\n apo(vn)\n for vf in Edge[vn]:\n if vf in visited:\n continue\n visited.add(vf)\n par[vf] = vn\n ast(vf)\n return par, order\n \ndef getcld(p):\n res = [[] for _ in range(len(p))]\n for i, v in enumerate(p[1:], 1):\n res[v].append(i)\n return res\n \n \n \nMOD = 10**9+7\nlimit = 1341398\np2 = [1]*limit\nfor i in range(1, limit):\n p2[i] = 2*p2[i-1]%MOD\n\nN = int(readline())\nP = [None] + list(map(int, readline().split()))\nEdge = [[] for _ in range(N+1)]\nfor i in range(1, N+1):\n Edge[i].append(P[i])\n Edge[P[i]].append(i)\n_, L = parorder(Edge, 0)\nC = getcld(P)\ndist = [0]*(N+1)\nfor l in L[1:]:\n p = P[l]\n dist[l] = 1 + dist[p]\nmd = dist[:]\nfor l in L[:0:-1]:\n p = P[l]\n md[p] = max(md[p], md[l])\n\nCi = [None]*(N+1)\nfor i in range(N+1):\n if C[i]:\n res = -1\n cc = None\n for ci in C[i]:\n if md[ci] > res:\n res = md[ci]\n cc = ci\n Ci[i] = cc\nans = 0\n\nres = [[0]]\nval = [1]*(N+1) \nsize = [1]*(N+1) \nused = [0]*(N+1)\nname = [None]*(N+1)\nmark = [None]*(N+1)\nwhile res:\n newres = []\n for a in res:\n ts = 1\n ks = 0\n ss = 0\n dic = []\n ctr = []\n\n for i in a:\n ts = ts*(p2[size[i]] - val[i])%MOD\n ks = (ks + val[i]*pow(p2[size[i]] - val[i], MOD-2, MOD))%MOD\n ss += size[i]\n\n if not used[i]:\n used[i] = 1\n if C[i]:\n dic.append(C[i])\n if name[i] is None:\n name[i] = Ci[i]\n if name[i] is not None:\n ctr.append(name[i])\n newres.extend(dic)\n if len(ctr) > 1:\n newres.append(ctr)\n for a0 in a:\n val[a0] = ts*ks%MOD\n size[a0] = ss\n ans = (ans + val[a0]*p2[N+1 - size[a0]])%MOD\n res = [nr[:] for nr in newres]\n #print(res)\nprint(ans)\n\n\"\"\"\ndef merge(sz, vl):\n res = 0\n ts = 1\n ks = 0\n for s, v in zip(sz, vl):\n ts = ts*(p2[s] - v)%MOD\n ks = (ks + v*pow(p2[s] - v, MOD-2, MOD))%MOD\n return ts*ks%MOD\n\n\n\nassert N < 2000\n\nst = [0]\naa = 0\nwhile st:\n size = [0]*(N+1)\n val = [0]*(N+1)\n cs = [[] for _ in range(N+1)]\n cv = [[] for _ in range(N+1)]\n \n nr = []\n for s in st:\n cs[s] = [1]\n cv[s] = [1]\n nr.extend(C[s])\n for l in L[::-1]:\n size[l] = sum(cs[l])\n val[l] = merge(cs[l], cv[l])\n if l:\n p = P[l]\n cs[p].append(size[l])\n cv[p].append(val[l])\n aa = (aa + val[0]*p2[N+1 - size[0]])%MOD\n st = nr[:]\n\nprint(aa)\n\"\"\"\n \n", "from collections import deque\n\n\ndef get_pow():\n cache = {}\n\n def func(x):\n if x not in cache:\n cache[x] = pow(2, x, mod)\n return cache[x]\n\n return func\n\n\nmod = 1000000007\nn = int(input())\nparents = list(map(int, input().split()))\nchildren = [set() for _ in range(n + 1)]\nfor c, p in enumerate(parents):\n children[p].add(c + 1)\n\nlevels = [{0}]\nwhile True:\n level = set()\n for p in levels[-1]:\n level.update(children[p])\n if not level:\n break\n levels.append(level)\nlevels.reverse()\n\nlevel_node_count = []\nballs = [None] * (n + 1)\n\nfor i, level in enumerate(levels):\n level_node_count.append(len(level))\n for node in level:\n cn = children[node]\n if cn:\n if len(cn) == 1:\n bs = balls[cn.pop()]\n bs.appendleft([1, 1, 0])\n balls[node] = bs\n continue\n balls_from_children = [balls[c] for c in children[node]]\n balls_from_children.sort(key=len)\n bs1 = balls_from_children[0]\n for bs2 in balls_from_children[1:]:\n for (b10, b11, b12), b2 in zip(bs1, bs2):\n b2[2] = ((b11 + b12) * b2[1] + b12 * b2[0]) % mod\n b2[1] = (b10 * b2[1] + b11 * b2[0]) % mod\n b2[0] = b2[0] * b10 % mod\n bs1 = bs2\n for b in bs1:\n b[0] = (b[0] + b[2]) % mod\n b[2] = 0\n bs1.appendleft([1, 1, 0])\n balls[node] = bs1\n else:\n balls[node] = deque([[1, 1, 0]])\n\nlevel_node_count.reverse()\n\npow2 = get_pow()\nprint((sum(b[1] * pow2(n - l + 1) % mod for l, b in zip(level_node_count, balls[0])) % mod))\n", "from collections import deque\n\n\ndef get_pow():\n cache = {}\n\n def func(x):\n if x not in cache:\n cache[x] = pow(2, x, mod)\n return cache[x]\n\n return func\n\n\nmod = 1000000007\nn = int(input())\nparents = list(map(int, input().split()))\nchildren = [set() for _ in range(n + 1)]\nfor c, p in enumerate(parents):\n children[p].add(c + 1)\n\nlevels = [{0}]\nwhile True:\n level = set()\n for p in levels[-1]:\n level.update(children[p])\n if not level:\n break\n levels.append(level)\nlevels.reverse()\n\nlevel_node_count = []\nballs = [None] * (n + 1)\n\nfor i, level in enumerate(levels):\n level_node_count.append(len(level))\n for node in level:\n cn = children[node]\n if cn:\n if len(cn) == 1:\n bs = balls[cn.pop()]\n bs.appendleft([1, 1, 0])\n balls[node] = bs\n continue\n balls_from_children = [balls[c] for c in children[node]]\n balls_from_children.sort(key=len)\n bs1 = balls_from_children[0]\n for bs2 in balls_from_children[1:]:\n for (b10, b11, b12), b2 in zip(bs1, bs2):\n b2[2] = ((b11 + b12) * b2[1] + b12 * b2[0]) % mod\n b2[1] = (b10 * b2[1] + b11 * b2[0]) % mod\n b2[0] = b2[0] * b10 % mod\n bs1 = bs2\n lim = len(balls_from_children[-2])\n for i, b in enumerate(bs1):\n if i >= lim:\n break\n b[0] = (b[0] + b[2]) % mod\n b[2] = 0\n bs1.appendleft([1, 1, 0])\n balls[node] = bs1\n else:\n balls[node] = deque([[1, 1, 0]])\n\nlevel_node_count.reverse()\n\npow2 = get_pow()\nprint((sum(b[1] * pow2(n - l + 1) % mod for l, b in zip(level_node_count, balls[0])) % mod))\n", "# seishin.py\nfrom collections import deque\nN = int(input())\n*P, = list(map(int, input().split()))\nMOD = 10**9 + 7\n\nG = [[] for i in range(N+1)]\nU = [0]*(N+1)\nC = [0]*(N+1)\nfor i, p in enumerate(P):\n G[p].append(i+1)\n U[i+1] = u = U[p]+1\n C[u] += 1\nQ = [None]*(N+1)\nPP = {}\ndef pp(k):\n if k not in PP:\n PP[k] = p = pow(2, k, MOD)\n return p\n return PP[k]\nL = [0]*(N+1)\n\nept = []\nsz = L.__getitem__\nfor i in range(N, -1, -1):\n g = G[i]\n if not g:\n continue\n\n # \u5b50\u30ce\u30fc\u30c9\u306edeque\u3092\u96c6\u3081\u308b\n g.sort(key=sz, reverse=1)\n k = len(g)\n e = [pp(k) - k, k, 0]\n\n g0 = g[0]\n L[i] = L[g0] + 1\n if L[g0] == 0:\n Q[i] = deque([e])\n continue\n Q[i] = R = Q[g0]\n if k > 1:\n # a0 <- a2\n for s, r in zip(Q[g[1]] or ept, R):\n r[0] += r[2]; r[2] = 0\n\n for j in g[1:]:\n S = Q[j]\n if not S:\n break\n\n # deque\u306e\u5c0f\u3055\u3044\u65b9\u304b\u3089\u5927\u304d\u3044\u65b9\u3078\u30de\u30fc\u30b8\u3059\u308b\u51e6\u7406\n for (a0, a1, a2), r in zip(S, R):\n b0, b1, b2 = r; a0 += a2\n r[0] = a0*b0 % MOD\n r[1] = (a0*b1 + a1*b0) % MOD\n r[2] = ((a0+a1)*b2 + a1*b1) % MOD\n R.appendleft(e)\nprint(((pp(N) + sum(pp(N+1-c) * a1 % MOD for (a0, a1, a2), c in zip(Q[0], C[1:]))) % MOD))\n", "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10**7)\nfrom collections import deque\n\nMOD = 10 ** 9 + 7\n\nN = int(input())\ngraph = [[] for _ in range(N+1)]\nfor i,x in enumerate(input().rstrip().split(),1):\n x = int(x)\n graph[i].append(x)\n graph[x].append(i)\n\n# \u5404\u6df1\u3055\u304b\u3089\u6765\u3066\u3044\u308b (0\u500b\u30011\u500b\u30012\u500b\u4ee5\u4e0a) \u306e\u5206\u5e03\u3092 \u78ba\u7387 mod MOD\u3067\u6301\u3064\u3002\n\nhalf = (MOD + 1) // 2\n\ndef merge(dp,dp1):\n L = len(dp1)\n for i in range(L):\n # 0\u500b,1\u500b,2\u500b\u4ee5\u4e0a\n a,b,c = dp[i]\n d,e,f = dp1[i]\n a,b,c = a*d, a*e + b*d, a*f + b*e + b*f + c*d + c*e + c*f\n a %= MOD\n b %= MOD\n c %= MOD\n dp[i] = (a,b,c)\n return\n\ndef dfs(v,parent = None):\n dp = None\n L = 0\n for u in graph[v]:\n if u == parent:\n continue\n dp1 = dfs(u,v)\n if dp is None:\n dp = dp1\n else:\n if len(dp) < len(dp1):\n dp,dp1 = dp1,dp\n # 2\u500b\u4ee5\u4e0a\u304c\u5165\u3063\u3066\u3044\u308b\u30a4\u30f3\u30c7\u30c3\u30af\u30b9\n if L < len(dp1):\n L = len(dp1)\n merge(dp,dp1)\n if dp is None:\n dp = deque()\n else:\n # 2\u500b\u4ee5\u4e0a\u3042\u308b\u3068\u304d\u306b\u30010\u500b\u5316\u3059\u308b\n for i in range(L):\n a,b,c = dp[i]\n dp[i] = (a+c,b,0)\n dp.appendleft((half,half,0))\n return dp\n\ndp = dfs(0)\n\nanswer = sum(b for a,b,c in dp)\nanswer *= pow(2,N+1,MOD)\nanswer %= MOD\nprint(answer)", "import sys\n\nsys.setrecursionlimit(10 ** 6)\ninput = sys.stdin.readline\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\n\ndef main():\n def dfs(u=0):\n def merge(dpu, dpv):\n vn = len(dpv)\n for d in range(-1, -1 - vn, -1):\n u0, u1, u2 = dpu[d]\n v0, v1, v2 = dpv[d]\n n0 = (u0 * v0) % md\n n1 = (u0 * v1 + u1 * v0) % md\n n2 = (u2 * (v0 + v1 + v2) + v2 * (u0 + u1) + u1 * v1) % md\n dpu[d] = (n0, n1, n2)\n\n # \u8449\u306e\u5834\u5408\n if len(to[u]) == 0:\n return [(inv2, inv2, 0)]\n # \u3059\u3079\u3066\u306e\u5b50\u3092\u30de\u30fc\u30b8\n dpu = []\n mxlen=0\n for v in to[u]:\n dpv = dfs(v)\n #\u6df1\u3055\u304c2\u6bb5\u4ee5\u4e0a\u3042\u3063\u305f\u3089u2\u3092u0\u306b\n if not dpu:\n dpu = dpv\n else:\n if len(dpu) < len(dpv): dpu, dpv = dpv, dpu\n mxlen=max(mxlen,len(dpv))\n merge(dpu, dpv)\n for d in range(-1,-1-mxlen,-1):\n u0,u1,u2=dpu[d]\n dpu[d] = (u0 + u2, u1, 0)\n dpu.append((inv2, inv2, 0))\n return dpu\n\n md = 10 ** 9 + 7\n # 1/2\u306emod\n inv2 = pow(2, md - 2, md)\n n = int(input())\n to = [[] for _ in range(n+1)]\n pp = list(map(int, input().split()))\n for i, p in enumerate(pp, 1):\n to[p].append(i)\n # print(to)\n dp0 = dfs()\n # print(dp0)\n ans = sum(u1 for _, u1, _ in dp0)\n print((ans * pow(2, n + 1, md)) % md)\n\nmain()\n", "n, = map(int, input().split())\np = [-1] + [*map(int, input().split())]\n\nMOD = 10**9+7\ndp = [[] for _ in range(n+1)]\ndep = [0]*(n+1)\nnxt = [0]*(n+1)\n\nfor v in range(n,0,-1):\n _,nxt[p[v]],dep[p[v]] = sorted([nxt[p[v]],dep[p[v]],dep[v]+1])\n\ntot = [0]*(dep[0]+1)\nfor i in range(n+1): tot[dep[i]] += 1\n\ndef merge(p,v):\n if len(dp[p]) < len(dp[v]):\n dp[p],dp[v]=dp[v],dp[p]\n for i in range(-len(dp[v]),0):\n a,b,c = dp[p][i]\n d,e,f = dp[v][i]\n dp[p][i][:] = [a*d%MOD,(b*d+a*e)%MOD,c*f%MOD]\n\nfor v in range(n,-1,-1):\n dp[v].append([1,1,2])\n for i in range(-nxt[v]-1,0):\n dp[v][i][0] = dp[v][i][2] - dp[v][i][1]\n if v: merge(p[v],v)\n\nans = 0\nfor d in dp[0]:\n ans += pow(d[2],MOD-2,MOD)*d[1]%MOD\nprint(ans*pow(2,n+1,MOD)%MOD)", "# seishin.py\nfrom collections import deque\nN = int(input())\n*P, = map(int, input().split())\nMOD = 10**9 + 7\n\nG = [[] for i in range(N+1)]\nU = [0]*(N+1)\nC = [0]*(N+1)\nfor i, p in enumerate(P):\n G[p].append(i+1)\n U[i+1] = u = U[p]+1\n C[u] += 1\nQ = [None]*(N+1)\nPP = {}\ndef pp(k):\n if k not in PP:\n PP[k] = p = pow(2, k, MOD)\n return p\n return PP[k]\nL = [0]*(N+1)\n\nept = []\nsz = L.__getitem__\nfor i in range(N, -1, -1):\n g = G[i]\n if not g:\n continue\n\n # \u5b50\u30ce\u30fc\u30c9\u306edeque\u3092\u96c6\u3081\u308b\n g.sort(key=sz, reverse=1)\n k = len(g)\n e = [pp(k) - k, k, 0]\n\n g0 = g[0]\n L[i] = L[g0] + 1\n if L[g0] == 0:\n Q[i] = deque([e])\n continue\n Q[i] = R = Q[g0]\n if k > 1:\n # a0 <- a2\n for s, r in zip(Q[g[1]] or ept, R):\n r[0] += r[2]; r[2] = 0\n\n for j in g[1:]:\n S = Q[j]\n if not S:\n break\n\n # deque\u306e\u5c0f\u3055\u3044\u65b9\u304b\u3089\u5927\u304d\u3044\u65b9\u3078\u30de\u30fc\u30b8\u3059\u308b\u51e6\u7406\n for (a0, a1, a2), r in zip(S, R):\n b0, b1, b2 = r; a0 += a2\n r[0] = a0*b0 % MOD\n r[1] = (a0*b1 + a1*b0) % MOD\n r[2] = ((a0+a1)*b2 + a1*b1) % MOD\n R.appendleft(e)\nprint((pp(N) + sum(pp(N+1-c) * a1 % MOD for (a0, a1, a2), c in zip(Q[0], C[1:]))) % MOD)"] | {"inputs": ["2\n0 0\n", "5\n0 1 1 0 4\n", "31\n0 1 0 2 4 0 4 1 6 4 3 9 7 3 7 2 15 6 12 10 12 16 5 3 20 1 25 20 23 24 23\n"], "outputs": ["8\n", "96\n", "730395550\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 20,689 | |
96e2cfc660fe141b1edf9bbf062fd5c2 | UNKNOWN | You are in charge of controlling a dam. The dam can store at most L liters of water. Initially, the dam is empty. Some amount of water flows into the dam every morning, and any amount of water may be discharged every night, but this amount needs to be set so that no water overflows the dam the next morning.
It is known that v_i liters of water at t_i degrees Celsius will flow into the dam on the morning of the i-th day.
You are wondering about the maximum possible temperature of water in the dam at noon of each day, under the condition that there needs to be exactly L liters of water in the dam at that time. For each i, find the maximum possible temperature of water in the dam at noon of the i-th day. Here, consider each maximization separately, that is, the amount of water discharged for the maximization of the temperature on the i-th day, may be different from the amount of water discharged for the maximization of the temperature on the j-th day (j≠i).
Also, assume that the temperature of water is not affected by anything but new water that flows into the dam. That is, when V_1 liters of water at T_1 degrees Celsius and V_2 liters of water at T_2 degrees Celsius are mixed together, they will become V_1+V_2 liters of water at \frac{T_1*V_1+T_2*V_2}{V_1+V_2} degrees Celsius, and the volume and temperature of water are not affected by any other factors.
-----Constraints-----
- 1≤ N ≤ 5*10^5
- 1≤ L ≤ 10^9
- 0≤ t_i ≤ 10^9(1≤i≤N)
- 1≤ v_i ≤ L(1≤i≤N)
- v_1 = L
- L, each t_i and v_i are integers.
-----Input-----
Input is given from Standard Input in the following format:
N L
t_1 v_1
t_2 v_2
:
t_N v_N
-----Output-----
Print N lines. The i-th line should contain the maximum temperature such that it is possible to store L liters of water at that temperature in the dam at noon of the i-th day.
Each of these values is accepted if the absolute or relative error is at most 10^{-6}.
-----Sample Input-----
3 10
10 10
20 5
4 3
-----Sample Output-----
10.0000000
15.0000000
13.2000000
- On the first day, the temperature of water in the dam is always 10 degrees: the temperature of the only water that flows into the dam on the first day.
- 10 liters of water at 15 degrees of Celsius can be stored on the second day, by discharging 5 liters of water on the night of the first day, and mix the remaining water with the water that flows into the dam on the second day.
- 10 liters of water at 13.2 degrees of Celsius can be stored on the third day, by discharging 8 liters of water on the night of the first day, and mix the remaining water with the water that flows into the dam on the second and third days. | ["# \u306a\u3093\u3060\u304b\u91c8\u7136\u3068\u3057\u3066\u3044\u306a\u3044\u304c\u89e3\u8aac\u306e\u901a\u308a\u306b\nfrom collections import deque\nimport sys\n\ndef MI(): return list(map(int, sys.stdin.readline().split()))\n\nclass water:\n def __init__(self, t, v):\n self.v = v\n self.tv = v * t\n\n def __le__(self, other):\n return self.v * other.tv - self.tv * other.v >= 0\n\n def __isub__(self, other):\n t = self.tv / self.v\n self.v -= other\n self.tv = t * self.v\n return self\n\n def __iadd__(self, other):\n self.v+=other.v\n self.tv+=other.tv\n return self\n\ndef main():\n n, l = MI()\n dam = deque()\n t, v = MI()\n print(t)\n dam.append(water(t, v))\n # stv\u306ftv\u306e\u5408\u8a08\uff08v\u304cl\u306e\u3068\u304d\u306evt\uff09\n stv = t * v\n for _ in range(n-1):\n t, v = MI()\n # \u671d\u306b\u6c34\u3092\u3082\u3089\u3046\n dam.appendleft(water(t, v))\n over = v\n stv += t * v\n # \u5897\u3048\u305f\u5206\u306e\u6c34\u3092\u53e4\u3044\u65b9\u304b\u3089\u6368\u3066\u308b\n # \u30d9\u30af\u30c8\u30eb\u3054\u3068\u524a\u9664\u3067\u304d\u308b\u3082\u306e\n while dam[-1].v <= over:\n w = dam.pop()\n over -= w.v\n stv -= w.tv\n # \u6700\u5f8c\u306e\u306f\u307f\u51fa\u3057\u3066\u3044\u308b\u30d9\u30af\u30c8\u30eb\u306f\u7e2e\u3081\u308b\n stv -= dam[-1].tv # \u4e00\u5ea6\u5408\u8a08\u304b\u3089\u53d6\u308a\u51fa\u3057\u3066\n dam[-1] -= over # \u7e2e\u3081\u3066\n stv += dam[-1].tv # \u5143\u306b\u623b\u3059\n # \u305d\u306e\u65e5\u306e\u6c34\u6e29\u3092\u51fa\u529b\n print((stv / l))\n # \u30b0\u30e9\u30d5\u306e\u5de6\u5074\u304c\u51f9\u3093\u3067\u3044\u305f\u3089\u30d9\u30af\u30c8\u30eb\u3092\u5408\u6210\u3057\u3066\u51f8\u306b\u76f4\u3059\n while len(dam)>1 and dam[0] <= dam[1]:\n w = dam.popleft()\n dam[0] += w\n\nmain()\n", "from collections import deque\n\nN, L = list(map( int, input().split() ))\nT = []\nV = []\nfor i in range( N ):\n t, v = list(map( int, input().split() ))\n T.append( t )\n V.append( v )\n\ndq = deque()\nct, cv = 0.0, 0.0\nfor i in range( N ):\n while cv + V[ i ] > L:\n ft, fv = dq[ 0 ]\n take = min( cv + V[ i ] - L, fv )\n ct, cv = ( ct * cv - ft * take ) / ( cv - take ), cv - take\n if take == fv:\n dq.popleft()\n else:\n dq[ 0 ] = [ ft, fv - take ]\n ct, cv = ( ct * cv + T[ i ] * V[ i ] ) / L, L\n print(( \"%.7f\" % ct ))\n while len( dq ):\n bt, bv = dq[ len( dq ) - 1 ]\n if bt < T[ i ]: break\n T[ i ], V[ i ] = ( T[ i ] * V[ i ] + bt * bv ) / ( V[ i ] + bv ), V[ i ] + bv\n dq.pop()\n dq.append( [ T[ i ], V[ i ] ] )\n", "# F\nfrom collections import deque\n \nTT_list = []\n# input\nN, L = list(map(int, input().split()))\nT = 0.0\nvt_now = 0.0\nv_now = 0\nque = deque()\n\nfor i in range(N):\n ti, v = list(map(int, input().split()))\n t = float(ti)\n v_now += v\n vt_now += v*t\n # add\n if v == L:\n que.append([t, v])\n else:\n while v < L and len(que) > 0:\n t_, v_ = que[-1]\n if t_ <= t:\n que.append([t, v])\n break\n elif v + v_ >= L:\n v_ = v + v_ - L\n t = ((L - v) * t_ + v * t) / L\n v = L\n que = deque([[t, v]])\n v_now = L\n vt_now = t*L\n # break\n else:\n t = (t*v + t_*v_) / (v + v_)\n v = v + v_\n que.pop()\n # minus\n while v_now > L:\n if que[0][1] <= v_now - L:\n v_now -= que[0][1]\n vt_now -= que[0][1]*que[0][0]\n que.popleft()\n else:\n que[0][1] -= v_now - L\n vt_now -= (v_now - L)*que[0][0]\n v_now = L\n \n TT_list.append(vt_now / L)\n\nfor i in range(N):\n print((TT_list[i]))\n"] | {"inputs": ["3 10\n10 10\n20 5\n4 3\n", "4 15\n0 15\n2 5\n3 6\n4 4\n", "4 15\n1000000000 15\n9 5\n8 6\n7 4\n"], "outputs": ["10.0000000\n15.0000000\n13.2000000\n", "0.0000000\n0.6666667\n1.8666667\n2.9333333\n", "1000000000.0000000\n666666669.6666666\n400000005.0000000\n293333338.8666667\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 4,081 | |
0df419322105aeb2d78de184a3d33273 | UNKNOWN | Alice lives on a line. Today, she will travel to some place in a mysterious vehicle.
Initially, the distance between Alice and her destination is D. When she input a number x to the vehicle, it will travel in the direction of the destination by a distance of x if this move would shorten the distance between the vehicle and the destination, and it will stay at its position otherwise. Note that the vehicle may go past the destination when the distance between the vehicle and the destination is less than x.
Alice made a list of N numbers. The i-th number in this list is d_i. She will insert these numbers to the vehicle one by one.
However, a mischievous witch appeared. She is thinking of rewriting one number in the list so that Alice will not reach the destination after N moves.
She has Q plans to do this, as follows:
- Rewrite only the q_i-th number in the list with some integer so that Alice will not reach the destination.
Write a program to determine whether each plan is feasible.
-----Constraints-----
- 1≤ N ≤ 5*10^5
- 1≤ Q ≤ 5*10^5
- 1≤ D ≤ 10^9
- 1≤ d_i ≤ 10^9(1≤i≤N)
- 1≤ q_i ≤ N(1≤i≤Q)
- D and each d_i are integers.
-----Input-----
Input is given from Standard Input in the following format:
N D
d_1 d_2 ... d_N
Q
q_1 q_2 ... q_Q
-----Output-----
Print Q lines. The i-th line should contain YES if the i-th plan is feasible, and NO otherwise.
-----Sample Input-----
4 10
3 4 3 3
2
4 3
-----Sample Output-----
NO
YES
For the first plan, Alice will already arrive at the destination by the first three moves, and therefore the answer is NO.
For the second plan, rewriting the third number in the list with 5 will prevent Alice from reaching the destination as shown in the following figure, and thus the answer is YES. | ["n, d = list(map(int, input().split()))\nD = list(map(int, input().split()))\nA = [0]*(n+1)\nP = [0]*(n+1)\n\nP[0] = pos = d\nfor i, x in enumerate(D):\n if x <= 2*pos:\n pos = abs(x-pos)\n P[i+1] = pos\n if pos == 0:\n break\n\nfor i in range(n-1, -1, -1):\n if D[i] <= 2*A[i+1]+1:\n A[i] = A[i+1] + D[i]\n else:\n A[i] = A[i+1]\n\nq = input()\nQ = list(map(int, input().split()))\nfor i in Q:\n if P[i-1] <= A[i] and pos == 0:\n print(\"NO\")\n else:\n print(\"YES\")\n", "import sys\ninput = sys.stdin.readline\n\n\"\"\"\n\u5f8c\u308d\u304b\u3089\u3001\u5230\u9054\u4e0d\u53ef\u80fd\u8ddd\u96e2\u306e\u96c6\u5408\u3092\u898b\u3066\u3044\u304d\u305f\u3044\u3002\n\u96c6\u5408\u3092\u6301\u3064\u3068\u53b3\u3057\u3044\u304c\u3001\u6700\u5c0f\u5024\u3060\u3051\u6301\u3063\u3066\u304a\u3051\u3070\u3088\u3044\u3002\n\"\"\"\n\nN,dist = map(int,input().split())\nD = [int(x) for x in input().split()]\n\n# \u5404\u30bf\u30fc\u30f3\u306e\u51fa\u767a\u4f4d\u7f6e\nstart_dist = [dist]\nfor d in D:\n x = start_dist[-1]\n y = min(abs(x - d), x)\n start_dist.append(y)\n\nng_dist = [None] * (N+1)\nng_dist[N] = 1\n\nfor i,d in enumerate(D[::-1]):\n x = ng_dist[N-i]\n y = x if x <= d//2 else x + d\n ng_dist[N-i-1] = y\n\ninput()\nQ = [int(x) for x in input().split()]\n\nanswer = ['YES' if ng_dist[d] <= start_dist[d-1] else 'NO' for d in Q]\n\nprint('\\n'.join(answer))", "N, D = list(map( int, input().split() ))\nd = list( map( int, input().split() ) )\nQ = int( input() )\nq = list( [int( x ) - 1 for x in input().split()] )\n\ndis = [ 0 for i in range( N + 1 ) ]\ndis[ 0 ] = D\nfor i in range( N ):\n dis[ i + 1 ] = min( dis[ i ], abs( dis[ i ] - d[ i ] ) )\n\ndp = [ 0 for i in range( N + 1 ) ]\ndp[ N ] = 1\nfor i in range( N - 1, -1, -1 ):\n if dp[ i + 1 ] <= d[ i ] // 2:\n dp[ i ] = dp[ i + 1 ]\n else:\n dp[ i ] = dp[ i + 1 ] + d[ i ]\n\nfor qi in range( Q ):\n print(( [ \"NO\", \"YES\" ][ dis[ q[ qi ] ] >= dp[ q[ qi ] + 1 ] ] ))\n", "# E\nN, D = list(map(int, input().split()))\ndv = list(map(int, input().split()))\nQ = int(input())\nqv = list(map(int, input().split()))\n\n# trace of Alice\ndist_alice = D\ndist_alice_list = [D]\nfor i in range(N):\n if dist_alice >= dv[i]:\n dist_alice -= dv[i]\n elif 2*dist_alice >= dv[i]:\n dist_alice = dv[i] - dist_alice\n dist_alice_list.append(dist_alice)\n\nsol_min = [1]\nsol_min_ = 1 \nfor i in range(N-1, -1, -1):\n if 2 * sol_min_ > dv[i]:\n sol_min_ += dv[i]\n sol_min.append(sol_min_)\n\nfor i in range(Q):\n if dist_alice_list[qv[i]-1] >= sol_min[N-qv[i]]:\n print(\"YES\")\n else:\n print(\"NO\")\n \n", "N,D=list(map(int,input().split()))\nd=list(map(int,input().split()))\n\ndp=[D]*N\n\nif abs(D-d[0])<D:\n dp[0]=abs(D-d[0])\n\nfor i in range(1,N):\n dp[i]=min(dp[i-1],abs(dp[i-1]-d[i]))\n\nans=[\"NO\"]*N\ndata=[0]*(N+1)\nfor i in range(N-1,0,-1):\n if d[i]//2>data[i+1]:\n data[i]=data[i+1]\n else:\n data[i]=data[i+1]+d[i]\n if dp[i-1]>data[i+1]:\n ans[i]=\"YES\"\n\ni=0\nif d[i]//2>data[i+1]:\n data[i]=data[i+1]\nelse:\n data[i]=data[i+1]+d[i]\n\nif D>data[i+1]:\n ans[i]=\"YES\"\n\nQ=int(input())\nq=list(map(int,input().split()))\nfor i in range(Q):\n print((ans[q[i]-1]))\n\n\n#print(dp)\n#print(data)\n#print(ans)\n", "n, D = map(int, input().split())\nx = list(map(int, input().split()))\nQ = int(input())\nq = list(map(int, input().split()))\n\nind = [D]\nfor i in range(n):\n\tind.append(min(ind[-1], abs(ind[-1] - x[i])))\n\nl = [1]\nfor i in range(n-1, -1, -1):\n\tif x[i] < 2*l[-1]:\n\t\tl.append(x[i] + l[-1])\n\telse:\n\t\tl.append(l[-1])\nl = l[::-1]\n\nfor i in range(Q):\n\tif l[q[i]] <= ind[q[i]-1]:\n\t\tprint(\"YES\")\n\telse:\n\t\tprint(\"NO\")", "import sys\nreadline = sys.stdin.readline\n\nN, D = list(map(int, readline().split()))\n\nA = list(map(int, readline().split())) + [0]\n\nreach = [None]*(N+2)\nreach[-1] = D\nfor i in range(N+1):\n r = reach[i-1]\n a = A[i]\n reach[i] = min(r, abs(r-a))\n\nputter = [0]*(N+2)\nfor i in range(N, -1, -1):\n p = putter[i+1]\n a = A[i]\n if 2*p+1 >= a:\n p += a\n putter[i] = p\n\nres = ['NO']*N\nfor i in range(N):\n if reach[i-1] > putter[i+1]:\n res[i] = 'YES'\n\nQ = int(readline())\nprint(('\\n'.join(res[int(i)-1] for i in readline().split())))\n\n", "#!/usr/bin/env python3\n\n\ndef solve(n, d, da, q, qa):\n\n a = [d]\n x = d\n for di in da:\n x = min(x, max(x - di, di - x))\n a.append(x)\n\n b = [1]\n x = 1\n for i in range(n - 1, -1, -1):\n di = da[i]\n if di // 2 < x:\n x += di\n b.append(x)\n b.reverse()\n\n for qi in qa:\n if b[qi] <= a[qi - 1]:\n print('YES')\n else:\n print('NO')\n\n\ndef main():\n n, d = input().split()\n n = int(n)\n d = int(d)\n da = list(map(int, input().split()))\n q = input()\n q = int(q)\n qa = list(map(int, input().split()))\n\n solve(n, d, da, q, qa)\n\ndef __starting_point():\n main()\n\n\n__starting_point()", "\n# -*- coding: utf-8 -*-\nimport sys\nimport math\n\nN,D = list(map(int, sys.stdin.readline().rstrip().split()))\nds = list(map(int, sys.stdin.readline().rstrip().split()))\nQ, = list(map(int, sys.stdin.readline().rstrip().split()))\nqs = list(map(int, sys.stdin.readline().rstrip().split()))\n\n\ntargets = [1]\nfor d in reversed(ds):\n if(d//2 < targets[-1]):\n targets.append(targets[-1] + d)\n else:\n targets.append(targets[-1])\ntargets.reverse()\n\ncurrent = D\ncan_avoids = []\nfor i in range(N):\n d = ds[i]\n target = targets[i+1]\n #print(\"current:\", current)\n can_avoids.append(current >= target)\n if d//2 < current:\n current -= d\n current = max(-current, current)\n\n#print(targets)\n#print(can_avoids)\n\nfor q in qs:\n if (can_avoids[q-1]):\n print(\"YES\")\n else:\n print(\"NO\")\n\n\nreturn\n", "N, D = list(map(int, input().split()))\nds = list(map(int, input().split()))\nQ = int(input())\nquerys = list([int(x) - 1 for x in input().split()])\n\n# ps[i]: i\u56de\u76ee\u306e\u79fb\u52d5\u5f8c\u306e\u4f4d\u7f6e\uff08\u76ee\u7684\u5730\u307e\u3067\u306e\u8ddd\u96e2\uff09\nps = [0] * (N + 1)\nps[0] = D\nfor i in range(N):\n ps[i + 1] = min(abs(ps[i] - ds[i]), ps[i])\n\nif ps[N] != 0:\n print(('\\n'.join(['YES'] * Q)))\n return\n\n# ms[i]: i\u756a\u76ee\u306e\u79fb\u52d5\u5f8c\u306bm\u4ee5\u4e0b\u306e\u4f4d\u7f6e\u306a\u3089\u3070\u5168\u3066\u3001\u76ee\u7684\u5730\u306b\u5230\u9054\u53ef\u80fd\u3067\u3042\u308b\u3088\u3046\u306am\u306e\u6700\u5927\u5024\nms = [0] * (N + 1)\nfor i in range(N)[::-1]:\n if ms[i + 1] + 1 >= ds[i] - ms[i + 1]:\n ms[i] = ms[i + 1] + ds[i]\n else:\n ms[i] = ms[i + 1]\n\nfor q in querys:\n if ps[q] <= ms[q + 1]: # \u59a8\u5bb3\u306f\u4e0d\u53ef\u80fd\n print('NO')\n else:\n print('YES')\n", "import sys\ninput = sys.stdin.readline\n\n\"\"\"\n\u5f8c\u308d\u304b\u3089\u3001\u5230\u9054\u4e0d\u53ef\u80fd\u8ddd\u96e2\u306e\u96c6\u5408\u3092\u898b\u3066\u3044\u304d\u305f\u3044\u3002\n\u96c6\u5408\u3092\u6301\u3064\u3068\u53b3\u3057\u3044\u304c\u3001\u6700\u5c0f\u5024\u3060\u3051\u6301\u3063\u3066\u304a\u3051\u3070\u3088\u3044\u3002\n\"\"\"\n\nN,dist = map(int,input().split())\nD = [int(x) for x in input().split()]\n\n# \u5404\u30bf\u30fc\u30f3\u306e\u51fa\u767a\u4f4d\u7f6e\nstart_dist = [dist]\nfor d in D:\n x = start_dist[-1]\n y = x-d if x > d else d - x\n start_dist.append(x if x < y else y)\n\nng_dist = [None] * (N+1)\nng_dist[N] = 1\n\nfor i,d in enumerate(D[::-1]):\n x = ng_dist[N-i]\n y = x if x <= d//2 else x + d\n ng_dist[N-i-1] = y\n\ninput()\nQ = [int(x) for x in input().split()]\n\nanswer = ['YES' if ng_dist[d] <= start_dist[d-1] else 'NO' for d in Q]\n\nprint('\\n'.join(answer))", "N, D = list(map(int,input().split()))\nd = list(map(int,input().split()))\nQ = int(input())\nq = list(map(int,input().split()))\n\na = [D for i in range(N)]\nb = [1 for i in range(N+1)]\nfor i in range(1,N):\n\ta[i] = min(abs(a[i-1]-d[i-1]),a[i-1])\nfor i in range(N)[::-1]:\n\tif d[i]//2 < b[i+1]:\n\t\tb[i] = b[i+1] + d[i]\n\telse:\n\t\tb[i] = b[i+1]\n\nres = \"\"\nfor i in q:\n\tif a[i-1] < b[i]:\n\t\tres+=\"NO\"\n\telse:\n\t\tres+=\"YES\"\n\tres+=\"\\n\"\n\nprint(res)\n\n\n\n\n\n", "N,start = map(int,input().split())\nD = list(map(int,input().split()))\ninput()\nQ = list(map(int,input().split()))\n\nQ = [(k-1,i) for i,k in enumerate(Q)]\nQ.sort()\n\nP = [start]\nfor d in D:\n a = P[-1]\n b = abs(a-d)\n P.append(min(a,b))\n\nresult = [None]*len(Q)\n\nx = 1\n\nfor i,d in zip(reversed(range(len(D))), reversed(D)):\n if Q[-1][0] == i:\n result[Q[-1][1]] = P[i] >= x\n Q.pop()\n if not Q:\n break\n\n if abs(x-d) < x:\n x += d\n\nfor r in result:\n print('YES' if r else 'NO')", "N, D = list(map( int, input().split() ))\nd = list( map( int, input().split() ) )\nQ = int( input() )\nq = list( [int( x ) - 1 for x in input().split()] )\n\ndis = [ 0 for i in range( N + 1 ) ]\ndis[ 0 ] = D\nfor i in range( N ):\n dis[ i + 1 ] = min( dis[ i ], abs( dis[ i ] - d[ i ] ) )\n\ndp = [ 0 for i in range( N + 1 ) ]\ndp[ N ] = 1\nfor i in range( N - 1, -1, -1 ):\n if dp[ i + 1 ] <= d[ i ] // 2:\n dp[ i ] = dp[ i + 1 ]\n else:\n dp[ i ] = dp[ i + 1 ] + d[ i ]\n\nfor qi in range( Q ):\n print(( [ \"NO\", \"YES\" ][ dis[ q[ qi ] ] >= dp[ q[ qi ] + 1 ] ] ))\n", "import math\n\nN, D = list(map(int, input().split()))\nDs = list(map(int, input().split()))\nQ = int(input())\nQs = list(map(int, input().split()))\n\ndp = [math.inf]*(N+1) # (i\u304b\u3089\u5148\u3060\u3051\u3092\u307f\u3066)\uff1d\uff1e\u30b4\u30fc\u30eb\u3067\u304d\u306a\u3044\u6700\u5c0f\ndp[-1] = 1\nfor i in range(N-1, -1, -1):\n if Ds[i] >= 2 * dp[i+1]:\n dp[i] = dp[i+1]\n else:\n dp[i] = dp[i+1]+Ds[i]\n\nPos = [D]\nfor i in range(N):\n if Ds[i] > Pos[-1]*2:\n Pos.append(Pos[-1])\n else:\n Pos.append(abs(Pos[-1]-Ds[i]))\n\nfor q in Qs:\n if dp[q]>Pos[q-1]:\n print('NO')\n else:\n print('YES')\n", "N, D = list(map( int, input().split() ))\nd = list( map( int, input().split() ) )\nQ = int( input() )\nq = list( map( int, input().split() ) )\n\ndis = [ 0 for i in range( N + 1 ) ]\ndis[ 0 ] = D\nfor i in range( N ):\n dis[ i + 1 ] = min( dis[ i ], abs( dis[ i ] - d[ i ] ) )\n\ndp = [ 0 for i in range( N + 1 ) ]\ndp[ N ] = 1\nfor i in range( N - 1, -1, -1 ):\n if dp[ i + 1 ] <= d[ i ] // 2:\n dp[ i ] = dp[ i + 1 ]\n else:\n dp[ i ] = dp[ i + 1 ] + d[ i ]\n\nfor qi in range( Q ):\n print(( [ \"NO\", \"YES\" ][ dis[ q[ qi ] - 1 ] >= dp[ q[ qi ] ] ] ))\n", "N, D = map(int, input().split())\nd = list(map(int, input().split()))\nQ = int(input())\nq = list(map(lambda x : int(x)-1 , input().split()))\n\ndis = [0 for i in range(N+1)]\ndis[0] = D\nfor i in range(N):\n dis[i+1] = min(dis[i], abs(dis[i] - d[i]))\n\ndp = [0 for i in range(N+1)]\ndp[N] = 1\nfor i in range(N-1, -1, -1):\n if d[i] // 2 >= dp[i+1]:\n dp[i] = dp[i+1]\n else:\n dp[i] = dp[i+1] + d[i]\n\nfor qi in range(Q):\n print([\"YES\", \"NO\"][dis[q[ qi ]] < dp[q[ qi ] + 1]])", "n, D = map(int, input().split())\nx = list(map(int, input().split()))\nQ = int(input())\nq = list(map(int, input().split()))\n\nind = [D]\nfor i in range(n):\n\tind.append(min(ind[-1], abs(ind[-1] - x[i])))\n#print(ind)\n\nl = [1]\nfor i in range(n-1, -1, -1):\n\tif x[i] < 2*l[-1]:\n\t\tl.append(x[i] + l[-1])\n\telse:\n\t\tl.append(l[-1])\nl = l[::-1]\n\nfor i in range(Q):\n\tif l[q[i]] <= ind[q[i]-1]:\n\t\tprint(\"YES\")\n\telse:\n\t\tprint(\"NO\")", "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\ndef main():\n # YouTube\u306e\u901a\u308a\n dn, s = MI()\n dd = LI()\n qn = II()\n qq = LI()\n qi = [(q - 1, i) for i, q in enumerate(qq)]\n # pos[i]...dd[i]\u306e\u79fb\u52d5\u524d\u306e\u4f4d\u7f6e\n pos = [s]\n for d in dd:\n pos.append(min(pos[-1], abs(d - pos[-1])))\n # print(pos)\n # bb[i]...dd[i]\u306e\u79fb\u52d5\u524d\u306b\u3053\u306e\u8ddd\u96e2\u4ee5\u4e0a\u306e\u4f4d\u7f6e\u306b\u3044\u308c\u3070\u30b4\u30fc\u30eb\u306b\u5c4a\u304b\u306a\u3044\u3068\u3044\u3046\u5883\u76ee\n bb = [1] * (dn + 1)\n for i in range(dn - 1, -1, -1):\n d = dd[i]\n if d < bb[i + 1] * 2:\n bb[i] = bb[i + 1] + d\n else:\n bb[i] = bb[i + 1]\n # print(bb)\n # dd0 dd1 dd2 dd3\n # po0 po1 po2 po3 po4\n # bb0 bb1 bb2 bb3 bb4\n # \u3068\u3044\u3046\u524d\u5f8c\u95a2\u4fc2\u306a\u306e\u3067q\u756a\u76ee(0-origin)\u306edd\u306b\u9b54\u6cd5\u3092\u304b\u3051\u308b\u3068\u304d\u306f\n # pos[q]>=bb[q+1]\u3067\u3042\u308b\u306a\u3089\u59a8\u5bb3\u53ef\u80fd(YES)\n ans = [\"\"] * qn\n for q, ai in qi:\n if pos[q] >= bb[q + 1]: ans[ai] = \"YES\"\n else: ans[ai] = \"NO\"\n print(*ans, sep=\"\\n\")\n\nmain()\n"] | {"inputs": ["4 10\n3 4 3 3\n2\n4 3\n", "5 9\n4 4 2 3 2\n5\n1 4 2 3 5\n", "6 15\n4 3 5 4 2 1\n6\n1 2 3 4 5 6\n"], "outputs": ["NO\nYES\n", "YES\nYES\nYES\nYES\nYES\n", "NO\nNO\nYES\nNO\nNO\nYES\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 13,433 | |
04d1cae1414586a06de27c90ebf9fc8e | UNKNOWN | Snuke's town has a subway system, consisting of N stations and M railway lines. The stations are numbered 1 through N. Each line is operated by a company. Each company has an identification number.
The i-th ( 1 \leq i \leq M ) line connects station p_i and q_i bidirectionally. There is no intermediate station. This line is operated by company c_i.
You can change trains at a station where multiple lines are available.
The fare system used in this subway system is a bit strange. When a passenger only uses lines that are operated by the same company, the fare is 1 yen (the currency of Japan). Whenever a passenger changes to a line that is operated by a different company from the current line, the passenger is charged an additional fare of 1 yen. In a case where a passenger who changed from some company A's line to another company's line changes to company A's line again, the additional fare is incurred again.
Snuke is now at station 1 and wants to travel to station N by subway. Find the minimum required fare.
-----Constraints-----
- 2 \leq N \leq 10^5
- 0 \leq M \leq 2×10^5
- 1 \leq p_i \leq N (1 \leq i \leq M)
- 1 \leq q_i \leq N (1 \leq i \leq M)
- 1 \leq c_i \leq 10^6 (1 \leq i \leq M)
- p_i \neq q_i (1 \leq i \leq M)
-----Input-----
The input is given from Standard Input in the following format:
N M
p_1 q_1 c_1
:
p_M q_M c_M
-----Output-----
Print the minimum required fare. If it is impossible to get to station N by subway, print -1 instead.
-----Sample Input-----
3 3
1 2 1
2 3 1
3 1 2
-----Sample Output-----
1
Use company 1's lines: 1 → 2 → 3. The fare is 1 yen. | ["#!/usr/bin/env python3\nimport sys\ninput = sys.stdin.readline\nfrom collections import deque\nINF = 10**9\n\nn, m = map(int, input().split())\npqc = []\n\nseen = set()\nfor i in range(n):\n seen.add((i, 0))\nfor _ in range(m):\n p, q, c = map(int, input().split())\n p -= 1; q -= 1\n pqc.append((p, q, c))\n seen.add((p, c))\n seen.add((q, c))\ncomp = dict()\nfor i, node in enumerate(seen):\n comp[node] = i\n\nedge = [[] for _ in range(len(comp))]\nfor key in comp.keys():\n v, c = key\n if c != 0:\n frm = comp[(v, c)]\n too = comp[(v, 0)]\n edge[frm].append((too, 0))\n edge[too].append((frm, 1))\n\nfor p, q, c in pqc:\n frm = comp[(p, c)]\n too = comp[(q, c)]\n edge[frm].append((too, 0))\n edge[too].append((frm, 0))\n\nclass BFS:\n def __init__(self, adj):\n self.adj = adj\n self.dist = [INF] * len(adj)\n self.q = deque()\n\n def calc(self, start):\n self.dist[start] = 0\n self.q.append((0, start))\n while len(self.q) != 0:\n prov_cost, src = self.q.popleft()\n if self.dist[src] < prov_cost:\n continue\n for dest, cost in self.adj[src]:\n if self.dist[dest] > self.dist[src] + cost:\n self.dist[dest] = self.dist[src] + cost\n if cost == 1:\n self.q.append((self.dist[dest], dest))\n else:\n self.q.appendleft((self.dist[dest], dest))\n return self.dist\n\nbfs = BFS(edge)\nbfs.calc(comp[(0, 0)])\nans = bfs.dist[comp[(n-1, 0)]]\nif ans == INF:\n print(-1)\nelse:\n print(ans)", "from collections import deque\nN, M = map(int, input().split())\nF_C_of_S = [{} for i in range(N)]\n#Companies of Station\nC_of_S = {}\n\n#def Union-find\nparent = [-1]*M\ndef root(x):\n\tif (parent[x] < 0): return x\n\telse:\n\t\tparent[x] = y = root(parent[x])\n\t\treturn y\n\ndef unite(x, y):\n\tpx = root(x)\n\tpy = root(y)\n\tif (px == py): return False\n\tif (parent[px] > parent[py]):\n\t\tpx = root(y)\n\t\tpy = root(x)\n\tparent[px] += parent[py]\n\tparent[py] = px\n\treturn True\n\n\n#Union-find\npqcs = []\nfor i in range(M):\n\tp, q, c = map(int, input().split())\n\tp -= 1; q -= 1;\n\tpqcs += [(p, q, c)]\n\t\n\t#The first\n\tif not c in F_C_of_S[p]: F_C_of_S[p][c] = i\n\t#else\n\telse: unite(F_C_of_S[p][c], i)\n\tC_of_S.setdefault(p, set()).add(c)\n\t\n\t#The first\n\tif not (c in F_C_of_S[q]):F_C_of_S[q][c] = i\n\t#else\n\telse: unite(F_C_of_S[q][c], i)\n\tC_of_S.setdefault(q, set()).add(c)\n\n#stations of company\nS_of_C = {}\nfor i in range(M):\n\tp, q, c = pqcs[i]\n\tc_set = S_of_C.setdefault(root(i), set())\n\tc_set.add(p)\n\tc_set.add(q)\n\n\nQ = deque([(0, 0, 0)])\n#cost to go to the stations from station_0\ndist = [float('inf')]*N\ndist[0] = 0\n\ngdist = [float('inf')]*M\n\nwhile Q:\n\tcost, v, flag = Q.popleft()\n\t\n\tif not (flag):#(flag == 0) then gdist_update\n\t\tif (dist[v] < cost) or (v not in C_of_S):\n\t\t\tcontinue\n\t\tfor l in F_C_of_S[v].values():\n\t\t\tl = root(l)\n\t\t\tif (cost < gdist[l]):\n\t\t\t\tgdist[l] = cost\n\t\t\t\tQ.appendleft((cost, l, 1))\n\t\n\telse:#(flag == 1) then dist_update\n\t\tif (gdist[v] < cost) or (v not in S_of_C):\n\t\t\tcontinue\n\t\tfor s in S_of_C[v]:\n\t\t\tif (cost+1 < dist[s]):\n\t\t\t\tdist[s] = cost+1\n\t\t\t\tQ.append((cost+1, s, 0))\n\nprint(dist[N - 1] if dist[N - 1] < float('inf') else -1)", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn,m = list(map(int, readline().split()))\n\ng = {}\n\nfor _ in range(m):\n p,q,c = list(map(int, readline().split()))\n pc = ((p-1)<<20)+c\n qc = ((q-1)<<20)+c\n pp = (p-1)<<20\n qq = (q-1)<<20\n \n if pc not in g: g[pc] = []\n if qc not in g: g[qc] = []\n if pp not in g: g[pp] = []\n if qq not in g: g[qq] = []\n \n g[pc].append(qc)\n g[pc].append(pp)\n\n g[qc].append(pc)\n g[qc].append(qq)\n\n g[pp].append(pc)\n g[qq].append(qc)\n\nif 0 not in g: g[0] = []\n\nfrom collections import deque\nq = deque([(0,0)])\nres = {0:0}\n\nmask = (1<<20)-1\nwhile q:\n vl,dv = q.popleft()\n if res[vl] < dv: continue\n if (vl>>20) == n-1:\n res[(n-1)<<20] = dv+1\n break\n for tl in g[vl]:\n ndv = dv + (vl&mask==0 or tl&mask==0)\n if tl not in res or res[tl] > ndv:\n res[tl] = ndv\n if vl&mask==0 or tl&mask==0:\n q.append((tl,ndv))\n else:\n q.appendleft((tl,ndv))\n\nif (n-1)<<20 in res:\n print((res[(n-1)<<20]//2))\nelse:\n print((-1))\n\n\n\n\n", "import sys\nreadline = sys.stdin.readline\n\nfrom heapq import heappop as hpp, heappush as hp\ninf = 10**9+7\ndef dijkstra(N, s, Edge): \n dist = [inf] * N\n dist[s] = 0\n Q = [(0, s)]\n while Q:\n dn, vn = hpp(Q)\n if dn > dist[vn]:\n continue\n for df, vf in Edge[vn]:\n if dn + df < dist[vf]:\n dist[vf] = dn + df\n hp(Q, (dn + df,vf))\n return dist\n\ndef compress(L):\n L2 = list(set(L))\n L2.sort()\n C = {v : k for k, v in enumerate(L2)}\n return L2, C\n\n\nN, M = map(int, readline().split())\n\nEdge = []\nVS = set(range(N))\ngeta = 20\nEdge = [tuple(map(int, readline().split())) for _ in range(M)]\nfor a, b, c in Edge:\n a -= 1\n b -= 1\n VS |= {(c<<geta) | a, (c<<geta) | b}\n \n_, Cv = compress(list(VS))\n\nVnum = len(Cv)\n\nnEdge = [[] for _ in range(Vnum)]\n\nfor a, b, c in Edge:\n a -= 1\n b -= 1\n ca = Cv[(c<<geta) | a]\n cb = Cv[(c<<geta) | b]\n nEdge[ca].append((0, cb))\n nEdge[cb].append((0, ca))\n nEdge[a].append((1, ca))\n nEdge[ca].append((0, a))\n nEdge[b].append((1, cb))\n nEdge[cb].append((0, b))\n\ndist = dijkstra(Vnum, 0, nEdge)\nif dist[N-1] >= inf:\n dist[N-1] = -1\nprint(dist[N-1]) ", "import sys\nstdin = sys.stdin\n \nsys.setrecursionlimit(10**5) \n \ndef li(): return map(int, stdin.readline().split())\ndef li_(): return map(lambda x: int(x)-1, stdin.readline().split())\ndef lf(): return map(float, stdin.readline().split())\ndef ls(): return stdin.readline().split()\ndef ns(): return stdin.readline().rstrip()\ndef lc(): return list(ns())\ndef ni(): return int(stdin.readline())\ndef nf(): return float(stdin.readline())\n\nfrom collections import defaultdict, deque\n\n# \u5165\u529b\u30fb\u96a3\u63a5\u30ea\u30b9\u30c8\u4f5c\u6210\nn,m = li()\ngraph = defaultdict(set)\ngeta = pow(10,7)\n\nfor _ in range(m):\n p,q,c = li()\n \n graph[p + c*geta].add(q + c*geta)\n graph[q + c*geta].add(p + c*geta)\n \n graph[p + c*geta].add(p)\n graph[q + c*geta].add(q)\n \n graph[p].add(p + c*geta)\n graph[q].add(q + c*geta)\n \nque = deque()\nque.append((0, 1))\nvisited = set()\n\nans = -1\n\nwhile que:\n (cost, node) = que.popleft()\n \n if node in visited:\n continue\n \n elif node % geta == n:\n ans = cost\n break\n \n visited.add(node)\n \n \n for nex in graph[node]:\n if nex in visited:\n continue\n \n elif node <= n and nex > n:\n que.append((cost+1, nex))\n \n else:\n que.appendleft((cost, nex))\n \nprint(ans)", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\nfrom collections import deque\nN, M = map(int, input().split())\nX = []\nC = [set() for _ in range(N)]\nfor _ in range(M):\n p, q, c = [int(a) - 1 for a in input().split()]\n X.append((p, q, c))\n C[p].add(c)\n C[q].add(c)\nfor i, c in enumerate(C):\n C[i] = list(c)\n\nI = [N]\nD = [{} for _ in range(N)]\nfor i, c in enumerate(C):\n for j, a in enumerate(c):\n D[i][a] = I[-1] + j\n I.append(I[-1] + len(c))\n\nT = I[-1]\nE = [[] for _ in range(T)]\nfor p, q, c in X:\n E[D[p][c]].append((D[q][c], 0))\n E[D[q][c]].append((D[p][c], 0))\nfor i, c in enumerate(C):\n for j, a in enumerate(c):\n E[i].append((D[i][a], 1))\n E[D[i][a]].append((i, 1))\n\ndef BFS01(n, E, i0=0):\n Q = deque([i0])\n D = [-1] * n\n D[i0] = 0\n while Q:\n x = Q.popleft()\n for y, w in E[x]:\n if w:\n if D[y] == -1:\n D[y] = D[x] + 1\n Q.append(y)\n else:\n if D[y] == -1 or D[y] < D[x]:\n D[y] = D[x]\n Q.appendleft(y)\n return D\n\nD = BFS01(T, E, 0)\nprint(D[N-1] // 2)", "# -*- coding: utf-8 -*-\nimport bisect\nimport heapq\nimport math\nimport random\nimport sys\nfrom collections import Counter, defaultdict, deque\nfrom decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal\nfrom functools import lru_cache, reduce\nfrom itertools import combinations, combinations_with_replacement, product, permutations\nfrom operator import add, mul, sub\n\nsys.setrecursionlimit(10000)\n\n\ndef read_int():\n return int(input())\n\n\ndef read_int_n():\n return list(map(int, input().split()))\n\n\ndef read_float():\n return float(input())\n\n\ndef read_float_n():\n return list(map(float, input().split()))\n\n\ndef read_str():\n return input().strip()\n\n\ndef read_str_n():\n return list(map(str, input().split()))\n\n\ndef error_print(*args):\n print(*args, file=sys.stderr)\n\n\ndef mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap\n\n\ndef bfs01(g, s):\n d = {}\n for v in g.keys():\n d[v] = sys.maxsize\n d[s] = 0\n\n if s not in d:\n return d\n q = deque()\n q.append((d[s], s))\n\n NM = 1 << 30\n while q:\n _, u = q.popleft()\n for v in g[u]:\n if v > NM:\n c = 0\n else:\n c = 1\n alt = c + d[u]\n if d[v] > alt:\n d[v] = alt\n if c == 0:\n q.appendleft((d[v], v))\n else:\n q.append((d[v], v))\n return d\n\n\n@mt\ndef slv(N, M):\n\n g = defaultdict(list)\n NM = 30\n for _ in range(M):\n p, q, c = input().split()\n p = int(p)\n q = int(q)\n c = int(c)\n\n cp = (c << NM) + p\n cq = (c << NM) + q\n g[cp].append(cq)\n g[cq].append(cp)\n g[cp].append(p)\n g[cq].append(q)\n g[p].append((cp))\n g[q].append((cq))\n\n d = bfs01(g, 1)\n return -1 if N not in d or d[N] == sys.maxsize else d[N]\n\n\ndef main():\n N, M = read_int_n()\n\n print(slv(N, M))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "import sys,heapq\nfrom collections import defaultdict,deque\n\ninput = sys.stdin.readline\nn,m = map(int,input().split())\n#+\u8def\u7dda*chg : \u305d\u306e\u8def\u7dda\u30db\u30fc\u30e0\nchg = 10**6\n\nedge=defaultdict(set)\nused =defaultdict(bool)\nfor i in range(m):\n p,q,c = map(int,input().split())\n edge[p].add(p+c*chg)\n edge[p+c*chg].add(p)\n edge[p+c*chg].add(q+c*chg)\n edge[q+c*chg].add(p+c*chg)\n edge[q].add(q+c*chg)\n edge[q+c*chg].add(q)\n used[p] = False\n used[q] = False\n used[p+c*chg] = False\n used[q+c*chg] = False\n\nedgelist = deque()\nedgelist.append((1,0))\nres = float(\"inf\")\n\nwhile len(edgelist):\n x,cost = edgelist.pop()\n used[x] = True\n\n if x == n:\n res = cost\n break\n for e in edge[x]:\n if used[e]:\n continue\n #\u30db\u30fc\u30e0\u2192\u6539\u672d\n if x <= 10**5 and chg <= e:\n edgelist.appendleft((e,cost+1))\n else:\n edgelist.append((e,cost))\n \nif res == float(\"inf\"):\n print(-1)\nelse:\n print(res)", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 10**9+7\ndd = [(-1,0),(0,1),(1,0),(0,-1)]\nddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\nclass UnionFind:\n def __init__(self, size):\n self.table = [-1 for _ in range(size)]\n\n def find(self, x):\n if self.table[x] < 0:\n return x\n else:\n self.table[x] = self.find(self.table[x])\n return self.table[x]\n\n def union(self, x, y):\n s1 = self.find(x)\n s2 = self.find(y)\n if s1 != s2:\n if self.table[s1] <= self.table[s2]:\n self.table[s1] += self.table[s2]\n self.table[s2] = s1\n else:\n self.table[s2] += self.table[s1]\n self.table[s1] = s2\n return True\n return False\n\n def subsetall(self):\n a = []\n for i in range(len(self.table)):\n if self.table[i] < 0:\n a.append((i, -self.table[i]))\n return a\n\n def tall(self):\n d = collections.defaultdict(list)\n for i in range(len(self.table)):\n d[self.find(i)].append(i)\n return d\n\ndef main():\n M = 2**17\n n,m = LI()\n a = [LI() for _ in range(m)]\n e = collections.defaultdict(list)\n for p,q,c in a:\n pc = p+c*M\n qc = q+c*M\n pm = p-M\n qm = q-M\n e[pc].append(qc)\n e[qc].append(pc)\n e[pm].append(pc)\n e[qm].append(qc)\n e[pc].append(pm)\n e[qc].append(qm)\n\n def search():\n d = collections.defaultdict(lambda: inf)\n s = 1-M\n d[s] = 0\n q = []\n heapq.heappush(q, (0, s))\n v = set()\n while len(q):\n k, u = heapq.heappop(q)\n if u in v:\n continue\n v.add(u)\n if u < 0:\n for uv in e[u]:\n if uv in v:\n continue\n vd = k + 1\n if d[uv] > vd:\n d[uv] = vd\n heapq.heappush(q, (vd, uv))\n\n else:\n if u % M == n:\n return k\n\n for uv in e[u]:\n if uv in v:\n continue\n if d[uv] > k:\n d[uv] = k\n heapq.heappush(q, (k, uv))\n\n return -1\n\n return search()\n\n\n\nprint(main())\n", "# -*- coding: utf-8 -*-\nimport bisect\nimport heapq\nimport math\nimport random\nimport sys\nfrom collections import Counter, defaultdict, deque\nfrom decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal\nfrom functools import lru_cache, reduce\nfrom itertools import combinations, combinations_with_replacement, product, permutations\nfrom operator import add, mul, sub\n\nsys.setrecursionlimit(10000)\n\n\ndef read_int():\n return int(input())\n\n\ndef read_int_n():\n return list(map(int, input().split()))\n\n\ndef read_float():\n return float(input())\n\n\ndef read_float_n():\n return list(map(float, input().split()))\n\n\ndef read_str():\n return input().strip()\n\n\ndef read_str_n():\n return list(map(str, input().split()))\n\n\ndef error_print(*args):\n print(*args, file=sys.stderr)\n\n\ndef mt(f):\n import time\n\n def wrap(*args, **kwargs):\n s = time.time()\n ret = f(*args, **kwargs)\n e = time.time()\n\n error_print(e - s, 'sec')\n return ret\n\n return wrap\n\n\ndef bfs01(g, s):\n d = {}\n for v in g.keys():\n d[v] = sys.maxsize\n d[s] = 0\n\n if s not in d:\n return d\n q = deque()\n q.append((d[s], s))\n\n NM = 1 << 30\n while q:\n _, u = q.popleft()\n for v in g[u]:\n if v > NM:\n c = 0\n else:\n c = 1\n alt = c + d[u]\n if d[v] > alt:\n d[v] = alt\n if c == 0:\n q.appendleft((d[v], v))\n else:\n q.append((d[v], v))\n return d\n\n\n@mt\ndef slv(N, M):\n\n g = defaultdict(list)\n NM = 30\n for _ in range(M):\n p, q, c = input().split()\n p = int(p)\n q = int(q)\n c = int(c)\n\n cp = (c << NM) + p\n cq = (c << NM) + q\n g[cp].append(cq)\n g[cq].append(cp)\n g[cp].append(p)\n g[cq].append(q)\n g[p].append((cp))\n g[q].append((cq))\n\n d = bfs01(g, 1)\n return -1 if N not in d or d[N] == sys.maxsize else d[N]\n\n\ndef main():\n N, M = read_int_n()\n\n print(slv(N, M))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import deque,defaultdict\nimport sys\ninput = sys.stdin.readline\nN,M=map(int,input().split())\nmod =10**7\ntable=defaultdict(set)\nvisit=defaultdict(int)\nfor i in range(M):\n a,b,c=map(int,input().split())\n table[a].add(a+c*mod)\n table[b].add(b+c*mod)\n table[a+c*mod].add(a)\n table[b+c*mod].add(b)\n table[a+c*mod].add(b+c*mod)\n table[b+c*mod].add(a+c*mod)\n visit[a]=0\n visit[b]=0\n visit[b+c*mod]=0\n visit[a+c*mod]=0\n\nH=deque()\nH.append((1,0))\nvisit[1]=1\nans=mod\nwhile H:\n #print(H)\n x,cost=H.popleft()\n visit[x] = 1\n if x==N:\n ans=min(ans,cost)\n break\n for y in table[x]:\n if visit[y]==1:\n continue\n if x<=10**5 and mod<=y:\n H.append((y,cost+1))\n else:\n H.appendleft((y,cost))\nif ans==mod:\n print(-1)\nelse:\n print(ans)", "N, M = list(map(int, input().split()))\nES = []\nD = {}\n\n*parent, = list(range(M))\ndef root(x):\n if x == parent[x]:\n return x\n parent[x] = y = root(parent[x])\n return y\ndef unite(x, y):\n px = root(x); py = root(y)\n if px < py:\n parent[py] = px\n else:\n parent[px] = py\n\nE = {}\nfor i in range(M):\n p, q, c = list(map(int, input().split())); p -= 1; q -= 1\n ES.append((p, q, c))\n if (p, c) in D:\n unite(D[p, c], i)\n D[p, c] = i\n E.setdefault(p, set()).add(c)\n if (q, c) in D:\n unite(D[q, c], i)\n D[q, c] = i\n E.setdefault(q, set()).add(c)\n#P = [[] for i in range(M)]\nP = {}\nfor i in range(M):\n j = root(i)\n p, q, c = ES[i]\n s = P.setdefault(j, set())\n s.add(p); s.add(q)\n\nfrom collections import deque\nque = deque([(0, 0, 0)])\nINF = 10**18\ndist = [INF]*N\ndist[0] = 0\ngdist = [INF]*M\n\nwhile que:\n cost, v, t = que.popleft()\n if t:\n # edge\n if gdist[v] < cost or v not in P:\n continue\n for w in P[v]:\n if cost + 1 < dist[w]:\n dist[w] = cost + 1\n que.append((cost + 1, w, 0))\n else:\n # node\n if dist[v] < cost or v not in E:\n continue\n for c in E[v]:\n w = root(D[v, c])\n if cost < gdist[w]:\n gdist[w] = cost\n que.appendleft((cost, w, 1))\n\nprint((dist[N-1] if dist[N-1] < INF else -1))\n", "def dijkstra_heap(s,edge,mask):\n dist = defaultdict(lambda: float(\"inf\"))\n q = [s] # 0 \u304c\u4f1a\u793e\u306b\u5c5e\u3057\u3066\u3044\u306a\u3044\u72b6\u614b\n dist[s] = 0\n d = 0; q0 = []; q1 = []\n while q:\n for x in q:\n if x & mask == 0:\n for y in edge[x]:\n if dist[y[1]] <= d + y[0]:\n continue\n dist[y[1]] = d + y[0]\n q1.append(y[1])\n else:\n for y in edge[x]:\n if dist[y[1]] <= d:\n continue\n dist[y[1]] = d\n q0.append(y[1])\n if q0:\n q = q0\n q0 = []\n continue\n q = q1\n q1 = []\n d += 1\n return dist\n\ndef examE(inf):\n N, M = LI()\n edge = defaultdict(list)\n # edge[i] : i\u304b\u3089\u51fa\u308b\u9053\u306e[\u91cd\u307f,\u884c\u5148]\u306e\u914d\u5217\n L = 32\n Mask = (1 << L) - 1\n for i in range(M):\n p, q, c = list(map(int, input().split()))\n p -=1; q -=1\n p <<= L\n q <<= L\n edge[p].append((1,p + c))\n edge[p + c].append((0,p))\n edge[q].append((1,q + c))\n edge[q + c].append((0,q))\n #\u540c\u3058\u8def\u7dda\u3060\u3068\u30b3\u30b9\u30c8\uff10\n edge[p + c].append((0,q + c))\n edge[q + c].append((0,p + c))\n start = 0\n goal = (N-1) << L\n res = dijkstra_heap(start, edge, Mask)\n# print(res)\n ans = res[goal]\n if ans == inf:\n ans = -1\n print(ans)\n\n\nimport sys,copy,bisect,itertools,heapq,math\nfrom heapq import heappop,heappush,heapify\nfrom collections import Counter,defaultdict,deque\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\nmod = 10**9 + 7\ninf = float('inf')\n\nexamE(inf)\n", "def main():\n from heapq import heappush,heappop,heapify\n inf=2**31-1\n n,m,*t=map(int,open(0).read().split())\n z=[]\n for a,b,c in zip(t[::3],t[1::3],t[2::3]):\n z.extend([a,b,a+n*c,b+n*c])\n z={i:v for v,i in enumerate(sorted(set(z)))}\n try:\n z[1]\n except:\n print(-1)\n return\n edge=[[]for _ in range(len(z))]\n d={}\n l=[]\n for a,b,c in zip(t[::3],t[1::3],t[2::3]):\n if b<a:a,b=b,a\n i,j,x,y=z[a],z[b],z[a+n*c],z[b+n*c]\n if b==n:\n l.append(y)\n edge[i].append((1,x))\n edge[j].append((1,y))\n edge[x].extend([(0,i),(0,y)])\n edge[y].extend([(0,j),(0,x)])\n used=[False]+[True]*~-len(z)\n d=[0]+[inf]*~-len(z)\n edgelist=edge[0]\n heapify(edgelist)\n while edgelist:\n m=heappop(edgelist)\n if not used[m[1]]:\n continue\n d[m[1]]=m[0]\n used[m[1]]=False\n for e in edge[m[1]]:\n if used[e[1]]:\n heappush(edgelist,(e[0]+m[0],e[1]))\n a=min([d[i]for i in l]or[inf])\n print([a,-1][a==inf])\ndef __starting_point():\n main()\n__starting_point()", "from collections import defaultdict\nfrom collections import deque\n\nN, M = list(map(int, input().split()))\n\nchg = 10**6\nG = defaultdict(set)\nfor _ in range(M):\n p, q, c = list(map(int, input().split()))\n # \u7121\u5411\u30b0\u30e9\u30d5\n G[p].add(p+chg*c)\n G[p+chg*c].add(p)\n G[q].add(q+chg*c)\n G[q+chg*c].add(q)\n G[p+chg*c].add(q+chg*c)\n G[q+chg*c].add(p+chg*c)\n\n\ndist = defaultdict(lambda: 10**11)\ndist[1] = 0\n\nque = deque([1])\n\nwhile que:\n ci = que.popleft()\n\n for ni in G[ci]:\n if dist[ni] == 10**11:\n if ci >= chg and ni >= chg:\n dist[ni] = dist[ci]\n que.appendleft(ni)\n else:\n dist[ni] = dist[ci]+1\n que.append(ni)\n\n\nif dist[N] < 10**11:\n print((dist[N]//2))\nelse:\n print((-1))\n", "def resolve():\n def Dijkstra(s, g):\n from collections import deque\n d = {s}\n queue = deque()\n for q in edge[s]:\n queue.append((1, q))\n while queue:\n dist, point = queue.popleft()\n if point in d:\n continue\n d.add(point)\n if point == g:\n return dist\n for nextp in edge[point]:\n if not nextp in d:\n if not -1 in point or -1 in nextp:\n queue.appendleft((dist, nextp))\n else:\n queue.append((dist + 1, nextp))\n return -1\n import sys\n input = sys.stdin.readline\n from collections import defaultdict\n n, m = list(map(int, input().split()))\n edge = defaultdict(set)\n for _ in range(m):\n p, q, c = list(map(int, input().split()))\n p, q = p - 1, q - 1\n edge[(p, c)].add((q, c))\n edge[(q, c)].add((p, c))\n edge[(p, c)].add((p, -1))\n edge[(q, c)].add((q, -1))\n edge[(p, -1)].add((p, c))\n edge[(q, -1)].add((q, c))\n print((Dijkstra((0, -1), (n - 1, -1))))\n\n\ndef __starting_point():\n resolve()\n\n__starting_point()", "# coding: utf-8\n# Your code here!\nimport sys\nreadline = sys.stdin.readline\nread = sys.stdin.read\n\nn,m,*pqc = list(map(int, read().split()))\n\ng = {}\nM = iter(pqc)\n\nfor p,q,c in zip(M,M,M):\n pc = ((p-1)<<20)+c\n qc = ((q-1)<<20)+c\n pp = (p-1)<<20\n qq = (q-1)<<20\n \n if pc not in g: g[pc] = []\n if qc not in g: g[qc] = []\n if pp not in g: g[pp] = []\n if qq not in g: g[qq] = []\n \n g[pc].append(qc)\n g[pc].append(pp)\n\n g[qc].append(pc)\n g[qc].append(qq)\n\n g[pp].append(pc)\n g[qq].append(qc)\n\nif 0 not in g: g[0] = []\n\nfrom collections import deque\nq = deque([(0,0)])\nres = {0:0}\n\nmask = (1<<20)-1\nwhile q:\n vl,dv = q.popleft()\n if res[vl] < dv: continue\n if (vl>>20) == n-1:\n res[(n-1)<<20] = dv+1\n break\n for tl in g[vl]:\n ndv = dv + (vl&mask==0 or tl&mask==0)\n if tl not in res or res[tl] > ndv:\n res[tl] = ndv\n if vl&mask==0 or tl&mask==0:\n q.append((tl,ndv))\n else:\n q.appendleft((tl,ndv))\n\nif (n-1)<<20 in res:\n print((res[(n-1)<<20]//2))\nelse:\n print((-1))\n\n\n\n\n", "import sys\n\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef MI1(): return map(int1, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\nfrom collections import deque\n\ndef solve():\n dist = [inf] * len(to)\n q = deque()\n q.append((0, 0))\n dist[0] = 0\n while q:\n d, i = q.popleft()\n if d > dist[i]: continue\n if i < n:\n for j in to[i]:\n if dist[j] <= d + 1: continue\n dist[j] = d + 1\n q.append((d + 1, j))\n else:\n for j in to[i]:\n if j == n - 1:\n print(dist[i])\n return\n if dist[j] <= d: continue\n dist[j] = d\n q.appendleft((d, j))\n print(-1)\n\ninf=10**9\nn,m=MI()\nto=[]\nuctoi={}\n\nfor u in range(n):\n to.append([])\n uctoi[u,0]=u\n\nfor _ in range(m):\n u,v,c=MI()\n u,v=u-1,v-1\n if (u,c) not in uctoi:\n i=uctoi[u,c]=len(to)\n to.append([])\n to[i].append(u)\n to[u].append(i)\n else:i=uctoi[u,c]\n if (v,c) not in uctoi:\n j=uctoi[v,c]=len(to)\n to.append([])\n to[j].append(v)\n to[v].append(j)\n else:j=uctoi[v,c]\n to[i].append(j)\n to[j].append(i)\n#print(to)\n#print(fin)\n\nsolve()\n", "import heapq\n\nINF = 1000000000\n\n\ndef dijkstra(G, d, s):\n h = []\n d[s] = 0\n heapq.heappush(h, (0, s))\n\n while len(h) != 0:\n p = heapq.heappop(h)\n v = p[1]\n if d[v] < p[0]:\n continue\n for e in G[v]:\n if d[e[0]] > d[v] + e[1]:\n d[e[0]] = d[v] + e[1]\n heapq.heappush(h, (d[e[0]], e[0]))\n\n\ndef main():\n N, M = list(map(int, input().split()))\n p = [0] * M\n q = [0] * M\n c = [0] * M\n for i in range(M):\n p[i], q[i], c[i] = list(map(int, input().split()))\n p[i] -= 1\n q[i] -= 1\n plat = []\n for i in range(N):\n plat.append(dict())\n v_count = 0\n for i in range(M):\n p1 = plat[p[i]]\n if not c[i] in p1:\n p1[c[i]] = v_count\n v_count += 1\n p2 = plat[q[i]]\n if not c[i] in p2:\n p2[c[i]] = v_count\n v_count += 1\n for i in range(N):\n plat[i][-1] = v_count\n v_count += 1\n\n G = [[] for _ in range(v_count)]\n for i in range(M):\n p1 = plat[p[i]][c[i]]\n q1 = plat[q[i]][c[i]]\n G[p1].append((q1, 0))\n G[q1].append((p1, 0))\n for i in range(N):\n out = plat[i][-1]\n for v in list(plat[i].values()):\n if v == -1:\n continue\n G[v].append((out, 0))\n G[out].append((v, 1))\n\n start = plat[0][-1]\n goal = plat[N - 1][-1]\n\n d = [INF for _ in range(v_count)]\n\n dijkstra(G, d, start)\n\n if d[goal] == INF:\n print((-1))\n else:\n print((d[goal]))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "from collections import defaultdict, deque\n\nN, M = list(map(int, input().split()))\nD = {}\nEdges = []\n\n\nclass UnionFind:\n def __init__(self, n):\n self.par = [i for i in range(n)]\n self.rank = [0] * n\n\n # \u691c\u7d22\n def find(self, x):\n if self.par[x] == x:\n return x\n else:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n\n # \u4f75\u5408\n def union(self, x, y):\n x = self.find(x)\n y = self.find(y)\n\n if x == y:\n return\n\n if self.rank[x] < self.rank[y]:\n self.par[x] = y\n else:\n self.par[y] = x\n if self.rank[x] == self.rank[y]:\n self.rank[x] += 1\n\n # \u3059\u3079\u3066\u306e\u9802\u70b9\u306b\u5bfe\u3057\u3066\u89aa\u3092\u691c\u7d22\u3059\u308b\n def all_find(self):\n for n in range(len(self.par)):\n self.find(n)\n\n\nUF = UnionFind(M)\nfor i in range(M):\n p, q, c = list(map(int, input().split()))\n p, q = p-1, q-1\n Edges.append((p, q))\n\n if (p, c) in D:\n UF.union(D[p, c], i)\n D[p, c] = i\n\n if (q, c) in D:\n UF.union(D[q, c], i)\n D[q, c] = i\n\nUF.all_find()\n\nFirm_Node = defaultdict(set)\nfor i in range(M):\n p, q = Edges[i]\n Firm_Node[UF.par[i]].add(p)\n Firm_Node[UF.par[i]].add(q)\n\nG = defaultdict(list)\nfor firm, node in list(Firm_Node.items()):\n for n in node:\n G[n].append(firm + N)\n G[firm + N].append(n)\n\n\ndef dijkstra(x):\n d = {x: 0, N-1: 10**9}\n visited = {x}\n\n # d, u\n queue = deque([(0, x)])\n\n while queue:\n u = queue.pop()[1]\n visited.add(u)\n\n for node in G[u]:\n d.setdefault(node, float('inf'))\n if (node not in visited) and d[node] > d[u] + 1:\n d[node] = d[u] + 1\n if d[N-1] < 10**9:\n return d\n queue.appendleft([d[u]+1, node])\n return d\n\n\ndist = dijkstra(0)\nprint((dist[N-1] // 2 if dist[N-1] < 2*M else -1))\n", "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10**9)\nfrom collections import deque, defaultdict\nN, M = list(map(int, input().split()))\nG = defaultdict(list)\nfor _ in range(M):\n p, q, c = list(map(int, input().split()))\n G[(p-1, c-1)].append((p-1, -1))\n G[(q-1, c-1)].append((q-1, -1))\n G[(p-1, -1)].append((p-1, c-1))\n G[(q-1, -1)].append((q-1, c-1))\n G[(p-1, c-1)].append((q-1, c-1))\n G[(q-1, c-1)].append((p-1, c-1))\n\n\ndist = defaultdict(lambda :-1)\nque = deque([(0, -1)])\ndist[(0, -1)] = 0\nwhile que:\n v = que.pop()\n d = dist[v]\n for nv in G[v]:\n if dist[nv]<0:\n if nv[1] == -1:\n dist[nv] = d+1\n que.appendleft(nv)\n else:\n dist[nv] = d\n que.append(nv)\nprint((dist[(N-1, -1)]))\n\n\n\n", "import sys\nfrom collections import defaultdict,deque\n\ndef main():\n input = sys.stdin.readline\n n,m = map(int,input().split())\n #+\u8def\u7dda*chg : \u305d\u306e\u8def\u7dda\u30db\u30fc\u30e0\n chg = 10**6\n\n edge=defaultdict(set)\n used =defaultdict(bool)\n for i in range(m):\n p,q,c = map(int,input().split())\n edge[p].add(p+c*chg)\n edge[p+c*chg].add(p)\n edge[p+c*chg].add(q+c*chg)\n edge[q+c*chg].add(p+c*chg)\n edge[q].add(q+c*chg)\n edge[q+c*chg].add(q)\n used[p] = False\n used[q] = False\n used[p+c*chg] = False\n used[q+c*chg] = False\n\n edgelist = deque()\n edgelist.append((1,0))\n res = float(\"inf\")\n while len(edgelist):\n x,cost = edgelist.pop()\n used[x] = True\n\n if x == n:\n res = cost\n break\n for e in edge[x]:\n if used[e]:\n continue\n #\u884c\u5148\u304c\u6539\u672d\n if x <= 10**5 and chg <= e:\n edgelist.appendleft((e,cost+1))\n else:\n edgelist.append((e,cost))\n \n if res == float(\"inf\"):\n print(-1)\n else:\n print(res)\ndef __starting_point():\n main()\n__starting_point()", "import sys\nfrom collections import defaultdict,deque\ninput = sys.stdin.readline\nn,m = map(int,input().split())\n#+\u8def\u7dda*chg : \u305d\u306e\u8def\u7dda\u30db\u30fc\u30e0\nchg = 10**6\n\nedge=defaultdict(set)\nused =defaultdict(bool)\nfor i in range(m):\n p,q,c = map(int,input().split())\n edge[p].add(p+c*chg)\n edge[p+c*chg].add(p)\n edge[p+c*chg].add(q+c*chg)\n edge[q+c*chg].add(p+c*chg)\n edge[q].add(q+c*chg)\n edge[q+c*chg].add(q)\n used[p] = False\n used[q] = False\n used[p+c*chg] = False\n used[q+c*chg] = False\n\nedgelist = deque()\nedgelist.append((1,0))\nres = float(\"inf\")\nwhile len(edgelist):\n x,cost = edgelist.pop()\n used[x] = True\n\n if x == n:\n res = cost\n break\n for e in edge[x]:\n if used[e]:\n continue\n #\u884c\u5148\u304c\u6539\u672d\n if x <= 10**5 and chg <= e:\n edgelist.appendleft((e,cost+1))\n else:\n edgelist.append((e,cost))\n \nif res == float(\"inf\"):\n print(-1)\nelse:\n print(res)", "import sys\nstdin = sys.stdin\n \nsys.setrecursionlimit(10**7) \n \ndef li(): return list(map(int, stdin.readline().split()))\ndef li_(): return [int(x)-1 for x in stdin.readline().split()]\ndef lf(): return list(map(float, stdin.readline().split()))\ndef ls(): return stdin.readline().split()\ndef ns(): return stdin.readline().rstrip()\ndef lc(): return list(ns())\ndef ni(): return int(stdin.readline())\ndef nf(): return float(stdin.readline())\n\nfrom collections import deque, defaultdict\n\nn,m = li()\nmod = 10**7\n\ntable = defaultdict(set)\nvisit = defaultdict(int)\n\nfor i in range(m):\n a,b,c = li()\n \n table[a].add(a + c*mod)\n table[b].add(b + c*mod)\n table[a + c*mod].add(a)\n table[b + c*mod].add(b)\n table[a + c*mod].add(b + c*mod)\n table[b + c*mod].add(a + c*mod)\n \n visit[a] = 0\n visit[b] = 0\n visit[b + c*mod] = 0\n visit[a + c*mod] = 0\n \nque = deque()\nque.append((1,0))\n\nvisit[1] = 1\nans = mod\n\nwhile que:\n x, cost = que.popleft()\n visit[x] = 1\n \n if x == n:\n ans = min(ans, cost)\n break\n \n for y in table[x]:\n if visit[y] == 1:\n continue\n \n if x <= 10**5 and mod <= y:\n que.append((y, cost+1))\n \n else:\n que.appendleft((y, cost))\n \nprint((-1 if ans == mod else ans))\n", "from collections import deque\n\nN, M = map(int, input().split())\nF_C_of_S = [{} for i in range(N)]\n# Companies of Station\nC_of_S = {}\n\n# def Union-find\nparent = [-1]*M\ndef root(x):\n if (parent[x] < 0): return x\n else:\n parent[x] = y = root(parent[x])\n return y\n\ndef unite(x, y):\n px = root(x); py = root(y);\n if (px == py): return False\n if (parent[px] > parent[py]):\n px = root(y); py = root(x);\n parent[px] += parent[py]\n parent[py] = px\n return True\n\n# Union-find\npqcs = []\nfor i in range(M):\n p, q, c = map(int, input().split())\n p -= 1; q -= 1;\n pqcs += [(p, q, c)]\n # The first\n if not c in F_C_of_S[p]:\n F_C_of_S[p][c] = i\n # else\n else:\n unite(F_C_of_S[p][c], i)\n C_of_S.setdefault(p, set()).add(c)\n # The first\n if not (c in F_C_of_S[q]):\n F_C_of_S[q][c] = i\n # else\n else:\n unite(F_C_of_S[q][c], i)\n C_of_S.setdefault(q, set()).add(c)\n\n# stations of company\nS_of_C = {}\nfor i in range(M):\n p, q, c = pqcs[i]\n c_set = S_of_C.setdefault(root(i), set())\n c_set.add(p); c_set.add(q);\n\nQ = deque([(0, 0, 0)])\n# cost to go to the stations from station_0\ndist = [float('inf')] * N\ndist[0] = 0\n\ngdist = [float('inf')] * M\n\nwhile Q:\n cost, v, flag = Q.popleft()\n if not (flag): # (flag == 0) then gdist_update\n for l in F_C_of_S[v].values():\n l = root(l)\n if (cost < gdist[l]):\n gdist[l] = cost\n Q.appendleft((cost, l, 1))\n else: # (flag == 1) then dist_update\n for s in S_of_C[v]:\n if (cost + 1 < dist[s]):\n dist[s] = cost + 1\n Q.append((cost + 1, s, 0))\n\nprint(dist[N - 1] if dist[N - 1] < float('inf') else -1)", "from collections import defaultdict,deque\nimport sys\nsys.setrecursionlimit(10**6)\ninput=sys.stdin.readline\nN,M=list(map(int,input().split()))\nif M==0:\n print((-1))\n return\nG=defaultdict(set)\nfor i in range(M):\n a,b,c=list(map(int,input().split()))\n G[a+(c<<30)].add(b+(c<<30))\n G[b+(c<<30)].add(a+(c<<30))\n G[a].add(a+(c<<30))\n G[b].add(b+(c<<30))\n G[a+(c<<30)].add(a)\n G[b+(c<<30)].add(b)\ndef BFS(x):\n d={}\n for k in list(G.keys()):\n d[k]=float(\"inf\")\n stack=deque([(x,0)])\n if x not in d:\n return -1\n while stack:\n s,m=stack.popleft()\n if s==N:\n return m\n if d[s]>m:\n d[s]=m\n if s>=(1<<30):\n for i in G[s]:\n if d[i]>10**30:\n stack.appendleft((i,m))\n else: \n for i in G[s]:\n if d[i]>10**30:\n stack.append((i,m+1))\n return -1\n\nprint((BFS(1)))\n\n\n\n \n \n", "import sys\ninput=sys.stdin.readline\nfrom collections import defaultdict\nfrom heapq import heappush, heappop,heappushpop,heapify\nn,m = map(int, input().split())\nlink = defaultdict(list)\nchg=10**8\nfor _ in range(m):\n p,q,c=map(int, input().split())\n link[p].append([p+chg*c,1])\n link[p+chg*c].append([p,1])\n\n link[q+chg*c].append([p+chg*c,0])\n link[p+chg*c].append([q+chg*c,0])\n\n link[q+chg*c].append([q,1])\n link[q].append([q+chg*c,1])\n\ndef dks(g,start):\n INF=float('inf')\n visited = set()\n hq = []\n heappush(hq, (0,start))\n while hq:\n shortest, i = heappop(hq)\n if i in visited:\n continue\n visited.add(i)\n for j, t in g[i]:\n if j in visited:\n continue\n if j==n:\n return (shortest+t)//2\n heappush(hq, (shortest + t, j))\n return -1\nans=dks(link,1)\nprint(ans)", "import sys\ninput = sys.stdin.readline\nfrom collections import defaultdict\n\n\"\"\"\n(\u99c5\u3001\u4f1a\u793e)\u3092\u9802\u70b9\u306b\u30b0\u30e9\u30d5\u3092\u6301\u3064\u3002\u9802\u70b9\u6570O(M)\u3002\n\u305d\u306e\u307e\u307e\u8fba\u3092\u8cbc\u308b\u3068\u8fba\u304c\u591a\u304f\u306a\u308a\u3059\u304e\u308b\u3002\n(\u99c5\u3001\u4f1a\u793e) -> (\u99c5\u3001\u7121\u5c5e\u6027) -> (\u99c5\u3001\u4f1a\u793e)\n\"\"\"\n\nL = 32\nmask = (1 << L) - 1\nN,M = map(int,input().split())\ngraph = defaultdict(list)\nfor _ in range(M):\n p,q,c = map(int,input().split())\n p <<= L\n q <<= L\n graph[p].append(p+c)\n graph[p+c].append(p)\n graph[q].append(q+c)\n graph[q+c].append(q)\n graph[p+c].append(q+c)\n graph[q+c].append(p+c)\n\nINF = 10 ** 9\ndist = defaultdict(lambda: INF)\n\nstart = 1 << L\ngoal = N << L\n\nq = [start] # 0 \u304c\u4f1a\u793e\u306b\u5c5e\u3057\u3066\u3044\u306a\u3044\u72b6\u614b\ndist[start] = 0\nd = 0\nq0 = []\nq1 = []\nwhile q:\n for x in q:\n if x & mask == 0:\n for y in graph[x]:\n if dist[y] <= d + 1:\n continue\n dist[y] = d + 1\n q1.append(y)\n else:\n for y in graph[x]:\n if dist[y] <= d:\n continue\n dist[y] = d\n q0.append(y)\n if q0:\n q = q0\n q0 = []\n continue\n q = q1\n q1 = []\n d += 1\n\nanswer = dist[goal]\nif answer == INF:\n answer = -1\nprint(answer)", "def main():\n import sys\n from collections import deque\n input = sys.stdin.readline\n\n N, M = list(map(int, input().split()))\n adj = [[] for _ in range(N+1)]\n c2v = {}\n v = N+1\n for _ in range(M):\n p, q, c = list(map(int, input().split()))\n P = p*(10**7) + c\n Q = q*(10**7) + c\n if P not in c2v:\n c2v[P] = v\n adj[p].append((v, 1))\n adj.append([(p, 1)])\n v += 1\n if Q not in c2v:\n c2v[Q] = v\n adj[q].append((v, 1))\n adj.append([(q, 1)])\n v += 1\n adj[c2v[P]].append((c2v[Q], 0))\n adj[c2v[Q]].append((c2v[P], 0))\n\n que = deque()\n que.append(1)\n seen = [-1] * len(adj)\n seen[1] = 0\n while que:\n v = que.popleft()\n for u, cost in adj[v]:\n if seen[u] == -1:\n seen[u] = seen[v] + cost\n if cost:\n que.append(u)\n else:\n que.appendleft(u)\n print((seen[N] // 2))\n\n\ndef __starting_point():\n main()\n\n__starting_point()", "#!/usr/bin python3\n# -*- coding: utf-8 -*-\n\n# https://atcoder.jp/contests/arc061/tasks/arc061_c\n\n########################################################\n# 01BFS\n########################################################\n\nfrom collections import deque\n\nn, m = list(map(int, input().split()))\nab = set([])\nps = set([i<<20 for i in range(1, n+1)])\n\nfor _ in range(m):\n a, b, c = list(map(int, input().split()))\n a <<= 20\n b <<= 20\n ps.add(a+c)\n ps.add(b+c)\n ab.add((a, b, c))\n\n\npsr = {ps:i for i, ps in enumerate(ps)}\npsc = len(ps)\ngmap = [[] for _ in range(psc)]\nfor a, b, c in ab:\n a0 = psr[a]\n b0 = psr[b]\n a1 = psr[a+c]\n b1 = psr[b+c]\n gmap[a0].append((a1, 1))\n gmap[b0].append((b1, 1))\n gmap[a1].append((a0, 0))\n gmap[b1].append((b0, 0))\n gmap[a1].append((b1, 0))\n gmap[b1].append((a1, 0))\n\nINF = float('inf')\ndist = [INF] * psc\n\ndef zero_one_bfs(sp, gp):\n next_q = deque([])\n next_q.append(sp)\n dist[sp] = 0\n while next_q:\n cp = next_q.popleft()\n cd = dist[cp]\n if cp == gp: return cd\n for np, pay in gmap[cp]:\n if dist[np] <= cd+pay: continue\n dist[np] = cd + pay\n if pay == 1:\n next_q.append(np)\n else:\n next_q.appendleft(np)\n return dist[gp]\n\nret = zero_one_bfs(psr[1<<20], psr[n<<20])\nprint((-1 if ret == INF else ret))\n", "N, M = list(map(int, input().split()))\nES = []\nD = [{} for i in range(N)]\n\n*parent, = list(range(M))\ndef root(x):\n if x == parent[x]:\n return x\n parent[x] = y = root(parent[x])\n return y\ndef unite(x, y):\n px = root(x); py = root(y)\n if px < py:\n parent[py] = px\n else:\n parent[px] = py\n\nE = {}\nfor i in range(M):\n p, q, c = list(map(int, input().split())); p -= 1; q -= 1\n ES.append((p, q, c))\n if c in D[p]:\n unite(D[p][c], i)\n else:\n D[p][c] = i\n E.setdefault(p, set()).add(c)\n if c in D[q]:\n unite(D[q][c], i)\n else:\n D[q][c] = i\n E.setdefault(q, set()).add(c)\nP = {}\nfor i in range(M):\n p, q, c = ES[i]\n s = P.setdefault(root(i), set())\n s.add(p); s.add(q)\n\nfrom collections import deque\nque = deque([(0, 0, 0)])\nINF = 10**18\ndist = [INF]*N\ndist[0] = 0\ngdist = [INF]*M\n\nwhile que:\n cost, v, t = que.popleft()\n if t:\n # edge\n if gdist[v] < cost or v not in P:\n continue\n for w in P[v]:\n if cost + 1 < dist[w]:\n dist[w] = cost + 1\n que.append((cost + 1, w, 0))\n else:\n # node\n if dist[v] < cost or v not in E:\n continue\n for w in list(D[v].values()):\n w = root(w)\n if cost < gdist[w]:\n gdist[w] = cost\n que.appendleft((cost, w, 1))\n\nprint((dist[N-1] if dist[N-1] < INF else -1))\n", "from collections import *\nimport sys \nsys.setrecursionlimit(10 ** 9)\n\ndef solve():\n def dfs(u, f):\n G[u].append(f)\n G1[f].append(u)\n for v in g[u]:\n if v not in used:\n used.add(v)\n dfs(v, f)\n\n n, m = list(map(int, input().split()))\n edges = []\n for _ in range(m):\n edges.append(list(map(int, input().split())))\n edges.sort(key = lambda item: item[2])\n G = defaultdict(list)#\u8bb0\u5f55\u6bcf\u4e2a\u70b9\u53ef\u80fd\u5728\u54ea\u4e2a\u5206\u7ec4\u91cc\u9762\n G1 = defaultdict(list) #\u8bb0\u5f55\u6bcf\u4e2a\u5206\u7ec4\u91cc\u9762\u7684\u70b9\n en = 0\n cnt = 0\n while en < len(edges):\n st = en \n g = defaultdict(list)\n used = set()\n while en < len(edges) and edges[en][2] == edges[st][2]:\n x, y = edges[en][0], edges[en][1]\n g[x].append(y)\n g[y].append(x)\n en += 1\n for k in g:\n if k not in used:\n used.add(k)\n dfs(k, cnt)\n cnt += 1\n \n usedG = set()\n usedP = set()\n deq = deque()\n deq.append(1)\n usedP.add(1)\n step = 0\n while deq:\n siz = len(deq)\n for _ in range(siz):\n f = deq.popleft()\n if f == n:\n print(step)\n return \n for g in G[f]:\n if g not in usedG:\n usedG.add(g)\n for p in G1[g]:\n if p not in usedP:\n usedP.add(p)\n deq.append(p)\n step += 1\n \n print((-1))\n\nsolve()\n\n", "def dijkstra_heap(s,edge,mask):\n dist = defaultdict(lambda: float(\"inf\"))\n q = [s] # 0 \u304c\u4f1a\u793e\u306b\u5c5e\u3057\u3066\u3044\u306a\u3044\u72b6\u614b\n dist[s] = 0\n d = 0; q0 = []; q1 = []\n while q:\n for x in q:\n if x & mask == 0:\n for y in edge[x]:\n if dist[y[1]] <= d + y[0]:\n continue\n dist[y[1]] = d + y[0]\n q1.append(y[1])\n else:\n for y in edge[x]:\n if dist[y[1]] <= d+ y[0]:\n continue\n dist[y[1]] = d+ y[0]\n q0.append(y[1])\n if q0:\n q = q0\n q0 = []\n continue\n q = q1\n q1 = []\n d += 1\n return dist\n\ndef examE(inf):\n N, M = LI()\n edge = defaultdict(list)\n # edge[i] : i\u304b\u3089\u51fa\u308b\u9053\u306e[\u91cd\u307f,\u884c\u5148]\u306e\u914d\u5217\n L = 32\n Mask = (1 << L) - 1\n for i in range(M):\n p, q, c = list(map(int, input().split()))\n p -=1; q -=1\n p <<= L\n q <<= L\n #\u540c\u3058\u8def\u7dda\u3060\u3068\u30b3\u30b9\u30c8\uff10 \u4e57\u308b\u3068\u304d\u3060\u3051\u30b3\u30b9\u30c8\uff11\n edge[p].append((1,p + c))\n edge[p + c].append((0,p))\n edge[q].append((1,q + c))\n edge[q + c].append((0,q))\n edge[p + c].append((0,q + c))\n edge[q + c].append((0,p + c))\n start = 0\n goal = (N-1) << L\n res = dijkstra_heap(start, edge, Mask)\n# print(res)\n ans = res[goal]\n if ans == inf:\n ans = -1\n print(ans)\n\n\nimport sys,copy,bisect,itertools,heapq,math\nfrom heapq import heappop,heappush,heapify\nfrom collections import Counter,defaultdict,deque\ndef I(): return int(sys.stdin.readline())\ndef LI(): return list(map(int,sys.stdin.readline().split()))\ndef LS(): return sys.stdin.readline().split()\ndef S(): return sys.stdin.readline().strip()\nmod = 10**9 + 7\ninf = float('inf')\n\nexamE(inf)\n", "def main():\n N,M=map(int,input().split())\n\n if M == 0:\n print(-1)\n return\n\n INF = 10**6\n pqc = [tuple(map(lambda x:int(x)-1,input().split())) for _ in range(M)]\n\n to1d={v:{} for v in range(N)}\n count=2\n for p,q,c in pqc:\n if not to1d[p].get(c):\n to1d[p][c] = count\n count += 1\n if not to1d[q].get(c):\n to1d[q][c] = count\n count += 1\n\n G = [{} for _ in range(N+count)]\n for p,q,c in pqc:\n v1,v2 = to1d[p][c],to1d[q][c]\n G[v1][v2] = G[v2][v1] = 0\n\n for i in range(N):\n if len(to1d[i])<=1: continue\n for c in to1d[i].keys():\n v = to1d[i][c]\n G[v][count] = 1\n G[count][v] = 0\n count += 1\n\n def dijkstra(start = 0, goal = 1):\n from heapq import heappop, heappush\n NN = len(G)\n d = [INF]*NN\n d[start] = 0\n que = []\n heappush(que, start)\n while que:\n p = divmod(heappop(que),NN)\n v = p[1]\n if d[v] < p[0]: continue\n for u in G[v].keys():\n if d[u] > d[v] + G[v][u]:\n d[u] = d[v] + G[v][u]\n heappush(que, d[u]*NN+u)\n if v == goal: return d[goal]\n return d[goal]\n\n for c in to1d[0].keys():\n v = to1d[0][c]\n G[0][v] = 1\n for c in to1d[N-1].keys():\n v = to1d[N-1][c]\n G[v][1] = 0\n\n ans = dijkstra(0,1)\n print(ans if ans < INF else -1)\n \ndef __starting_point():\n main()\n__starting_point()", "import sys\ninput = sys.stdin.readline\nfrom collections import defaultdict\n\n\"\"\"\n(\u99c5\u3001\u4f1a\u793e)\u3092\u9802\u70b9\u306b\u30b0\u30e9\u30d5\u3092\u6301\u3064\u3002\u9802\u70b9\u6570O(M)\u3002\n\u305d\u306e\u307e\u307e\u8fba\u3092\u8cbc\u308b\u3068\u8fba\u304c\u591a\u304f\u306a\u308a\u3059\u304e\u308b\u3002\n(\u99c5\u3001\u4f1a\u793e) -> (\u99c5\u3001\u7121\u5c5e\u6027) -> (\u99c5\u3001\u4f1a\u793e)\n\"\"\"\n\nL = 32\nmask = (1 << L) - 1\nN,M = map(int,input().split())\ngraph = defaultdict(list)\nfor _ in range(M):\n p,q,c = map(int,input().split())\n p <<= L\n q <<= L\n graph[p].append(p+c)\n graph[p+c].append(p)\n graph[q].append(q+c)\n graph[q+c].append(q)\n graph[p+c].append(q+c)\n graph[q+c].append(p+c)\n\nINF = 10 ** 9\ndist = defaultdict(lambda: INF)\n\nstart = 1 << L\ngoal = N << L\n\nq = [start] # 0 \u304c\u4f1a\u793e\u306b\u5c5e\u3057\u3066\u3044\u306a\u3044\u72b6\u614b\ndist[start] = 0\nd = 0\nwhile q:\n qq = []\n while q:\n x = q.pop()\n if x & mask == 0:\n for y in graph[x]:\n if dist[y] <= d + 1:\n continue\n dist[y] = d + 1\n qq.append(y)\n else:\n for y in graph[x]:\n if dist[y] <= d:\n continue\n dist[y] = d\n q.append(y)\n d += 1\n q = qq\n\nanswer = dist[goal]\nif answer == INF:\n answer = -1\nprint(answer)", "# https://juppy.hatenablog.com/entry/2019/04/10/ARC061_-_E_%E3%81%99%E3%81%AC%E3%81%91%E5%90%9B%E3%81%AE%E5%9C%B0%E4%B8%8B%E9%89%84%E6%97%85%E8%A1%8C_-_Python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0_Atcoder\n# \u53c2\u8003\u306b\u3055\u305b\u3066\u3044\u305f\u3060\u304d\u307e\u3057\u305f\u3002\n\nfrom collections import deque, defaultdict\n\nchg = 10**6\nn, m = map(int, input().split())\nedges = defaultdict(set)\n# m=0\u306e\u305f\u3081\u306bdefaultdict\u306b\u3057\u3066\u304a\u304f\u3079\u304d\nvisited = defaultdict(set)\nfor i in range(m):\n p, q, c = map(int, input().split())\n edges[p+c*chg].add(q+c*chg)\n edges[q+c*chg].add(p+c*chg)\n edges[p].add(p+c*chg)\n edges[q].add(q+c*chg)\n edges[p+c*chg].add(p)\n edges[q+c*chg].add(q)\n visited[p] = False\n visited[q] = False\n visited[p+c*chg] = False\n visited[q+c*chg] = False\n\nans = float(\"inf\")\nque = deque()\n# now, dist\nque.append((1, 0))\n# \u4eca\u6c42\u3081\u308b\u306e\u306fend\u306e\u8ddd\u96e2\u3060\u3051\u306a\u306e\u3067\u3001dist\u914d\u5217\u306f\u3044\u3089\u306a\u3044\n# \u3055\u3089\u306b\u3001\u8ddd\u96e2\u306f0/1\u306a\u306e\u3067heap\u3067\u8fba\u3092\u7ba1\u7406\u3059\u308b\u5fc5\u8981\u3082\u306a\u304f\u30010\u306a\u3089\u6700\u77ed\u78ba\u5b9a\u306a\u306e\u3067\u5148\u306b\u30011\u306a\u3089\u305d\u306e\u6642\u70b9\u3067\u306e\u6700\u9577\u306a\u306e\u3067\u5f8c\u308d\u306b\u3059\u308c\u3070\u826f\u3044\nwhile que:\n now, dist = que.popleft()\n if visited[now]:\n continue\n visited[now] = True\n if now == n:\n ans = dist\n break\n for to in edges[now]:\n # \u99c5\u2192\u30db\u30fc\u30e0\n if now < chg and to > chg:\n que.append((to, dist+1))\n else:\n que.appendleft((to, dist))\nif ans == float(\"inf\"):\n print(-1)\nelse:\n print(ans)", "import sys\ninput = lambda: sys.stdin.readline().rstrip()\nfrom collections import deque\nN, M = map(int, input().split())\nX = []\nC = [set() for _ in range(N)]\nfor _ in range(M):\n p, q, c = [int(a) - 1 for a in input().split()]\n X.append((p, q, c))\n C[p].add(c)\n C[q].add(c)\nfor i, c in enumerate(C):\n C[i] = list(c)\n\nI = [N]\nD = [{} for _ in range(N)]\nfor i, c in enumerate(C):\n for j, a in enumerate(c):\n D[i][a] = I[-1] + j\n I.append(I[-1] + len(c))\n\nT = I[-1]\nE = [[] for _ in range(T)]\nfor p, q, c in X:\n E[D[p][c]].append((D[q][c], 0))\n E[D[q][c]].append((D[p][c], 0))\nfor i, c in enumerate(C):\n for j, a in enumerate(c):\n E[i].append((D[i][a], 1))\n E[D[i][a]].append((i, 1))\n\ndef BFS01(n, E, i0=0):\n Q = deque([i0])\n D = [-1] * n\n D[i0] = 0\n while Q:\n x = Q.popleft()\n for y, w in E[x]:\n if D[y] == -1:\n if w:\n D[y] = D[x] + 1\n Q.append(y)\n else:\n D[y] = D[x]\n Q.appendleft(y)\n return D\n\nD = BFS01(T, E, 0)\nprint(D[N-1] // 2)", "import sys, heapq\nfrom collections import defaultdict\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nclass DijkstraList():\n\t#\u96a3\u63a5\u30ea\u30b9\u30c8\u7248\n\t#\u540c\u4e00\u9802\u70b9\u306e\u8907\u6570\u56de\u63a2\u7d22\u3092\u9632\u3050\u305f\u3081\u8a2a\u554f\u3057\u305f\u9802\u70b9\u6570\u3092\u5909\u6570cnt\u3067\u6301\u3064\n\tdef __init__(self, adj, start):\n\t\tself.list = adj\n\t\tself.start = start\n\t\tself.size = len(adj)\n\n\tdef solve(self):\n\t\t#self.dist = [float(\"inf\") for _ in range(self.size)]\n\t\tself.dist = defaultdict(lambda :10**30)\n\t\tself.dist[self.start] = 0\n\t\t#self.prev = [-1 for _ in range(self.size)]\n\t\tself.q = []\n\t\tself.cnt = 0\n\n\t\theapq.heappush(self.q, (0, self.start))\n\n\t\twhile self.q and self.cnt < self.size:\n\t\t\tu_dist, u = heapq.heappop(self.q)\n\t\t\tif self.dist[u] < u_dist:\n\t\t\t\tcontinue\n\t\t\tfor v, w in self.list[u]:\n\t\t\t\tif self.dist[v] > u_dist + w:\n\t\t\t\t\tself.dist[v] = u_dist + w\n\t\t\t\t\t#self.prev[v] = u\n\t\t\t\t\theapq.heappush(self.q, (self.dist[v], v))\n\t\t\tself.cnt += 1\n\t\treturn\n\n\tdef distance(self, goal):\n\t\treturn self.dist[goal]\n\nn, m = map(int, input().split())\ncost = [10**30 for _ in range(n)]\nedges = defaultdict(list)\nfor _ in range(m):\n\tp, q, t = map(int, input().split())\n\tedges[p-1 + t * n].append((q-1 + t * n, 0))\n\tedges[q-1 + t * n].append((p-1 + t * n, 0))\n\tif len(edges[p-1 + t * n]) == 1:\n\t\tedges[p-1 + t * n].append((p-1 + 0 * n, 0))\n\t\tedges[p-1 + 0 * n].append((p-1 + t * n, 1))\n\tif len(edges[q-1 + t * n]) == 1:\n\t\tedges[q-1 + t * n].append((q-1 + 0 * n, 0))\n\t\tedges[q-1 + 0 * n].append((q-1 + t * n, 1))\n\nd = DijkstraList(edges, 0)\nd.solve()\nres = d.distance(n-1)\nif res > 10**20:\n\tprint(-1)\nelse:\n\tprint(res)", "class UnionFindVerSize():\n def __init__(self,init):\n \"\"\" N\u500b\u306e\u30ce\u30fc\u30c9\u306eUnion-Find\u6728\u3092\u4f5c\u6210\u3059\u308b \"\"\"\n # \u89aa\u306e\u756a\u53f7\u3092\u683c\u7d0d\u3059\u308b\u3002\u81ea\u5206\u304c\u89aa\u3060\u3063\u305f\u5834\u5408\u306f\u3001\u81ea\u5206\u306e\u756a\u53f7\u306b\u306a\u308a\u3001\u305d\u308c\u304c\u305d\u306e\u30b0\u30eb\u30fc\u30d7\u306e\u756a\u53f7\u306b\u306a\u308b\n self._parent = [n for n in range(0, len(init))]\n # \u30b0\u30eb\u30fc\u30d7\u306e\u30b5\u30a4\u30ba\uff08\u500b\u6570\uff09\n self._size = [1] * len(init)\n self._dict ={key:0 for key in init}\n for i in range(len(init)):\n v=init[i]\n self._dict[v]=i\n\n def find_root(self, x,key):\n \"\"\" x\u306e\u6728\u306e\u6839(x\u304c\u3069\u306e\u30b0\u30eb\u30fc\u30d7\u304b)\u3092\u6c42\u3081\u308b \"\"\"\n if key==1:\n x=self._dict[x]\n if self._parent[x] == x: return x\n self._parent[x] = self.find_root(self._parent[x],0) # \u7e2e\u7d04\n return self._parent[x]\n\n def unite(self, x, y):\n \"\"\" x\u3068y\u306e\u5c5e\u3059\u308b\u30b0\u30eb\u30fc\u30d7\u3092\u4f75\u5408\u3059\u308b \"\"\"\n x=self._dict[x]\n y=self._dict[y]\n gx = self.find_root(x,0)\n gy = self.find_root(y,0)\n if gx == gy: return\n\n # \u5c0f\u3055\u3044\u65b9\u3092\u5927\u304d\u3044\u65b9\u306b\u4f75\u5408\u3055\u305b\u308b\uff08\u6728\u306e\u504f\u308a\u304c\u6e1b\u308b\u306e\u3067\uff09\n if self._size[gx] < self._size[gy]:\n self._parent[gx] = gy\n self._size[gy] += self._size[gx]\n else:\n self._parent[gy] = gx\n self._size[gx] += self._size[gy]\n\n def get_size(self, x):\n x=self._dict[x]\n \"\"\" x\u304c\u5c5e\u3059\u308b\u30b0\u30eb\u30fc\u30d7\u306e\u30b5\u30a4\u30ba\uff08\u500b\u6570\uff09\u3092\u8fd4\u3059 \"\"\"\n return self._size[self.find_root(x,0)]\n\n def is_same_group(self, x, y):\n x=self._dict[x]\n y=self._dict[y]\n \"\"\" x\u3068y\u304c\u540c\u3058\u96c6\u5408\u306b\u5c5e\u3059\u308b\u304b\u5426\u304b \"\"\"\n return self.find_root(x,0) == self.find_root(y,0)\n\n def calc_group_num(self):\n \"\"\" \u30b0\u30eb\u30fc\u30d7\u6570\u3092\u8a08\u7b97\u3057\u3066\u8fd4\u3059 \"\"\"\n N = len(self._parent)\n ans = 0\n for i in range(N):\n if self.find_root(i,0) == i:\n ans += 1\n return ans\n\nimport sys\n\ninput=sys.stdin.readline\n\nN,M=map(int,input().split())\ncompany={}\ncedge={}\nnode=N\nedge={i:[] for i in range(N)}\nfor i in range(M):\n u,v,c=map(int,input().split())\n edge[u-1].append((v-1,1))\n edge[v-1].append((u-1,1))\n if c-1 not in company:\n company[c-1]=[]\n cedge[c-1]=[]\n company[c-1].append(u-1)\n company[c-1].append(v-1)\n cedge[c-1].append((u-1,v-1))\n\nfor i in company:\n uf=UnionFindVerSize(company[i])\n for u,v in cedge[i]:\n uf.unite(u,v)\n data={}\n for v in company[i]:\n p=uf.find_root(v,1)\n if p not in data:\n data[p]=[]\n data[p].append(v)\n for p in data:\n edge[node]=[]\n for v in data[p]:\n edge[v].append((node,0))\n edge[node].append((v,1))\n node+=1\n\nfrom collections import deque\ndist=[10**20]*node\ndist[0]=0\nque=deque([(0,0)])\nwhile que:\n v,d=que.popleft()\n for nv,c in edge[v]:\n if dist[nv]>d+c:\n if c==1:\n dist[nv]=d+c\n que.append((nv,d+c))\n else:\n dist[nv]=d+c\n que.appendleft((nv,d+c))\n\n\nans=dist[N-1]\nprint(ans if ans!=10**20 else -1)", "import sys\ninput = sys.stdin.readline\nfrom collections import defaultdict, deque\n\nn, m = map(int, input().split())\nG = defaultdict(set)\nU = 10**6\nseen = set()\nfor _ in range(m):\n p, q, c = map(int, input().split())\n G[p+U*c].add((q+U*c, 0))\n G[q+U*c].add((p+U*c, 0))\n G[p+U*c].add((p-U, 0))\n G[q+U*c].add((q-U, 0))\n G[p-U].add((p+U*c, 1))\n G[q-U].add((q+U*c, 1))\nque = deque()\nque.append((1-U, 0))\nwhile que:\n v, cnt = que.popleft()\n if v in seen:\n continue\n if v == n-U:\n print(cnt)\n return\n seen.add(v)\n for nv, cost in G[v]:\n if cost == 0:\n que.appendleft((nv, cnt+cost))\n else:\n que.append((nv, cnt+cost))\nprint(-1)", "import sys\ninput=sys.stdin.readline\nfrom collections import defaultdict,deque\nn,m=map(int,input().split())\nroute=10**6\nEdges=defaultdict(set)\nVisited=defaultdict(bool)\nfor _ in range(m):\n p,q,c=map(int,input().split())\n Edges[p].add(p+c*route)\n Edges[p+c*route].add(p)\n Edges[p+c*route].add(q+c*route)\n Edges[q+c*route].add(p+c*route)\n Edges[q].add(q+c*route)\n Edges[q+c*route].add(q)\nq=deque()\nq.append((1,0))\ncost=-1\nwhile q:\n fr,c=q.popleft()\n Visited[fr]=True\n if fr==n:\n cost=c\n break\n for to in Edges[fr]:\n if Visited[to]:\n continue\n if fr<=10**5 and to>route:\n q.append((to,c+1))\n else:\n q.appendleft((to,c))\nprint(cost)", "import sys, heapq\nfrom collections import defaultdict\ndef input():\n\treturn sys.stdin.readline()[:-1]\n\nclass DijkstraList():\n\t#\u96a3\u63a5\u30ea\u30b9\u30c8\u7248\n\t#\u540c\u4e00\u9802\u70b9\u306e\u8907\u6570\u56de\u63a2\u7d22\u3092\u9632\u3050\u305f\u3081\u8a2a\u554f\u3057\u305f\u9802\u70b9\u6570\u3092\u5909\u6570cnt\u3067\u6301\u3064\n\tdef __init__(self, adj, start):\n\t\tself.list = adj\n\t\tself.start = start\n\t\tself.size = len(adj)\n\n\tdef solve(self):\n\t\t#self.dist = [float(\"inf\") for _ in range(self.size)]\n\t\tself.dist = defaultdict(lambda :10**30)\n\t\tself.dist[self.start] = 0\n\t\t#self.prev = [-1 for _ in range(self.size)]\n\t\tself.q = []\n\t\tself.cnt = 0\n\n\t\theapq.heappush(self.q, (0, self.start))\n\n\t\twhile self.q and self.cnt < self.size:\n\t\t\tu_dist, u = heapq.heappop(self.q)\n\t\t\tif self.dist[u] < u_dist:\n\t\t\t\tcontinue\n\t\t\tfor v, w in self.list[u]:\n\t\t\t\tif self.dist[v] > u_dist + w:\n\t\t\t\t\tself.dist[v] = u_dist + w\n\t\t\t\t\t#self.prev[v] = u\n\t\t\t\t\theapq.heappush(self.q, (self.dist[v], v))\n\t\t\tself.cnt += 1\n\t\treturn\n\n\tdef distance(self, goal):\n\t\treturn self.dist[goal]\n\nn, m = map(int, input().split())\ncost = [10**30 for _ in range(n)]\nedges = defaultdict(list)\nfor _ in range(m):\n\tp, q, t = map(int, input().split())\n\tedges[p-1 + t * n].append((q-1 + t * n, 0))\n\tedges[q-1 + t * n].append((p-1 + t * n, 0))\n\tif len(edges[p-1 + t * n]) == 1:\n\t\tedges[p-1 + t * n].append((p-1 + 0 * n, 0))\n\t\tedges[p-1 + 0 * n].append((p-1 + t * n, 1))\n\tif len(edges[q-1 + t * n]) == 1:\n\t\tedges[q-1 + t * n].append((q-1 + 0 * n, 0))\n\t\tedges[q-1 + 0 * n].append((q-1 + t * n, 1))\n\nd = DijkstraList(edges, 0)\nd.solve()\nres = d.distance(n-1)\nif res > 10**20:\n\tprint(-1)\nelse:\n\tprint(res)", "import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools\n\nsys.setrecursionlimit(10**7)\ninf = 10**20\neps = 1.0 / 10**10\nmod = 10**9+7\ndd = [(-1,0),(0,1),(1,0),(0,-1)]\nddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef I(): return int(sys.stdin.readline())\ndef F(): return float(sys.stdin.readline())\ndef S(): return input()\ndef pf(s): return print(s, flush=True)\n\n\nclass UnionFind:\n def __init__(self, size):\n self.table = [-1 for _ in range(size)]\n\n def find(self, x):\n if self.table[x] < 0:\n return x\n else:\n self.table[x] = self.find(self.table[x])\n return self.table[x]\n\n def union(self, x, y):\n s1 = self.find(x)\n s2 = self.find(y)\n if s1 != s2:\n if self.table[s1] <= self.table[s2]:\n self.table[s1] += self.table[s2]\n self.table[s2] = s1\n else:\n self.table[s2] += self.table[s1]\n self.table[s1] = s2\n return True\n return False\n\n def subsetall(self):\n a = []\n for i in range(len(self.table)):\n if self.table[i] < 0:\n a.append((i, -self.table[i]))\n return a\n\n def tall(self):\n d = collections.defaultdict(list)\n for i in range(len(self.table)):\n d[self.find(i)].append(i)\n return d\n\ndef main():\n M = 2**17\n n,m = LI()\n a = [LI() for _ in range(m)]\n e = collections.defaultdict(list)\n for p,q,c in a:\n pc = p+c*M\n qc = q+c*M\n pm = p-M\n qm = q-M\n e[pc].append(qc)\n e[qc].append(pc)\n e[pm].append(pc)\n e[qm].append(qc)\n e[pc].append(pm)\n e[qc].append(qm)\n\n def search():\n d = collections.defaultdict(lambda: inf)\n s = 1-M\n d[s] = 0\n q = []\n heapq.heappush(q, (0, s))\n v = set()\n while len(q):\n k, u = heapq.heappop(q)\n if u in v:\n continue\n v.add(u)\n if u < 0:\n for uv in e[u]:\n if uv in v:\n continue\n vd = k + 1\n if d[uv] > vd:\n d[uv] = vd\n heapq.heappush(q, (vd, uv))\n\n else:\n if u % M == n:\n return k\n\n for uv in e[u]:\n if uv in v:\n continue\n if d[uv] > k:\n d[uv] = k\n heapq.heappush(q, (k, uv))\n\n return -1\n\n return search()\n\n\n\nprint(main())\n", "import sys\ninput = sys.stdin.readline\nfrom collections import defaultdict\n\n\"\"\"\n(\u99c5\u3001\u4f1a\u793e)\u3092\u9802\u70b9\u306b\u30b0\u30e9\u30d5\u3092\u6301\u3064\u3002\u9802\u70b9\u6570O(M)\u3002\n\u305d\u306e\u307e\u307e\u8fba\u3092\u8cbc\u308b\u3068\u8fba\u304c\u591a\u304f\u306a\u308a\u3059\u304e\u308b\u3002\n(\u99c5\u3001\u4f1a\u793e) -> (\u99c5\u3001\u7121\u5c5e\u6027) -> (\u99c5\u3001\u4f1a\u793e)\n\"\"\"\n\nL = 32\nmask = (1 << L) - 1\nN,M = map(int,input().split())\ngraph = defaultdict(list)\nfor _ in range(M):\n p,q,c = map(int,input().split())\n p <<= L\n q <<= L\n graph[p].append(p+c)\n graph[p+c].append(p)\n graph[q].append(q+c)\n graph[q+c].append(q)\n graph[p+c].append(q+c)\n graph[q+c].append(p+c)\n\nINF = 10 ** 9\ndist = defaultdict(lambda: INF)\n\nstart = 1 << L\ngoal = N << L\n\nq = [start] # 0 \u304c\u4f1a\u793e\u306b\u5c5e\u3057\u3066\u3044\u306a\u3044\u72b6\u614b\ndist[start] = 0\nd = 0\nq0 = []\nq1 = []\nwhile q:\n for x in q:\n if x & mask == 0:\n for y in graph[x]:\n if dist[y] <= d + 1:\n continue\n dist[y] = d + 1\n q1.append(y)\n else:\n for y in graph[x]:\n if dist[y] <= d:\n continue\n dist[y] = d\n q0.append(y)\n if q0:\n q = q0\n q0 = []\n continue\n q = q1\n q1 = []\n d += 1\n\nanswer = dist[goal]\nif answer == INF:\n answer = -1\nprint(answer)", "from sys import setrecursionlimit, stderr\nfrom functools import reduce\nfrom itertools import *\nfrom collections import *\nfrom bisect import bisect\nfrom heapq import *\n\ndef read():\n return int(input())\n \ndef reads():\n return [int(x) for x in input().split()]\n\nN, M = reads()\nedges = [[] for _ in range(N)]\nedgesc = defaultdict(lambda: [])\nfor _ in range(M):\n p, q, c = reads()\n p, q = p-1, q-1\n edges[p].append((q, c))\n edges[q].append((p, c))\n edgesc[p, c].append(q)\n edgesc[q, c].append(p)\n\nINF = 1 << 30\ndef dijkstra(edges, s):\n result = defaultdict(lambda: INF)\n result[s, -1] = 0\n que = deque([(0, s, -1)])\n while len(que) > 0:\n (d, u, c) = que.popleft()\n if result[u, c] < d:\n continue\n if c < 0:\n for (t, c2) in edges[u]:\n if d + 1 < result[t, c2]:\n result[t, c2] = d + 1\n que.append((d + 1, t, c2))\n else:\n for t in edgesc[u, c]:\n if d < result[t, c]:\n result[t, c] = d\n que.appendleft((d, t, c))\n if d < result[u, -1]:\n result[u, -1] = d\n que.appendleft((d, u, -1))\n return result\n\ndist = dijkstra(edges, 0)\ntry:\n print(min(d for (u, _), d in dist.items() if u == N-1))\nexcept ValueError:\n print(-1)"] | {"inputs": ["3 3\n1 2 1\n2 3 1\n3 1 2\n", "8 11\n1 3 1\n1 4 2\n2 3 1\n2 5 1\n3 4 3\n3 6 3\n3 7 3\n4 8 4\n5 6 1\n6 7 5\n7 8 5\n", "2 0\n"], "outputs": ["1\n", "2\n", "-1\n"]} | COMPETITION | PYTHON3 | ATCODER.JP | 69,979 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.