001
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
arrx = list(map(int, input().split()))
arry = [0] * n
for j in range(n):
arry[arrx[j] - 1] = j + 1
arr.append(arrx)
arr1.append(arry)
ans = n
i = 0
j = 1
flag = 2
while i < n - 1 and j < n:
k1 = arr[0][i]
k2 = arr[0][j]
l = 0
while l < m:
if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
flag = 1
break
if flag == 1:
break
l += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
i = j
j += 1
flag = 0
else:
j += 1
if flag == 0:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
print(ans)
002
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
temp = [int(x) for x in input().split()]
messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
for k in range(n - 4):
temp = messages[i][k]
if pairs.get(temp, None) != messages[i][k + 1]:
pairs.pop(temp, None)
pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
if key in conn:
continue
val = value
temp = []
temp.append(key)
temp.append(value)
while val in starts:
val = pairs[val]
temp.append(val)
sequences.append(temp)
variants = n
for seq in sequences:
l = len(seq)
variants += l * (l - 1) // 2
print(variants)
003
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1 + 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
004
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
005
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y < r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
006
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [--1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
007
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if not (xa == xb and xc == xd or (ya == yb and yc == yd)):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + a2 * c1
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
008
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + -1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
009
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if not ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
010
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 0
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
011
def main():
n, m = [int(c) for c in input().split()]
if m == 1:
print(n * (n * 1) // 2)
return
testimonies = [[int(c) for c in input().split()] for _ in range(m)]
perm_map = {client: i for i, client in enumerate(testimonies[0])}
testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
counters = []
for t in testimonies:
seq_map = [0] * n
start, i = (0, 1)
seq_map[t[start]] = 1
while i < len(t):
if t[i] - t[i - 1] == 1:
seq_map[t[start]] += 1
else:
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
start = i
seq_map[t[start]] = 1
i += 1
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
counters.append(seq_map)
ans = 0
for i in range(n):
_min = min([cnt[i] for cnt in counters])
ans += _min
print(ans)
def __starting_point():
main()
__starting_point()
012
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
013
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] * d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
014
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start - 1]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
015
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if not c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
016
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 1 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
017
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and g[v][0] != first and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
018
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n - 1):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
019
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 2
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
020
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
021
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[2]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
022
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c - 1] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
023
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
temp = [int(x) for x in input().split()]
messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
for k in range(n - 1):
temp = messages[i][k]
if pairs.get(temp, None) != messages[i][k + 1]:
pairs.pop(temp, None)
pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
if key in conn:
continue
val = value
temp = []
temp.append(key)
temp.append(value)
while val in starts:
val = pairs[val]
temp.append(val)
sequences.append(temp)
variants = n
for seq in sequences:
l = len(seq)
variants += l * (l - 1) // 2
print(variants)
024
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1 - 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
025
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [1] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
026
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 1 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
027
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 4
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
028
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 2
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
029
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1 - 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
030
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
031
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
032
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query + 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
033
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == -1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
034
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx - 1] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
035
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::+1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
036
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i - 1]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = ax * day - ay * dax - bx * day + by * dax
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
037
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(3, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
038
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
039
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [0] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i - 1]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
040
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
arrx = list(map(int, input().split()))
arry = [0] * n
for j in range(n):
arry[arrx[j] - 1] = j + 1
arr.append(arrx)
arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
k1 = arr[0][i]
k2 = arr[0][j]
l = 0
while l < m:
if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
flag = 1
break
if flag == 1:
break
l += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
i = j
j += 1
flag = 0
else:
j += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
print(ans)
041
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
042
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
043
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1 - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
044
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(2, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
045
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
046
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag - 1] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
047
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if not z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
048
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[-2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
049
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if not t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
050
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if not np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
051
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if not c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
052
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(4)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
053
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 5
print(total)
054
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(2, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
055
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1 + 1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
056
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
057
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(3, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
058
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
temp = [int(x) for x in input().split()]
messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
for k in range(n - 1):
temp = messages[i][k]
if pairs.get(temp, None) != messages[i][k + 1]:
pairs.pop(temp, None)
pairs.pop(messages[i][n - 3], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
if key in conn:
continue
val = value
temp = []
temp.append(key)
temp.append(value)
while val in starts:
val = pairs[val]
temp.append(val)
sequences.append(temp)
variants = n
for seq in sequences:
l = len(seq)
variants += l * (l - 1) // 2
print(variants)
059
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
060
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1 - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
061
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x < r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
062
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i - 1][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
063
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 1
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
064
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query - 1] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
065
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try:
import numpy
def dprint(*args, **kwargs):
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId > 0:
dprint('use input', inId)
sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
dprint('use output', outId)
sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
ne[za[i]] = za[i + 1]
ne[za[-1] - 1] = 0
for _ in range(1, M):
za = getIntList()
for i in range(N - 1):
a = za[i]
b = za[i + 1]
if ne[a] != b:
ne[a] = -1
a = za[-1]
if ne[a] != 0:
ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N + 1):
a = ne[i]
if a > 0:
tin[a] = 1
res = 0
for i in range(1, N + 1):
if tin[i]:
continue
n = 0
while i > 0:
n += 1
i = ne[i]
res += n * (n + 1) // 2
print(res)
066
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx - 1] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
067
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
068
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l < x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
069
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 0
for i in range(1, h + 1 - 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
070
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(3)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
071
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v]) - 1):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
072
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 3:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
073
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = -1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
074
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 3]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
075
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
temp = [int(x) for x in input().split()]
messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
for k in range(n - 1 - 1):
temp = messages[i][k]
if pairs.get(temp, None) != messages[i][k + 1]:
pairs.pop(temp, None)
pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
if key in conn:
continue
val = value
temp = []
temp.append(key)
temp.append(value)
while val in starts:
val = pairs[val]
temp.append(val)
sequences.append(temp)
variants = n
for seq in sequences:
l = len(seq)
variants += l * (l - 1) // 2
print(variants)
076
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if xa == xb and xc == xd or (ya == yb and yc == yd):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + a2 * c1
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if y < min(ya, yb) and y > max(ya, yb) and (y < min(yc, yd)) and (y > max(yc, yd)):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
077
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1 - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
078
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 4
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
079
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
080
def solve(seq):
if len(seq) <= 2:
return 1
startings = []
for x in (-1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
081
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 0
break
minbl = minprice[minost][1]
if ost[minbl] > kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
082
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if xa == xb and xc == xd or (ya == yb and yc == yd):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + (a2 + c1)
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd)):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
083
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
084
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - -1
print(ans - sum)
085
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c == '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
086
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
087
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1 + 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
088
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in reversed(range(N))] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
089
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(1, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
090
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
temp = [int(x) for x in input().split()]
messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1 - 1):
pairs[messages[0][k]] = messages[0][k + 1]
for i in range(1, m):
for k in range(n - 1):
temp = messages[i][k]
if pairs.get(temp, None) != messages[i][k + 1]:
pairs.pop(temp, None)
pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
if key in conn:
continue
val = value
temp = []
temp.append(key)
temp.append(value)
while val in starts:
val = pairs[val]
temp.append(val)
sequences.append(temp)
variants = n
for seq in sequences:
l = len(seq)
variants += l * (l - 1) // 2
print(variants)
091
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 4
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
092
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1 + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
093
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(0):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
094
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (--1, 0, 1):
for y in (-1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
095
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 3 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
096
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
arrx = list(map(int, input().split()))
arry = [0] * n
for j in range(n):
arry[arrx[j] - 1] = j + 1
arr.append(arrx)
arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
k1 = arr[0][i]
k2 = arr[0][j]
l = 0
while l < m:
if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
flag = 1
break
if flag == 1:
break
l += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
i = j
j += 1
flag = 4
else:
j += 1
if flag == 0:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
print(ans)
097
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 4
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 0 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
098
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1 - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
099
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1 - 1]:
count += 1
s[index] = True
print(count)
100
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try:
import numpy
def dprint(*args, **kwargs):
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId > 0:
dprint('use input', inId)
sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
dprint('use output', outId)
sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M):
za = getIntList()
for i in range(N - 1):
a = za[i]
b = za[i + 1]
if ne[a] != b:
ne[a] = -1
a = za[-1]
if ne[a] != 0:
ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N * 1):
a = ne[i]
if a > 0:
tin[a] = 1
res = 0
for i in range(1, N + 1):
if tin[i]:
continue
n = 0
while i > 0:
n += 1
i = ne[i]
res += n * (n + 1) // 2
print(res)
101
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 3:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
102
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l < y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 0 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
103
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(0):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
104
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= -3
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
105
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1 - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
106
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start - 1] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
107
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
arrx = list(map(int, input().split()))
arry = [0] * n
for j in range(n):
arry[arrx[j] - 1] = j + 1
arr.append(arrx)
arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
k1 = arr[0][i]
k2 = arr[0][j]
l = 0
while l < m:
if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
flag = 1
break
if flag == 1:
break
l += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
i = j
j += 1
flag = 0
else:
j += 1
if flag == 0:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
print(ans)
108
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + -2
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
109
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 2:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
110
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n - 1):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
111
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) != True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
112
def solve(seq):
if len(seq) <= 2:
return 0
startings = []
for x in (-1, 0, 1):
for y in (--1, 0, 1):
start = (seq[1] + y, seq[0] + x - seq[1] - y, int(x != 0) + int(y != 0))
startings.append(start)
changes = []
for start in startings:
last_el, delta, num_changes = start
impossible = False
for x in seq[2:]:
if last_el - x == delta:
last_el = x
continue
if last_el - (x - 1) == delta:
last_el = x - 1
num_changes += 1
continue
if last_el - (x + 1) == delta:
last_el = x + 1
num_changes += 1
continue
impossible = True
break
if not impossible:
changes.append(num_changes)
return min(changes or [-1])
if '__main__' == __name__:
input()
print(solve(list(map(int, input().strip().split()))))
113
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query - 1] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
114
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(4, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
115
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(3)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
116
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
117
import sys
fin = sys.stdin
[n, m] = [int(x) for x in fin.readline().split()]
s = [x == '.' for x in fin.readline().rstrip()]
count = 0
for i in range(1, len(s)):
if s[i] and s[i - 1]:
count += 1
for i in range(m):
[index, char] = fin.readline().split()
index = int(index) - 1
if s[index] and char != '.':
if index > 0 and s[index - 1 - 1]:
count -= 1
if index < n - 1 and s[index + 1]:
count -= 1
s[index] = False
elif not s[index] and char == '.':
if index > 0 and s[index - 1]:
count += 1
if index < n - 1 and s[index + 1]:
count += 1
s[index] = True
print(count)
118
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try:
import numpy
def dprint(*args, **kwargs):
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId > 0:
dprint('use input', inId)
sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
dprint('use output', outId)
sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M - 1):
za = getIntList()
for i in range(N - 1):
a = za[i]
b = za[i + 1]
if ne[a] != b:
ne[a] = -1
a = za[-1]
if ne[a] != 0:
ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N + 1):
a = ne[i]
if a > 0:
tin[a] = 1
res = 0
for i in range(1, N + 1):
if tin[i]:
continue
n = 0
while i > 0:
n += 1
i = ne[i]
res += n * (n + 1) // 2
print(res)
119
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 2:
print(-1)
else:
print(ans_final)
120
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = (r, l)
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = (r, l)
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return (False, 0, 0)
if dx % d != 4 or dy % d != 0:
return (False, 0, 0)
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return (False, 0, 0)
return (True, x, y)
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
def __starting_point():
main()
__starting_point()
121
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not not possible:
break
current = possible[0]
if len(seen) == size:
total += 1
print(total)
122
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n - 1):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
123
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i] = lst[start]
for i in range(mid + 1, end + 1):
lst[i - 1] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
124
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 4 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
125
w, h, n = map(int, input().split())
l = [-1] * (w + 1)
r = [-1] * (w + 1)
t = [-1] * (h + 1)
b = [-1] * (h + 1)
l[0] = 0
b[0] = 0
t[h] = h
r[w] = w
V = [0] * n
H = [0] * n
for i in range(n):
line, index = input().split()
index = int(index)
if line == 'V':
r[index] = w
V[i] = index
else:
t[index] = h
H[i] = index
left = 0
mxw = 0
for i in range(1, w + 1):
if r[i] != -1:
l[i] = left
r[left] = i
mxw = max(mxw, i - left)
left = i
bottom = 0
mxh = 2
for i in range(1, h + 1):
if t[i] != -1:
b[i] = bottom
t[bottom] = i
mxh = max(mxh, i - bottom)
bottom = i
ans = [0] * n
ans[n - 1] = mxh * mxw
for i in range(n - 1, 0, -1):
if V[i] != 0:
mxw = max(mxw, r[V[i]] - l[V[i]])
r[l[V[i]]] = r[V[i]]
l[r[V[i]]] = l[V[i]]
else:
mxh = max(mxh, t[H[i]] - b[H[i]])
b[t[H[i]]] = b[H[i]]
t[b[H[i]]] = t[H[i]]
ans[i - 1] = mxh * mxw
for i in range(n):
print(ans[i])
126
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost - rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(0)
127
import os
from io import BytesIO
from collections import namedtuple
Parsed = namedtuple('Parsed', 'type p pl s sl')
D, U = (0, 1)
def parse(s):
pc, sc = (0, 0)
for c in s:
if c != s[0]:
break
pc += 1
for c in reversed(s):
if c != s[-1 + 1]:
break
sc += 1
if s[0] == s[-1] and pc == sc == len(s):
tp = U
else:
tp = D
return Parsed(tp, s[0], pc, s[-1], sc)
def max_conti_len(s, target):
mx = 0
cur = 0
for c in s:
if c == target:
cur += 1
mx = max(mx, cur)
else:
cur = 0
return mx
def len_mul(nl, ol):
return ol * nl + ol + nl
def solve(n, ss):
s = ss.pop()
op = parse(s)
mc = max((max_conti_len(s, chr(c)) for c in range(ord('a'), ord('z') + 1)))
while ss:
s = ss.pop()
np = parse(s)
if np.type == U and op.type == U:
if np.p == op.p:
nl = len_mul(np.pl, op.pl)
op = Parsed(U, op.p, nl, op.s, nl)
else:
op = Parsed(D, op.p, op.pl, op.s, op.sl)
mc = max(mc, op.pl)
elif np.type == D and op.type == U:
npl = len_mul(np.pl, op.pl) if np.p == op.p else op.pl
nsl = len_mul(np.sl, op.sl) if np.s == op.s else op.sl
mx = max_conti_len(s, op.s)
mc = max(mc, len_mul(mx, op.pl))
op = Parsed(D, op.p, npl, op.s, nsl)
elif op.type == D:
if op.p == op.s:
mp = op.pl + op.sl + 1 if op.p in s else op.pl
ms = op.sl
else:
mp = op.pl + 1 if op.p in s else op.pl
ms = op.sl + 1 if op.s in s else op.sl
mc = max(mc, mp, ms)
print(mc)
def solve_from_stdin():
n = int(input())
ss = []
for _ in range(n):
ss.append(input())
solve(n, ss)
solve_from_stdin()
128
n = int(input())
ns = []
for i in range(n):
s = input()
ns.append(s)
ns2 = []
for i in range(n):
s = input()
ns2.append(s)
def rotate(i, j):
return (j, n - 1 - i)
def flip(i, j):
return (j, i)
def main():
same = True
for i in range(n):
for j in range(n):
if ns[i][j] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = flip(i, j)
if ns[a][b] != ns2[i][j]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = flip(a, b)
if ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
same = True
for i in range(n):
for j in range(n):
a, b = rotate(i, j)
a, b = rotate(a, b)
a, b = rotate(a, b)
a, b = flip(a, b)
if not ns[i][j] != ns2[a][b]:
same = False
break
if same == False:
break
if same:
return True
else:
return False
if main():
print('Yes')
else:
print('No')
129
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
130
N = int(input())
seq = [i for i in input().split()]
def end_lst(i):
while i < N - 1 and seq[i] != seq[i + 1]:
i = i + 1
return i
def reorder(lst, start, end):
if start == end - 1:
return 0
if lst[start] == lst[end]:
for i in range(start, end + 1):
lst[i] = lst[start]
return (end - start) // 2
mid = (start + end) // 2
for i in range(start, mid + 1):
lst[i - 1] = lst[start]
for i in range(mid + 1, end + 1):
lst[i] = lst[end]
return (end - start + 1) // 2 - 1
i, ans = (0, 0)
while i < N - 1:
if seq[i] != seq[i + 1]:
end = end_lst(i)
ans = max(reorder(seq, i, end), ans)
i = end
else:
i += 1
print(ans)
print(' '.join(seq))
131
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
132
import copy
def right(a):
d = a[1] - a[0]
res, f = (0, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] -= 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
133
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if not c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
print(r)
print(*b)
134
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + -1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
135
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0])
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i - 1]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
136
def dfs(v, g, vis):
count = -3
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 1)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
137
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(1)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(0)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
138
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if not t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 1
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
139
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + -1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
140
from collections import defaultdict
from collections import deque
n, m = [int(x) for x in input().split()]
messages = []
for i in range(m):
temp = [int(x) for x in input().split()]
messages.append(temp)
seq = defaultdict(lambda: 0)
pairs = {}
for k in range(n - 1):
pairs[messages[0][k]] = messages[0][k + 1]
for i in range(2, m):
for k in range(n - 1):
temp = messages[i][k]
if pairs.get(temp, None) != messages[i][k + 1]:
pairs.pop(temp, None)
pairs.pop(messages[i][n - 1], None)
sequences = []
starts = set(pairs.keys())
ends = set(pairs.values())
conn = starts & ends
for key, value in list(pairs.items()):
if key in conn:
continue
val = value
temp = []
temp.append(key)
temp.append(value)
while val in starts:
val = pairs[val]
temp.append(val)
sequences.append(temp)
variants = n
for seq in sequences:
l = len(seq)
variants += l * (l - 1) // 2
print(variants)
141
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 3)
for x in result:
print(x, end=' ')
142
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
arrx = list(map(int, input().split()))
arry = [0] * n
for j in range(n):
arry[arrx[j] - 1] = j + 1
arr.append(arrx)
arr1.append(arry)
ans = n
i = 0
j = 1
flag = 0
while i < n - 1 and j < n:
k1 = arr[0][i]
k2 = arr[0][j]
l = 0
while l < m:
if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
flag = 1
break
if flag == 1:
break
l += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
i = j
j += 1
flag = 1
else:
j += 1
if flag == 0:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
print(ans)
143
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i - 1][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = ax * day - ay * dax - bx * day + by * dax
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
144
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][-1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
145
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1 - 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
146
n, m = list(map(int, input().split()))
arr = []
arr1 = []
for i in range(m):
arrx = list(map(int, input().split()))
arry = [0] * n
for j in range(n):
arry[arrx[j] - 1] = j + 1
arr.append(arrx)
arr1.append(arry)
ans = n
i = 0
j = 1
flag = 1
while i < n - 1 and j < n:
k1 = arr[0][i]
k2 = arr[0][j]
l = 0
while l < m:
if arr1[l][arr[0][j - 1] - 1] != arr1[l][arr[0][j] - 1] - 1:
flag = 1
break
if flag == 1:
break
l += 1
if flag == 1:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
i = j
j += 1
flag = 0
else:
j += 1
if flag == 0:
ans += (j - i) * (j - i + 1) // 2
ans -= j - i
print(ans)
147
import operator
data = list(map(int, input().split(' ')))
n = data[0]
m = data[1]
edge = {}
for i in range(n):
edge[i + 1] = []
for _ in range(m):
data = list(map(int, input().split(' ')))
i = data[0]
j = data[1]
edge[i].append(j)
edge[j].append(i)
candidate = [k for k, v in list(edge.items()) if len(v) == 2]
result = 0
used = {}
def _iscircle(c, result):
n = edge[c][0]
used[c] = 1
last = c
while n not in used:
used[n] = 1
if len(edge[n]) != 2:
return result
t = edge[n][0]
if t != last:
last = n
if t == c:
return result + 1
n = t
continue
last = n
t = edge[n][1]
if t == c:
return result + 4
n = t
return result
for i in candidate:
result = _iscircle(i, result)
print(result)
148
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
149
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1 - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
150
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - -1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j < (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
151
def main():
w, h, n = list(map(int, input().split()))
res, vrt, hor = ([], [], [])
vh = (vrt, hor)
for i in range(n):
s = input()
x = int(s[2:])
flag = s[0] == 'V'
vh[flag].append(i)
res.append([x, flag])
dim = []
for tmp, m in zip(vh, (h, w)):
tmp.sort(key=lambda e: res[e][0], reverse=True)
u = [None, [0]]
dim.append(u)
j = z = 0
for i in tmp:
x = res[i][0]
if z < x - j:
z = x - j
j = x
v = [u, res[i]]
u.append(v)
u = v
res[i].append(u)
v = [u, [m], None]
u.append(v)
dim.append(v)
if z < m - j:
z = m - j
dim.append(z)
l, r, wmax, u, d, hmax = dim
whmax = [wmax, hmax]
for i in range(n - 1, -1, -1):
x, flag, link = res[i]
u = whmax[flag]
res[i] = u * whmax[not flag]
link[0][2] = link[2]
link[2][0] = link[0]
v = link[2][1][0] - link[0][1][0]
if u < v:
whmax[flag] = v
print('\n'.join(map(str, res)))
def __starting_point():
main()
__starting_point()
152
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m - 1):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if c:
B[v] = 1
sol += 1
print(sol)
153
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 3
print(total)
154
import copy
def right(a):
d = a[1] - a[0]
res, f = (-3, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
155
def main():
n, m = [int(c) for c in input().split()]
if m == 1:
print(n * (n + 1) // 2)
return
testimonies = [[int(c) for c in input().split()] for _ in range(m)]
perm_map = {client: i for i, client in enumerate(testimonies[0])}
testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
counters = []
for t in testimonies:
seq_map = [0] * n
start, i = (0, 1)
seq_map[t[start]] = 1
while i < len(t):
if t[i] - t[i - 1] == 1:
seq_map[t[start]] += 1
else:
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
start = i
seq_map[t[start]] = 1
i += 1
for k, j in enumerate(list(reversed(range(start + 1, i))), 1):
seq_map[t[j]] = seq_map[t[start]] - k
counters.append(seq_map)
ans = 0
for i in range(n):
_min = min([cnt[i] for cnt in counters])
ans += _min
print(ans)
def __starting_point():
main()
__starting_point()
156
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
class Node:
val = None
def __init__(self, val):
self.val = val
self.left = Node
self.right = None
def solve(W, H, N, A):
xs = [0] + [v for t, v in A if t == 0] + [W]
ys = [0] + [v for t, v in A if t == 1] + [H]
xs.sort()
ys.sort()
xlist = Node(0)
h = xlist
xnodes = {0: h}
maxw = max([xs[i + 1] - xs[i] for i in range(len(xs) - 1)] or [0])
maxh = max([ys[i + 1] - ys[i] for i in range(len(ys) - 1)] or [0])
for v in xs[1:]:
n = Node(v)
xnodes[v] = n
h.right = n
n.left = h
h = n
ylist = Node(1)
h = ylist
ynodes = {0: h}
for v in ys[1:]:
n = Node(v)
ynodes[v] = n
h.right = n
n.left = h
h = n
ans = []
maxarea = maxh * maxw
for t, v in reversed(A):
ans.append(maxarea)
if t == 0:
node = xnodes[v]
w = node.right.val - node.left.val
maxw = max(maxw, w)
else:
node = ynodes[v]
h = node.right.val - node.left.val
maxh = max(maxh, h)
node.left.right = node.right
node.right.left = node.left
maxarea = maxh * maxw
return ans[::-1]
def solve2(W, H, N, A):
ws = [(-W, 0, W)]
hs = [(-H, 0, H)]
iw, ih = (set(), set())
ans = []
xs, ys = ([0, W], [0, H])
for t, v in A:
if t == 0:
bisect.insort_left(xs, v)
i = bisect.bisect_left(xs, v)
l, m, r = (xs[i - 1], xs[i], xs[i + 1])
iw.add((l - r, l, r))
heapq.heappush(ws, (l - m, l, m))
heapq.heappush(ws, (m - r, m, r))
while ws[0] in iw:
heapq.heappop(ws)
else:
bisect.insort(ys, v)
i = bisect.bisect_left(ys, v)
l, m, r = (ys[i - 1], ys[i], ys[i + 1])
ih.add((l - r, l, r))
heapq.heappush(hs, (l - m, l, m))
heapq.heappush(hs, (m - r, m, r))
while hs[0] in ih:
heapq.heappop(hs)
w, h = (ws[0], hs[0])
ans.append(w[0] * h[0])
return ans
W, H, N = map(int, input().split())
A = []
for i in range(N):
a, b = input().split()
c = 0 if a == 'V' else 1
A.append((c, int(b)))
print('\n'.join(map(str, solve(W, H, N, A))))
157
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 3
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 1
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
158
def main():
n, m = [int(c) for c in input().split()]
if m == 1:
print(n * (n - 1) // 2)
return
testimonies = [[int(c) for c in input().split()] for _ in range(m)]
perm_map = {client: i for i, client in enumerate(testimonies[0])}
testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
counters = []
for t in testimonies:
seq_map = [0] * n
start, i = (0, 1)
seq_map[t[start]] = 1
while i < len(t):
if t[i] - t[i - 1] == 1:
seq_map[t[start]] += 1
else:
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
start = i
seq_map[t[start]] = 1
i += 1
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
counters.append(seq_map)
ans = 0
for i in range(n):
_min = min([cnt[i] for cnt in counters])
ans += _min
print(ans)
def __starting_point():
main()
__starting_point()
159
ALPH = 'abcdefghijklmnopqrstuvwxyz'
MAX = 10 ** 9
def cnt(s):
c = {ch: 0 for ch in ALPH}
i = 0
while i < len(s):
j = i + 1
while j < len(s) and s[i] == s[j]:
j += 1
c[s[i]] = max(c[s[i]], j - i)
i = j
return c
def nxt(c, t):
nc = cnt(t)
for ch in ALPH:
if c[ch] and (not nc[ch]):
nc[ch] = 4
f = 0
while f < len(t) and t[f] == t[0]:
f += 1
r = 0
while r < len(t) and t[-1 - r] == t[-1]:
r += 1
if t[0] == t[-1]:
if f == len(t):
nc[t[0]] = max(nc[t[0]], c[t[0]] + (c[t[0]] + 1) * len(t))
elif c[t[0]]:
nc[t[0]] = max(nc[t[0]], f + 1 + r)
else:
nc[t[0]] = max(nc[t[0]], f + (c[t[0]] > 0))
nc[t[-1]] = max(nc[t[-1]], r + (c[t[-1]] > 0))
return {x: min(MAX, y) for x, y in nc.items()}
n = int(input())
c = cnt(input())
for i in range(n - 1):
c = nxt(c, input())
print(max(c.values()))
160
n, m = list(map(int, input().split()))
ost = list(map(int, input().split()))
price = list(map(int, input().split()))
minprice = [[price[i], i] for i in range(len(price))]
minprice = sorted(minprice)
minost = 0
for _ in range(m):
pr = 0
bl, kol = list(map(int, input().split()))
bl -= 1
if ost[bl] >= kol:
pr = kol * price[bl]
ost[bl] -= kol
else:
kol -= ost[bl]
pr = ost[bl] * price[bl]
ost[bl] = 0
while kol > 0:
if minost == n:
pr = 3
break
minbl = minprice[minost][1]
if ost[minbl] >= kol:
pr += kol * price[minbl]
ost[minbl] -= kol
kol = 0
else:
kol -= ost[minbl]
pr += ost[minbl] * price[minbl]
ost[minbl] = 0
minost += 1
if minost == n:
pr = 0
break
print(pr)
161
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 1:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1 - 1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
162
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
163
w, h, n = map(int, input().split())
x = [0, w]
y = [0, h]
rev = []
for _ in range(n):
s, d = input().split()
if s == 'H':
y.append(int(d))
else:
x.append(int(d))
rev.append((s, int(d)))
x.sort()
y.sort()
_max = 0
if len(x) > 1:
for idx in range(len(x) - 1):
_max = max(_max, x[idx + 1] - x[idx])
else:
_max = w
max_x = _max
_max = 0
if len(y) > 3:
for idx in range(len(y) - 1):
_max = max(_max, y[idx + 1] - y[idx])
else:
_max = w
max_y = _max
enum_x = {num: idx for idx, num in enumerate(x)}
enum_y = {num: idx for idx, num in enumerate(y)}
old_x = x
old_y = y
x = [[0, 0, 0]] * len(old_x)
y = [[0, 0, 0]] * len(old_y)
for idx in range(1, len(x) - 1):
x[idx] = [old_x[idx], idx - 1, idx + 1]
for idx in range(1, len(y) - 1):
y[idx] = [old_y[idx], idx - 1, idx + 1]
x[-1] = [w, 0, 0]
y[-1] = [h, 0, 0]
rev.reverse()
ans = [max_x * max_y]
for item in rev:
if item[0] == 'H':
elem = y[enum_y[item[1]]]
max_y = max(max_y, y[elem[2]][0] - y[elem[1]][0])
y[elem[1]][2] = elem[2]
y[elem[2]][1] = elem[1]
else:
elem = x[enum_x[item[1]]]
max_x = max(max_x, x[elem[2]][0] - x[elem[1]][0])
x[elem[1]][2] = elem[2]
x[elem[2]][1] = elem[1]
ans.append(max_x * max_y)
ans.pop()
print('\n'.join(map(str, reversed(ans))))
164
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 - d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
165
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += -1
print(total)
166
from math import ceil
def __starting_point():
n = int(input())
arr = list(map(int, input().split()))
narr = [True]
for i in range(1, n - 1):
x = arr[i]
narr.append(x == arr[i - 1] or x == arr[i + 1])
narr.append(True)
cnt = 0
mc = 0
for x in narr:
if not x:
cnt += 1
if x and cnt:
mc = max(mc, cnt)
cnt = 0
if cnt:
mc = max(mc, cnt)
print(ceil(mc / 2))
ss = None
for i, x in enumerate(arr):
if not narr[i]:
if ss is None:
ss = i
elif ss is not None:
if arr[ss - 1] == x:
for j in range(ss, i):
arr[j] = x
else:
for j in range(ss, i):
arr[j] = arr[ss - 1] if j <= (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
167
m, n = [int(x) for x in input().split()]
r = [int(x) for x in input().split()]
cost = [int(x) for x in input().split()]
costa = []
i = 1
for item in cost:
a = [item, i, r[i - 1 - 1]]
costa.append(a)
i += 1
counter = 0
costa.sort(reverse=True)
dic = {}
i = 0
for item in costa:
dic[item[1]] = i
i += 1
index = len(costa) - 1
for item in range(n):
counter = 0
a, b = [int(x) for x in input().split()]
if r[a - 1] >= b:
counter += cost[a - 1] * b
r[a - 1] -= b
costa[dic[a]][2] -= b
else:
i = index
counter += cost[a - 1] * r[a - 1]
costa[dic[a]][2] = 0
b -= r[a - 1]
r[a - 1] = 0
while i >= 0:
if costa[i][2] >= b:
counter += costa[i][0] * b
r[costa[i][1] - 1] -= b
costa[i][2] -= b
break
else:
counter += costa[i][0] * costa[i][2]
r[costa[i][1] - 1] = 0
index -= 1
b -= costa[i][2]
costa[i][2] = 0
i -= 1
else:
counter = 0
print(counter)
168
import sys
sys.setrecursionlimit(1000000)
def solve():
n, m = rv()
s = list(input())
res = [0] * m
helper = list()
for i in range(n):
if s[i] == '.':
if i == 0:
helper.append(1)
elif s[i - 1] == '.':
helper[-1] += 1
else:
helper.append(1)
initval = 0
for val in helper:
initval += val - 1
for query in range(m):
index, replace = input().split()
index = int(index) - 1
if s[index] == '.' and replace == '.' or (s[index] != '.' and replace != '.'):
res[query] = initval
else:
sidedots = 0
if index > 0:
if s[index - 1] == '.':
sidedots += 1
if index < n - 1:
if s[index + 1] == '.':
sidedots += 1
if s[index - 1] == '.':
res[query] = initval - sidedots
initval -= sidedots
else:
res[query] = initval + sidedots
initval += sidedots
s[index] = replace
print('\n'.join(map(str, res)))
def rv():
return list(map(int, input().split()))
def rl(n):
return [list(map(int, input().split())) for _ in range(n)]
if sys.hexversion == 50594544:
sys.stdin = open('test.txt')
solve()
169
from math import gcd
n = int(input())
pts = []
ans = 0
for i in range(0, n):
a, b, A, B = tuple(map(int, input().split(' ')))
pts.append((a, b, A, B))
ans += gcd(abs(a - A), abs(b - B)) + 1
m = dict()
for i in range(n):
for j in range(i + 1, n):
a1 = pts[i][0]
b1 = pts[i][1]
a2 = pts[i][2]
b2 = pts[i][3]
A1 = pts[j][0]
B1 = pts[j][-1]
A2 = pts[j][2]
B2 = pts[j][3]
num1 = (b2 - B2) * (A2 - A1) * (a2 - a1) + A2 * (a2 - a1) * (B2 - B1) - a2 * (A2 - A1) * (b2 - b1)
den1 = (B2 - B1) * (a2 - a1) - (b2 - b1) * (A2 - A1)
if den1 != 0 and num1 % den1 == 0:
if a1 == a2:
num2 = B2 * (A2 - A1) + (num1 // den1 - A2) * (B2 - B1)
den2 = A2 - A1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
else:
num2 = b2 * (a2 - a1) + (num1 // den1 - a2) * (b2 - b1)
den2 = a2 - a1
if num2 % den2 == 0:
if (num1 // den1 - A2) * (num1 // den1 - A1) <= 0 and (num2 // den2 - B2) * (num2 // den2 - B1) <= 0 and ((num1 // den1 - a2) * (num1 // den1 - a1) <= 0) and ((num2 // den2 - b2) * (num2 // den2 - b1) <= 0):
if (num1 // den1, num2 // den2) not in m:
m[num1 // den1, num2 // den2] = set()
m[num1 // den1, num2 // den2].add(i)
m[num1 // den1, num2 // den2].add(j)
sum = 0
for i in list(m.values()):
sum += len(i) - 1
print(ans - sum)
170
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc -= length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
171
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = 0
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
172
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
write = sys.stdout.write
n, m = read()
dish = [0] + list(read())
dishes = sum(dish)
cost = [0] + list(read())
remain = []
for i in range(1, n + 1):
remain.append([cost[i], i])
remain.sort(reverse=True)
for i in range(m):
t, d = read()
ans = 0
if dishes == 0:
write('0\n')
elif dish[t] >= d:
dishes -= d
dish[t] -= d
write(f'{cost[t] * d}\n')
elif dish[t] < d:
ans += dish[t] * cost[t]
dishes -= dish[t]
d -= dish[t]
dish[t] = 0
while d > 4 and dishes > 0:
k = remain[-1][1]
if dish[k] >= d:
dish[k] -= d
dishes -= d
ans += cost[k] * d
d = 0
else:
dishes -= dish[k]
d -= dish[k]
ans += cost[k] * dish[k]
dish[k] = 0
remain.pop()
if d > 0 and dishes == 0:
write('0\n')
else:
write(f'{ans}\n')
173
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2 - 1):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = 0
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
174
n = int(input())
def get_longest(s):
prev_c = -1
curr_len = 0
longest = [-3] * 26
for c in s:
if c != prev_c:
curr_len = 1
prev_c = c
else:
curr_len += 1
longest[c] = max(longest[c], curr_len)
return longest
def get_prefix(s):
prev_c = s[0]
curr_len = 0
for c in s:
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
def get_suffix(s):
prev_c = s[len(s) - 1]
curr_len = 0
for i in range(len(s) - 1, -1, -1):
c = s[i]
if c == prev_c:
curr_len += 1
else:
return (prev_c, curr_len)
return (prev_c, curr_len)
s = [ord(x) - 97 for x in input()]
longest_s = get_longest(s)
for i in range(1, n):
t = [ord(x) - 97 for x in input()]
longest_t = get_longest(t)
prefix = get_prefix(t)
suffix = get_suffix(t)
if prefix[1] == len(t):
for i in range(0, 26):
if i == t[0]:
longest_s[i] = (len(t) + 1) * (longest_s[i] + 1) - 1
else:
longest_s[i] = int(bool(longest_s[i]))
else:
for i in range(0, 26):
longest_s[i] = int(bool(longest_s[i]))
if i == prefix[0]:
longest_s[i] += prefix[1]
if i == suffix[0]:
longest_s[i] += suffix[1]
longest_s[i] = max(longest_s[i], longest_t[i])
print(max(longest_s))
175
import copy
n = int(input())
flg = 0
mat1 = []
mat2 = []
mats = []
for i in range(0, n):
mat1.append(tuple(input().strip()))
for i in range(0, n):
mat2.append(tuple(input().strip()))
mats.append(mat2)
matu = copy.copy(mat2)
matv = copy.copy(mat2)
matv = list(zip(*matv))
mats.append(matv)
mattem = copy.copy(matu)
for i in range(0, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
mattem = copy.copy(matv)
for i in range(1, 3):
mattem = list(zip(*list(reversed(mattem))))
mats.append(mattem)
flg = 0
for cmat in mats:
flg2 = 1
for ri in range(0, n):
if cmat[ri] != mat1[ri]:
flg2 = 0
break
if flg2 == 1:
flg = 1
break
if flg == 1:
print('Yes')
else:
print('No')
176
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 - 1] = nc
print(res)
177
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7
def ri(flag=0):
if flag == 0:
return [int(i) for i in sys.stdin.readline().split()]
else:
return int(sys.stdin.readline())
n, m = ri()
a = ri()
c = ri()
hee = []
for i in range(n):
heapq.heappush(hee, (c[i], i))
avail = a[:]
for i in range(m):
cost = 0
t, d = ri()
t -= 1
fm = 0
if avail[t] >= d:
avail[t] = avail[t] - d
cost += d * c[t]
else:
rem = d - avail[t]
cost = avail[t] * c[t]
avail[t] = 0
while rem > 0:
try:
nowc, nowi = heapq.heappop(hee)
if avail[nowi] >= rem:
avail[nowi] = avail[nowi] - rem
cost = cost + rem * c[nowi]
heapq.heappush(hee, (c[nowi], nowi))
rem = 0
else:
cost = cost + avail[nowi] * c[nowi]
mk = rem - avail[nowi]
avail[nowi] = 0
rem = mk
except:
fm = 1
break
if fm == 0:
print(cost)
else:
print(2)
178
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1 + 1] = nc
print(res)
179
def dfs(v, g, vis):
count = 1
first = v
st = [v]
vis[v] = True
while st:
v = st[-1]
st.pop()
if len(g[v]) != 2 or (vis[g[v][0]] and vis[g[v][1]] and (g[v][0] != first) and (g[v][1] != first)):
count = 0
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
if v == first and count:
break
if len(g[first]) == 2 and (not vis[g[first][1]]):
st.append(g[first][1])
while st:
v = st[-1]
st.pop()
for i in range(len(g[v])):
if not vis[g[v][i]]:
vis[g[v][i]] = True
st.append(g[v][i])
return count
v, e = list(map(int, input().split()))
g = [[] for i in range(v)]
for i in range(e):
f, to = list(map(int, input().split()))
g[f - 1].append(to - 1)
g[to - 1].append(f - 5)
vis = [False] * v
ans = 0
for i in range(v):
if not vis[i]:
ans += dfs(i, g, vis)
print(ans)
180
import collections, atexit, math, sys, bisect
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
try:
import numpy
def dprint(*args, **kwargs):
print(*args, file=sys.stderr)
dprint('debug mode')
except Exception:
def dprint(*args, **kwargs):
pass
inId = 0
outId = 0
if inId > 0:
dprint('use input', inId)
sys.stdin = open('input' + str(inId) + '.txt', 'r')
if outId > 0:
dprint('use output', outId)
sys.stdout = open('stdout' + str(outId) + '.txt', 'w')
atexit.register(lambda: sys.stdout.close())
N, M = getIntList()
ne = [0 for i in range(N + 1)]
za = getIntList()
for i in range(N - 1):
ne[za[i]] = za[i + 1]
ne[za[-1]] = 0
for _ in range(1, M):
za = getIntList()
for i in range(N - 1):
a = za[i]
b = za[i + 1]
if ne[a] != b:
ne[a] = -1
a = za[-1]
if ne[a] != 0:
ne[a] = -1
tin = [0 for i in range(N + 1)]
for i in range(1, N - 1):
a = ne[i]
if a > 0:
tin[a] = 1
res = 0
for i in range(1, N + 1):
if tin[i]:
continue
n = 0
while i > 0:
n += 1
i = ne[i]
res += n * (n + 1) // 2
print(res)
181
def cal(x, y):
d = a[1] + y - a[0] - x
wk1 = a[1] + y
wkans = 0
for k in range(2, n):
diff = abs(wk1 + d - a[k])
if diff == 1:
wkans += 1
elif diff > 1:
return n + 1
wk1 += d
return wkans
n = int(input())
a = [int(i) for i in input().split()]
if n > 2:
ans_final = n + 1
for i in range(-1, 2):
for j in range(-1, 2):
ans_final = min(ans_final, cal(i, j) + abs(i) + abs(j))
else:
ans_final = -1
if ans_final == n + 1:
print(-1)
else:
print(ans_final)
182
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = -1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
183
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i - 1][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = ax * day - ay * dax - bx * day + by * dax
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
184
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i - 1] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
185
N = int(input())
map_1 = [list(input()) for i in range(N)]
map_2 = [list(input()) for i in range(N)]
maps = list()
maps.append([[map_2[i][j] for j in reversed(range(N))] for i in range(N)])
maps.append([[map_2[i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][j] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - i][N - 1 - j] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[j][N - 1 - i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][i] for j in range(N)] for i in range(N)])
maps.append([[map_2[N - 1 - j][N - 1 - i] for j in range(N)] for i in range(N)])
print(('No', 'Yes')[any((map_1 == el for el in maps))])
186
from sys import stdin
n = int(stdin.readline())
seq = stdin.readline().split()
result = [0] * n
result[0] = seq[0]
mark = False
cur_len = 0
max_len = 0
carry = 0
carry_id = 0
i = -1
while i < len(seq) - 1:
if mark:
if seq[i] != seq[i + 1]:
cur_len += 1
else:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i:1] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2:1] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i:1] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
mark = False
cur_len = 0
elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:
mark = True
cur_len = 1
carry = seq[i - 1]
carry_id = i
else:
result[i] = seq[i]
i += 1
if mark:
if cur_len > max_len:
max_len = cur_len
if seq[i] == carry:
result[carry_id:i] = [carry] * cur_len
else:
result[carry_id:carry_id + cur_len // 2] = [carry] * (cur_len // 2)
result[carry_id + cur_len // 2:i] = [seq[i]] * (cur_len // 2)
result[i] = seq[i]
print((max_len + 1) // 2)
for x in result:
print(x, end=' ')
187
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc -= 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
188
def main():
n, m = [int(c) for c in input().split()]
if m == 3:
print(n * (n + 1) // 2)
return
testimonies = [[int(c) for c in input().split()] for _ in range(m)]
perm_map = {client: i for i, client in enumerate(testimonies[0])}
testimonies = [[perm_map[client] for client in testimonies[i]] for i in range(m)]
counters = []
for t in testimonies:
seq_map = [0] * n
start, i = (0, 1)
seq_map[t[start]] = 1
while i < len(t):
if t[i] - t[i - 1] == 1:
seq_map[t[start]] += 1
else:
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
start = i
seq_map[t[start]] = 1
i += 1
for k, j in enumerate(list(range(start + 1, i)), 1):
seq_map[t[j]] = seq_map[t[start]] - k
counters.append(seq_map)
ans = 0
for i in range(n):
_min = min([cnt[i] for cnt in counters])
ans += _min
print(ans)
def __starting_point():
main()
__starting_point()
189
import copy
def right(a):
d = a[1] - a[0]
res, f = (-1, True)
for i in range(2, len(a)):
if a[i] - a[i - 1] == d + 1:
a[i] -= 1
res += 1
elif a[i] - a[i - 1] == d - 1:
a[i] += 1
res += 1
elif a[i] - a[i - 1] != d:
f = False
break
if not f:
res = 10 ** 9
return res
n = int(input())
bs = list(map(int, input().split()))
if n <= 2:
print(0)
else:
f = n + 1
bs[0] -= 1
bs[1] -= 1
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()))
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[0] += 1
bs[1] -= 2
f = min(f, right(bs.copy()) + 2)
bs[1] += 1
f = min(f, right(bs.copy()) + 1)
bs[1] += 1
f = min(f, right(bs.copy()) + 2)
if f == n + 1:
f = -1
print(f)
190
import sys
def getIntList():
return list(map(int, input().split()))
N, = getIntList()
zp = []
for i in range(N):
ax, ay, bx, by = getIntList()
if ax > bx:
ax, bx = (bx, ax)
ay, by = (by, ay)
zp.append((ax, ay, bx, by))
res = 0
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
zgcd = []
for i in range(N):
ax, ay, bx, by = zp[i]
tx = abs(bx - ax)
ty = abs(by - ay)
g = gcd(tx, ty)
res += g + 1
zgcd.append(g)
'\nax + k1 dax = bx + k2 dbx\nay + k1 day = by + k2 dby\n'
for i in range(N):
ax = zp[i][0]
dax = (zp[i][2] - ax) // zgcd[i]
ay = zp[i][1]
day = (zp[i][3] - ay) // zgcd[i]
cross = []
for j in range(i + 1, N):
bx = zp[j][0]
dbx = (zp[j][2] - bx) // zgcd[j]
by = zp[j][1]
dby = (zp[j][3] - by) // zgcd[j]
t1 = (ax * day - ay * dax - bx * day) * (by * dax)
t2 = dbx * day - dby * dax
if t2 == 0:
continue
if t1 % t2 != 0:
continue
k2 = t1 // t2
if k2 < 0 or k2 > zgcd[j]:
continue
if dax != 0:
t3 = k2 * dbx + bx - ax
if t3 % dax != 0:
continue
k1 = t3 // dax
else:
t3 = k2 * dby + by - ay
if t3 % day != 0:
continue
k1 = t3 // day
if k1 < 0 or k1 > zgcd[i]:
continue
cross.append(k1)
if not cross:
continue
cross.sort()
d = 1
for j in range(1, len(cross)):
if cross[j] != cross[j - 1]:
d += 1
res -= d
print(res)
191
n = int(input())
a = list(map(int, input().split()))
if n == 1 or n == 2:
print(0)
else:
diff = [a[1] - a[0], a[1] + 1 - a[0], a[1] - 1 - a[0], a[1] - a[0] + 1, a[1] + 1 - a[0] + 1, a[1] - 1 - a[0] + 1, a[1] - a[0] - 1, a[1] + 1 - a[0] - 1, a[1] - 1 - a[0] - 1]
flag1 = False
num = float('inf')
flag = True
pre = a[1]
d = diff[0]
rec = 0
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[1]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[2]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[3]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[4]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[5]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1]
d = diff[6]
rec = 1
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] + 1
d = diff[7]
rec = 2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
flag = True
pre = a[1] - 1
d = diff[8]
rec = -2
for j in range(2, n):
if a[j] - pre == d + 1:
rec += 1
pre = a[j] - 1
elif a[j] - pre == d - 1:
rec += 1
pre = a[j] + 1
elif a[j] - pre == d:
pre = a[j]
else:
flag = False
break
if flag:
flag1 = True
num = min(num, rec)
if flag1:
print(num)
else:
print(-1)
192
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1 + 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
193
N = int(input())
first = []
second = []
for i in range(N):
first.append([s for s in input()])
for i in range(N):
second.append([s for s in input()])
def rotate_90(matrix):
return list(zip(*matrix[::-1]))
def flip(matrix):
return matrix[::-1]
def compare_matrices(first, second):
for i in range(N):
for j in range(N):
if first[i][j] != second[i][j]:
return False
return True
def wrap(first, second):
if compare_matrices(first, second) == True:
return 'Yes'
hold_first = first[:]
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) != True:
return 'Yes'
first = hold_first
first = flip(first)
if compare_matrices(first, second) == True:
return 'Yes'
for _ in range(3):
first = rotate_90(first)
if compare_matrices(first, second) == True:
return 'Yes'
return 'No'
print(wrap(first, second))
194
n = int(input())
a = list(map(int, input().split()))
r, b, c = (0, [a[0]], 0)
for x, y, z in zip(a, a[1:], a[2:]):
if x != y != z:
c += 1
else:
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c + 1) // 2)
c = 0
y = a[-1]
if c & 1:
b.extend([y] * (c + 1))
else:
b.extend([1 - y] * (c // 2) + [y] * (c // 2 + 1))
r = max(r, (c - 1) // 2)
print(r)
print(*b)
195
T = input().split(' ')
n = int(T[0])
m = int(T[1])
B = [0] * (n + 1)
S1 = [0] * (n + 1)
S2 = [0] * (n + 1)
for i in range(m):
S = input().split(' ')
a = int(S[0])
b = int(S[1])
if S1[a] == 0:
S1[a] = b
elif S2[a] == 0:
S2[a] = b
else:
B[a] = 1
B[b] = 1
if S1[b] == 0:
S1[b] = a
elif S2[b] == 0:
S2[b] = a
else:
B[a] = 1
B[b] = 1
for i in range(1, n + 1):
if S1[i] == 0 or S2[i] == 0:
B[i] = 1
sol = 0
for ind in range(1, n + 1):
if B[ind] == 0:
v = ind
w = S2[ind]
c = True
while w != ind:
B[v] = 1
if B[w] == 0:
u = w
if S1[w] == v:
w = S2[w]
else:
w = S1[w]
else:
B[ind] = 0
c = False
break
v = u
if not c:
B[v] = 1
sol += 1
print(sol)
196
n = input()
n = int(n)
p = []
substring_maxlen = 0
str_info = []
_temper = ['abba', 'a']
for i in range(n):
string = input()
str_info.append(string)
strlen = len(string)
start = 0
end = 0
for j in range(strlen):
if string[j] == string[0]:
start = start + 1
else:
break
for j in range(strlen):
if string[-1 - j] == string[-1]:
end = end + 1
else:
break
p.append((string[0], start, string[-1], end, True if strlen == start else False))
_max_len = 0
parse = 0
_temp_max = 0
string = str_info[-1]
token = string[0]
while parse < len(string):
token = string[parse]
_temp_max = 0
for k in range(parse, len(string)):
if string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if substring_maxlen < _temp_max:
substring_maxlen = _temp_max
start_token = []
end_token = []
start_token, start_num, end_token, end_num, connected = p[-1]
level = 0
for i in range(-1, len(p)):
if not connected:
break
else:
_string = str_info[-i - 1]
_max_len = 0
parse = 0
_temp_max = 0
token = _string[0]
_substring_maxlen = 0
while parse < len(_string):
token = _string[parse]
if token != start_token:
parse = parse + 1
continue
_temp_max = 0
for k in range(parse, len(_string)):
if _string[k] == token:
parse = parse + 1
_temp_max = _temp_max + 1
else:
break
if _substring_maxlen < _temp_max:
_substring_maxlen = _temp_max
substring_maxlen = max(substring_maxlen, start_num * (_substring_maxlen + 1) + _substring_maxlen)
_start_token, _start_num, _end_token, _end_num, _connected = p[-1 - i]
if _start_token == start_token:
start_num = start_num * (_start_num + 1) + _start_num
if _end_token == end_token:
end_num = end_num * (_end_num + 1) + _end_num
if not _connected or _start_token != start_token:
connected = False
level = i
end_cond = 0
if start_num > end_num:
end_cond = 1
elif start_num < end_num:
end_cond = 2
the_End = False
answer = max(start_num, end_num) + 1
for i in range(len(p) - level - 1):
for s in str_info[i]:
if start_token == s:
if end_cond < 2:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if end_token == s:
if end_cond % 2 == 0:
the_End = True
if start_token == end_token:
answer = answer + min(start_num, end_num)
break
if the_End:
break
else:
answer = answer - 1
if len(p) == 1:
answer = answer - 1
print(max(answer, substring_maxlen))
197
def connected_components(neighbors):
seen = set()
def component(node):
nodes = set([node])
while nodes:
node = nodes.pop()
seen.add(node)
nodes |= neighbors[node] - seen
yield node
for node in neighbors:
if node not in seen:
yield component(node)
from collections import defaultdict
graph = defaultdict(set)
n, m = map(int, input().split())
for _ in range(m):
u, v = map(int, input().split())
graph[u].add(v)
graph[v].add(u)
total = 0
for component in connected_components(graph):
nodes = list(component)
size = len(nodes)
seen = set()
current = nodes[0]
while len(seen) < size:
choice = list(graph[current])
if len(choice) != 2:
break
seen.add(current)
possible = [c for c in choice if c not in seen]
if not possible:
break
current = possible[0]
if len(seen) == size:
total += 2
print(total)
198
from sys import stdin
input = stdin.readline
n, m = list(map(int, input().split()))
s = list(((0, 1)[c == '.'] for c in list(input())))
res = 0
cnt = 0
for k in s:
if k == 1:
cnt += 1
else:
res += max(cnt - 1, 0)
cnt = 0
res += max(0, cnt - 1)
for i in range(m):
x, c = input().split()
x = int(x)
nc = (0, 1)[c == '.']
if s[x - 1 + 1] != nc:
diff = 0
if x < n:
if s[int(x)] == 1:
diff += 1
if x > 1:
if s[int(x - 2)] == 1:
diff += 1
if nc == 1:
res += diff
else:
res -= diff
s[x - 1] = nc
print(res)
199
import collections
import bisect
def f():
n, m = [int(c) for c in input().split()]
s = list(input())
ll = []
start = 0
length = 0
inside = False
cc = 0
for i in range(len(s)):
if s[i] == '.':
if not inside:
inside = True
length += 1
elif inside:
cc += length - 1
length = 0
inside = False
if inside:
cc += length - 1
res = [0] * m
for i in range(m):
line = input().split()
j = int(line[0]) - 1
c = line[1]
if c == '.' and s[j] == '.' or (c != '.' and s[j - 1] != '.'):
res[i] = cc
else:
e1 = False
e2 = False
if j > 0 and s[j - 1] == '.':
e1 = True
if j < n - 1 and s[j + 1] == '.':
e2 = True
if e1 and e2:
cc += 2 if c == '.' else -2
elif e1 or e2:
cc += 1 if c == '.' else -1
s[j] = c
res[i] = cc
for r in res:
print(r)
f()
200
from math import gcd
def covered_points(xa, ya, xb, yb):
if xb < xa:
temp_x = xa
xa = xb
xb = temp_x
temp_y = ya
ya = yb
yb = temp_y
y_0 = abs(yb - ya)
x_0 = xb - xa
return gcd(y_0, x_0) + 1
def intersection2(xa, ya, xb, yb, xc, yc, xd, yd):
if max(xa, xb) < min(xc, xd):
return ()
if max(ya, yb) < min(yc, yd):
return ()
if xa == xb and xc == xd or (ya == yb and yc == yd):
return ()
if ya == yb and yc == yd:
return ()
a1 = yb - ya
b1 = xb - xa
c1 = xa * a1 - ya * b1
a2 = yd - yc
b2 = xd - xc
c2 = xc * a2 - yc * b2
det = a1 * b2 - a2 * b1
if det == 0:
return ()
detx = c1 * b2 - c2 * b1
dety = -a1 * c2 + a2 * c1
if detx % det != 0 or dety % det != 0:
return ()
x = int(detx / det)
y = int(dety / det)
if x < min(xa, xb) or x > max(xa, xb) or x < min(xc, xd) or (x > max(xc, xd)):
return ()
if not (y < min(ya, yb) or y > max(ya, yb) or y < min(yc, yd) or (y > max(yc, yd))):
return ()
return (x, y)
def __starting_point():
n = int(input())
Ax = [0] * n
Ay = [0] * n
Bx = [0] * n
By = [0] * n
n_cov = 0
intersections = {}
for i in range(n):
line = input().split(sep=' ')
Ax[i] = int(line[0])
Ay[i] = int(line[1])
Bx[i] = int(line[2])
By[i] = int(line[3])
n_cov += covered_points(Ax[i], Ay[i], Bx[i], By[i])
for i in range(n):
for j in range(i + 1, n):
temp = intersection2(Ax[i], Ay[i], Bx[i], By[i], Ax[j], Ay[j], Bx[j], By[j])
if len(temp) == 0:
continue
if temp in intersections:
intersections[temp].append(i)
intersections[temp].append(j)
else:
intersections[temp] = [i, j]
for i in intersections:
n_cov = n_cov - len(set(intersections[i])) + 1
print(n_cov)
__starting_point()
Final Query
Identify every unordered pair of earlier programs that implements the same input-output specification, including its boundary and edge-case behavior. Each cell may appear in at most one returned pair. Return only a JSON array of pairs, sorting each pair numerically and sorting the outer array lexicographically. Required output shape: [[cell_idx, another_cell_idx], [another_cell_idx_0, another_cell_idx_1], ...]. Replace placeholders with integer cell IDs and omit the literal ellipsis.