001
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y > 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
002
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum <= 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
003
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()
004
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
005
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[5:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
006
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 3
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 2 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
007
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == -2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
008
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()
009
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 0
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
010
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))
011
def main():
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
roundup = []
rounddown = []
sumsofar = []
for i, (a, b) in enumerate(zip(reversed(A), reversed(B))):
ssf = sumsofar[-1] if sumsofar else 0
t = roundup[-1] if roundup else 0
roundup.append(t + ssf + b * (1 + 2 * i))
t = rounddown[-1] if rounddown else 0
rounddown.append(t + ssf + a * (1 + 2 * i))
sumsofar.append(ssf + a + b)
roundup = list(reversed(roundup))
rounddown = list(reversed(rounddown))
sumsofar = list(reversed(sumsofar))
bestres = 0
sofar = 0
for i, (a, b) in enumerate(zip(A, B)):
rup, rdo = (roundup, rounddown)
if i % 2:
a, b = (b, a)
rup, rdo = (rdo, rup)
bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i)
sofar += a * 2 * i
sofar += b * (2 * i + -1)
bestres = max(bestres, sofar)
print(bestres)
def __starting_point():
main()
__starting_point()
012
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s >= s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
013
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch != 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
014
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()
015
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()
016
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))
017
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 1
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
018
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1] = a[i][n - 1]
pref_up[i][n - 1 - 1] = a[i][n - 1]
pref_down[i][n - 1] = a[i][n - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
elif i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e+18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
elif j == n - 1:
ans = max(ans, zig[1 - j % 2][n - 1])
elif j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
019
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 4 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
020
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)
021
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()
022
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()
023
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][0] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
024
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()
025
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 3]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
026
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in reversed(range(k)):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
027
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()
028
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))
029
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1 - 1] = a[i][n - 1]
pref_up[i][n - 1] = a[i][n - 1]
pref_down[i][n - 1] = a[i][n - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
elif i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e+18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
elif j == n - 1:
ans = max(ans, zig[1 - j % 2][n - 1])
elif j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
030
from sys import stdin
from math import *
line = stdin.readline().rstrip().split()
n = int(line[0])
numbers = list(map(int, stdin.readline().rstrip().split()))
numbers2 = list(map(int, stdin.readline().rstrip().split()))
growRateAccum = 0
topAccum = 0
bottomAccum = 0
accumsB = [0] * n
accumsT = [0] * n
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum += numbers[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers[i]
if i < n - 1:
growRateAccum *= numbers2[i + 1]
accum += growRateAccum
accumsB[i] = accum
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum += numbers2[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers2[i]
if i < n - 1:
growRateAccum += numbers[i + 1]
accum += growRateAccum
accumsT[i] = accum
cMax = 0
currAccum = 0
growRateAccum = sum(numbers[1:]) + sum(numbers2[1:])
for i in range(n):
if i % 2 == 0:
cMax = max(cMax, currAccum + accumsT[i])
else:
cMax = max(cMax, currAccum + accumsB[i])
if i < n - 1:
if i % 2 == 0:
currAccum += numbers2[i] + growRateAccum * 2
else:
currAccum += numbers[i] + growRateAccum * 2
growRateAccum -= numbers[i + 1]
growRateAccum -= numbers2[i + 1]
print(cMax)
031
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244353
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n nonlocal color\n nonlocal bipertite\n nonlocal color_count\n\n color[s] = c\n color_count[c] += 1\n for i in range(0, len(graph[s])):\n\n if color[graph[s][i]] == -1:\n dfs(graph[s][i], 1-c)\n\n if color[s] == color[graph[s][i]]:\n bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
next_value = pow_value[i - 1] * 2 % MOD
pow_value.append(next_value)
while t:
n, m = list(map(int, input().split()))
if m == 0:
print(pow(3, n, MOD))
t -= 1
continue
graph.clear()
bipertite = True
result = 1
for node in range(0, n + 1):
color[node] = -1
while m:
u, v = list(map(int, input().split()))
graph[u].append(v)
graph[v].append(u)
m -= 1
for i in range(1, n + 1 - 1):
if color[i] != -1:
continue
bipertite = True
color_count[0] = color_count[1] = 0
queue = []
queue.append(i)
color[i] = 0
color_count[0] += 1
while queue:
if bipertite == False:
break
front_node = queue.pop()
for child_node in range(0, len(graph[front_node])):
if color[graph[front_node][child_node]] == -1:
color[graph[front_node][child_node]] = 1 - color[front_node]
queue.append(graph[front_node][child_node])
color_count[color[graph[front_node][child_node]]] += 1
elif color[front_node] == color[graph[front_node][child_node]]:
bipertite = False
break
if bipertite == False:
print(0)
break
current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
result = result * current % MOD
if bipertite:
print(result)
t -= 1
032
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
ans = 1
part = 0
factor = 0
fila = deque([])
n, m = map(int, input().split())
if m > n // 2 * (n // 2 + 1):
saida.append('0')
for edge_count in range(m):
input()
continue
edge = [[] for i in range(n + 1)]
visitados = [-1] * (n + 1)
assure = 1
for arestas in range(m):
u, v = map(int, input().split())
edge[u].append(v)
edge[v].append(u)
visitados[1] = 0
fila.append(1)
break_all = False
while not break_all:
par, impar = (1, 0)
while fila and (not break_all):
search = fila.popleft()
current = visitados[search]
for i in edge[search]:
if visitados[i] == -1:
visitados[i] = current ^ 1
if visitados[i] & 1:
impar += 1
else:
par += 1
fila.append(i)
elif visitados[i] == current:
break_all = True
else:
assert visitados[i] == current ^ 1
if break_all:
ans = 0
elif (par, impar) == (1, 0):
factor += 1
else:
ans *= pow(2, par, modulo) + pow(2, impar, modulo)
ans %= modulo
while assure <= n:
if visitados[assure] == -1:
part += 1
visitados[assure] = 2 * part
fila.append(assure)
break
assure += 1
if assure == n + 1:
break
ans //= pow(3, factor, modulo)
ans %= modulo
saida.append(str(ans))
print('\n'.join(saida))
033
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 1):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
034
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-3] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
035
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
ans = 1
part = 0
factor = 0
fila = deque([])
n, m = map(int, input().split())
if m > n // 2 * (n // 2 + 1):
saida.append('0')
for edge_count in range(m):
input()
continue
edge = [[] for i in range(n + 1)]
visitados = [-1] * (n + 1)
assure = 1
for arestas in range(m):
u, v = map(int, input().split())
edge[u].append(v)
edge[v].append(u)
visitados[1] = 0
fila.append(1)
break_all = False
while not break_all:
par, impar = (1, 0)
while fila and (not break_all):
search = fila.popleft()
current = visitados[search]
for i in edge[search]:
if visitados[i] == -1:
visitados[i] = current ^ 1
if visitados[i] & 1:
impar += 1
else:
par += 1
fila.append(i)
elif visitados[i] == current:
break_all = True
else:
assert visitados[i] == current ^ 1
if break_all:
ans = 0
elif (par, impar) == (1, 0):
factor += 1
else:
ans *= pow(2, par, modulo) + pow(2, impar, modulo)
ans %= modulo
while assure <= n:
if visitados[assure] == -1:
part += 1
visitados[assure] = 2 * part
fila.append(assure)
break
assure += 1
if assure == n + 1:
break
ans *= pow(2, factor, modulo)
ans %= modulo
saida.append(str(ans))
print('\n'.join(saida))
036
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))
037
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 + 1
for i in range(n - 1):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
038
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
curl_ud_weights = [0] * n
curl_du_weights = [0] * n
sums = [0] * n
sums[n - 1] = a[n - 1] + b[n - 1]
curl_ud_weights[n - 1] = b[n - 1]
curl_du_weights[n - 1] = a[n - 1]
for i in range(n - 2, -1, -1):
sums[i] = sums[i + 1] + (a[i] + b[i])
remain = n * 2 - i * 2 - 1
curl_ud_weights[i] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i]
curl_du_weights[i + 1] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i]
snake_weight = 0
max_weight = 0
current_weight = -1
for t in range(0, 2 * n, 2):
remain = t % 4
if remain == 0:
current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight
snake_weight += a[t // 2] * t + b[t // 2] * (t + 1)
elif remain == 2:
current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight
snake_weight += b[t // 2] * t + a[t // 2] * (t + 1)
if current_weight > max_weight:
max_weight = current_weight
print(max_weight)
'\n3\n0 1 0\n0 0 0\n'
039
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 - 1
for i in range(n):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
040
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()))
041
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in reversed(range(len(ops))):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
042
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 5]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
043
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 2) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
044
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy + m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
045
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif not x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
046
def main():
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
roundup = []
rounddown = []
sumsofar = []
for i, (a, b) in enumerate(zip(reversed(A), reversed(B))):
ssf = sumsofar[-1] if sumsofar else 0
t = roundup[-1] if roundup else 0
roundup.append(t + ssf + b * (1 + 2 * i))
t = rounddown[-1] if rounddown else 0
rounddown.append(t + ssf + a * (1 + 2 * i))
sumsofar.append(ssf + a + b)
roundup = list(reversed(roundup))
rounddown = list(reversed(rounddown))
sumsofar = list(reversed(sumsofar))
bestres = 0
sofar = 0
for i, (a, b) in enumerate(zip(A, B)):
rup, rdo = (roundup, rounddown)
if i % 2:
a, b = (b, a)
rup, rdo = (rdo, rup)
bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i)
sofar += a * 3 * i
sofar += b * (2 * i + 1)
bestres = max(bestres, sofar)
print(bestres)
def __starting_point():
main()
__starting_point()
047
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244355
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
048
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1 - 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
049
def main():
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
roundup = []
rounddown = []
sumsofar = []
for i, (a, b) in enumerate(zip(reversed(A), reversed(B))):
ssf = sumsofar[-1] if sumsofar else 0
t = roundup[-1] if roundup else 0
roundup.append(t + ssf + b * (1 + 2 * i))
t = rounddown[-1] if rounddown else 0
rounddown.append(t + ssf + a * (1 + 2 * i))
sumsofar.append(ssf + a + b)
roundup = list(reversed(roundup))
rounddown = list(reversed(rounddown))
sumsofar = list(reversed(sumsofar))
bestres = 0
sofar = 0
for i, (a, b) in enumerate(zip(A, B)):
rup, rdo = (roundup, rounddown)
if i % 2:
a, b = (b, a)
rup, rdo = (rdo, rup)
bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i)
sofar += a * 2 * i
sofar += b * (-2 * i + 1)
bestres = max(bestres, sofar)
print(bestres)
def __starting_point():
main()
__starting_point()
050
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R - 1]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
051
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1] = a[i][n - 1]
pref_up[i][n - 1] = a[i][n - 1]
pref_down[i][n - 1] = a[i][n - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
elif i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e+18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
elif j == n - 1:
ans = max(ans, zig[1 - j % 2][n - 1])
elif j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
052
import sys
input = sys.stdin.readline
from collections import deque
class Unionfind:
def __init__(self, n):
self.par = [-1] * n
self.rank = [1] * n
def root(self, x):
p = x
while not self.par[p] < 0:
p = self.par[p]
while x != p:
tmp = x
x = self.par[x]
self.par[tmp] = p
return p
def unite(self, x, y):
rx, ry = (self.root(x), self.root(y))
if rx == ry:
return False
if self.rank[rx] < self.rank[ry]:
rx, ry = (ry, rx)
self.par[rx] += self.par[ry]
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.par[self.root(x)]
def bfs(s):
q = deque([s])
color[s] = 1
b, w = (1, 0)
while q:
v = q.popleft()
for nv in adj_list[v]:
if color[nv] == 0:
color[nv] = -color[v]
q.append(nv)
if color[nv] == 1:
b += 1
else:
w += 1
elif color[nv] == color[v]:
return (-1, -1)
return (b, w)
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
adj_list = [[] for _ in range(n)]
uf = Unionfind(n)
MOD = 998244353
for _ in range(m):
u, v = map(int, input().split())
adj_list[u - 1].append(v - 1)
adj_list[v - 1].append(u - 1)
uf.unite(u - 1, v - 1)
roots = set((uf.root(i) for i in range(n)))
ans = 1
color = [0] * n
for r in roots:
if uf.count(r) == 3:
ans *= 3
else:
b, w = bfs(r)
if b == -1:
ans = 0
break
else:
ans *= pow(2, b, MOD) + pow(2, w, MOD)
ans %= MOD
print(ans)
053
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r + 1]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
054
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 and 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)
055
import sys
input = sys.stdin.readline
from collections import deque
class Unionfind:
def __init__(self, n):
self.par = [-1] * n
self.rank = [1] * n
def root(self, x):
p = x
while not self.par[p] < 0:
p = self.par[p]
while x != p:
tmp = x
x = self.par[x]
self.par[tmp] = p
return p
def unite(self, x, y):
rx, ry = (self.root(x), self.root(y))
if rx == ry:
return False
if self.rank[rx] < self.rank[ry]:
rx, ry = (ry, rx)
self.par[rx] += self.par[ry - 1]
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.par[self.root(x)]
def bfs(s):
q = deque([s])
color[s] = 1
b, w = (1, 0)
while q:
v = q.popleft()
for nv in adj_list[v]:
if color[nv] == 0:
color[nv] = -color[v]
q.append(nv)
if color[nv] == 1:
b += 1
else:
w += 1
elif color[nv] == color[v]:
return (-1, -1)
return (b, w)
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
adj_list = [[] for _ in range(n)]
uf = Unionfind(n)
MOD = 998244353
for _ in range(m):
u, v = map(int, input().split())
adj_list[u - 1].append(v - 1)
adj_list[v - 1].append(u - 1)
uf.unite(u - 1, v - 1)
roots = set((uf.root(i) for i in range(n)))
ans = 1
color = [0] * n
for r in roots:
if uf.count(r) == 1:
ans *= 3
else:
b, w = bfs(r)
if b == -1:
ans = 0
break
else:
ans *= pow(2, b, MOD) + pow(2, w, MOD)
ans %= MOD
print(ans)
056
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()))
057
import sys
input = sys.stdin.readline
from collections import deque
class Unionfind:
def __init__(self, n):
self.par = [-1] * n
self.rank = [1] * n
def root(self, x):
p = x
while not self.par[p] < 0:
p = self.par[p]
while x != p:
tmp = x
x = self.par[x]
self.par[tmp] = p
return p
def unite(self, x, y):
rx, ry = (self.root(x), self.root(y))
if rx == ry:
return False
if self.rank[rx] < self.rank[ry]:
rx, ry = (ry, rx)
self.par[rx] += self.par[ry]
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.par[self.root(x)]
def bfs(s):
q = deque([s])
color[s] = 1
b, w = (1, 0)
while q:
v = q.popleft()
for nv in adj_list[v]:
if color[nv] == 0:
color[nv] = -color[v]
q.append(nv)
if color[nv] == 1:
b += 1
else:
w += 1
elif color[nv] == color[v]:
return (-1, -1)
return (b, w)
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
adj_list = [[] for _ in range(n)]
uf = Unionfind(n)
MOD = 998244353
for _ in range(m):
u, v = map(int, input().split())
adj_list[u - 1].append(v - 1)
adj_list[v - 1].append(u - 1)
uf.unite(u - 1, v - 1)
roots = set((uf.root(i) for i in range(n)))
ans = 1
color = [0] * n
for r in roots:
if uf.count(r) == 1:
ans *= 1
else:
b, w = bfs(r)
if b == -1:
ans = 0
break
else:
ans *= pow(2, b, MOD) + pow(2, w, MOD)
ans %= MOD
print(ans)
058
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)
059
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 1)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
060
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))
061
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 1
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
062
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter
def calc(s, a):
return (pow(2, s, mod) + pow(2, a - s, mod)) % mod
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGELIST = [[] for j in range(n + 1)]
ANS = 1
Group = [j for j in range(n + 1)]
for a, b in EDGE:
Union(a, b)
EDGELIST[a].append(b)
EDGELIST[b].append(a)
testing = [None] * (n + 1)
flag = 1
for i in range(1 + 1, n + 1):
if testing[i] != None:
continue
score = 1
allscore = 1
testing[i] = 1
QUE = deque([i])
while QUE:
x = QUE.pop()
for to in EDGELIST[x]:
if testing[to] == -testing[x]:
continue
if testing[to] == testing[x]:
flag = 0
break
testing[to] = -testing[x]
if testing[to] == 1:
score += 1
allscore += 1
QUE.append(to)
if flag == 0:
break
if flag == 0:
break
ANS = ANS * calc(score, allscore) % mod
if flag == 0:
print(0)
continue
print(ANS)
063
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 1
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
064
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) // mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
065
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter
def calc(s, a):
return (pow(2, s, mod) + pow(2, a - s, mod)) % mod
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGELIST = [[] for j in range(n + 1)]
ANS = 1
Group = [j for j in range(n + 1)]
for a, b in EDGE:
Union(a, b)
EDGELIST[a].append(b)
EDGELIST[b].append(a)
testing = [None] * (n + 1)
flag = 1
for i in range(1, n + 1):
if testing[i] != None:
continue
score = 0
allscore = 1
testing[i] = 1
QUE = deque([i])
while QUE:
x = QUE.pop()
for to in EDGELIST[x]:
if testing[to] == -testing[x]:
continue
if testing[to] == testing[x]:
flag = 0
break
testing[to] = -testing[x]
if testing[to] == 1:
score += 1
allscore += 1
QUE.append(to)
if flag == 0:
break
if flag == 0:
break
ANS = ANS * calc(score, allscore) % mod
if flag == 0:
print(0)
continue
print(ANS)
066
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()
067
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 2:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
068
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))
069
from sys import stdin
from math import *
line = stdin.readline().rstrip().split()
n = int(line[0])
numbers = list(map(int, stdin.readline().rstrip().split()))
numbers2 = list(map(int, stdin.readline().rstrip().split()))
growRateAccum = 0
topAccum = 0
bottomAccum = 0
accumsB = [0] * n
accumsT = [0] * n
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum *= numbers[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers[i]
if i < n - 1:
growRateAccum += numbers2[i + 1]
accum += growRateAccum
accumsB[i] = accum
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum += numbers2[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers2[i]
if i < n - 1:
growRateAccum += numbers[i + 1]
accum += growRateAccum
accumsT[i] = accum
cMax = 0
currAccum = 0
growRateAccum = sum(numbers[1:]) + sum(numbers2[1:])
for i in range(n):
if i % 2 == 0:
cMax = max(cMax, currAccum + accumsT[i])
else:
cMax = max(cMax, currAccum + accumsB[i])
if i < n - 1:
if i % 2 == 0:
currAccum += numbers2[i] + growRateAccum * 2
else:
currAccum += numbers[i] + growRateAccum * 2
growRateAccum -= numbers[i + 1]
growRateAccum -= numbers2[i + 1]
print(cMax)
070
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244355
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n nonlocal color\n nonlocal bipertite\n nonlocal color_count\n\n color[s] = c\n color_count[c] += 1\n for i in range(0, len(graph[s])):\n\n if color[graph[s][i]] == -1:\n dfs(graph[s][i], 1-c)\n\n if color[s] == color[graph[s][i]]:\n bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
next_value = pow_value[i - 1] * 2 % MOD
pow_value.append(next_value)
while t:
n, m = list(map(int, input().split()))
if m == 0:
print(pow(3, n, MOD))
t -= 1
continue
graph.clear()
bipertite = True
result = 1
for node in range(0, n + 1):
color[node] = -1
while m:
u, v = list(map(int, input().split()))
graph[u].append(v)
graph[v].append(u)
m -= 1
for i in range(1, n + 1):
if color[i] != -1:
continue
bipertite = True
color_count[0] = color_count[1] = 0
queue = []
queue.append(i)
color[i] = 0
color_count[0] += 1
while queue:
if bipertite == False:
break
front_node = queue.pop()
for child_node in range(0, len(graph[front_node])):
if color[graph[front_node][child_node]] == -1:
color[graph[front_node][child_node]] = 1 - color[front_node]
queue.append(graph[front_node][child_node])
color_count[color[graph[front_node][child_node]]] += 1
elif color[front_node] == color[graph[front_node][child_node]]:
bipertite = False
break
if bipertite == False:
print(0)
break
current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
result = result * current % MOD
if bipertite:
print(result)
t -= 1
071
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
curl_ud_weights = [0] * n
curl_du_weights = [0] * n
sums = [0] * n
sums[n - 1] = a[n - 1] + b[n - 1]
curl_ud_weights[n - 1] = b[n - 1]
curl_du_weights[n - 1] = a[n - 1]
for i in range(n - 2, -1, -1):
sums[i] = sums[i + 1] + (a[i] + b[i])
remain = n * 2 - i * 2 - 1
curl_ud_weights[i] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i]
curl_du_weights[i - 1] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i]
snake_weight = 0
max_weight = 0
current_weight = -1
for t in range(0, 2 * n, 2):
remain = t % 4
if remain == 0:
current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight
snake_weight += a[t // 2] * t + b[t // 2] * (t + 1)
elif remain == 2:
current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight
snake_weight += b[t // 2] * t + a[t // 2] * (t + 1)
if current_weight > max_weight:
max_weight = current_weight
print(max_weight)
'\n3\n0 1 0\n0 0 0\n'
072
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[0]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
073
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i - 1] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
074
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][0] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
075
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))
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
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)
078
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()))
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
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 4]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
081
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 3
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
082
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] != l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
083
def main():
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
roundup = []
rounddown = []
sumsofar = []
for i, (a, b) in enumerate(zip(reversed(A), reversed(B))):
ssf = sumsofar[-1] if sumsofar else 0
t = roundup[-1] if roundup else 0
roundup.append(t + ssf + b * (1 + 2 * i))
t = rounddown[-1] if rounddown else 0
rounddown.append(t + ssf + a * (1 + 2 * i))
sumsofar.append(ssf + a + b)
roundup = list(reversed(roundup))
rounddown = list(reversed(rounddown))
sumsofar = list(reversed(sumsofar))
bestres = 0
sofar = 0
for i, (a, b) in enumerate(zip(A, B)):
rup, rdo = (roundup, rounddown)
if i % 2:
a, b = (b, a)
rup, rdo = (rdo, rup)
bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i)
sofar += a * -2 * i
sofar += b * (2 * i + 1)
bestres = max(bestres, sofar)
print(bestres)
def __starting_point():
main()
__starting_point()
084
def main():
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
roundup = []
rounddown = []
sumsofar = []
for i, (a, b) in enumerate(zip(reversed(A), reversed(B))):
ssf = sumsofar[-1] if sumsofar else 0
t = roundup[-1] if roundup else 0
roundup.append(t + ssf + b * (-1 + 2 * i))
t = rounddown[-1] if rounddown else 0
rounddown.append(t + ssf + a * (1 + 2 * i))
sumsofar.append(ssf + a + b)
roundup = list(reversed(roundup))
rounddown = list(reversed(rounddown))
sumsofar = list(reversed(sumsofar))
bestres = 0
sofar = 0
for i, (a, b) in enumerate(zip(A, B)):
rup, rdo = (roundup, rounddown)
if i % 2:
a, b = (b, a)
rup, rdo = (rdo, rup)
bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i)
sofar += a * 2 * i
sofar += b * (2 * i + 1)
bestres = max(bestres, sofar)
print(bestres)
def __starting_point():
main()
__starting_point()
085
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()
086
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()
087
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 2:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
088
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] >= k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
089
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1 - 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
090
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == -1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
091
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [4, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
092
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch != left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
093
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244357
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n nonlocal color\n nonlocal bipertite\n nonlocal color_count\n\n color[s] = c\n color_count[c] += 1\n for i in range(0, len(graph[s])):\n\n if color[graph[s][i]] == -1:\n dfs(graph[s][i], 1-c)\n\n if color[s] == color[graph[s][i]]:\n bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
next_value = pow_value[i - 1] * 2 % MOD
pow_value.append(next_value)
while t:
n, m = list(map(int, input().split()))
if m == 0:
print(pow(3, n, MOD))
t -= 1
continue
graph.clear()
bipertite = True
result = 1
for node in range(0, n + 1):
color[node] = -1
while m:
u, v = list(map(int, input().split()))
graph[u].append(v)
graph[v].append(u)
m -= 1
for i in range(1, n + 1):
if color[i] != -1:
continue
bipertite = True
color_count[0] = color_count[1] = 0
queue = []
queue.append(i)
color[i] = 0
color_count[0] += 1
while queue:
if bipertite == False:
break
front_node = queue.pop()
for child_node in range(0, len(graph[front_node])):
if color[graph[front_node][child_node]] == -1:
color[graph[front_node][child_node]] = 1 - color[front_node]
queue.append(graph[front_node][child_node])
color_count[color[graph[front_node][child_node]]] += 1
elif color[front_node] == color[graph[front_node][child_node]]:
bipertite = False
break
if bipertite == False:
print(0)
break
current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
result = result * current % MOD
if bipertite:
print(result)
t -= 1
094
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 3 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
095
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0], reverse=True)
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
096
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1 - 1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((2 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
097
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))
098
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)
099
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)
100
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)
101
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N, M = readmap()
A = [0] + readlist() + [M]
on_time = []
off_time = []
for i in range(1, N + 2):
if i % 2 == 1:
on_time.append(A[i] - A[i - 1])
else:
off_time.append(A[i] - A[i - 1])
sum_on_time = sum(on_time)
max_on_time = sum_on_time
if N % 2 == 1:
i = N + 1
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 1
print(max_on_time)
else:
i = N
sum_on_time -= A[N + 1] - A[N]
while i > 0:
if A[i] - A[i - 1] > 1:
x = A[i - 1] + 1
max_on_time = max(max_on_time, sum_on_time + A[i] - x)
sum_on_time = sum_on_time + (A[i] - A[i - 1]) - (A[i - 1] - A[i - 2])
if A[i - 1] - A[i - 2] > 1:
x = A[i - 1] - 1
max_on_time = max(max_on_time, sum_on_time + x - A[i - 2])
i -= 2
print(max_on_time)
102
import sys
input = sys.stdin.readline
from collections import deque
class Unionfind:
def __init__(self, n):
self.par = [-1] * n
self.rank = [1] * n
def root(self, x):
p = x
while not self.par[p] < 0:
p = self.par[p]
while x != p:
tmp = x
x = self.par[x]
self.par[tmp] = p
return p
def unite(self, x, y):
rx, ry = (self.root(x), self.root(y))
if rx == ry:
return False
if self.rank[rx] < self.rank[ry]:
rx, ry = (ry, rx)
self.par[rx] += self.par[ry]
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.par[self.root(x)]
def bfs(s):
q = deque([s])
color[s] = 1
b, w = (1, 0)
while q:
v = q.popleft()
for nv in adj_list[v]:
if color[nv] == 0:
color[nv] = -color[v]
q.append(nv)
if color[nv] == 1:
b += 1
else:
w += 1
elif color[nv] == color[v]:
return (-1, -1)
return (b, w)
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
adj_list = [[] for _ in range(n)]
uf = Unionfind(n)
MOD = 998244353
for _ in range(m):
u, v = map(int, input().split())
adj_list[u - 1].append(v - 1)
adj_list[v - 1].append(u - 1)
uf.unite(u - 1, v - 1)
roots = set((uf.root(i) for i in range(n)))
ans = 1
color = [0] * n
for r in roots:
if uf.count(r) == 5:
ans *= 3
else:
b, w = bfs(r)
if b == -1:
ans = 0
break
else:
ans *= pow(2, b, MOD) + pow(2, w, MOD)
ans %= MOD
print(ans)
103
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 6 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
104
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 + 1
for i in range(n):
if i != n - 1:
teclight += gar[i - 1]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
105
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))
106
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)
107
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()
108
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h < 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
109
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 4:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
110
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] >= hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
111
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()
112
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))
113
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) & parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
114
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
115
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)
116
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 <= i < n and -2 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
117
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
ans = 1
part = 0
factor = 0
fila = deque([])
n, m = map(int, input().split())
if m > n // 2 * (n // 2 + 1):
saida.append('0')
for edge_count in range(m):
input()
continue
edge = [[] for i in range(n + 1)]
visitados = [-1] * (n + 1)
assure = 1
for arestas in range(m):
u, v = map(int, input().split())
edge[u].append(v)
edge[v].append(u)
visitados[1] = 0
fila.append(1)
break_all = False
while not break_all:
par, impar = (1, 0)
while fila and (not break_all):
search = fila.popleft()
current = visitados[search]
for i in edge[search]:
if visitados[i] == -1:
visitados[i] = current ^ 1
if visitados[i] & 1:
impar += 1
else:
par += 1
fila.append(i)
elif visitados[i] == current:
break_all = True
else:
assert visitados[i] == current ^ 1
if break_all:
ans = 0
elif (par, impar) == (1, 0):
factor += 1
else:
ans *= pow(2, par, modulo) + pow(2, impar, modulo)
ans %= modulo
while assure <= n:
if visitados[assure] == -1:
part += 1
visitados[assure] = 2 * part
fila.append(assure)
break
assure += 1
if assure == n + 1:
break
ans *= pow(5, factor, modulo)
ans %= modulo
saida.append(str(ans))
print('\n'.join(saida))
118
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S + tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 0:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
119
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1] = a[i][n - 1 - 1]
pref_up[i][n - 1] = a[i][n - 1]
pref_down[i][n - 1] = a[i][n - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
elif i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e+18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
elif j == n - 1:
ans = max(ans, zig[1 - j % 2][n - 1])
elif j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
120
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y // m + x
neigh.append([])
if x and l[yx] == l[yx - 1]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
121
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 4 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
122
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=' ')
123
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)
124
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // -2
else:
n = n // 2 + 1
for i in range(n):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
125
M = 998244353
def powmod(a, x, m=M):
y = 1
while 0 < x:
if x % 2 == 1:
y *= a
y %= m
x //= 2
a = a ** 2
a %= m
return y
def solve(s):
n = len(s)
nb = nc = 0
ch = s[0]
if ch == 'b':
nb += 1
elif ch != 'c':
nc += 1
sf = True
tf = True
left = ch
for ch in s[1:]:
if ch == 'b':
nb += 1
elif ch == 'c':
nc += 1
if ch == left:
sf = False
else:
tf = False
left = ch
if tf:
return 1
if n == 3:
if (nb + nc * 2) % 3:
return 7 if sf else 6
else:
return 3
if n % 3:
return (powmod(3, n - 1) + M - powmod(2, n - 1) + (1 if sf else 0)) % M
elif (nb + nc * 2) % 3:
return (powmod(3, n - 1) + M - (powmod(2, n - 1) - powmod(2, n // 3 - 1)) + (1 if sf else 0)) % M
else:
return (powmod(3, n - 1) + M - (powmod(2, n // 3) + 4 * powmod(8, n // 3 - 1)) + (1 if sf else 0)) % M
def main():
s = input()
print(solve(s))
def __starting_point():
main()
__starting_point()
126
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo * m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
127
msg_in = input().split()
x = int(msg_in[0])
y = int(msg_in[1])
num_of_transform = [0, 0]
matrix = []
blank = []
for i in range(y + 2):
blank.append(' ')
matrix.append(blank)
for i in range(x):
msg_in = input()
matrix.append([' '])
for j in msg_in:
matrix[i + 1].append(j)
matrix[i + 1].append(' ')
matrix.append(blank)
while True:
for i in range(1, x + 1):
for j in range(1, y + 1):
sum = 0
if matrix[i][j] != ' ':
if matrix[i][j - 1] == matrix[i][j]:
sum += 1
if matrix[i][j + 1] == matrix[i][j]:
sum += 1
if matrix[i - 1][j] == matrix[i][j]:
sum += 1
if matrix[i + 1][j] == matrix[i][j]:
sum += 1
if sum < 2:
matrix[i][j] = ' '
num_of_transform[0] += 1
if num_of_transform[0] == x * y:
print('No')
break
elif num_of_transform[0] == num_of_transform[1]:
print('Yes')
break
else:
num_of_transform[1] = num_of_transform[0]
128
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244349
for _ in range(t):
ans = 1
part = 0
factor = 0
fila = deque([])
n, m = map(int, input().split())
if m > n // 2 * (n // 2 + 1):
saida.append('0')
for edge_count in range(m):
input()
continue
edge = [[] for i in range(n + 1)]
visitados = [-1] * (n + 1)
assure = 1
for arestas in range(m):
u, v = map(int, input().split())
edge[u].append(v)
edge[v].append(u)
visitados[1] = 0
fila.append(1)
break_all = False
while not break_all:
par, impar = (1, 0)
while fila and (not break_all):
search = fila.popleft()
current = visitados[search]
for i in edge[search]:
if visitados[i] == -1:
visitados[i] = current ^ 1
if visitados[i] & 1:
impar += 1
else:
par += 1
fila.append(i)
elif visitados[i] == current:
break_all = True
else:
assert visitados[i] == current ^ 1
if break_all:
ans = 0
elif (par, impar) == (1, 0):
factor += 1
else:
ans *= pow(2, par, modulo) + pow(2, impar, modulo)
ans %= modulo
while assure <= n:
if visitados[assure] == -1:
part += 1
visitados[assure] = 2 * part
fila.append(assure)
break
assure += 1
if assure == n + 1:
break
ans *= pow(3, factor, modulo)
ans %= modulo
saida.append(str(ans))
print('\n'.join(saida))
129
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=' ')
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 - 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))
131
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()))
132
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1] = a[i][n - 1]
pref_up[i][n - 1] = a[i][n - 1]
pref_down[i][n - 1 - 1] = a[i][n - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
elif i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e+18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
elif j == n - 1:
ans = max(ans, zig[1 - j % 2][n - 1])
elif j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
133
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=' ')
134
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1 - 1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
135
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if not new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
136
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1):
if a[i + 1] - a[i] == 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
137
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 1
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
138
from sys import stdin
from collections import deque
n, S = [int(x) for x in stdin.readline().split()]
ppl = []
base = 0
tSlices = 0
for dude in range(n):
s, a, b = [int(x) for x in stdin.readline().split()]
base += s * a
tSlices += s
ppl.append([b - a, s])
if tSlices % S != 0:
ppl.append([0, S - tSlices % S])
ppl.sort(reverse=True)
totalS = 0
totalH = 0
for h, s in ppl:
if totalS + s < S:
totalS += s
totalH += h * s
else:
s -= S - totalS
totalH += h * (S - totalS)
if totalH > 0:
base += totalH
else:
break
totalS = 0
totalH = 0
if h > 2:
base += h * (s // S * S)
totalS = s % S
totalH = h * (s % S)
else:
break
print(base)
139
def bins(sortedlist, x):
n = len(sortedlist)
start = 0
end = n - 1
while start <= end:
mid = int((start + end) / 2)
if not x == sortedlist[mid][0]:
return mid
elif x < sortedlist[mid][0]:
end = mid - 1
else:
start = mid + 1
if sortedlist[mid][0] <= x:
return mid
else:
return mid - 1
n, s = list(map(int, input().split()))
hap = []
for i in range(n):
hap.append(list(map(int, input().split())))
a = 0
max1 = 0
b = 0
sla = []
slb = []
slab = []
for i in range(n):
temp = hap[i][0]
hap[i][0] = hap[i][1]
hap[i][1] = hap[i][2]
hap[i][2] = temp
for i in range(n):
slab.append([hap[i][0] - hap[i][1], hap[i][2]])
happi = 0
for i in range(n):
if hap[i][0] > hap[i][1]:
a += hap[i][2]
happi += hap[i][2] * hap[i][0]
else:
b += hap[i][2]
happi += hap[i][2] * hap[i][1]
sla.sort()
slb.sort()
slab.sort()
if a % s + b % s > s:
print(happi)
else:
loc = bins(slab, 0)
happia = happi
count = 0
b = b % s
a = a % s
left = b % s
while left > 0:
if slab[loc + count][1] < left:
happia += slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happia += slab[loc + count][0] * left
break
count -= 1
left = a % s
count = 0
happib = happi
while loc < n and slab[loc][0] <= 0:
loc += 1
while left > 0:
if slab[loc + count][1] < left:
happib -= slab[loc + count][0] * slab[loc + count][1]
left -= slab[loc + count][1]
else:
happib -= slab[loc + count][0] * left
break
count += 1
print(max(happia, happib))
140
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 >= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
141
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) // mod)
main()
142
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return 0 <= i < n and 3 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
143
from sys import stdin
from math import *
line = stdin.readline().rstrip().split()
n = int(line[0])
numbers = list(map(int, stdin.readline().rstrip().split()))
numbers2 = list(map(int, stdin.readline().rstrip().split()))
growRateAccum = 0
topAccum = 0
bottomAccum = 0
accumsB = [0] * n
accumsT = [0] * n
growRateAccum = 0
accum = 0
for i in reversed(range(n - 1, -1, -1)):
accum += numbers[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers[i]
if i < n - 1:
growRateAccum += numbers2[i + 1]
accum += growRateAccum
accumsB[i] = accum
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum += numbers2[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers2[i]
if i < n - 1:
growRateAccum += numbers[i + 1]
accum += growRateAccum
accumsT[i] = accum
cMax = 0
currAccum = 0
growRateAccum = sum(numbers[1:]) + sum(numbers2[1:])
for i in range(n):
if i % 2 == 0:
cMax = max(cMax, currAccum + accumsT[i])
else:
cMax = max(cMax, currAccum + accumsB[i])
if i < n - 1:
if i % 2 == 0:
currAccum += numbers2[i] + growRateAccum * 2
else:
currAccum += numbers[i] + growRateAccum * 2
growRateAccum -= numbers[i + 1]
growRateAccum -= numbers2[i + 1]
print(cMax)
144
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 1 - 1):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
145
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (-1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
146
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -4):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
147
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, -3, 0, 1, 0, 0, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
148
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 2 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 2:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
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] if j <= (i + ss) / 2 else x
ss = None
print(*arr)
__starting_point()
150
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, -1, 0, 1]
dy = [0, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
151
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = -1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += 1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
152
def main():
n, M = [int(i) for i in input().split(' ')]
a = [0] + [int(i) for i in input().split(' ')] + [M]
n = n + 2
incr_sum = []
s = 0
for i in range(n):
if i % 2 == 1:
s += a[i] - a[i - 1]
incr_sum.append(s)
max_sum = s
for i in range(n - 4):
if a[i + 1] - a[i] != 1:
to_add = a[i + 1] - 1
s_ = incr_sum[i]
s_ += to_add - a[i]
s_ += a[-1] - a[i + 1] - (incr_sum[-1] - incr_sum[i + 1])
if s_ > max_sum:
max_sum = s_
print(max_sum)
def __starting_point():
main()
__starting_point()
153
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter
def calc(s, a):
return (pow(2, s, mod) + pow(2, a - s, mod)) % mod
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGELIST = [[] for j in range(n + 1)]
ANS = 1
Group = [j for j in range(n + 1)]
for a, b in EDGE:
Union(a, b)
EDGELIST[a].append(b)
EDGELIST[b].append(a)
testing = [None] * (n + 1)
flag = 1
for i in range(1, n + 1):
if testing[i] != None:
continue
score = 1
allscore = 1
testing[i] = 2
QUE = deque([i])
while QUE:
x = QUE.pop()
for to in EDGELIST[x]:
if testing[to] == -testing[x]:
continue
if testing[to] == testing[x]:
flag = 0
break
testing[to] = -testing[x]
if testing[to] == 1:
score += 1
allscore += 1
QUE.append(to)
if flag == 0:
break
if flag == 0:
break
ANS = ANS * calc(score, allscore) % mod
if flag == 0:
print(0)
continue
print(ANS)
154
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if not i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
155
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
gar = []
shadow = []
gar.append(a[0])
light = False
a.append(m)
for i in range(1, n + 1):
dl = a[i] - a[i - 1]
if light:
gar.append(dl)
light = False
else:
shadow.append(dl)
light = True
light = sum(gar)
dark = sum(shadow)
lightmax = light
teclight = 0
tecdark = 0
if n % 2 == 0:
n = n // 2
else:
n = n // 2 + 1
for i in range(n):
if i != n - 1:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i - 1]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
elif len(shadow) == n:
teclight += gar[i]
light -= gar[i]
if gar[i] > 1:
newlight = teclight - 1 + dark
lightmax = max(lightmax, newlight)
tecdark += shadow[i]
dark -= shadow[i]
if shadow[i] > 1:
newlight = teclight + shadow[i] - 1 + dark
lightmax = max(lightmax, newlight)
print(lightmax)
156
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()
157
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()
158
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=' ')
159
from collections import namedtuple
Member = namedtuple('Member', ['parts', 'a_happy', 'b_happy'])
def happy_diff(m):
return m.a_happy - m.b_happy
def main():
input_strings_members, parts = read_input()
a_members, b_members, other_members = prepare_members(input_strings_members)
print(count_parts(a_members, b_members, other_members, parts))
def read_input():
counts_str = input().split()
members_count, parts = list(map(int, counts_str))
return ([input() for _ in range(members_count)], parts)
def prepare_members(input_strings_members):
a_members = []
b_members = []
other_members = []
for line in input_strings_members:
m = Member(*list(map(int, line.split())))
if happy_diff(m) > 0:
a_members.append(m)
elif happy_diff(m) < 0:
b_members.append(m)
else:
other_members.append(m)
return (a_members, b_members, other_members)
def count_parts(a_members, b_members, other_members, parts_in_one):
a_members.sort(key=lambda m: happy_diff(m), reverse=False)
a_modulo = sum((m.parts for m in a_members)) % parts_in_one
a_modulo_members, a_happy_members = split_members_into_happy_groups(a_members, a_modulo)
a_happy = sum((m.a_happy * m.parts for m in a_happy_members))
b_members.sort(key=lambda m: happy_diff(m), reverse=True)
b_modulo = sum((m.parts for m in b_members)) % parts_in_one
b_modulo_members, b_happy_members = split_members_into_happy_groups(b_members, b_modulo)
b_happy = sum((m.b_happy * m.parts for m in b_happy_members))
last_happy = count_last_pizzas_happy(a_modulo_members, b_modulo_members, other_members, parts_in_one)
return a_happy + b_happy + last_happy
def split_members_into_happy_groups(members, modulo):
modulo_members = []
happy_members = []
current_modulo = 0
for i in range(len(members)):
m = members[i]
new_current_modulo = current_modulo + m.parts
if new_current_modulo < modulo:
modulo_members.append(m)
current_modulo = new_current_modulo
continue
modulo_members.append(Member(modulo - current_modulo, m.a_happy, m.b_happy))
if new_current_modulo > modulo:
happy_members.append(Member(new_current_modulo - modulo, m.a_happy, m.b_happy))
if i + 1 < len(members):
happy_members.extend(members[i + 1:])
break
return (modulo_members, happy_members)
def count_last_pizzas_happy(a, b, other, parts_in_one):
last_sorted_members = a + other + b
if sum((m.parts for m in last_sorted_members)) <= parts_in_one:
return max(sum((m.a_happy * m.parts for m in last_sorted_members)), sum((m.b_happy * m.parts for m in last_sorted_members)))
return sum((m.a_happy * m.parts for m in a + other)) + sum((m.b_happy * m.parts for m in b))
def test1():
a, b, c = prepare_members(['7 4 7', '5 8 8', '12 5 8', '6 11 6', '3 3 7', '5 9 6'])
assert count_parts(a, b, c, 10) == 314
def test2():
a, b, c = prepare_members(['3 5 7', '4 6 7', '5 9 5'])
assert count_parts(a, b, c, 12) == 84
def test3():
a, b, c = prepare_members(['2 3 1', '2 2 2', '2 1 3'])
assert count_parts(a, b, c, 3) == 16
def test4():
a, b, c = prepare_members(['2 1 4', '2 3 1'])
assert count_parts(a, b, c, 3) == 14
def test5():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 3) == (8 + 6 + 4) * 2
def test6():
a, b, c = prepare_members(['2 1 2', '2 2 1', '2 1 3', '2 3 1', '2 1 4', '2 4 1'])
assert count_parts(a, b, c, 5) == 16 + 16 + 3
def test_without_last_pizzas():
a, b, c = prepare_members(['3 3 1', '3 5 6'])
assert count_parts(a, b, c, 3) == 27
def test_with_one_last_pizza():
a, b, c = prepare_members(['2 3 1', '1 5 6'])
assert count_parts(a, b, c, 3) == 11
def test_with_two_last_pizzas():
a, b, c = prepare_members(['2 3 4', '2 3 1', '1 1 1'])
assert count_parts(a, b, c, 3) == 15
def test_without_different_happies():
a, b, c = prepare_members(['2 2 2', '4 1 1', '5 6 6'])
assert count_parts(a, b, c, 3) == 38
def __starting_point():
main()
__starting_point()
160
n = int(input())
a = [list(map(int, input().split())) for i in range(2)]
if n != 1:
sum_up, pref_up, sum_down, pref_down = [[[0 for i in range(n)] for j in range(2)] for _ in range(4)]
for i in range(2):
sum_up[i][n - 1] = a[i][n - 1]
pref_up[i][n - 1] = a[i][n - 1]
pref_down[i][n - 1] = a[i][n - 1 - 1]
for j in range(n - 2, -1, -1):
sum_up[i][j] = sum_up[i][j + 1] + a[i][j]
pref_up[i][j] = pref_up[i][j + 1] + sum_up[i][j]
pref_down[i][j] = pref_down[i][j + 1] + a[i][j] * (n - j)
zig = [[0 for i in range(n)] for j in range(2)]
for j in range(n):
for i in range(2):
if j % 2 == 0:
if i == 0:
zig[i][j] = a[i][j] * j * 2 + zig[i][j - 1]
else:
zig[i][j] = a[i][j] * (j * 2 + 1) + zig[1 - i][j]
elif i == 0:
zig[1 - i][j] = a[1 - i][j] * j * 2 + zig[1 - i][j - 1]
else:
zig[1 - i][j] = a[1 - i][j] * (j * 2 + 1) + zig[i][j]
ans = -1e+18
for j in range(n):
if j == 0:
ans = max(ans, pref_up[0][j] + pref_down[1][j] + sum_up[1][j] * n - sum_up[0][j] - sum_up[1][j])
elif j == n - 1:
ans = max(ans, zig[1 - j % 2][n - 1])
elif j % 2 == 1:
ans = max(ans, pref_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2 + 1) - 1) + pref_down[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2 + 1) - 1 + n - j) + zig[0][j])
else:
ans = max(ans, pref_up[1][j + 1] - sum_up[1][j + 1] + sum_up[1][j + 1] * (4 * (j // 2) + 2) + pref_down[0][j + 1] - sum_up[0][j + 1] + sum_up[0][j + 1] * (4 * (j // 2) + 2 - 1 + n - j) + zig[1][j])
ans = max(ans, pref_up[1][0] + pref_down[0][1] + sum_up[0][1] * n)
print(ans)
else:
print(a[1][0])
161
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()
162
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
curl_ud_weights = [0] * n
curl_du_weights = [0] * n
sums = [0] * n
sums[n - 1] = a[n - 1] + b[n - 1]
curl_ud_weights[n - 1] = b[n - 1]
curl_du_weights[n - 1] = a[n - 1]
for i in range(n - 2, -1, -1):
sums[i] = sums[i + 1] + (a[i] + b[i])
remain = n * 2 - i * 2 - 1
curl_ud_weights[i - 1] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i]
curl_du_weights[i] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i]
snake_weight = 0
max_weight = 0
current_weight = -1
for t in range(0, 2 * n, 2):
remain = t % 4
if remain == 0:
current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight
snake_weight += a[t // 2] * t + b[t // 2] * (t + 1)
elif remain == 2:
current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight
snake_weight += b[t // 2] * t + a[t // 2] * (t + 1)
if current_weight > max_weight:
max_weight = current_weight
print(max_weight)
'\n3\n0 1 0\n0 0 0\n'
163
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()
164
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=' ')
165
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter
def calc(s, a):
return (pow(2, s, mod) + pow(2, a - s, mod)) % mod
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGELIST = [[] for j in range(n + 1)]
ANS = 1
Group = [j for j in range(n + 1)]
for a, b in EDGE:
Union(a, b)
EDGELIST[a].append(b)
EDGELIST[b].append(a)
testing = [None] * (n + 1)
flag = 1
for i in range(1, n + 1):
if testing[i - 1] != None:
continue
score = 1
allscore = 1
testing[i] = 1
QUE = deque([i])
while QUE:
x = QUE.pop()
for to in EDGELIST[x]:
if testing[to] == -testing[x]:
continue
if testing[to] == testing[x]:
flag = 0
break
testing[to] = -testing[x]
if testing[to] == 1:
score += 1
allscore += 1
QUE.append(to)
if flag == 0:
break
if flag == 0:
break
ANS = ANS * calc(score, allscore) % mod
if flag == 0:
print(0)
continue
print(ANS)
166
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))
167
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 0, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-0] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
168
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244353
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n nonlocal color\n nonlocal bipertite\n nonlocal color_count\n\n color[s] = c\n color_count[c] += 1\n for i in range(0, len(graph[s])):\n\n if color[graph[s][i]] == -1:\n dfs(graph[s][i], 1-c)\n\n if color[s] == color[graph[s][i]]:\n bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(0, 3 * 10 ** 5 + 1000):
next_value = pow_value[i - 1] * 2 % MOD
pow_value.append(next_value)
while t:
n, m = list(map(int, input().split()))
if m == 0:
print(pow(3, n, MOD))
t -= 1
continue
graph.clear()
bipertite = True
result = 1
for node in range(0, n + 1):
color[node] = -1
while m:
u, v = list(map(int, input().split()))
graph[u].append(v)
graph[v].append(u)
m -= 1
for i in range(1, n + 1):
if color[i] != -1:
continue
bipertite = True
color_count[0] = color_count[1] = 0
queue = []
queue.append(i)
color[i] = 0
color_count[0] += 1
while queue:
if bipertite == False:
break
front_node = queue.pop()
for child_node in range(0, len(graph[front_node])):
if color[graph[front_node][child_node]] == -1:
color[graph[front_node][child_node]] = 1 - color[front_node]
queue.append(graph[front_node][child_node])
color_count[color[graph[front_node][child_node]]] += 1
elif color[front_node] == color[graph[front_node][child_node]]:
bipertite = False
break
if bipertite == False:
print(0)
break
current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
result = result * current % MOD
if bipertite:
print(result)
t -= 1
169
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()))
170
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, 0, 0, 1, 0, -3, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
171
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)
172
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si + a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
173
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 3, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
174
def solve(s):
if len(s) == 2:
return 1 if s[0] == s[1] else 2
elif len(s) == 3:
if s[0] == s[1] == s[2]:
return 1
elif s[0] == s[1] or s[1] == s[2]:
return 6
elif s[0] == s[2]:
return 7
else:
return 3
if all((a == b for a, b in zip(s, s[1:]))):
return 1
dp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
dp[0][0][0] = 1
dp[0][1][1] = 1
dp[0][2][-2] = 1
MOD = 998244353
for _ in range(len(s) - 1):
ndp = [[[0] * 3 for _ in range(3)] for _ in range(2)]
ndp[0][0][0] = (dp[0][1][0] + dp[0][2][0]) % MOD
ndp[0][0][1] = (dp[0][1][1] + dp[0][2][1]) % MOD
ndp[0][0][2] = (dp[0][1][2] + dp[0][2][2]) % MOD
ndp[0][1][0] = (dp[0][0][2] + dp[0][2][2]) % MOD
ndp[0][1][1] = (dp[0][0][0] + dp[0][2][0]) % MOD
ndp[0][1][2] = (dp[0][0][1] + dp[0][2][1]) % MOD
ndp[0][2][0] = (dp[0][0][1] + dp[0][1][1]) % MOD
ndp[0][2][1] = (dp[0][0][2] + dp[0][1][2]) % MOD
ndp[0][2][2] = (dp[0][0][0] + dp[0][1][0]) % MOD
ndp[1][0][0] = (dp[0][0][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][0][1] = (dp[0][0][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][0][2] = (dp[0][0][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][0] = (dp[0][1][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][1][1] = (dp[0][1][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
ndp[1][1][2] = (dp[0][1][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][0] = (dp[0][2][1] + dp[1][0][1] + dp[1][1][1] + dp[1][2][1]) % MOD
ndp[1][2][1] = (dp[0][2][2] + dp[1][0][2] + dp[1][1][2] + dp[1][2][2]) % MOD
ndp[1][2][2] = (dp[0][2][0] + dp[1][0][0] + dp[1][1][0] + dp[1][2][0]) % MOD
dp = ndp
return (sum((dp[1][x][sum(map(ord, s)) % 3] for x in range(3))) + all((a != b for a, b in zip(s, s[1:])))) % MOD
s = input()
print(solve(s))
175
from collections import defaultdict
import sys
input = sys.stdin.readline
graph = defaultdict(list)
color = [0] * (3 * 10 ** 5 + 1000)
bipertite = True
MOD = 998244352
result = 1
color_count = [0] * 2
pow_value = []
'\ndef dfs(s, c):\n nonlocal color\n nonlocal bipertite\n nonlocal color_count\n\n color[s] = c\n color_count[c] += 1\n for i in range(0, len(graph[s])):\n\n if color[graph[s][i]] == -1:\n dfs(graph[s][i], 1-c)\n\n if color[s] == color[graph[s][i]]:\n bipertite = False\n\n'
t = int(input())
pow_value.append(1)
for i in range(1, 3 * 10 ** 5 + 1000):
next_value = pow_value[i - 1] * 2 % MOD
pow_value.append(next_value)
while t:
n, m = list(map(int, input().split()))
if m == 0:
print(pow(3, n, MOD))
t -= 1
continue
graph.clear()
bipertite = True
result = 1
for node in range(0, n + 1):
color[node] = -1
while m:
u, v = list(map(int, input().split()))
graph[u].append(v)
graph[v].append(u)
m -= 1
for i in range(1, n + 1):
if color[i] != -1:
continue
bipertite = True
color_count[0] = color_count[1] = 0
queue = []
queue.append(i)
color[i] = 0
color_count[0] += 1
while queue:
if bipertite == False:
break
front_node = queue.pop()
for child_node in range(0, len(graph[front_node])):
if color[graph[front_node][child_node]] == -1:
color[graph[front_node][child_node]] = 1 - color[front_node]
queue.append(graph[front_node][child_node])
color_count[color[graph[front_node][child_node]]] += 1
elif color[front_node] == color[graph[front_node][child_node]]:
bipertite = False
break
if bipertite == False:
print(0)
break
current = (pow_value[color_count[0]] + pow_value[color_count[1]]) % MOD
result = result * current % MOD
if bipertite:
print(result)
t -= 1
176
import sys
input = sys.stdin.readline
from collections import deque
class Unionfind:
def __init__(self, n):
self.par = [-1] * n
self.rank = [1] * n
def root(self, x):
p = x
while not self.par[p] < 0:
p = self.par[p]
while x != p:
tmp = x
x = self.par[x]
self.par[tmp] = p
return p
def unite(self, x, y):
rx, ry = (self.root(x), self.root(y))
if rx == ry:
return False
if self.rank[rx] < self.rank[ry]:
rx, ry = (ry, rx)
self.par[rx] += self.par[ry]
self.par[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.root(x) == self.root(y)
def count(self, x):
return -self.par[self.root(x)]
def bfs(s):
q = deque([s])
color[s] = 1
b, w = (1, 0)
while q:
v = q.popleft()
for nv in adj_list[v]:
if color[nv] == 0:
color[nv] = -color[v]
q.append(nv)
if color[nv] == 1:
b += 1
else:
w += 1
elif color[nv] == color[v]:
return (-1, -1)
return (b, w)
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
adj_list = [[] for _ in range(n)]
uf = Unionfind(n)
MOD = 998244353
for _ in range(m):
u, v = map(int, input().split())
adj_list[u - 1].append(v - 1)
adj_list[v - 1].append(u - 1)
uf.unite(u - 1, v - 1)
roots = set((uf.root(i) for i in range(n)))
ans = 1
color = [0] * n
for r in roots:
if uf.count(r) == 1:
ans *= 7
else:
b, w = bfs(r)
if b == -1:
ans = 0
break
else:
ans *= pow(2, b, MOD) + pow(2, w, MOD)
ans %= MOD
print(ans)
177
a, b = [int(i) for i in input().split()]
q = [int(i) for i in input().split()]
s = []
for p in range(b):
s += [[int(i) for i in input().split()]]
S = []
k = 0
for p in range(b - 1, -1, -1):
if s[p][1] > k:
S += [s[p]]
k = s[p][1]
Q1 = sorted(q[:S[-1][1]])
x, y = (0, S[-1][1] - 1)
S = [[0, 0]] + S
l = 1
for j in range(S[-1][1] - 1, -1, -1):
if x > y:
break
if j < S[-l][1]:
k = S[-l][0]
l += -1
if k == 1:
q[j] = Q1[y]
y -= 1
if k == 2:
q[j] = Q1[x]
x += 1
print(' '.join(list(map(str, q))))
178
from collections import deque
from sys import stdin, stdout
input = stdin.readline
saida = []
t = int(input())
modulo = 998244353
for _ in range(t):
ans = 1
part = 0
factor = 0
fila = deque([])
n, m = map(int, input().split())
if m >= n // 2 * (n // 2 + 1):
saida.append('0')
for edge_count in range(m):
input()
continue
edge = [[] for i in range(n + 1)]
visitados = [-1] * (n + 1)
assure = 1
for arestas in range(m):
u, v = map(int, input().split())
edge[u].append(v)
edge[v].append(u)
visitados[1] = 0
fila.append(1)
break_all = False
while not break_all:
par, impar = (1, 0)
while fila and (not break_all):
search = fila.popleft()
current = visitados[search]
for i in edge[search]:
if visitados[i] == -1:
visitados[i] = current ^ 1
if visitados[i] & 1:
impar += 1
else:
par += 1
fila.append(i)
elif visitados[i] == current:
break_all = True
else:
assert visitados[i] == current ^ 1
if break_all:
ans = 0
elif (par, impar) == (1, 0):
factor += 1
else:
ans *= pow(2, par, modulo) + pow(2, impar, modulo)
ans %= modulo
while assure <= n:
if visitados[assure] == -1:
part += 1
visitados[assure] = 2 * part
fila.append(assure)
break
assure += 1
if assure == n + 1:
break
ans *= pow(3, factor, modulo)
ans %= modulo
saida.append(str(ans))
print('\n'.join(saida))
179
from math import ceil, log
t = 1
for test in range(t):
n, m = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.append(m)
prev = 0
on = 0
counter = 0
for i in arr:
if counter % 2 == 0:
on += i - prev
prev = i
counter += 1
off = m - on
counter = 0
ans = on
prev = 0
prevOn = 0
for i in arr:
if counter % 6 == 0:
if i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn - (i - prev))
if tmp > ans:
ans = tmp
prevOn += i - prev
elif i - prev != 1:
tmp = prevOn + i - prev - 1 + m - i - (on - prevOn)
if tmp > ans:
ans = tmp
prev = i
counter += 1
print(ans)
180
def main():
from collections import deque
n, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
l = list((tuple(map(int, input().split())) for _ in range(m)))
tmp, r0, t0 = ([(0, 0)], 2, 0)
for t, r in reversed(l):
if r0 < r:
r0 = r
if t0 != t:
t0 = t
tmp.append((t, r))
else:
tmp[-1] = (t, r)
t0, r0 = tmp.pop()
q = deque(sorted(aa[:r0]))
aa = aa[r0:]
aa.reverse()
ff = (None, q.pop, q.popleft)
for t, r in reversed(tmp):
f = ff[t0]
for i in range(r0 - r):
aa.append(f())
t0, r0 = (t, r)
print(' '.join(map(str, reversed(aa))))
def __starting_point():
main()
__starting_point()
181
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
curl_ud_weights = [0] * n
curl_du_weights = [0] * n
sums = [0] * n
sums[n - 1] = a[n - 1] + b[n - 1]
curl_ud_weights[n - 1] = b[n - 1]
curl_du_weights[n - 1] = a[n - 1]
for i in range(n - 2, -1, -1):
sums[i] = sums[i + 1] + (a[i] + b[i])
remain = n * 2 - i * 2 - 1
curl_ud_weights[i + 1] = sums[i + 1] + curl_ud_weights[i + 1] + remain * b[i]
curl_du_weights[i] = sums[i + 1] + curl_du_weights[i + 1] + remain * a[i]
snake_weight = 0
max_weight = 0
current_weight = -1
for t in range(0, 2 * n, 2):
remain = t % 4
if remain == 0:
current_weight = sums[t // 2] * t + curl_ud_weights[t // 2] + snake_weight
snake_weight += a[t // 2] * t + b[t // 2] * (t + 1)
elif remain == 2:
current_weight = sums[t // 2] * t + curl_du_weights[t // 2] + snake_weight
snake_weight += b[t // 2] * t + a[t // 2] * (t + 1)
if current_weight > max_weight:
max_weight = current_weight
print(max_weight)
'\n3\n0 1 0\n0 0 0\n'
182
mod = 998244353
import sys
input = sys.stdin.readline
from collections import deque
from collections import Counter
def calc(s, a):
return (pow(2, s, mod) + pow(2, a - s, mod)) % mod
def find(x):
while Group[x] != x:
x = Group[x]
return x
def Union(x, y):
if find(x) != find(y):
Group[find(y)] = Group[find(x)] = min(find(y), find(x))
testcase = int(input())
for test in range(testcase):
n, m = list(map(int, input().split()))
EDGE = [list(map(int, input().split())) for i in range(m)]
EDGELIST = [[] for j in range(n + 1)]
ANS = 1
Group = [j for j in range(n + 1)]
for a, b in EDGE:
Union(a, b)
EDGELIST[a].append(b)
EDGELIST[b].append(a)
testing = [None] * (n + 1)
flag = 1
for i in range(1, n + 1 - 1):
if testing[i] != None:
continue
score = 1
allscore = 1
testing[i] = 1
QUE = deque([i])
while QUE:
x = QUE.pop()
for to in EDGELIST[x]:
if testing[to] == -testing[x]:
continue
if testing[to] == testing[x]:
flag = 0
break
testing[to] = -testing[x]
if testing[to] == 1:
score += 1
allscore += 1
QUE.append(to)
if flag == 0:
break
if flag == 0:
break
ANS = ANS * calc(score, allscore) % mod
if flag == 0:
print(0)
continue
print(ANS)
183
M = 998244353
s = input()
n = len(s) - 1
v = sum(map(ord, s))
print((pow(3, n, M) - pow(-2, n, M) + pow(2, n // 3, M) * (n % 3 == 2) * (1 - 3 * (v % 3 == 0)) + all((s[i] != s[i + 1] for i in range(n))) - (v == 294) - 1) * any((s[0] != k for k in s)) % M + 1)
184
import sys
n, m = [int(x) for x in input().split()]
notes = [int(x) for x in input().split()]
managers = []
for line in sys.stdin:
managers.append(tuple((int(x) for x in line.split())))
bearing_managers = []
M, T = (0, 0)
for t, r in reversed(managers):
if r > M:
if t == T:
bearing_managers[-1] = (t, r)
else:
T = t
bearing_managers.append((t, r))
M = r
bearing_managers.reverse()
t, r = bearing_managers[0]
bearing_managers.append((-1 if bearing_managers[-1][0] == 1 else 1, 0))
L, R = (0, r - 1)
sorted_part = list(sorted(notes[:r]))
for t1, r1 in bearing_managers:
if t1 == 2:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[R]
R -= 1
else:
for i in range(r - 1, r1 - 1, -1):
notes[i] = sorted_part[L]
L += 1
r = r1
for x in notes:
sys.stdout.write(str(x) + ' ')
185
def solve(ls):
ls.sort(key=lambda q: q[-3] - q[0])
m = sum((si for a, b, si in ls))
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return (x, y, z, n)
n, s = list(map(int, input().split()))
first = []
second = []
for i in range(n):
si, ai, bi = list(map(int, input().split()))
if ai > bi:
first.append((ai, bi, si))
else:
second.append((bi, ai, si))
x1, y1, z1, n1 = solve(first)
x2, y2, z2, n2 = solve(second)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
186
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))
187
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)
188
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()))
189
def main():
a = input().strip()
l = len(a)
if l < 6:
s = set()
s.add(a)
q = [a]
oa = ord('a')
while q:
a = q.pop()
for i in range(l - 1):
if a[i] != a[i + 1]:
t = chr(oa + 3 - (ord(a[i]) - oa) - (ord(a[i + 1]) - oa))
na = a[:i] + t * 2 + a[i + 2:]
if na not in s:
s.add(na)
q.append(na)
print(len(s))
return
t = a[0] * l
if t == a:
print(1)
return
x = 0
for c in a:
if c == 'b':
x += 1
elif c == 'c':
x += 2
ans = 0
if all((a[i] != a[i + 1] for i in range(l - 1))):
ans += 1
mod = 998244353
dp = (1, 0, 0, 0, 1, 0, -3, 0, 1, 0, 0, 0)
for i in range(l - 1):
s = (dp[-1] + dp[-2] + dp[-3]) % mod
dp = ((dp[3] + dp[6]) % mod, (dp[4] + dp[7]) % mod, (dp[5] + dp[8]) % mod, (dp[2] + dp[8]) % mod, (dp[0] + dp[6]) % mod, (dp[1] + dp[7]) % mod, (dp[1] + dp[4]) % mod, (dp[2] + dp[5]) % mod, (dp[0] + dp[3]) % mod, (dp[0] + dp[5] + dp[7] + s) % mod, (dp[1] + dp[3] + dp[8] + s) % mod, (dp[2] + dp[4] + dp[6] + s) % mod)
print((ans + dp[9 + x % 3]) % mod)
main()
190
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=' ')
191
import sys
sys.setrecursionlimit(5000)
n, m = list(map(int, input().split()))
dx = [-1, 0, 0, 1]
dy = [2, -1, 1, 0]
L = list((input() for i in range(n)))
def check(x, y, px, py):
return x >= 0 and x < n and (y >= 0) and (y < m)
def DFS(x, y, px, py, visited):
visited[x][y] = True
for i in range(4):
newx = x + dx[i]
newy = y + dy[i]
if not check(newx, newy, px, py):
continue
if newx == px and newy == py:
continue
if L[x][y] == L[newx][newy]:
if visited[newx][newy]:
return True
if DFS(newx, newy, x, y, visited):
return True
return False
def solve():
visited = [[False for j in range(m)] for i in range(n)]
for i in range(n):
for j in range(m):
if visited[i][j]:
continue
if DFS(i, j, -1, -1, visited):
return True
return False
print('Yes' if solve() else 'No')
'\n3 3\nAAA\nABA\nABA\n'
192
from sys import stdin
from math import *
line = stdin.readline().rstrip().split()
n = int(line[0])
numbers = list(map(int, stdin.readline().rstrip().split()))
numbers2 = list(map(int, stdin.readline().rstrip().split()))
growRateAccum = 0
topAccum = 0
bottomAccum = 0
accumsB = [0] * n
accumsT = [0] * n
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum += numbers[i] * ((n - i) * 2 - 1 - 1)
growRateAccum *= numbers[i]
if i < n - 1:
growRateAccum += numbers2[i + 1]
accum += growRateAccum
accumsB[i] = accum
growRateAccum = 0
accum = 0
for i in range(n - 1, -1, -1):
accum += numbers2[i] * ((n - i) * 2 - 1 - 1)
growRateAccum += numbers2[i]
if i < n - 1:
growRateAccum += numbers[i + 1]
accum += growRateAccum
accumsT[i] = accum
cMax = 0
currAccum = 0
growRateAccum = sum(numbers[1:]) + sum(numbers2[1:])
for i in range(n):
if i % 2 == 0:
cMax = max(cMax, currAccum + accumsT[i])
else:
cMax = max(cMax, currAccum + accumsB[i])
if i < n - 1:
if i % 2 == 0:
currAccum += numbers2[i] + growRateAccum * 2
else:
currAccum += numbers[i] + growRateAccum * 2
growRateAccum -= numbers[i + 1]
growRateAccum -= numbers2[i + 1]
print(cMax)
193
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))
194
def main():
n, m = list(map(int, input().split()))
l = [c for _ in range(n) for c in input()]
neigh = []
for y in range(n):
for x in range(m):
yx = y * m + x
neigh.append([])
if x and l[yx] == l[yx - 3]:
neigh[-1].append(yx - 1)
neigh[-2].append(yx)
if y and l[yx] == l[yx - m]:
neigh[-1].append(yx - m)
neigh[-1 - m].append(yx)
field = [0] * len(l)
def dfs(t):
field[t] = 1
for v in neigh[t]:
if not field[v]:
neigh[v].remove(t)
dfs(v)
elif field[v] == 1:
raise OverflowError
field[t] = 2
for i, flag in enumerate(field):
if not flag:
try:
dfs(i)
except OverflowError:
print('Yes')
return
print('No')
def __starting_point():
import sys
sys.setrecursionlimit(10000)
main()
__starting_point()
195
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()
196
def main():
n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
roundup = []
rounddown = []
sumsofar = []
for i, (a, b) in enumerate(zip(reversed(A), reversed(B))):
ssf = sumsofar[-1] if sumsofar else 0
t = roundup[-1] if roundup else 0
roundup.append(t + ssf + b * (1 + 2 * i))
t = rounddown[-1] if rounddown else 0
rounddown.append(t + ssf + a * (1 + 2 * i))
sumsofar.append(ssf + a + b)
roundup = list(reversed(roundup))
rounddown = list(reversed(rounddown))
sumsofar = list(reversed(sumsofar))
bestres = 0
sofar = 0
for i, (a, b) in enumerate(zip(A, B)):
rup, rdo = (roundup, rounddown)
if i % 2:
a, b = (b, a)
rup, rdo = (rdo, rup)
bestres = max(bestres, sofar + rup[i] + sumsofar[i] * 2 * i)
sofar += a * 2 * i
sofar += b * (2 * i + 1)
bestres = max(bestres, sofar)
print(bestres)
def __starting_point():
main()
__starting_point()
197
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == -2:
for p in range(k):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__starting_point()
198
n, m = [int(x) for x in input().split()]
field = [''] * n
labels = [[0]] * n
import sys
sys.setrecursionlimit(10000)
for i in range(n):
field[i] = input().strip()
labels[i] = [0] * m
def is_valid(i, j):
return -2 <= i < n and 0 <= j < m
def dfs(i, j, p, k, cc=0):
if labels[i][j] == k:
return True
labels[i][j] = k
res = False
dd = [[0, 1], [1, 0], [-1, 0], [0, -1]]
for d in dd:
if is_valid(i + d[0], j + d[1]) and (i + d[0] != p[0] or j + d[1] != p[1]):
if field[i + d[0]][j + d[1]] == field[i][j]:
res = res or dfs(i + d[0], j + d[1], [i, j], k, cc + 1)
return res
ok = False
k = 1
for i in range(n):
for j in range(m):
if labels[i][j] == 0:
ok = ok or dfs(i, j, [i, j], k)
k += 1
if ok:
print('Yes')
else:
print('No')
199
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)
200
3
class StdReader:
def read_int(self):
return int(self.read_string())
def read_ints(self, sep=None):
return [int(i) for i in self.read_strings(sep)]
def read_float(self):
return float(self.read_string())
def read_floats(self, sep=None):
return [float(i) for i in self.read_strings(sep)]
def read_string(self):
return input()
def read_strings(self, sep=None):
return self.read_string().split(sep)
reader = StdReader()
def part_sort(a, i, j, reverse=False):
a[i:j] = sorted(a[i:j], reverse=reverse)
def part_sorted(b, i, j, reverse=False):
a = list(b)
part_sort(a, i, j, reverse)
return a
def main():
n, m = reader.read_ints()
a = reader.read_ints()
ops = []
for i in range(m):
t, r = reader.read_ints()
op = (t, r)
while ops and op[1] >= ops[-1][1]:
ops.pop()
ops.append(op)
max_r = ops[0][1]
b = sorted(a[:max_r])
bl = 0
br = max_r - 1
for i in range(len(ops)):
t, r = ops[i]
r1 = 0
if i < len(ops) - 1:
t1, r1 = ops[i + 1]
k = r - r1
if t == 1:
for p in reversed(range(k)):
a[r - 1 - p] = b[br]
br -= 1
else:
for p in range(k):
a[r - 1 - p] = b[bl]
bl += 1
for ai in a:
print(ai, end=' ')
def __starting_point():
main()
__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.