id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_2601
|
K = int(input())
for i in range(K):
print(chr(64 + i), end='')
K = int(input())
for i in range(K):
print(chr(65 + i), end='')
|
ConDefects/ConDefects/Code/abc282_a/Python/44657009
|
condefects-python_data_2602
|
import bisect
import sys
import math
import itertools
from collections import deque
import queue
from functools import cache
from collections import defaultdict
sys.setrecursionlimit(100000000)
sys.getrecursionlimit()
#input = sys.stdin.readline
from heapq import heappop,heappush
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class Set(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size: n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b + 1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class Deque:
def __init__(self, src_arr=[], max_size=300000):
self.N = max(max_size, len(src_arr)) + 1
self.buf = list(src_arr) + [None] * (self.N - len(src_arr))
self.head = 0
self.tail = len(src_arr)
def __index(self, i):
l = len(self)
if not -l <= i < l: raise IndexError('index out of range: ' + str(i))
if i < 0:
i += l
return (self.head + i) % self.N
def __extend(self):
ex = self.N - 1
self.buf[self.tail+1 : self.tail+1] = [None] * ex
self.N = len(self.buf)
if self.head > 0:
self.head += ex
def is_full(self):
return len(self) >= self.N - 1
def is_empty(self):
return len(self) == 0
def append(self, x):
if self.is_full(): self.__extend()
self.buf[self.tail] = x
self.tail += 1
self.tail %= self.N
def appendleft(self, x):
if self.is_full(): self.__extend()
self.buf[(self.head - 1) % self.N] = x
self.head -= 1
self.head %= self.N
def pop(self):
if self.is_empty(): raise IndexError('pop() when buffer is empty')
ret = self.buf[(self.tail - 1) % self.N]
self.tail -= 1
self.tail %= self.N
return ret
def popleft(self):
if self.is_empty(): raise IndexError('popleft() when buffer is empty')
ret = self.buf[self.head]
self.head += 1
self.head %= self.N
return ret
def __len__(self):
return (self.tail - self.head) % self.N
def __getitem__(self, key):
return self.buf[self.__index(key)]
def __setitem__(self, key, value):
self.buf[self.__index(key)] = value
def __str__(self):
return 'Deque({0})'.format(str(list(self)))
class UnionFind():
# 初期化
def __init__(self, n):
self.par = [-1] * n
self.rank = [0] * n
self.siz = [1] * n
# 根を求める
def root(self, x):
if self.par[x] == -1:
return x # x が根の場合は x を返す
else:
self.par[x] = self.root(self.par[x]) # 経路圧縮
return self.par[x]
# x と y が同じグループに属するか (根が一致するか)
def issame(self, x, y):
return self.root(x) == self.root(y)
# x を含むグループと y を含むグループを併合する
def unite(self, x, y):
# x 側と y 側の根を取得する
rx = self.root(x)
ry = self.root(y)
if rx == ry: return False # すでに同じグループのときは何もしない
# union by rank
if self.rank[rx] < self.rank[ry]: # ry 側の rank が小さくなるようにする
rx, ry = ry, rx
self.par[ry] = rx # ry を rx の子とする
if self.rank[rx] == self.rank[ry]: # rx 側の rank を調整する
self.rank[rx] += 1
self.siz[rx] += self.siz[ry] # rx 側の siz を調整する
return True
def size(self, x):
return uf.siz[uf.root(x)]
'''
map(int,input().split())
list(map(int,input().split()))
'''
#########################################################################
#########################################################################
n = int(input())
a = list(map(int,input().split()))
seta = set()
for i in a:
seta.add(i)
lista = sorted(list(seta))[::-1]
nn = len(lista)
dicta = defaultdict(int)
for i in range(len(lista)):
dicta[lista[i]] = i
dictb = defaultdict(int)
for i in a:
dictb[i] += 1
print(dicta)
print(dictb)
for i in range(n):
ans = 0
if nn > i:
ans += dictb[lista[i]]
print(ans)
import bisect
import sys
import math
import itertools
from collections import deque
import queue
from functools import cache
from collections import defaultdict
sys.setrecursionlimit(100000000)
sys.getrecursionlimit()
#input = sys.stdin.readline
from heapq import heappop,heappush
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class Set(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size: n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b + 1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class Deque:
def __init__(self, src_arr=[], max_size=300000):
self.N = max(max_size, len(src_arr)) + 1
self.buf = list(src_arr) + [None] * (self.N - len(src_arr))
self.head = 0
self.tail = len(src_arr)
def __index(self, i):
l = len(self)
if not -l <= i < l: raise IndexError('index out of range: ' + str(i))
if i < 0:
i += l
return (self.head + i) % self.N
def __extend(self):
ex = self.N - 1
self.buf[self.tail+1 : self.tail+1] = [None] * ex
self.N = len(self.buf)
if self.head > 0:
self.head += ex
def is_full(self):
return len(self) >= self.N - 1
def is_empty(self):
return len(self) == 0
def append(self, x):
if self.is_full(): self.__extend()
self.buf[self.tail] = x
self.tail += 1
self.tail %= self.N
def appendleft(self, x):
if self.is_full(): self.__extend()
self.buf[(self.head - 1) % self.N] = x
self.head -= 1
self.head %= self.N
def pop(self):
if self.is_empty(): raise IndexError('pop() when buffer is empty')
ret = self.buf[(self.tail - 1) % self.N]
self.tail -= 1
self.tail %= self.N
return ret
def popleft(self):
if self.is_empty(): raise IndexError('popleft() when buffer is empty')
ret = self.buf[self.head]
self.head += 1
self.head %= self.N
return ret
def __len__(self):
return (self.tail - self.head) % self.N
def __getitem__(self, key):
return self.buf[self.__index(key)]
def __setitem__(self, key, value):
self.buf[self.__index(key)] = value
def __str__(self):
return 'Deque({0})'.format(str(list(self)))
class UnionFind():
# 初期化
def __init__(self, n):
self.par = [-1] * n
self.rank = [0] * n
self.siz = [1] * n
# 根を求める
def root(self, x):
if self.par[x] == -1:
return x # x が根の場合は x を返す
else:
self.par[x] = self.root(self.par[x]) # 経路圧縮
return self.par[x]
# x と y が同じグループに属するか (根が一致するか)
def issame(self, x, y):
return self.root(x) == self.root(y)
# x を含むグループと y を含むグループを併合する
def unite(self, x, y):
# x 側と y 側の根を取得する
rx = self.root(x)
ry = self.root(y)
if rx == ry: return False # すでに同じグループのときは何もしない
# union by rank
if self.rank[rx] < self.rank[ry]: # ry 側の rank が小さくなるようにする
rx, ry = ry, rx
self.par[ry] = rx # ry を rx の子とする
if self.rank[rx] == self.rank[ry]: # rx 側の rank を調整する
self.rank[rx] += 1
self.siz[rx] += self.siz[ry] # rx 側の siz を調整する
return True
def size(self, x):
return uf.siz[uf.root(x)]
'''
map(int,input().split())
list(map(int,input().split()))
'''
#########################################################################
#########################################################################
n = int(input())
a = list(map(int,input().split()))
seta = set()
for i in a:
seta.add(i)
lista = sorted(list(seta))[::-1]
nn = len(lista)
dicta = defaultdict(int)
for i in range(len(lista)):
dicta[lista[i]] = i
dictb = defaultdict(int)
for i in a:
dictb[i] += 1
for i in range(n):
ans = 0
if nn > i:
ans += dictb[lista[i]]
print(ans)
|
ConDefects/ConDefects/Code/abc273_c/Python/52009785
|
condefects-python_data_2603
|
from collections import *
import sys
import heapq
import bisect
import itertools
from functools import lru_cache
import math
import copy
sys.setrecursionlimit(int(1e7))
dxdy1 = ((0, 1), (0, -1), (1, 0), (-1, 0))
dxdy2 = ((0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1))
dxdy3 = ((0, 1), (1, 0))
dxdy4 = ((1, 1), (1, -1), (-1, 1), (-1, -1))
INF = float("inf")
MOD = 998244353
mod = 998244353
MOD2 = 10**9 + 7
mod2 = 10**9 + 7
# memo : len([a,b,...,z])==26
input = lambda: sys.stdin.readline().rstrip()
mi = lambda: map(int, input().split())
li = lambda: list(mi())
N, M = mi()
adj = [[] for _ in range(N)]
for _ in range(M):
u, v = mi()
u -= 1
v -= 1
adj[u].append(v)
adj[v].append(u)
ans1 = []
q = deque()
visited = [0] * N
q.append((-1, 0))
while q:
pre, node = q.pop()
if pre >= 0:
ans1.append((pre + 1, node + 1))
visited[node] = 1
for nxt in adj[node]:
if visited[nxt] == 1:
continue
q.append((node, nxt))
for z, w in ans1:
print(z, w)
ans2 = []
visited = [0] * N
q.append(0)
while q:
node = q.popleft()
visited[node] = 1
for nxt in adj[node]:
if visited[nxt] == 1:
continue
visited[nxt] = 1
q.append(nxt)
ans2.append((node + 1, nxt + 1))
for z, w in ans2:
print(z, w)
from collections import *
import sys
import heapq
import bisect
import itertools
from functools import lru_cache
import math
import copy
sys.setrecursionlimit(int(1e7))
dxdy1 = ((0, 1), (0, -1), (1, 0), (-1, 0))
dxdy2 = ((0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1))
dxdy3 = ((0, 1), (1, 0))
dxdy4 = ((1, 1), (1, -1), (-1, 1), (-1, -1))
INF = float("inf")
MOD = 998244353
mod = 998244353
MOD2 = 10**9 + 7
mod2 = 10**9 + 7
# memo : len([a,b,...,z])==26
input = lambda: sys.stdin.readline().rstrip()
mi = lambda: map(int, input().split())
li = lambda: list(mi())
N, M = mi()
adj = [[] for _ in range(N)]
for _ in range(M):
u, v = mi()
u -= 1
v -= 1
adj[u].append(v)
adj[v].append(u)
ans1 = []
q = deque()
visited = [0] * N
q.append((-1, 0))
while q:
pre, node = q.pop()
if visited[node] == 1:
continue
if pre >= 0:
ans1.append((pre + 1, node + 1))
visited[node] = 1
for nxt in adj[node]:
if visited[nxt] == 1:
continue
q.append((node, nxt))
for z, w in ans1:
print(z, w)
ans2 = []
visited = [0] * N
q.append(0)
while q:
node = q.popleft()
visited[node] = 1
for nxt in adj[node]:
if visited[nxt] == 1:
continue
visited[nxt] = 1
q.append(nxt)
ans2.append((node + 1, nxt + 1))
for z, w in ans2:
print(z, w)
|
ConDefects/ConDefects/Code/abc251_f/Python/47833391
|
condefects-python_data_2604
|
MOD = 998244353
def mod_inv(x, m):
a, b, c, d = x, 1, m-x, m-1
while c != 1:
if c == 0:
print(x, m)
e, f = divmod(a, c)
a, b, c, d = c, d, f, (b-e*d)%m
return d
F = [0]*(10**4+2)
def init_factors():
F[0] = 1
x = 1
for i in range(1, 10**4+2):
x = x * i % MOD
F[i] = x
init_factors()
def get_comb(n, r):
if r < 0:
return 0
return F[n]*mod_inv(F[r]*F[n-r]%MOD, MOD)%MOD
def mult_mat(M1, M2):
return [[sum(M1[i][k]*M2[k][j]%MOD for k in range(2)) for j in range(2)] for i in range(2)]
def pow_mat(M, n):
M2 = [[1,0],[0,1]]
while n > 0:
if n%2 == 1:
M2 = mult_mat(M2, M)
M = mult_mat(M, M)
n //= 2
return M2
def solve():
N, D = map(int, input().split())
ans = 0
L = D+1
for k in range(L//2 + 1):
a = get_comb(L-2, k)
b = get_comb(L-2, k-1)
c = get_comb(L-2, k-2)
M = [[a, b],[b, c]]
M2 = pow_mat(M, N)
ans += (M2[0][0] + M2[1][1])*(1 if L%2==0 and k == L//2 else 2)
print(ans%MOD)
solve()
MOD = 998244353
def mod_inv(x, m):
a, b, c, d = x, 1, m-x, m-1
while c != 1:
if c == 0:
print(x, m)
e, f = divmod(a, c)
a, b, c, d = c, d, f, (b-e*d)%m
return d
F = [0]*(10**4+2)
def init_factors():
F[0] = 1
x = 1
for i in range(1, 10**4+2):
x = x * i % MOD
F[i] = x
init_factors()
def get_comb(n, r):
if r < 0 or n < r:
return 0
return F[n]*mod_inv(F[r]*F[n-r]%MOD, MOD)%MOD
def mult_mat(M1, M2):
return [[sum(M1[i][k]*M2[k][j]%MOD for k in range(2)) for j in range(2)] for i in range(2)]
def pow_mat(M, n):
M2 = [[1,0],[0,1]]
while n > 0:
if n%2 == 1:
M2 = mult_mat(M2, M)
M = mult_mat(M, M)
n //= 2
return M2
def solve():
N, D = map(int, input().split())
ans = 0
L = D+1
for k in range(L//2 + 1):
a = get_comb(L-2, k)
b = get_comb(L-2, k-1)
c = get_comb(L-2, k-2)
M = [[a, b],[b, c]]
M2 = pow_mat(M, N)
ans += (M2[0][0] + M2[1][1])*(1 if L%2==0 and k == L//2 else 2)
print(ans%MOD)
solve()
|
ConDefects/ConDefects/Code/abc256_g/Python/32688484
|
condefects-python_data_2605
|
from collections import defaultdict, deque, Counter
from itertools import combinations, permutations, product, accumulate
from heapq import heapify, heappop, heappush
import math
import bisect
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def ceil_div(x, y): return -(-x//y)
#################################################
# ABC004-D
from heapq import heapify, heappop, heappush
class Flow:
def __init__(self, n, inf=float("inf")):
self.V = n
self.inf = inf
self.G = [[] for _ in range(n)]
self.H = [] #ポテンシャル
self.pre = [] # dijkstra経路復元用
def add_edge(self, from_, to, cap, cost):
#cost(1つ目):負辺除去後コスト, cost(2つ目):元コスト
self.G[from_].append([to, cap, len(self.G[to]), cost, cost])
self.G[to].append([from_, 0, len(self.G[from_])-1, -cost, -cost])
def dijkstra(self, s):
self.pre = [None]*self.V
hq = [(0, s)]
self.H[s] = 0
while hq:
d, now = heappop(hq)
if d > self.H[now]:
continue
for i in range(len(self.G[now])):
next, cap, r, cost, c = self.G[now][i]
if cap > 0 and self.H[now]+cost < self.H[next]:
self.H[next] = self.H[now]+cost
self.pre[next] = (now, i)
heappush(hq, (self.H[next], next))
def rest(self, s, t, flow):
now = t
while now != s and self.pre[now] is not None:
p, i = self.pre[now]
flow = min(flow, self.G[p][i][1])
now = p
if flow == 0 or now != s:
return 0, 0
now = t
ret = 0
while now != s:
p, i = self.pre[now]
next, cap, rev, c, cost = self.G[p][i]
self.G[p][i][1] -= flow
self.G[now][rev][1] += flow
ret += cost*flow
now = p
return flow, ret
def minimum_cost_flow(self, s, t, F, x):
flow = 0
ans = x
while F-flow > 0:
self.H = [self.inf]*self.V
self.dijkstra(s)
for i in range(self.V):
for j in range(len(self.G[i])):
self.G[i][j][3] += self.H[i]-self.H[self.G[i][j][0]]
f, a = self.rest(s, t, F-flow)
if f == 0:
return None
ans += a
flow += f
return ans
N = int(input())
g = Flow(302)
s, t = 300, 301
for i in range(150):
g.add_edge(s, i, 1, 0)
g.add_edge(i+150, t, 1, 0)
INF = 0
E = []
for _ in range(N):
a, b, c = map(int, input().split())
a -= 1; b -= 1
INF += c
E.append((a, b, c))
for a, b, c in E:
g.add_edge(a, b+150, 1, INF-c)
ans = [0]
for i in range(1, N):
c = g.minimum_cost_flow(s, t, 1, -(ans[-1]-INF*(i-1)))
if c is None: break
ans.append(INF*i-c)
print(len(ans)-1)
print(*ans[1:], sep="\n")
from collections import defaultdict, deque, Counter
from itertools import combinations, permutations, product, accumulate
from heapq import heapify, heappop, heappush
import math
import bisect
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def ceil_div(x, y): return -(-x//y)
#################################################
# ABC004-D
from heapq import heapify, heappop, heappush
class Flow:
def __init__(self, n, inf=float("inf")):
self.V = n
self.inf = inf
self.G = [[] for _ in range(n)]
self.H = [] #ポテンシャル
self.pre = [] # dijkstra経路復元用
def add_edge(self, from_, to, cap, cost):
#cost(1つ目):負辺除去後コスト, cost(2つ目):元コスト
self.G[from_].append([to, cap, len(self.G[to]), cost, cost])
self.G[to].append([from_, 0, len(self.G[from_])-1, -cost, -cost])
def dijkstra(self, s):
self.pre = [None]*self.V
hq = [(0, s)]
self.H[s] = 0
while hq:
d, now = heappop(hq)
if d > self.H[now]:
continue
for i in range(len(self.G[now])):
next, cap, r, cost, c = self.G[now][i]
if cap > 0 and self.H[now]+cost < self.H[next]:
self.H[next] = self.H[now]+cost
self.pre[next] = (now, i)
heappush(hq, (self.H[next], next))
def rest(self, s, t, flow):
now = t
while now != s and self.pre[now] is not None:
p, i = self.pre[now]
flow = min(flow, self.G[p][i][1])
now = p
if flow == 0 or now != s:
return 0, 0
now = t
ret = 0
while now != s:
p, i = self.pre[now]
next, cap, rev, c, cost = self.G[p][i]
self.G[p][i][1] -= flow
self.G[now][rev][1] += flow
ret += cost*flow
now = p
return flow, ret
def minimum_cost_flow(self, s, t, F, x):
flow = 0
ans = x
while F-flow > 0:
self.H = [self.inf]*self.V
self.dijkstra(s)
for i in range(self.V):
for j in range(len(self.G[i])):
self.G[i][j][3] += self.H[i]-self.H[self.G[i][j][0]]
f, a = self.rest(s, t, F-flow)
if f == 0:
return None
ans += a
flow += f
return ans
N = int(input())
g = Flow(302)
s, t = 300, 301
for i in range(150):
g.add_edge(s, i, 1, 0)
g.add_edge(i+150, t, 1, 0)
INF = 0
E = []
for _ in range(N):
a, b, c = map(int, input().split())
a -= 1; b -= 1
INF += c
E.append((a, b, c))
for a, b, c in E:
g.add_edge(a, b+150, 1, INF-c)
ans = [0]
for i in range(1, N+1):
c = g.minimum_cost_flow(s, t, 1, -(ans[-1]-INF*(i-1)))
if c is None: break
ans.append(INF*i-c)
print(len(ans)-1)
print(*ans[1:], sep="\n")
|
ConDefects/ConDefects/Code/abc247_g/Python/39496981
|
condefects-python_data_2606
|
s = input()
t = input()
for i in range(len(s)):
if s[i] != t[i]:
print(i + 1)
exit()
print(1)
s = input()
t = input()
for i in range(len(s)):
if s[i] != t[i]:
print(i + 1)
exit()
print(len(t))
|
ConDefects/ConDefects/Code/abc280_c/Python/46198348
|
condefects-python_data_2607
|
s, t = input(), input()
for i in range(len(s)):
if s[i] != t[i]:
print(i+1)
break
s, t = input() + "0", input()
for i in range(len(s)):
if s[i] != t[i]:
print(i+1)
break
|
ConDefects/ConDefects/Code/abc280_c/Python/45414208
|
condefects-python_data_2608
|
# ansmod = 10 ** 9 + 7
# ansmod = 998244353
import sys
def main(f):
s = f.readline()[:-1]
t = f.readline()[:-1]
for id, i in enumerate(s):
if i != t[id]:
return id + 1
return id + 1
if __name__ == "__main__":
print(main(sys.stdin))
# print(main(sys.stdin) % ansmod)
# ansmod = 10 ** 9 + 7
# ansmod = 998244353
import sys
def main(f):
s = f.readline()[:-1]
t = f.readline()[:-1]
for id, i in enumerate(s):
if i != t[id]:
return id + 1
return id + 2
if __name__ == "__main__":
print(main(sys.stdin))
# print(main(sys.stdin) % ansmod)
|
ConDefects/ConDefects/Code/abc280_c/Python/46197892
|
condefects-python_data_2609
|
S = list(input())
T = list(input())
for i in range(len(T)):
if i == len(T)-1:
ans = i
break
if S[i] != T[i]:
ans = i+1
break
print(ans)
S = list(input())
T = list(input())
for i in range(len(T)):
if i == len(T)-1:
ans = i+1
break
if S[i] != T[i]:
ans = i+1
break
print(ans)
|
ConDefects/ConDefects/Code/abc280_c/Python/45722893
|
condefects-python_data_2610
|
import sys
from math import sqrt
input = lambda: sys.stdin.buffer.readline().rstrip()
from typing import Generic, Iterable, TypeVar, Deque
from collections import deque
T = TypeVar('T')
class SlidingWindowMinimum(Generic[T]):
def __init__(self, a: Iterable[T], k: int):
self.a = list(a)
self.n = len(self.a)
assert 1 <= k <= self.n
a, n = self.a, self.n
dq: Deque[T] = deque()
ans = []
for i in range(n):
while dq and a[dq[-1]] > a[i]:
dq.pop()
dq.append(i)
if dq and dq[0] <= i-k:
dq.popleft()
ans.append(a[dq[0]])
self.ans = ans
def prod(self, l):
return self.ans[l]
# from titan_pylib.data_structures.segment_tree.segment_tree import SegmentTree
# from titan_pylib.data_structures.segment_tree.segment_tree_interface import SegmentTreeInterface
from abc import ABC, abstractmethod
from typing import TypeVar, Generic, Union, Iterable, Callable, List
T = TypeVar('T')
class SegmentTreeInterface(ABC, Generic[T]):
@abstractmethod
def __init__(self, n_or_a: Union[int, Iterable[T]],
op: Callable[[T, T], T],
e: T):
raise NotImplementedError
@abstractmethod
def set(self, k: int, v: T) -> None:
raise NotImplementedError
@abstractmethod
def get(self, k: int) -> T:
raise NotImplementedError
@abstractmethod
def prod(self, l: int, r: int) -> T:
raise NotImplementedError
@abstractmethod
def all_prod(self) -> T:
raise NotImplementedError
@abstractmethod
def max_right(self, l: int, f: Callable[[T], bool]) -> int:
raise NotImplementedError
@abstractmethod
def min_left(self, r: int, f: Callable[[T], bool]) -> int:
raise NotImplementedError
@abstractmethod
def tolist(self) -> List[T]:
raise NotImplementedError
@abstractmethod
def __getitem__(self, k: int) -> T:
raise NotImplementedError
@abstractmethod
def __setitem__(self, k: int, v: T) -> None:
raise NotImplementedError
@abstractmethod
def __str__(self):
raise NotImplementedError
@abstractmethod
def __repr__(self):
raise NotImplementedError
from typing import Generic, Iterable, TypeVar, Callable, Union, List
T = TypeVar('T')
class SegmentTree(SegmentTreeInterface, Generic[T]):
"""セグ木です。非再帰です。
"""
def __init__(self,
n_or_a: Union[int, Iterable[T]],
op: Callable[[T, T], T],
e: T) -> None:
"""``SegmentTree`` を構築します。
:math:`O(n)` です。
Args:
n_or_a (Union[int, Iterable[T]]): ``n: int`` のとき、 ``e`` を初期値として長さ ``n`` の ``SegmentTree`` を構築します。
``a: Iterable[T]`` のとき、 ``a`` から ``SegmentTree`` を構築します。
op (Callable[[T, T], T]): 2項演算の関数です。
e (T): 単位元です。
"""
self._op = op
self._e = e
if isinstance(n_or_a, int):
self._n = n_or_a
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self._data = [e] * (self._size << 1)
else:
n_or_a = list(n_or_a)
self._n = len(n_or_a)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
_data = [e] * (self._size << 1)
_data[self._size:self._size+self._n] = n_or_a
for i in range(self._size-1, 0, -1):
_data[i] = op(_data[i<<1], _data[i<<1|1])
self._data = _data
def set(self, k: int, v: T) -> None:
"""一点更新です。
:math:`O(\\log{n})` です。
Args:
k (int): 更新するインデックスです。
v (T): 更新する値です。
制約:
:math:`-n \\leq n \\leq k < n`
"""
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.set({k}, {v}), n={self._n}'
if k < 0:
k += self._n
k += self._size
self._data[k] = v
for _ in range(self._log):
k >>= 1
self._data[k] = self._op(self._data[k<<1], self._data[k<<1|1])
def get(self, k: int) -> T:
"""一点取得です。
:math:`O(1)` です。
Args:
k (int): インデックスです。
制約:
:math:`-n \\leq n \\leq k < n`
"""
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.get({k}), n={self._n}'
if k < 0:
k += self._n
return self._data[k+self._size]
def prod(self, l: int, r: int) -> T:
"""区間 ``[l, r)`` の総積を返します。
:math:`O(\\log{n})` です。
Args:
l (int): インデックスです。
r (int): インデックスです。
制約:
:math:`0 \\leq l \\leq r \\leq n`
"""
assert 0 <= l <= r <= self._n, \
f'IndexError: {self.__class__.__name__}.prod({l}, {r})'
l += self._size
r += self._size
lres = self._e
rres = self._e
while l < r:
if l & 1:
lres = self._op(lres, self._data[l])
l += 1
if r & 1:
rres = self._op(self._data[r^1], rres)
l >>= 1
r >>= 1
return self._op(lres, rres)
def all_prod(self) -> T:
"""区間 ``[0, n)`` の総積を返します。
:math:`O(1)` です。
"""
return self._data[1]
def max_right(self, l: int, f: Callable[[T], bool]) -> int:
'''Find the largest index R s.t. f([l, R)) == True. / O(\\log{n})'''
assert 0 <= l <= self._n, \
f'IndexError: {self.__class__.__name__}.max_right({l}, f) index out of range'
assert f(self._e), \
f'{self.__class__.__name__}.max_right({l}, f), f({self._e}) must be true.'
if l == self._n:
return self._n
l += self._size
s = self._e
while True:
while l & 1 == 0:
l >>= 1
if not f(self._op(s, self._data[l])):
while l < self._size:
l <<= 1
if f(self._op(s, self._data[l])):
s = self._op(s, self._data[l])
l |= 1
return l - self._size
s = self._op(s, self._data[l])
l += 1
if l & -l == l:
break
return self._n
def min_left(self, r: int, f: Callable[[T], bool]) -> int:
'''Find the smallest index L s.t. f([L, r)) == True. / O(\\log{n})'''
assert 0 <= r <= self._n, \
f'IndexError: {self.__class__.__name__}.min_left({r}, f) index out of range'
assert f(self._e), \
f'{self.__class__.__name__}.min_left({r}, f), f({self._e}) must be true.'
if r == 0:
return 0
r += self._size
s = self._e
while True:
r -= 1
while r > 1 and r & 1:
r >>= 1
if not f(self._op(self._data[r], s)):
while r < self._size:
r = r << 1 | 1
if f(self._op(self._data[r], s)):
s = self._op(self._data[r], s)
r ^= 1
return r + 1 - self._size
s = self._op(self._data[r], s)
if r & -r == r:
break
return 0
def tolist(self) -> List[T]:
"""
:math:`O(n)` です。
"""
return [self.get(i) for i in range(self._n)]
def show(self) -> None:
"""デバッグ用のメソッドです。
"""
print(f'<{self.__class__.__name__}> [\n' + '\n'.join([' ' + ' '.join(map(str, [self._data[(1<<i)+j] for j in range(1<<i)])) for i in range(self._log+1)]) + '\n]')
def __getitem__(self, k: int) -> T:
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.__getitem__({k}), n={self._n}'
return self.get(k)
def __setitem__(self, k: int, v: T):
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.__setitem__{k}, {v}), n={self._n}'
self.set(k, v)
def __len__(self):
return self._n
def __str__(self):
return str(self.tolist())
def __repr__(self):
return f'{self.__class__.__name__}({self})'
# ----------------------- #
n, k = map(int, input().split())
sx, sy = map(int, input().split())
xy = [tuple(map(int, input().split())) for _ in range(n)]
def calc1(i, j):
xi, yi = xy[i]
xj, yj = xy[j]
return sqrt((xi-xj)**2 + (yi-yj)**2)
def calc2(i, j):
xi, yi = xy[i]
xj, yj = xy[j]
return sqrt((sx-xi)**2 + (sy-yi)**2) + sqrt((sx-xj)**2 + (sy-yj)**2)
ans = sqrt((sx-xy[0][0])**2 + (sy-xy[0][1])**2)\
+ sqrt((xy[-1][0]-sx)**2 + (xy[-1][1]-sy)**2)
sabun = [0] * (n-1)
for i in range(n-1):
d1 = calc1(i, i+1)
d2 = calc2(i, i+1)
ans += min(d1, d2)
sabun[i] = abs(d1 - d2)
INF = 10**9
dp = SegmentTree(n, op=lambda s, t: min(s, t), e=INF)
dp[0] = 0
for i in range(n-1):
dp[i+1] = dp.prod(max(0, i+1-k), i+1) + sabun[i]
ans += dp.prod(n-k, n)
print(f'{ans:.10f}')
import sys
from math import sqrt
input = lambda: sys.stdin.buffer.readline().rstrip()
from typing import Generic, Iterable, TypeVar, Deque
from collections import deque
T = TypeVar('T')
class SlidingWindowMinimum(Generic[T]):
def __init__(self, a: Iterable[T], k: int):
self.a = list(a)
self.n = len(self.a)
assert 1 <= k <= self.n
a, n = self.a, self.n
dq: Deque[T] = deque()
ans = []
for i in range(n):
while dq and a[dq[-1]] > a[i]:
dq.pop()
dq.append(i)
if dq and dq[0] <= i-k:
dq.popleft()
ans.append(a[dq[0]])
self.ans = ans
def prod(self, l):
return self.ans[l]
# from titan_pylib.data_structures.segment_tree.segment_tree import SegmentTree
# from titan_pylib.data_structures.segment_tree.segment_tree_interface import SegmentTreeInterface
from abc import ABC, abstractmethod
from typing import TypeVar, Generic, Union, Iterable, Callable, List
T = TypeVar('T')
class SegmentTreeInterface(ABC, Generic[T]):
@abstractmethod
def __init__(self, n_or_a: Union[int, Iterable[T]],
op: Callable[[T, T], T],
e: T):
raise NotImplementedError
@abstractmethod
def set(self, k: int, v: T) -> None:
raise NotImplementedError
@abstractmethod
def get(self, k: int) -> T:
raise NotImplementedError
@abstractmethod
def prod(self, l: int, r: int) -> T:
raise NotImplementedError
@abstractmethod
def all_prod(self) -> T:
raise NotImplementedError
@abstractmethod
def max_right(self, l: int, f: Callable[[T], bool]) -> int:
raise NotImplementedError
@abstractmethod
def min_left(self, r: int, f: Callable[[T], bool]) -> int:
raise NotImplementedError
@abstractmethod
def tolist(self) -> List[T]:
raise NotImplementedError
@abstractmethod
def __getitem__(self, k: int) -> T:
raise NotImplementedError
@abstractmethod
def __setitem__(self, k: int, v: T) -> None:
raise NotImplementedError
@abstractmethod
def __str__(self):
raise NotImplementedError
@abstractmethod
def __repr__(self):
raise NotImplementedError
from typing import Generic, Iterable, TypeVar, Callable, Union, List
T = TypeVar('T')
class SegmentTree(SegmentTreeInterface, Generic[T]):
"""セグ木です。非再帰です。
"""
def __init__(self,
n_or_a: Union[int, Iterable[T]],
op: Callable[[T, T], T],
e: T) -> None:
"""``SegmentTree`` を構築します。
:math:`O(n)` です。
Args:
n_or_a (Union[int, Iterable[T]]): ``n: int`` のとき、 ``e`` を初期値として長さ ``n`` の ``SegmentTree`` を構築します。
``a: Iterable[T]`` のとき、 ``a`` から ``SegmentTree`` を構築します。
op (Callable[[T, T], T]): 2項演算の関数です。
e (T): 単位元です。
"""
self._op = op
self._e = e
if isinstance(n_or_a, int):
self._n = n_or_a
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
self._data = [e] * (self._size << 1)
else:
n_or_a = list(n_or_a)
self._n = len(n_or_a)
self._log = (self._n - 1).bit_length()
self._size = 1 << self._log
_data = [e] * (self._size << 1)
_data[self._size:self._size+self._n] = n_or_a
for i in range(self._size-1, 0, -1):
_data[i] = op(_data[i<<1], _data[i<<1|1])
self._data = _data
def set(self, k: int, v: T) -> None:
"""一点更新です。
:math:`O(\\log{n})` です。
Args:
k (int): 更新するインデックスです。
v (T): 更新する値です。
制約:
:math:`-n \\leq n \\leq k < n`
"""
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.set({k}, {v}), n={self._n}'
if k < 0:
k += self._n
k += self._size
self._data[k] = v
for _ in range(self._log):
k >>= 1
self._data[k] = self._op(self._data[k<<1], self._data[k<<1|1])
def get(self, k: int) -> T:
"""一点取得です。
:math:`O(1)` です。
Args:
k (int): インデックスです。
制約:
:math:`-n \\leq n \\leq k < n`
"""
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.get({k}), n={self._n}'
if k < 0:
k += self._n
return self._data[k+self._size]
def prod(self, l: int, r: int) -> T:
"""区間 ``[l, r)`` の総積を返します。
:math:`O(\\log{n})` です。
Args:
l (int): インデックスです。
r (int): インデックスです。
制約:
:math:`0 \\leq l \\leq r \\leq n`
"""
assert 0 <= l <= r <= self._n, \
f'IndexError: {self.__class__.__name__}.prod({l}, {r})'
l += self._size
r += self._size
lres = self._e
rres = self._e
while l < r:
if l & 1:
lres = self._op(lres, self._data[l])
l += 1
if r & 1:
rres = self._op(self._data[r^1], rres)
l >>= 1
r >>= 1
return self._op(lres, rres)
def all_prod(self) -> T:
"""区間 ``[0, n)`` の総積を返します。
:math:`O(1)` です。
"""
return self._data[1]
def max_right(self, l: int, f: Callable[[T], bool]) -> int:
'''Find the largest index R s.t. f([l, R)) == True. / O(\\log{n})'''
assert 0 <= l <= self._n, \
f'IndexError: {self.__class__.__name__}.max_right({l}, f) index out of range'
assert f(self._e), \
f'{self.__class__.__name__}.max_right({l}, f), f({self._e}) must be true.'
if l == self._n:
return self._n
l += self._size
s = self._e
while True:
while l & 1 == 0:
l >>= 1
if not f(self._op(s, self._data[l])):
while l < self._size:
l <<= 1
if f(self._op(s, self._data[l])):
s = self._op(s, self._data[l])
l |= 1
return l - self._size
s = self._op(s, self._data[l])
l += 1
if l & -l == l:
break
return self._n
def min_left(self, r: int, f: Callable[[T], bool]) -> int:
'''Find the smallest index L s.t. f([L, r)) == True. / O(\\log{n})'''
assert 0 <= r <= self._n, \
f'IndexError: {self.__class__.__name__}.min_left({r}, f) index out of range'
assert f(self._e), \
f'{self.__class__.__name__}.min_left({r}, f), f({self._e}) must be true.'
if r == 0:
return 0
r += self._size
s = self._e
while True:
r -= 1
while r > 1 and r & 1:
r >>= 1
if not f(self._op(self._data[r], s)):
while r < self._size:
r = r << 1 | 1
if f(self._op(self._data[r], s)):
s = self._op(self._data[r], s)
r ^= 1
return r + 1 - self._size
s = self._op(self._data[r], s)
if r & -r == r:
break
return 0
def tolist(self) -> List[T]:
"""
:math:`O(n)` です。
"""
return [self.get(i) for i in range(self._n)]
def show(self) -> None:
"""デバッグ用のメソッドです。
"""
print(f'<{self.__class__.__name__}> [\n' + '\n'.join([' ' + ' '.join(map(str, [self._data[(1<<i)+j] for j in range(1<<i)])) for i in range(self._log+1)]) + '\n]')
def __getitem__(self, k: int) -> T:
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.__getitem__({k}), n={self._n}'
return self.get(k)
def __setitem__(self, k: int, v: T):
assert -self._n <= k < self._n, \
f'IndexError: {self.__class__.__name__}.__setitem__{k}, {v}), n={self._n}'
self.set(k, v)
def __len__(self):
return self._n
def __str__(self):
return str(self.tolist())
def __repr__(self):
return f'{self.__class__.__name__}({self})'
# ----------------------- #
n, k = map(int, input().split())
sx, sy = map(int, input().split())
xy = [tuple(map(int, input().split())) for _ in range(n)]
def calc1(i, j):
xi, yi = xy[i]
xj, yj = xy[j]
return sqrt((xi-xj)**2 + (yi-yj)**2)
def calc2(i, j):
xi, yi = xy[i]
xj, yj = xy[j]
return sqrt((sx-xi)**2 + (sy-yi)**2) + sqrt((sx-xj)**2 + (sy-yj)**2)
ans = sqrt((sx-xy[0][0])**2 + (sy-xy[0][1])**2)\
+ sqrt((xy[-1][0]-sx)**2 + (xy[-1][1]-sy)**2)
sabun = [0] * (n-1)
for i in range(n-1):
d1 = calc1(i, i+1)
d2 = calc2(i, i+1)
ans += min(d1, d2)
sabun[i] = abs(d1 - d2)
INF = 10**18
dp = SegmentTree(n, op=lambda s, t: min(s, t), e=INF)
dp[0] = 0
for i in range(n-1):
dp[i+1] = dp.prod(max(0, i+1-k), i+1) + sabun[i]
ans += dp.prod(n-k, n)
print(f'{ans:.10f}')
|
ConDefects/ConDefects/Code/abc334_f/Python/50685006
|
condefects-python_data_2611
|
def segfunc(x, y):
return min(x,y)
ide_ele = 100000000000
class segtree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
n,k=map(int,input().split())
sx,sy=map(int,input().split())
d=[]
p=[]
dsum=0
for i in range(n):
x,y=map(int,input().split())
dist1=((sx-x)**2+(sy-y)**2)**0.5
if i==0:
d.append(dist1)
dsum+=dist1
else:
dist2=((p[-1][0]-sx)**2+(p[-1][1]-sy)**2)**0.5
dist3=((p[-1][0]-x)**2+(p[-1][1]-y)**2)**0.5
d.append(dist1+dist2-dist3)
dsum+=dist3
p.append((x,y))
dp=[10**18]*n
dp[0]=0
seg=segtree(dp,segfunc,ide_ele)
for i in range(1,n):
dp[i]=seg.query(max(0,i-k),i)+d[i]
seg.update(i,dp[i])
dist=((p[-1][0]-sx)**2+(p[-1][1]-sy)**2)**0.5
ans=seg.query(n-k,n)+dist+dsum
print(ans)
def segfunc(x, y):
return min(x,y)
ide_ele = 10**18
class segtree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
n,k=map(int,input().split())
sx,sy=map(int,input().split())
d=[]
p=[]
dsum=0
for i in range(n):
x,y=map(int,input().split())
dist1=((sx-x)**2+(sy-y)**2)**0.5
if i==0:
d.append(dist1)
dsum+=dist1
else:
dist2=((p[-1][0]-sx)**2+(p[-1][1]-sy)**2)**0.5
dist3=((p[-1][0]-x)**2+(p[-1][1]-y)**2)**0.5
d.append(dist1+dist2-dist3)
dsum+=dist3
p.append((x,y))
dp=[10**18]*n
dp[0]=0
seg=segtree(dp,segfunc,ide_ele)
for i in range(1,n):
dp[i]=seg.query(max(0,i-k),i)+d[i]
seg.update(i,dp[i])
dist=((p[-1][0]-sx)**2+(p[-1][1]-sy)**2)**0.5
ans=seg.query(n-k,n)+dist+dsum
print(ans)
|
ConDefects/ConDefects/Code/abc334_f/Python/49407992
|
condefects-python_data_2612
|
import sys
sys.set_int_max_str_digits(0)
#####segfunc#####
def segfunc(x, y):
return min(x,y)
#################
inf=5*10**14
#####ide_ele#####
ide_ele = inf
#################
class LazySegmentTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
add(l, r, x): 区間[l, r)にxを加算 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
num: n以上の最小の2のべき乗
data: 値配列(1-index)
lazy: 遅延配列(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.data = [ide_ele] * 2 * self.num
self.lazy = [0] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.data[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def gindex(self, l, r):
"""
伝搬する対象の区間を求める
lm: 伝搬する必要のある最大の左閉区間
rm: 伝搬する必要のある最大の右開区間
"""
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
"""
遅延伝搬処理
ids: 伝搬する対象の区間
"""
for i in reversed(ids):
v = self.lazy[i]
if not v:
continue
self.lazy[2 * i] += v
self.lazy[2 * i + 1] += v
self.data[2 * i] += v
self.data[2 * i + 1] += v
self.lazy[i] = 0
def add(self, l, r, x):
"""
区間[l, r)の値にxを加算
l, r: index(0-index)
x: additional value
"""
*ids, = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.data[l] += x
l += 1
if r & 1:
self.lazy[r - 1] += x
self.data[r - 1] += x
r >>= 1
l >>= 1
for i in ids:
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1]) + self.lazy[i]
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
*ids, = self.gindex(l, r)
self.propagates(*ids)
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.data[l])
l += 1
if r & 1:
res = self.segfunc(res, self.data[r - 1])
l >>= 1
r >>= 1
return res
def dist(x1,y1,x2,y2):
pw=pow(x1-x2,2)+pow(y1-y2,2)
return pw**(1/2)
def main():
N,K=map(int,input().split())
Sx,Sy=map(int,input().split())
dists=[inf]*N
xy=[]
for _ in range(N):
x,y=map(int,input().split())
xy.append((x,y))
xf,yf=xy[0]
dists[0]=dist(Sx,Sy,xf,yf)
#print(dists)
lseg=LazySegmentTree(dists,segfunc,ide_ele)
for i in range(N-1):
xb,yb=xy[i]
xn,yn=xy[i+1]
bipass=dist(xb,yb,Sx,Sy)+dist(Sx,Sy,xn,yn)
direct=dist(xb,yb,xn,yn)
nd=lseg.query(0,i+1)+bipass
cur=lseg.query(i+1,i+2)
ad=round(-(cur-nd),8)
#print(cur,nd,ad)
lseg.add(i+1,i+2,ad)
#dists[i+1]=min(dists[:i+1])+bipass
if i-K+1>=0:
lseg.add(i-K+1,i-K+2,10**18)
#dists[i-K+1]=inf
lseg.add(0,i+1,direct)
#for j in range(i+1):
# dists[j]+=direct
#print(bipass,direct,dists)
#print([lseg.query(j,j+1) for j in range(N)])
xe,ye=xy[-1]
res=dist(xe,ye,Sx,Sy)
print(lseg.query(0,N)+res)
main()
import sys
sys.set_int_max_str_digits(0)
#####segfunc#####
def segfunc(x, y):
return min(x,y)
#################
inf=5*10**15
#####ide_ele#####
ide_ele = inf
#################
class LazySegmentTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
add(l, r, x): 区間[l, r)にxを加算 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
num: n以上の最小の2のべき乗
data: 値配列(1-index)
lazy: 遅延配列(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.data = [ide_ele] * 2 * self.num
self.lazy = [0] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.data[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def gindex(self, l, r):
"""
伝搬する対象の区間を求める
lm: 伝搬する必要のある最大の左閉区間
rm: 伝搬する必要のある最大の右開区間
"""
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self, *ids):
"""
遅延伝搬処理
ids: 伝搬する対象の区間
"""
for i in reversed(ids):
v = self.lazy[i]
if not v:
continue
self.lazy[2 * i] += v
self.lazy[2 * i + 1] += v
self.data[2 * i] += v
self.data[2 * i + 1] += v
self.lazy[i] = 0
def add(self, l, r, x):
"""
区間[l, r)の値にxを加算
l, r: index(0-index)
x: additional value
"""
*ids, = self.gindex(l, r)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] += x
self.data[l] += x
l += 1
if r & 1:
self.lazy[r - 1] += x
self.data[r - 1] += x
r >>= 1
l >>= 1
for i in ids:
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1]) + self.lazy[i]
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
*ids, = self.gindex(l, r)
self.propagates(*ids)
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.data[l])
l += 1
if r & 1:
res = self.segfunc(res, self.data[r - 1])
l >>= 1
r >>= 1
return res
def dist(x1,y1,x2,y2):
pw=pow(x1-x2,2)+pow(y1-y2,2)
return pw**(1/2)
def main():
N,K=map(int,input().split())
Sx,Sy=map(int,input().split())
dists=[inf]*N
xy=[]
for _ in range(N):
x,y=map(int,input().split())
xy.append((x,y))
xf,yf=xy[0]
dists[0]=dist(Sx,Sy,xf,yf)
#print(dists)
lseg=LazySegmentTree(dists,segfunc,ide_ele)
for i in range(N-1):
xb,yb=xy[i]
xn,yn=xy[i+1]
bipass=dist(xb,yb,Sx,Sy)+dist(Sx,Sy,xn,yn)
direct=dist(xb,yb,xn,yn)
nd=lseg.query(0,i+1)+bipass
cur=lseg.query(i+1,i+2)
ad=round(-(cur-nd),8)
#print(cur,nd,ad)
lseg.add(i+1,i+2,ad)
#dists[i+1]=min(dists[:i+1])+bipass
if i-K+1>=0:
lseg.add(i-K+1,i-K+2,10**18)
#dists[i-K+1]=inf
lseg.add(0,i+1,direct)
#for j in range(i+1):
# dists[j]+=direct
#print(bipass,direct,dists)
#print([lseg.query(j,j+1) for j in range(N)])
xe,ye=xy[-1]
res=dist(xe,ye,Sx,Sy)
print(lseg.query(0,N)+res)
main()
|
ConDefects/ConDefects/Code/abc334_f/Python/53789974
|
condefects-python_data_2613
|
N,K=list(map(int, input().split()))
Sx,Sy=list(map(int, input().split()))
def segfunc(x, y):
return min(x,y)
ide_ele =10**15
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
P=[]
def calc(S,T):
return ((S[0]-T[0])**2+(S[1]-T[1])**2)**0.5
for _ in range(N):
P.append(list(map(int, input().split())))
P.append([Sx,Sy])
ans=calc((Sx,Sy),P[0])
dp=[0]*N
for i in range(N):
a=calc(P[i],P[i+1])
b=calc(P[i],P[-1])+calc(P[-1],P[i+1])
ans+=a
dp[i]=b-a
Seg=SegTree([10**17]*(N+10),segfunc,ide_ele)
Seg.update(0,0)
for i in range(1,N+1):
Seg.update(i,Seg.query(max(0,i-K),i)+dp[i-1])
ans+=Seg.query(N,N+1)
print(ans)
N,K=list(map(int, input().split()))
Sx,Sy=list(map(int, input().split()))
def segfunc(x, y):
return min(x,y)
ide_ele =10**17
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
P=[]
def calc(S,T):
return ((S[0]-T[0])**2+(S[1]-T[1])**2)**0.5
for _ in range(N):
P.append(list(map(int, input().split())))
P.append([Sx,Sy])
ans=calc((Sx,Sy),P[0])
dp=[0]*N
for i in range(N):
a=calc(P[i],P[i+1])
b=calc(P[i],P[-1])+calc(P[-1],P[i+1])
ans+=a
dp[i]=b-a
Seg=SegTree([10**17]*(N+10),segfunc,ide_ele)
Seg.update(0,0)
for i in range(1,N+1):
Seg.update(i,Seg.query(max(0,i-K),i)+dp[i-1])
ans+=Seg.query(N,N+1)
print(ans)
|
ConDefects/ConDefects/Code/abc334_f/Python/50005734
|
condefects-python_data_2614
|
from atcoder.segtree import SegTree
N,K=map(int,input().split())
s=tuple(map(int,input().split()))
C=[tuple(map(int,input().split())) for _ in range(N)]
#from random import randint
#N,K=200000,200000
#s=(randint(-10**9,10**9),randint(-10**9,10**9))
#C=[(randint(-10**9,10**9),randint(-10**9,10**9)) for _ in range(N)]
def dist(p,q):
return ((p[0]-q[0])**2+(p[1]-q[1])**2)**0.5
base=dist(s,C[0])+dist(C[N-1],s)
for i in range(N-1):base+=dist(C[i],C[i+1])
A=[0]+[dist(C[i],s)+dist(s,C[i+1])-dist(C[i],C[i+1]) for i in range(N-1)]+[0]
#dp[i]:iまで見て、A[i]を含むAの元を間隔K以下で選ぶ合計の最小値
#dp[i]=min(dp[i-1],...,dp[i-K])+A[i]
INF=10**12
dp=SegTree(min,INF,N+1)
dp.set(0,0)
for i in range(1,N+1):
dp.set(i,dp.prod(max(0,i-K),i)+A[i])
print(dp.get(N)+base)
from atcoder.segtree import SegTree
N,K=map(int,input().split())
s=tuple(map(int,input().split()))
C=[tuple(map(int,input().split())) for _ in range(N)]
#from random import randint
#N,K=200000,200000
#s=(randint(-10**9,10**9),randint(-10**9,10**9))
#C=[(randint(-10**9,10**9),randint(-10**9,10**9)) for _ in range(N)]
def dist(p,q):
return ((p[0]-q[0])**2+(p[1]-q[1])**2)**0.5
base=dist(s,C[0])+dist(C[N-1],s)
for i in range(N-1):base+=dist(C[i],C[i+1])
A=[0]+[dist(C[i],s)+dist(s,C[i+1])-dist(C[i],C[i+1]) for i in range(N-1)]+[0]
#dp[i]:iまで見て、A[i]を含むAの元を間隔K以下で選ぶ合計の最小値
#dp[i]=min(dp[i-1],...,dp[i-K])+A[i]
INF=10**18
dp=SegTree(min,INF,N+1)
dp.set(0,0)
for i in range(1,N+1):
dp.set(i,dp.prod(max(0,i-K),i)+A[i])
print(dp.get(N)+base)
|
ConDefects/ConDefects/Code/abc334_f/Python/54979078
|
condefects-python_data_2615
|
N = int(input())
if N == 3:
ans = [[5,9,1],[3,7,8],[6,2,4]]
elif N == 5:
ans = [[1,3,5,7,9],[11,13,15,17,19],[21,23,25,8,2],[4,10,14,6,12],[16,18,20,22,24]]
else:
odd1 = []
odd2 = []
evn1 = []
evn2 = []
for i in range(1, N*N+1):
if i % 2 == 0:
if i % 3 != 0:
evn2.append(i)
else:
evn1.append(i)
else:
if i % 3 != 0:
odd1.append(i)
else:
odd2.append(i)
nums = odd1 + odd2 + evn1 + evn2
ans = [[0]*N for _ in range(N)]
for i in range(N):
for j in range(N):
ans[i][j] = nums[i*N+j]
for r in ans:
print(*r)
N = int(input())
if N == 3:
ans = [[5,9,1],[3,7,8],[6,2,4]]
elif N == 4:
ans = [[1,3,5,7],[9,11,13,15],[6,4,2,10],[8,12,14,16]]
elif N == 5:
ans = [[1,3,5,7,9],[11,13,15,17,19],[21,23,25,8,2],[4,10,14,6,12],[16,18,20,22,24]]
else:
odd1 = []
odd2 = []
evn1 = []
evn2 = []
for i in range(1, N*N+1):
if i % 2 == 0:
if i % 3 != 0:
evn2.append(i)
else:
evn1.append(i)
else:
if i % 3 != 0:
odd1.append(i)
else:
odd2.append(i)
nums = odd1 + odd2 + evn1 + evn2
ans = [[0]*N for _ in range(N)]
for i in range(N):
for j in range(N):
ans[i][j] = nums[i*N+j]
for r in ans:
print(*r)
|
ConDefects/ConDefects/Code/arc149_c/Python/39106363
|
condefects-python_data_2616
|
from collections import deque
N=int(input())
ans=[]
i=0
x=N**2
temp=[]
mod=[deque([]) for _ in range(3)]
while x>0:
if x%2==1:
temp.append(x)
i+=1
else:
mod[x%3].append(x)
x-=1
if i==N:
ans.append(temp)
temp=[]
i=0
l=len(temp)
if l!=0:
a=ans[-1][l]
l1=l
while temp[-1]%3!=ans[-1][l]%3:
l-=1
b=ans[-1][l]
ans[-1][l]=a
ans[-1][l1]=b
j=0
while j<N:
x=3-ans[-1][i]%3
if x==3:
x=0
temp.append(mod[x].popleft())
i+=1
j+=1
if i==N:
ans.append(temp)
temp=[]
i=0
while len(mod[0])+len(mod[1])+len(mod[2])>0:
if len(mod[0])>0:
temp.append(mod[0].popleft())
elif len(mod[1])>0:
temp.append(mod[1].popleft())
elif len(mod[2])>0:
temp.append(mod[2].popleft())
i+=1
if i==N:
ans.append(temp)
temp=[]
i=0
for i in range(N):
print(*ans[i])
from collections import deque
N=int(input())
ans=[]
i=0
x=N**2
temp=[]
mod=[deque([]) for _ in range(3)]
while x>0:
if x%2==1:
temp.append(x)
i+=1
else:
mod[x%3].append(x)
x-=1
if i==N:
ans.append(temp)
temp=[]
i=0
l=len(temp)
if l!=0:
a=ans[-1][l]
l1=l
while temp[-1]%3!=ans[-1][l]%3:
l-=1
b=ans[-1][l]
ans[-1][l]=a
ans[-1][l1]=b
j=0
while j<N:
x=3-ans[-1][i]%3
if x==3:
x=0
temp.append(mod[x].popleft())
i+=1
j+=1
if i==N:
ans.append(temp)
temp=[]
i=0
while len(mod[0])+len(mod[1])+len(mod[2])>0:
if len(mod[0])>0:
temp.append(mod[0].popleft())
elif len(mod[1])>0:
temp.append(mod[1].popleft())
elif len(mod[2])>0:
temp.append(mod[2].popleft())
i+=1
if i==N:
ans.append(temp)
temp=[]
i=0
if N==3:
ans=[[1,9,7],[3,6,2],[5,4,8]]
for i in range(N):
print(*ans[i])
|
ConDefects/ConDefects/Code/arc149_c/Python/37254775
|
condefects-python_data_2617
|
n = int(input())
if n == 3:
print(5, 9, 1)
print(3, 7, 8)
print(6, 2, 4)
exit()
if n == 4:
print(9, 11, 13, 15)
print(1, 3, 5, 7)
print(8, 6, 10, 14)
print(4, 2, 12, 16)
exit()
if n == 5:
print(1, 5, 7, 11, 13)
print(17, 25, 23, 19, 3)
print(9, 15, 21, 6, 12)
print(18, 24, 14, 4, 8)
print(10, 2, 16, 20, 22)
seq = [i for i in range(1, n*n+1) if i % 3 and i & 1]+[i for i in range(1, n*n+1) if i % 3 == 0 and i & 1] + \
[i for i in range(1, n*n+1) if i % 3 == 0 and i & 1 == 0] + \
[i for i in range(1, n*n+1) if i % 3 and i & 1 == 0]
ans = [[0]*n for _ in range(n)]
for i in range(n*n):
x, y = divmod(i, n)
ans[x][y] = seq[i]
for ai in ans:
print(*ai)
# できる気がせん
n = int(input())
if n == 3:
print(5, 9, 1)
print(3, 7, 8)
print(6, 2, 4)
exit()
if n == 4:
print(9, 11, 13, 15)
print(1, 3, 5, 7)
print(8, 6, 10, 14)
print(4, 2, 12, 16)
exit()
if n == 5:
print(1, 5, 7, 11, 13)
print(17, 25, 23, 19, 3)
print(9, 15, 21, 6, 12)
print(18, 24, 14, 4, 8)
print(10, 2, 16, 20, 22)
exit()
seq = [i for i in range(1, n*n+1) if i % 3 and i & 1]+[i for i in range(1, n*n+1) if i % 3 == 0 and i & 1] + \
[i for i in range(1, n*n+1) if i % 3 == 0 and i & 1 == 0] + \
[i for i in range(1, n*n+1) if i % 3 and i & 1 == 0]
ans = [[0]*n for _ in range(n)]
for i in range(n*n):
x, y = divmod(i, n)
ans[x][y] = seq[i]
for ai in ans:
print(*ai)
|
ConDefects/ConDefects/Code/arc149_c/Python/45546378
|
condefects-python_data_2618
|
n = int(input())
if n == 3:
ans = [[5,9,1],[3,7,8],[6,2,4]]
elif n == 4:
ans = [[15,11,16,12],[13,3,6,9],[14,7,8,1],[4,2,10,5]]
elif n == 5:
ans = [[1,7,11,13,17],[19,23,25,21,5],[3,9,15,24,10],[6,12,18,2,4],[8,10,14,16,20]]
else:
seen = [False for i in range(n ** 2 + 1)]
ans = [0 for i in range(n ** 2)]
l = []
for i in range(3,n**2 - 2,6):
if len(l) == n:
break
l.append([i,i+3])
seen[i] = True
seen[i+3] = True
for i in range(n):
ans[(n**2 + 1) // 2 - i - 1] = l[i][0]
ans[(n**2 + 1) // 2 - i + n - 1] = l[i][1]
now = 0
for i in range(1,n**2 + 1,2):
if now == (n**2 + 1) // 2:
break
if not seen[i]:
ans[now] = i
now += 1
now = (n ** 2 + 1) // 2 + n
for i in range(2,n ** 2 + 1,2):
if now == n ** 2:
break
if not seen[i]:
ans[now] = i
now += 1
ans = [[ans[i + j * n] for i in range(n)] for j in range(n)]
ANS = [" ".join(map(str,i)) for i in ans]
print("\n".join(ANS))
n = int(input())
if n == 3:
ans = [[5,9,1],[3,7,8],[6,2,4]]
elif n == 4:
ans = [[15,11,16,12],[13,3,6,9],[14,7,8,1],[4,2,10,5]]
elif n == 5:
ans = [[1,7,11,13,17],[19,23,25,21,5],[3,9,15,24,10],[6,12,18,2,4],[8,22,14,16,20]]
else:
seen = [False for i in range(n ** 2 + 1)]
ans = [0 for i in range(n ** 2)]
l = []
for i in range(3,n**2 - 2,6):
if len(l) == n:
break
l.append([i,i+3])
seen[i] = True
seen[i+3] = True
for i in range(n):
ans[(n**2 + 1) // 2 - i - 1] = l[i][0]
ans[(n**2 + 1) // 2 - i + n - 1] = l[i][1]
now = 0
for i in range(1,n**2 + 1,2):
if now == (n**2 + 1) // 2:
break
if not seen[i]:
ans[now] = i
now += 1
now = (n ** 2 + 1) // 2 + n
for i in range(2,n ** 2 + 1,2):
if now == n ** 2:
break
if not seen[i]:
ans[now] = i
now += 1
ans = [[ans[i + j * n] for i in range(n)] for j in range(n)]
ANS = [" ".join(map(str,i)) for i in ans]
print("\n".join(ANS))
|
ConDefects/ConDefects/Code/arc149_c/Python/37461602
|
condefects-python_data_2619
|
n, m = map(int, input().split())
G = [[] for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
G[a].append((b, -c))
G[b].append((a, c))
used = [False for _ in range(n)]
cost = [0 for _ in range(n)]
def dfs(u, d):
res = [u]
used[u] = True
cost[u] = d
for v, c in G[u]:
if used[v]: continue
res += dfs(v, d + c)
return res
g = []
st = []
for i in range(n):
if used[i]: continue
comp = dfs(i, 0)
m = min(cost[u] for u in comp)
for u in comp:
cost[u] -= m
bit = 0
for u in comp:
bit |= (1 << cost[u])
g.append(bit)
st.append(comp)
bitset=[[]for _ in range(n+1)]
for bit in range(1<<n):
cnt=bit.bit_count()
bitset[cnt].append(bit)
ans=[-1]*n
for i in range(len(g)):
now=0
dp=[False]*(1<<n)
dp[0]=True
x=g[i]
for j in range(len(g)):
if i==j:
continue
for bit in bitset[now]:
if dp[bit]==False:
continue
for sft in range(n):
if bit|(g[j]<<sft)>=(1<<n):
break
dp[bit|(g[j]<<sft)]=True
now+=g[j].bit_count()
# print(dp)
ok=[]
for bit in bitset[n-x.bit_count()]:
if dp[bit]==False:
continue
# print(x,bit)
for sft in range(n):
if x<<sft>=(1<<n):
break
if bit^(x<<sft)==(1<<n)-1:
ok.append(sft)
if len(ok)==1:
# print(ok)
# print(st[i])
for s in st[i]:
ans[s]=s+ok[0]+1
print(*ans)
n, m = map(int, input().split())
G = [[] for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
G[a].append((b, -c))
G[b].append((a, c))
used = [False for _ in range(n)]
cost = [0 for _ in range(n)]
def dfs(u, d):
res = [u]
used[u] = True
cost[u] = d
for v, c in G[u]:
if used[v]: continue
res += dfs(v, d + c)
return res
g = []
st = []
for i in range(n):
if used[i]: continue
comp = dfs(i, 0)
m = min(cost[u] for u in comp)
for u in comp:
cost[u] -= m
bit = 0
for u in comp:
bit |= (1 << cost[u])
g.append(bit)
st.append(comp)
bitset=[[]for _ in range(n+1)]
for bit in range(1<<n):
cnt=bit.bit_count()
bitset[cnt].append(bit)
ans=[-1]*n
for i in range(len(g)):
now=0
dp=[False]*(1<<n)
dp[0]=True
x=g[i]
for j in range(len(g)):
if i==j:
continue
for bit in bitset[now]:
if dp[bit]==False:
continue
for sft in range(n):
if bit|(g[j]<<sft)>=(1<<n):
break
dp[bit|(g[j]<<sft)]=True
now+=g[j].bit_count()
# print(dp)
ok=[]
for bit in bitset[n-x.bit_count()]:
if dp[bit]==False:
continue
# print(x,bit)
for sft in range(n):
if x<<sft>=(1<<n):
break
if bit^(x<<sft)==(1<<n)-1:
ok.append(sft)
if len(ok)==1:
# print(ok)
# print(st[i])
for s in st[i]:
ans[s]=cost[s]+ok[0]+1
print(*ans)
|
ConDefects/ConDefects/Code/abc352_f/Python/53476783
|
condefects-python_data_2620
|
from bisect import bisect,bisect_left
from collections import *
from heapq import *
from math import gcd,ceil,sqrt,floor,inf,pi
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#----------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
# x.bit_count()
def popcnt(x):
ans=0
while x:
ans+=1
x&=x-1
return ans
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
class UF:#秩+路径+容量，边数
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
self.size=AI(n,1)
self.edge=A(n)
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
self.edge[pu]+=1
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
self.edge[pu]+=self.edge[pv]+1
self.size[pu]+=self.size[pv]
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
self.edge[pv]+=self.edge[pu]+1
self.size[pv]+=self.size[pu]
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d=AI(n,inf)
d[s]=0
heap=[(0,s)]
while heap:
dis,u=heappop(heap)
if dis>d[u]:
continue
for v,w in graph[u]:
if d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def exgcd(a,b):
if b==0:
return 1,0,a
x,y,g=exgcd(b,a%b)
x,y=y,(x-a//b*y)
return x,y,g
def lis(nums):
res=[]
for k in nums:
i=bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
def michange(a,b):
d=defaultdict(deque)
for i,x in enumerate(b):
d[x].append(i)
order=A(len(a))
for i,x in enumerate(a):
if not d:
return -1
order[i]=d[x].popleft()
return RP(order)
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
'''
from random import randint,shuffle
def ra(n,a,b):
return [randint(a,b) for i in range(n)]
def check(l,r):
return sum(s[i]==s[i-1] for i in range(l+1,r+1))
'''
def dfs(u):
global res,seq
vis[u]=1
res.append(val[u])
seq[-1].append(u)
for v,w in g[u]:
if not vis[v]:
val[v]=val[u]-w
dfs(v)
@lru_cache(None)
def dp(i,s):
if s==ma:
return 1
j=pos[i]
cur=0
while j<ma:
if not j&s:
if dp(i+1,j|s):
cur=1
pb[i].add(j)
j<<=1
return cur
mod=998244353
t=1
for i in range(t):
n,m=RL()
g=G(n)
for i in range(m):
a,b,c=RL()
g[a-1].append((b-1,c))
g[b-1].append((a-1,-c))
vis=A(n)
val=A(n)
pos=[]
seq=[]
for i in range(n):
if not vis[i]:
res=[]
seq.append([])
dfs(i)
mi=min(res)
mask=0
for x in res:
mask|=1<<(x-mi)
for j in seq[-1]:
val[j]-=mi-1
pos.append(mask)
ma=(1<<n)-1
nn=len(pos)
pb=[set() for _ in range(nn)]
dp(0,0)
ans=AI(n,-1)
for i in range(nn):
if len(pb[i])==1:
mask=pb[i].pop()
shift=0
while not mask&1:
mask>>=1
shift+=1
for x in seq[i]:
ans[x]=val[x]+shift
print(*ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.sta1ck_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
111-115
121-122
131
141
151
'''
from bisect import bisect,bisect_left
from collections import *
from heapq import *
from math import gcd,ceil,sqrt,floor,inf,pi
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#----------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
# x.bit_count()
def popcnt(x):
ans=0
while x:
ans+=1
x&=x-1
return ans
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
class UF:#秩+路径+容量，边数
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
self.size=AI(n,1)
self.edge=A(n)
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
self.edge[pu]+=1
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
self.edge[pu]+=self.edge[pv]+1
self.size[pu]+=self.size[pv]
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
self.edge[pv]+=self.edge[pu]+1
self.size[pv]+=self.size[pu]
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d=AI(n,inf)
d[s]=0
heap=[(0,s)]
while heap:
dis,u=heappop(heap)
if dis>d[u]:
continue
for v,w in graph[u]:
if d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def exgcd(a,b):
if b==0:
return 1,0,a
x,y,g=exgcd(b,a%b)
x,y=y,(x-a//b*y)
return x,y,g
def lis(nums):
res=[]
for k in nums:
i=bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
def michange(a,b):
d=defaultdict(deque)
for i,x in enumerate(b):
d[x].append(i)
order=A(len(a))
for i,x in enumerate(a):
if not d:
return -1
order[i]=d[x].popleft()
return RP(order)
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
'''
from random import randint,shuffle
def ra(n,a,b):
return [randint(a,b) for i in range(n)]
def check(l,r):
return sum(s[i]==s[i-1] for i in range(l+1,r+1))
'''
def dfs(u):
global res,seq
vis[u]=1
res.append(val[u])
seq[-1].append(u)
for v,w in g[u]:
if not vis[v]:
val[v]=val[u]-w
dfs(v)
@lru_cache(None)
def dp(i,s):
if s==ma:
return 1
j=pos[i]
cur=0
while j<=ma:
if not j&s:
if dp(i+1,j|s):
cur=1
pb[i].add(j)
j<<=1
return cur
mod=998244353
t=1
for i in range(t):
n,m=RL()
g=G(n)
for i in range(m):
a,b,c=RL()
g[a-1].append((b-1,c))
g[b-1].append((a-1,-c))
vis=A(n)
val=A(n)
pos=[]
seq=[]
for i in range(n):
if not vis[i]:
res=[]
seq.append([])
dfs(i)
mi=min(res)
mask=0
for x in res:
mask|=1<<(x-mi)
for j in seq[-1]:
val[j]-=mi-1
pos.append(mask)
ma=(1<<n)-1
nn=len(pos)
pb=[set() for _ in range(nn)]
dp(0,0)
ans=AI(n,-1)
for i in range(nn):
if len(pb[i])==1:
mask=pb[i].pop()
shift=0
while not mask&1:
mask>>=1
shift+=1
for x in seq[i]:
ans[x]=val[x]+shift
print(*ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.sta1ck_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
111-115
121-122
131
141
151
'''
|
ConDefects/ConDefects/Code/abc352_f/Python/54716291
|
condefects-python_data_2621
|
N = int(input())
P = [int(i) for i in input().split()]
Q = int(input())
queries = [[int(i) for i in input().split()] for _ in range(Q)]
# print(queries)
from collections import defaultdict
class UnionFind():
def __init__(self,n):
self.n=n
self.parents=[-1]*n
def find(self,x):
if self.parents[x]<0:
return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self,x):
return -self.parents[self.find(x)]
def same(self,x,y):
return self.find(x)==self.find(y)
def members(self,x):
root=self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members=defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r,m in self.all_group_members().items())
uf = UnionFind(N)
G = [set() for _ in range(N)]
rG = [-1 for _ in range(N)]
for i,p in enumerate(P):
p-=1
G[p].add(i+1)
rG[i+1] = p
# print(G,rG)
ans = [i for i in range(N)]
# print(rG)
for q in queries:
if q[0]==1:
u,v = q[1:]
u-=1; v-=1
if uf.same(u,v):
continue
cu = u
v = ans[uf.find(v)]
# cnt = 0
while cu!=v:
# cnt+=1
# if cnt>10:
# raise Exception
# print('cu', cu)
uf.union(cu, v)
ans[uf.find(cu)]=v
cu = ans[uf.find(rG[cu])]
par = uf.find(u)
ans[par] = v
else:
x = q[1]-1
par = uf.find(x)
print(ans[par]+1)
N = int(input())
P = [int(i) for i in input().split()]
Q = int(input())
queries = [[int(i) for i in input().split()] for _ in range(Q)]
# print(queries)
from collections import defaultdict
class UnionFind():
def __init__(self,n):
self.n=n
self.parents=[-1]*n
def find(self,x):
if self.parents[x]<0:
return x
else:
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.parents[x]>self.parents[y]:
x,y=y,x
self.parents[x]+=self.parents[y]
self.parents[y]=x
def size(self,x):
return -self.parents[self.find(x)]
def same(self,x,y):
return self.find(x)==self.find(y)
def members(self,x):
root=self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i,x in enumerate(self.parents) if x<0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members=defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r,m in self.all_group_members().items())
uf = UnionFind(N)
G = [set() for _ in range(N)]
rG = [-1 for _ in range(N)]
for i,p in enumerate(P):
p-=1
G[p].add(i+1)
rG[i+1] = p
# print(G,rG)
ans = [i for i in range(N)]
# print(rG)
for q in queries:
if q[0]==1:
u,v = q[1:]
u-=1; v-=1
if uf.same(u,v):
continue
cu = ans[uf.find(u)]
v = ans[uf.find(v)]
# cnt = 0
while cu!=v:
# cnt+=1
# if cnt>10:
# raise Exception
# print('cu', cu)
uf.union(cu, v)
ans[uf.find(cu)]=v
cu = ans[uf.find(rG[cu])]
par = uf.find(u)
ans[par] = v
else:
x = q[1]-1
par = uf.find(x)
print(ans[par]+1)
|
ConDefects/ConDefects/Code/abc295_g/Python/40825469
|
condefects-python_data_2622
|
"""
Author ankisho
Created 2023/08/31 16:46JST
"""
from collections import deque
def operation(sh,sw,dh,dw,nope):
nh = sh
nw = sw
while True:
nh+=dh
nw+=dw
if nh<0 or nh>=N or nw<0 or nw>=N: break
if S[nh][nw]=='#': break
if dis[nh][nw]==-1:
dis[nh][nw]=nope
que.append((nh,nw,nope))
else:
break
N = int(input())
A,B = map(int,input().split())
C,D = map(int,input().split())
S = [input() for _ in range(N)]
dis = [[-1]*N for _ in range(N)]
dis[A-1][B-1]=0
que = deque()
que.append((A-1,B-1,0))
while que:
h,w,d = que.popleft()
#各方向に移動できるまで移動させる
operation(h,w,1,1,d+1)
operation(h,w,1,-1,d+1)
operation(h,w,-1,1,d+1)
operation(h,w,-1,-1,d+1)
#print(dis)
print(dis[C-1][D-1])
"""
Author ankisho
Created 2023/08/31 16:46JST
"""
from collections import deque
def operation(sh,sw,dh,dw,nope):
nh = sh
nw = sw
while True:
nh+=dh
nw+=dw
if nh<0 or nh>=N or nw<0 or nw>=N: break
if S[nh][nw]=='#': break
if dis[nh][nw]==-1:
dis[nh][nw]=nope
que.append((nh,nw,nope))
elif dis[nh][nw]<nope:
break
N = int(input())
A,B = map(int,input().split())
C,D = map(int,input().split())
S = [input() for _ in range(N)]
dis = [[-1]*N for _ in range(N)]
dis[A-1][B-1]=0
que = deque()
que.append((A-1,B-1,0))
while que:
h,w,d = que.popleft()
#各方向に移動できるまで移動させる
operation(h,w,1,1,d+1)
operation(h,w,1,-1,d+1)
operation(h,w,-1,1,d+1)
operation(h,w,-1,-1,d+1)
#print(dis)
print(dis[C-1][D-1])
|
ConDefects/ConDefects/Code/abc246_e/Python/45083106
|
condefects-python_data_2623
|
import collections
N=int(input())
Ax,Ay=map(int,input().split())
Bx,By=map(int,input().split())
S=[input() for i in range(N)]
Ax-=1
Ay-=1
By-=1
Bx-=1
D=[[-1 for j in range(N)] for i in range(N)]
D[Ax][Ay]=0
Q=collections.deque()
Q.append((Ax,Ay))
while Q:
h,w=Q.popleft()
for dx in [-1, 1]:
for dy in [-1, 1]:
nh=h+dx
nw=w+dy
while True:
if nh == -1 or nh == N or nw == -1 or nw == N:
break
if S[nh][nw] == "#":
break
if D[nh][nw] != -1 and D[nh][nw] <= D[nh][nw]:
break
if D[nh][nw] < D[h][w]:
D[nh][nw] = D[h][w] + 1
Q.append((nh, nw))
nh+=dx
nw+=dy
print(D[Bx][By])
import collections
N=int(input())
Ax,Ay=map(int,input().split())
Bx,By=map(int,input().split())
S=[input() for i in range(N)]
Ax-=1
Ay-=1
By-=1
Bx-=1
D=[[-1 for j in range(N)] for i in range(N)]
D[Ax][Ay]=0
Q=collections.deque()
Q.append((Ax,Ay))
while Q:
h,w=Q.popleft()
for dx in [-1, 1]:
for dy in [-1, 1]:
nh=h+dx
nw=w+dy
while True:
if nh == -1 or nh == N or nw == -1 or nw == N:
break
if S[nh][nw] == "#":
break
if D[nh][nw] != -1 and D[nh][nw] <= D[h][w]:
break
if D[nh][nw] < D[h][w]:
D[nh][nw] = D[h][w] + 1
Q.append((nh, nw))
nh+=dx
nw+=dy
print(D[Bx][By])
|
ConDefects/ConDefects/Code/abc246_e/Python/45269631
|
condefects-python_data_2624
|
from collections import deque
N = int(input())
sy, sx = map(lambda x: int(x) - 1, input().split())
gy, gx = map(lambda x: int(x) - 1, input().split())
S = [ input() for _ in range(N)]
queue = deque([(sy, sx)])
dis = [ [1e32] * N for _ in range(N)]
dis[sy][sx] = 0
dir = [ [1, 1], [1, -1], [-1, 1], [-1, -1]]
def is_ok(y : int, x : int, td : int):
if not (0 <= y <= N - 1 and 0 <= x <= N - 1):
return False
if S[y][x] == "#":
return False
if dis[y][x] <= td:
return False
return True
while queue:
y, x = queue.popleft()
td = dis[y][x] + 1
for dy, dx in dir:
ty, tx = y, x
while True:
ty, tx = ty + dy, tx + dx
if not (0 <= ty <= N - 1 and 0 <= tx <= N - 1):
break
elif S[ty][tx] == "#":
break
elif dis[ty][tx] <= td:
break
else:
dis[ty][tx] = td
queue.append((ty, tx))
print(dis[gy][gx] if dis[gy][gx] < 1e32 else -1)
from collections import deque
N = int(input())
sy, sx = map(lambda x: int(x) - 1, input().split())
gy, gx = map(lambda x: int(x) - 1, input().split())
S = [ input() for _ in range(N)]
queue = deque([(sy, sx)])
dis = [ [1e32] * N for _ in range(N)]
dis[sy][sx] = 0
dir = [ [1, 1], [1, -1], [-1, 1], [-1, -1]]
def is_ok(y : int, x : int, td : int):
if not (0 <= y <= N - 1 and 0 <= x <= N - 1):
return False
if S[y][x] == "#":
return False
if dis[y][x] <= td:
return False
return True
while queue:
y, x = queue.popleft()
td = dis[y][x] + 1
for dy, dx in dir:
ty, tx = y, x
while True:
ty, tx = ty + dy, tx + dx
if not (0 <= ty <= N - 1 and 0 <= tx <= N - 1):
break
elif S[ty][tx] == "#":
break
elif dis[ty][tx] < td:
break
else:
dis[ty][tx] = td
queue.append((ty, tx))
print(dis[gy][gx] if dis[gy][gx] < 1e32 else -1)
|
ConDefects/ConDefects/Code/abc246_e/Python/45553928
|
condefects-python_data_2625
|
from collections import deque
N=int(input())
sx,sy=map(int,input().split())
gx,gy=map(int,input().split())
sx,sy,gx,gy=sx-1,sy-1,gx-1,gy-1
S=[list(input()) for _ in range(N)]
d=((1,1),(1,-1),(-1,-1),(-1,1))
que=deque()
inf=1<<60
dist=[[[inf]*N for _ in range(N)] for _ in range(4)]
for i in range(4):
dist[i][sy][sx]=1
que.append((sy,sx,i,1))
while que:
y,x,v,time=que.popleft()
if dist[v][y][x]<time:continue
dy,dx=d[v]
if 0<=y+dy<=N-1 and 0<=x+dx<=N-1:
if S[y+dy][x+dx]==".":
if dist[v][y+dy][x+dx]>time:
dist[v][y+dy][x+dx]=time
que.appendleft((dy+y,dx+x,v,time))
for i in range(4):
if dist[i][y][x]>time+1:
dist[i][y][x]=time+1
que.append((y,x,i,time+1))
ans=inf
for i in range(4):
ans=min(ans,dist[i][gy][gx])
if ans==inf:
print(-1)
else:
print(ans)
from collections import deque
N=int(input())
sx,sy=map(int,input().split())
gx,gy=map(int,input().split())
sx,sy,gx,gy=sx-1,sy-1,gx-1,gy-1
S=[list(input()) for _ in range(N)]
d=((1,1),(1,-1),(-1,-1),(-1,1))
que=deque()
inf=1<<60
dist=[[[inf]*N for _ in range(N)] for _ in range(4)]
for i in range(4):
dist[i][sy][sx]=1
que.append((sy,sx,i,1))
while que:
y,x,v,time=que.popleft()
if dist[v][y][x]<time:continue
dy,dx=d[v]
if 0<=y+dy<=N-1 and 0<=x+dx<=N-1:
if S[x+dx][y+dy]==".":
if dist[v][y+dy][x+dx]>time:
dist[v][y+dy][x+dx]=time
que.appendleft((dy+y,dx+x,v,time))
for i in range(4):
if dist[i][y][x]>time+1:
dist[i][y][x]=time+1
que.append((y,x,i,time+1))
ans=inf
for i in range(4):
ans=min(ans,dist[i][gy][gx])
if ans==inf:
print(-1)
else:
print(ans)
|
ConDefects/ConDefects/Code/abc246_e/Python/45962991
|
condefects-python_data_2626
|
s = input()
t = input()
if s[0:3] == t[0:3]:
print('Yes')
else:
print('No')
s = input()
t = input()
if s[0:len(s)] == t[0:len(s)]:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc268_b/Python/45422238
|
condefects-python_data_2627
|
import sys
input = lambda: sys.stdin.readline().rstrip()
from heapq import heapify, heappush as hpush, heappop as hpop
def dijkstra(n, E, i0=0):
kk = 18
mm = (1 << kk) - 1
h = [i0]
D = [-1] * n
done = [0] * n
D[i0] = 0
while h:
x = hpop(h)
d, i = x >> kk, x & mm
if done[i]: continue
done[i] = 1
for j, w in E[i]:
nd = d + w
if D[j] < 0 or D[j] > nd:
if done[j] == 0:
hpush(h, (nd << kk) + j)
D[j] = nd
return D
N, M = map(int, input().split())
X = [[] for _ in range(N + 1)]
for i in range(N):
X[i].append((i + 1, 1))
for i in range(N):
X[i+1].append((i, 1))
for _ in range(M):
l, r = map(int, input().split())
l -= 1
d = 0
X[l].append((r, d))
X[r].append((l, d))
D = dijkstra(N + 1, X)
A = [(2 - D[i+1] + D[i]) // 2 for i in range(N)]
print("".join(map(str, A)))
import sys
input = lambda: sys.stdin.readline().rstrip()
from heapq import heapify, heappush as hpush, heappop as hpop
def dijkstra(n, E, i0=0):
kk = 20
mm = (1 << kk) - 1
h = [i0]
D = [-1] * n
done = [0] * n
D[i0] = 0
while h:
x = hpop(h)
d, i = x >> kk, x & mm
if done[i]: continue
done[i] = 1
for j, w in E[i]:
nd = d + w
if D[j] < 0 or D[j] > nd:
if done[j] == 0:
hpush(h, (nd << kk) + j)
D[j] = nd
return D
N, M = map(int, input().split())
X = [[] for _ in range(N + 1)]
for i in range(N):
X[i].append((i + 1, 1))
for i in range(N):
X[i+1].append((i, 1))
for _ in range(M):
l, r = map(int, input().split())
l -= 1
d = 0
X[l].append((r, d))
X[r].append((l, d))
D = dijkstra(N + 1, X)
A = [(2 - D[i+1] + D[i]) // 2 for i in range(N)]
print("".join(map(str, A)))
|
ConDefects/ConDefects/Code/agc056_c/Python/27693193
|
condefects-python_data_2628
|
n, m = map(int, input().split())
edge = [[] for _ in range(n+1)]
eset = [set() for _ in range(n+1)]
for _ in range(m):
a, b = map(int, input().split())
edge[a] += [b]
eset[a].add(b)
ans = 0
for i in range(n):
vis = [0]*(n+1)
i += 1
vis[i] = 1
q = [i]
while q:
v = q.pop()
for nv in edge[v]:
if vis[nv]: continue
vis[nv] = 1
q += [nv]
ans += 1
print(ans)
n, m = map(int, input().split())
edge = [[] for _ in range(n+1)]
eset = [set() for _ in range(n+1)]
for _ in range(m):
a, b = map(int, input().split())
edge[a] += [b]
eset[a].add(b)
ans = 0
for i in range(n):
vis = [0]*(n+1)
i += 1
vis[i] = 1
q = [i]
while q:
v = q.pop()
for nv in edge[v]:
if vis[nv]: continue
vis[nv] = 1
q += [nv]
ans += 1
print(ans-m)
|
ConDefects/ConDefects/Code/abc292_e/Python/50119653
|
condefects-python_data_2629
|
n = int(input())
sec = [[] for _ in range(n)]
for i in range(n):
sec[i] = list(map(int, input().split()))
sec.sort()
now = 0
nex = 1
ans = []
while now < n:
left = sec[now][0]
right = sec[now][1]
while nex < n and left <= sec[nex][0] <= right:
right = sec[nex][1]
nex += 1
ans.append([left, right])
now = nex
nex += 1
for i in range(len(ans)):
print(*ans[i])
n = int(input())
sec = [[] for _ in range(n)]
for i in range(n):
sec[i] = list(map(int, input().split()))
sec.sort()
now = 0
nex = 1
ans = []
while now < n:
left = sec[now][0]
right = sec[now][1]
while nex < n and left <= sec[nex][0] <= right:
right = max(right, sec[nex][1])
nex += 1
ans.append([left, right])
now = nex
nex += 1
for i in range(len(ans)):
print(*ans[i])
|
ConDefects/ConDefects/Code/abc256_d/Python/45322740
|
condefects-python_data_2630
|
N = int(input())
LR = [list(map(int, input().split())) for _ in range(N)]
LR.sort()
pl, pr = LR[0]
for i in range(1, N):
l, r = LR[i]
if pr < l:
print(pl, pr)
pl = l
pr = r
print(pl, pr)
N = int(input())
LR = [list(map(int, input().split())) for _ in range(N)]
LR.sort()
pl, pr = LR[0]
for i in range(1, N):
l, r = LR[i]
if pr < l:
print(pl, pr)
pl = l
pr = max(pr, r)
print(pl, pr)
|
ConDefects/ConDefects/Code/abc256_d/Python/45531373
|
condefects-python_data_2631
|
N=int(input())
L=[]
R=[]
for i in range(N):
l,r=map(int,input().split())
L.append(l)
R.append(r)
L.sort()
R.sort()
c=0
ans=0
now_l=0
now_r=0
is_in=[False]*(max(max(L),max(R))+1)
for i in range(1,max(max(L),max(R))+1):
print(c,now_l,now_r)
while now_l<len(L) and i>=L[now_l]:
c+=1
now_l+=1
while now_r<len(R) and i>=R[now_r]:
c-=1
now_r+=1
if(c>0):
is_in[i]=True
is_left=False
l=0
r=0
# print(is_in)
for i in range(1,max(max(L),max(R))+1):
if(is_left):
if(not is_in[i]):
is_left=False
r=i
print(l,r)
else:
if(is_in[i]):
is_left=True
l=i
N=int(input())
L=[]
R=[]
for i in range(N):
l,r=map(int,input().split())
L.append(l)
R.append(r)
L.sort()
R.sort()
c=0
ans=0
now_l=0
now_r=0
is_in=[False]*(max(max(L),max(R))+1)
for i in range(1,max(max(L),max(R))+1):
# print(c,now_l,now_r)
while now_l<len(L) and i>=L[now_l]:
c+=1
now_l+=1
while now_r<len(R) and i>=R[now_r]:
c-=1
now_r+=1
if(c>0):
is_in[i]=True
is_left=False
l=0
r=0
# print(is_in)
for i in range(1,max(max(L),max(R))+1):
if(is_left):
if(not is_in[i]):
is_left=False
r=i
print(l,r)
else:
if(is_in[i]):
is_left=True
l=i
|
ConDefects/ConDefects/Code/abc256_d/Python/44868880
|
condefects-python_data_2632
|
n=int(input())
LR=[list(map(int,input().split())) for _ in range(n)]
LR.sort()
A=[LR[0]]
for i in range(1,n):
L,R=LR[i]
if A[-1][1]<L:
A+=[[L,R]]
else:
A[-1][1]=R
for i in A:
print(*i)
n=int(input())
LR=[list(map(int,input().split())) for _ in range(n)]
LR.sort()
A=[LR[0]]
for i in range(1,n):
L,R=LR[i]
if A[-1][1]<L:
A+=[[L,R]]
else:
A[-1][1]=max(A[-1][1],R)
for i in A:
print(*i)
|
ConDefects/ConDefects/Code/abc256_d/Python/44916698
|
condefects-python_data_2633
|
N = int(input())
CS = [0]*(2*10**5 + 1)
LR = [list(map(int, input().split())) for _ in range(N)]
LR += [[2*10**5,2*10**5]] # 番兵
LR.sort()
left,right,ans = 0,0,[]
for i in range(N+1):
L,R = LR[i][0],LR[i][1]
if right < L: # 新しい区間
ans.append((left,right))
left,right = L,R
elif right < R: # 区間を延長
right = R
for l,r in ans[1:]:
print(l,r)
N = int(input())
CS = [0]*(2*10**5 + 1)
LR = [list(map(int, input().split())) for _ in range(N)]
LR += [[10**6,10**6]] # 番兵
LR.sort()
left,right,ans = 0,0,[]
for i in range(N+1):
L,R = LR[i][0],LR[i][1]
if right < L: # 新しい区間
ans.append((left,right))
left,right = L,R
elif right < R: # 区間を延長
right = R
for l,r in ans[1:]:
print(l,r)
|
ConDefects/ConDefects/Code/abc256_d/Python/46018107
|
condefects-python_data_2634
|
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
N=int(input())
LR=[list(map(int,input().split())) for _ in range(N)]
ans=[LR[0][0],LR[0][1]]
ans=SortedSet(ans)
for i in range(1,N):
# print(ans)
l=ans.index(LR[i][0])-1
r=ans.index(LR[i][1])-1
# print(l,r)
for j in range(l+1,r+1):
ans.discard(ans[l+1])
# print(ans)
if(r%2==1):
ans.add(LR[i][1])
if(l%2==1):
ans.add(LR[i][0])
# if(l%2==0 and r%2==0):
# for j in range(l+1,r+1):
# ans.discard(ans[l])
# elif(l%2==0 and r%2==1):
# for j in range(l+1,r+1):
# ans.discard(ans[l])
# ans.add(LR[i][1])
# elif(l%2==1 and r%2==0):
for i in range(len(ans)//2):
print(ans[i*2],ans[i*2+1])
# ans_l=[LR[0][0]]
# ans_l=SortedSet(ans_l)
# ans_r=[LR[0][1]]
# ans_r=SortedSet(ans_r)
# for i in range(1,N):
# l=ans_r.index(LR[i][0])
# r=ans_l.index(LR[i][1])
# if(l==len(ans_r)):
# pass
# elif(r==0):
# pass
# else:
# l
# for i in range(r-l)
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
N=int(input())
LR=[list(map(int,input().split())) for _ in range(N)]
ans=[LR[0][0],LR[0][1]]
ans=SortedSet(ans)
for i in range(1,N):
# print(ans)
l=ans.index(LR[i][0])-1
r=ans.index_right(LR[i][1])-1
# print(l,r)
for j in range(l+1,r+1):
ans.discard(ans[l+1])
# print(ans)
if(r%2==1):
ans.add(LR[i][1])
if(l%2==1):
ans.add(LR[i][0])
# if(l%2==0 and r%2==0):
# for j in range(l+1,r+1):
# ans.discard(ans[l])
# elif(l%2==0 and r%2==1):
# for j in range(l+1,r+1):
# ans.discard(ans[l])
# ans.add(LR[i][1])
# elif(l%2==1 and r%2==0):
for i in range(len(ans)//2):
print(ans[i*2],ans[i*2+1])
# ans_l=[LR[0][0]]
# ans_l=SortedSet(ans_l)
# ans_r=[LR[0][1]]
# ans_r=SortedSet(ans_r)
# for i in range(1,N):
# l=ans_r.index(LR[i][0])
# r=ans_l.index(LR[i][1])
# if(l==len(ans_r)):
# pass
# elif(r==0):
# pass
# else:
# l
# for i in range(r-l)
|
ConDefects/ConDefects/Code/abc256_d/Python/44864172
|
condefects-python_data_2635
|
n=int(input())
que=[]
for i in range(n):
l,r=map(int,input().split())
que.append((l,r))
que.sort()
now=0
ans=[]
while now<n:
ans.append(que[now][0])
tmp=que[now][1]
if now==n-1:
ans.append(tmp)
break
now+=1
while tmp>=que[now][0]:
tmp=max(tmp,que[now][1])
now+=1
if now==n:
break
ans.append(tmp)
for i in range(len(ans)//2):
print(ans[i],ans[i+1])
n=int(input())
que=[]
for i in range(n):
l,r=map(int,input().split())
que.append((l,r))
que.sort()
now=0
ans=[]
while now<n:
ans.append(que[now][0])
tmp=que[now][1]
if now==n-1:
ans.append(tmp)
break
now+=1
while tmp>=que[now][0]:
tmp=max(tmp,que[now][1])
now+=1
if now==n:
break
ans.append(tmp)
for i in range(0,len(ans),2):
print(ans[i],ans[i+1])
|
ConDefects/ConDefects/Code/abc256_d/Python/46191783
|
condefects-python_data_2636
|
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
from collections import deque, defaultdict
from decimal import Decimal
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
from itertools import permutations, combinations
from random import randrange, choices
from string import ascii_lowercase, ascii_uppercase
from os import environ
from copy import deepcopy
import math
import sys
sys.setrecursionlimit(10000000)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]:
break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, i = self._position(x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a:
self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a, i = self._position(x)
if i == len(a) or a[i] != x:
return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return a[i]
else:
for a in self.a:
if i < len(a):
return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return self._pop(a, i)
else:
for a in self.a:
if i < len(a):
return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(a)
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]:
break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a:
self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a, i = self._position(x)
if i == len(a) or a[i] != x:
return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return a[i]
else:
for a in self.a:
if i < len(a):
return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return self._pop(a, i)
else:
for a in self.a:
if i < len(a):
return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
n = int(input())
intervals = sorted([list(map(int, input().split())) for _ in range(n)])
ans = [intervals[0]]
for i in range(1, n):
l1, r1 = ans[-1]
l2, r2 = intervals[i]
if l2 <= r1:
ans[-1][1] = r2
else:
ans.append([l2, r2])
# print(ans)
for a in ans:
print(*a)
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
from collections import deque, defaultdict
from decimal import Decimal
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
from itertools import permutations, combinations
from random import randrange, choices
from string import ascii_lowercase, ascii_uppercase
from os import environ
from copy import deepcopy
import math
import sys
sys.setrecursionlimit(10000000)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]:
break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, i = self._position(x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a:
self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a, i = self._position(x)
if i == len(a) or a[i] != x:
return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return a[i]
else:
for a in self.a:
if i < len(a):
return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return self._pop(a, i)
else:
for a in self.a:
if i < len(a):
return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
self.size = len(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(a)
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]:
break
return (a, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a:
self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a, i = self._position(x)
if i == len(a) or a[i] != x:
return False
self._pop(a, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return a[i]
else:
for a in self.a:
if i < len(a):
return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0:
return self._pop(a, i)
else:
for a in self.a:
if i < len(a):
return self._pop(a, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
n = int(input())
intervals = sorted([list(map(int, input().split())) for _ in range(n)])
ans = [intervals[0]]
for i in range(1, n):
l1, r1 = ans[-1]
l2, r2 = intervals[i]
if l2 <= r1:
ans[-1][1] = max(r1, r2)
else:
ans.append([l2, r2])
# print(ans)
for a in ans:
print(*a)
|
ConDefects/ConDefects/Code/abc256_d/Python/44696240
|
condefects-python_data_2637
|
N = int(input())
num = 2 * 10 ** 5
L = [0] * (num + 2)
for _ in range(N):
l, r = map(int, input().split())
L[l] += 1
L[r] -= -1
for i in range(num):
L[i+1] += L[i]
flg = False
l = 0
r = 0
for i in range(1,num+1):
if flg == False:
if L[i-1] == 0 and L[i] > 0:
l = i
flg = True
else:
if L[i-1] > 0 and L[i] == 0:
r = i
print(l,r)
flg = False
N = int(input())
num = 2 * 10 ** 5
L = [0] * (num + 2)
for _ in range(N):
l, r = map(int, input().split())
L[l] += 1
L[r] -= 1
for i in range(num):
L[i+1] += L[i]
flg = False
l = 0
r = 0
for i in range(1,num+1):
if flg == False:
if L[i-1] == 0 and L[i] > 0:
l = i
flg = True
else:
if L[i-1] > 0 and L[i] == 0:
r = i
print(l,r)
flg = False
|
ConDefects/ConDefects/Code/abc256_d/Python/45516891
|
condefects-python_data_2638
|
n=int(input())
s=[list(map(int,input().split())) for i in range(n)]
s.sort(key=lambda x:x[0])
ans=[]
now=0
while now<n:
appending=[s[now][0],s[now][1]]
while now<n-1 and s[now+1][0]<=appending[-1]:
now+=1
appending[-1]=s[now][1]
ans.append(appending)
now+=1
for k in ans:
print(*k)
n=int(input())
s=[list(map(int,input().split())) for i in range(n)]
s.sort(key=lambda x:x[0])
ans=[]
now=0
while now<n:
appending=[s[now][0],s[now][1]]
while now<n-1 and s[now+1][0]<=appending[-1]:
now+=1
appending[-1]=max(appending[-1],s[now][1])
ans.append(appending)
now+=1
for k in ans:
print(*k)
|
ConDefects/ConDefects/Code/abc256_d/Python/46043258
|
condefects-python_data_2639
|
N=int(input())
q=[]
for i in range(N):
l,r = list(map(int, input().split()))
q.append((l,r))
ans=[]
q.sort()
now_l,now_r = q[0]
for i in range(N):
l,r = q[i]
if l<=now_r:
now_r = r
else:
ans.append((now_l,now_r))
now_l,now_r = q[i]
ans.append((now_l,now_r))
for i in ans:
print(*i)
N=int(input())
q=[]
for i in range(N):
l,r = list(map(int, input().split()))
q.append((l,r))
ans=[]
q.sort()
now_l,now_r = q[0]
for i in range(N):
l,r = q[i]
if l<=now_r:
now_r = max(r,now_r)
else:
ans.append((now_l,now_r))
now_l,now_r = q[i]
ans.append((now_l,now_r))
for i in ans:
print(*i)
|
ConDefects/ConDefects/Code/abc256_d/Python/45339988
|
condefects-python_data_2640
|
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
N,K = map(int,input().split())
UV = [tuple(map(int,input().split())) for _ in range(N-1)]
es = [[] for _ in range(N)]
for u,v in UV:
u,v = u-1,v-1
es[u].append(v)
es[v].append(u)
depth = [-1] * N
depth[0] = 0
size = [1] * N
def rec(v,p=-1):
for to in es[v]:
if to==p: continue
depth[to] = depth[v] + 1
size[v] += rec(to,v)
return size[v]
rec(0)
if not N <= K <= N + sum(depth):
exit(print('No'))
print('Yes')
size_order = list(range(N))
size_order.sort(key=lambda x: -size[x])
rem = K-N
st = set()
for v in size_order:
if size[v] > rem: continue
rem -= size[v]
st.add(v)
if rem == 0: break
X = [None] * N
for v in range(N):
if v in st:
X[v] = depth[v]
else:
X[v] = -depth[v]
x_order = list(range(N))
x_order.sort(key=lambda x: X[x])
now = 1
ans = [None] * N
for v in x_order:
ans[v] = now
now += 1
print(*ans)
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
N,K = map(int,input().split())
UV = [tuple(map(int,input().split())) for _ in range(N-1)]
es = [[] for _ in range(N)]
for u,v in UV:
u,v = u-1,v-1
es[u].append(v)
es[v].append(u)
depth = [-1] * N
depth[0] = 0
size = [1] * N
def rec(v,p=-1):
for to in es[v]:
if to==p: continue
depth[to] = depth[v] + 1
size[v] += rec(to,v)
return size[v]
rec(0)
if not N <= K <= N + sum(depth):
exit(print('No'))
print('Yes')
size_order = list(range(1,N))
size_order.sort(key=lambda x: -size[x])
rem = K-N
st = set()
for v in size_order:
if size[v] > rem: continue
rem -= size[v]
st.add(v)
if rem == 0: break
X = [None] * N
for v in range(N):
if v in st:
X[v] = depth[v]
else:
X[v] = -depth[v]
x_order = list(range(N))
x_order.sort(key=lambda x: X[x])
now = 1
ans = [None] * N
for v in x_order:
ans[v] = now
now += 1
print(*ans)
|
ConDefects/ConDefects/Code/arc175_d/Python/52191885
|
condefects-python_data_2641
|
#ARC175D LIS on Tree 2
#入力受取
N, K = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = map(lambda x: int(x) - 1, input().split())
G[u].append(v)
G[v].append(u)
#深さを割り当て
D = [1] * N
Q = [(0, -1, 1)]
for now, back, d in Q:
D[now] = d
for nxt in G[now]:
if nxt != back:
Q.append((nxt, now, d + 1))
#持ち点を計算 この時点で構築可否を判定
cost = sum(D)
if K not in range(N, cost + 1):
exit( print('No') )
else:
print('Yes')
#A[d]: 深さがdである頂点の一覧
#B[d]: 深さがdである頂点の個数 の累積和
M = max(D)
A = [[] for _ in range(M + 1)]
for i, d in enumerate(D):
A[d].append(i)
B = [0] * (M + 2)
for d in range(1, M + 1):
B[d + 1] = B[d] + len(A[d])
#前から加算(1) Pに値を割り当て
P = [0] * N
diff = K
for d in range(1, M + 1):
cnt = B[-1] - B[d] #値がd以上の頂点数
if cnt <= diff:
diff -= cnt
for i in A[d]:
P[i] = d
continue
elif 0 <= diff < cnt:
#後ろからdiff個をdに、それ以外を値d - 1に割り振る
Q = []
for e in range(M, d - 1, -1):
Q.extend(A[e])
while Q:
i = Q.pop()
if diff:
P[i] = d
diff -= 1
else:
P[i] = d - 1
break
assert all(P[i] <= D[i] for i in range(N))
assert sum(P) == K
#割り当て
Q = sorted((P[i], - D[i], i) for i in range(N))
ans = [0] * N
for c, (_, _, i) in enumerate(Q, start = 1):
ans[i] = c
print(*ans)
#ARC175D LIS on Tree 2
#入力受取
N, K = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = map(lambda x: int(x) - 1, input().split())
G[u].append(v)
G[v].append(u)
#深さを割り当て
D = [1] * N
Q = [(0, -1, 1)]
for now, back, d in Q:
D[now] = d
for nxt in G[now]:
if nxt != back:
Q.append((nxt, now, d + 1))
#持ち点を計算 この時点で構築可否を判定
cost = sum(D)
if K not in range(N, cost + 1):
exit( print('No') )
else:
print('Yes')
#A[d]: 深さがdである頂点の一覧
#B[d]: 深さがdである頂点の個数 の累積和
M = max(D)
A = [[] for _ in range(M + 1)]
for i, d in enumerate(D):
A[d].append(i)
B = [0] * (M + 2)
for d in range(1, M + 1):
B[d + 1] = B[d] + len(A[d])
#前から加算(1) Pに値を割り当て
P = [0] * N
diff = K
for d in range(1, M + 1):
cnt = B[-1] - B[d] #値がd以上の頂点数
if cnt <= diff:
diff -= cnt
for i in A[d]:
P[i] = d
continue
elif 0 <= diff < cnt:
#後ろからdiff個をdに、それ以外を値d - 1に割り振る
Q = []
for e in range(d, M + 1):
Q.extend(A[e])
while Q:
i = Q.pop()
if diff:
P[i] = d
diff -= 1
else:
P[i] = d - 1
break
assert all(P[i] <= D[i] for i in range(N))
assert sum(P) == K
#割り当て
Q = sorted((P[i], - D[i], i) for i in range(N))
ans = [0] * N
for c, (_, _, i) in enumerate(Q, start = 1):
ans[i] = c
print(*ans)
|
ConDefects/ConDefects/Code/arc175_d/Python/51701679
|
condefects-python_data_2642
|
import sys
readline = sys.stdin.readline
n,K = map(int,readline().split())
g = [[] for _ in range(n)]
for _ in range(n-1):
u,v = map(int,readline().split())
g[u-1].append(v-1)
g[v-1].append(u-1)
order = []
st = [0]
parent = [-1]*n
size = [1]*n
while st:
v = st.pop()
order.append(v)
for c in g[v]:
if c != parent[v]:
st.append(c)
parent[c] = v
for i in order[::-1]:
if i:
size[parent[i]] += size[i]
print("Yes")
res = [0]*n
for i in order[1:]:
p = parent[i]
if size[i] <= K:
K -= size[i]
res[i] = 1
#print(res)
L = 1
M = n
ans = [0]*n
for i in order[::-1]:
if res[i]:
ans[i] = M
M -= 1
else:
ans[i] = L
L += 1
if K == 0:
print("Yes")
print(*ans)
else:
print("No")
import sys
readline = sys.stdin.readline
n,K = map(int,readline().split())
g = [[] for _ in range(n)]
for _ in range(n-1):
u,v = map(int,readline().split())
g[u-1].append(v-1)
g[v-1].append(u-1)
order = []
st = [0]
parent = [-1]*n
size = [1]*n
while st:
v = st.pop()
order.append(v)
for c in g[v]:
if c != parent[v]:
st.append(c)
parent[c] = v
for i in order[::-1]:
if i:
size[parent[i]] += size[i]
K -= n
res = [0]*n
for i in order[1:]:
p = parent[i]
if size[i] <= K:
K -= size[i]
res[i] = 1
#print(res)
L = 1
M = n
ans = [0]*n
for i in order[::-1]:
if res[i]:
ans[i] = M
M -= 1
else:
ans[i] = L
L += 1
if K == 0:
print("Yes")
print(*ans)
else:
print("No")
|
ConDefects/ConDefects/Code/arc175_d/Python/51662439
|
condefects-python_data_2643
|
import sys
input = sys.stdin.readline
from operator import itemgetter
from collections import Counter
N,K=map(int,input().split())
E=[[] for i in range(N)]
for i in range(N-1):
u,v=map(int,input().split())
u-=1
v-=1
E[u].append(v)
E[v].append(u)
# 木のHL分解+LCA
ROOT=0
QUE=[ROOT]
Parent=[-1]*N
Parent[ROOT]=N # ROOTの親を定めておく.
Child=[[] for i in range(N)]
TOP_SORT=[] # トポロジカルソート
while QUE: # トポロジカルソートと同時に親を見つける
x=QUE.pop()
TOP_SORT.append(x)
for to in E[x]:
if Parent[to]==-1:
Parent[to]=x
Child[x].append(to)
QUE.append(to)
Children=[1]*N
for x in TOP_SORT[::-1]: #（自分を含む）子ノードの数を調べる
if x==ROOT:
break
Children[Parent[x]]+=Children[x]
C=[]
for i in range(N):
C.append([Children[i],i])
C.sort(key=itemgetter(0),reverse=True)
ANS2=[1]*N
K-=N
for cx,c in C:
if c==0:
continue
if K>=cx:
ANS2[c]=ANS2[Parent[c]]+1
K-=cx
else:
ANS2[c]=ANS2[Parent[c]]
CS=Counter(ANS2)
S=[0]*(N+1)
now=0
for i in range(N+1):
now+=CS[i]
S[i]=now
ANS=[0]*N
#print(ANS,S)
for cx,c in C:
ANS[c]=S[ANS2[c]]
S[ANS2[c]]-=1
if K==0:
print("Yes")
print(*ANS)
import sys
input = sys.stdin.readline
from operator import itemgetter
from collections import Counter
N,K=map(int,input().split())
E=[[] for i in range(N)]
for i in range(N-1):
u,v=map(int,input().split())
u-=1
v-=1
E[u].append(v)
E[v].append(u)
# 木のHL分解+LCA
ROOT=0
QUE=[ROOT]
Parent=[-1]*N
Parent[ROOT]=N # ROOTの親を定めておく.
Child=[[] for i in range(N)]
TOP_SORT=[] # トポロジカルソート
while QUE: # トポロジカルソートと同時に親を見つける
x=QUE.pop()
TOP_SORT.append(x)
for to in E[x]:
if Parent[to]==-1:
Parent[to]=x
Child[x].append(to)
QUE.append(to)
Children=[1]*N
for x in TOP_SORT[::-1]: #（自分を含む）子ノードの数を調べる
if x==ROOT:
break
Children[Parent[x]]+=Children[x]
C=[]
for i in range(N):
C.append([Children[i],i])
C.sort(key=itemgetter(0),reverse=True)
ANS2=[1]*N
K-=N
for cx,c in C:
if c==0:
continue
if K>=cx:
ANS2[c]=ANS2[Parent[c]]+1
K-=cx
else:
ANS2[c]=ANS2[Parent[c]]
CS=Counter(ANS2)
S=[0]*(N+1)
now=0
for i in range(N+1):
now+=CS[i]
S[i]=now
ANS=[0]*N
#print(ANS,S)
for cx,c in C:
ANS[c]=S[ANS2[c]]
S[ANS2[c]]-=1
if K==0:
print("Yes")
print(*ANS)
else:
print("No")
|
ConDefects/ConDefects/Code/arc175_d/Python/51694704
|
condefects-python_data_2644
|
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
N,K,S = mi()
A = li()
cum = [0] * (N+1)
for i in range(N):
cum[i+1] = A[i] + cum[i]
nxt_edge = [-1] * (N+1)
for i in range(N):
r = bisect.bisect_left(cum,S+cum[i])
if r!=N+1:
nxt_edge[i] = r
INF = 10**9
def cond(d):
dp = [INF] * (N+1)
dp[0] = 0
for i in range(N):
dp[i+1] = min(dp[i+1],dp[i]+d)
if nxt_edge[i]!=-1:
r = nxt_edge[i]
dp[r] = min(dp[r],dp[i]+(d+1)*(r-i-1))
dp_mini_edge = [INF] * (N+1)
dp_mini_edge[0] = 0
dp_maxi_edge = [0] * (N+1)
pre = [-1] * (N+1)
for i in range(N):
if dp[i+1] == dp[i]+d:
pre[i+1] = i
dp_mini_edge[i+1] = min(dp_mini_edge[i+1],dp_mini_edge[i])
dp_maxi_edge[i+1] = max(dp_maxi_edge[i+1],dp_maxi_edge[i])
if nxt_edge[i]!=-1:
r = nxt_edge[i]
if dp[r] == dp[i] + (d+1)*(r-i-1):
pre[r] = i
dp_mini_edge[r] = min(dp_mini_edge[r],dp_mini_edge[i]+1)
dp_maxi_edge[r] = max(dp_maxi_edge[r],dp_maxi_edge[i]+1)
check_val = dp[N] - d*N + dp_mini_edge[N] * d
for i in range(dp_mini_edge[N],min(K,dp_maxi_edge[N])+1)[::-1]:
if dp[N]-d*N + i * d <= N-K:
return i
return -1
res = 0
left,right = -2,2*N+1
while right-left>1:
mid = (left+right)//2
check = cond(mid)
res = max(res,check)
if check == -1:
right = mid
else:
left = mid
print(res)
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
N,K,S = mi()
A = li()
cum = [0] * (N+1)
for i in range(N):
cum[i+1] = A[i] + cum[i]
nxt_edge = [-1] * (N+1)
for i in range(N):
r = bisect.bisect_left(cum,S+cum[i])
if r!=N+1:
nxt_edge[i] = r
INF = 10**15
def cond(d):
dp = [INF] * (N+1)
dp[0] = 0
for i in range(N):
dp[i+1] = min(dp[i+1],dp[i]+d)
if nxt_edge[i]!=-1:
r = nxt_edge[i]
dp[r] = min(dp[r],dp[i]+(d+1)*(r-i-1))
dp_mini_edge = [INF] * (N+1)
dp_mini_edge[0] = 0
dp_maxi_edge = [0] * (N+1)
pre = [-1] * (N+1)
for i in range(N):
if dp[i+1] == dp[i]+d:
pre[i+1] = i
dp_mini_edge[i+1] = min(dp_mini_edge[i+1],dp_mini_edge[i])
dp_maxi_edge[i+1] = max(dp_maxi_edge[i+1],dp_maxi_edge[i])
if nxt_edge[i]!=-1:
r = nxt_edge[i]
if dp[r] == dp[i] + (d+1)*(r-i-1):
pre[r] = i
dp_mini_edge[r] = min(dp_mini_edge[r],dp_mini_edge[i]+1)
dp_maxi_edge[r] = max(dp_maxi_edge[r],dp_maxi_edge[i]+1)
check_val = dp[N] - d*N + dp_mini_edge[N] * d
for i in range(dp_mini_edge[N],min(K,dp_maxi_edge[N])+1)[::-1]:
if dp[N]-d*N + i * d <= N-K:
return i
return -1
res = 0
left,right = -2,2*N+1
while right-left>1:
mid = (left+right)//2
check = cond(mid)
res = max(res,check)
if check == -1:
right = mid
else:
left = mid
print(res)
|
ConDefects/ConDefects/Code/arc168_e/Python/47767454
|
condefects-python_data_2645
|
N,M=map(int,input().split())
A=input()
B=input()
X=[[0,0] for _ in range(M)]
a=0
b=0
if M==0:
print(N-1)
exit()
elif N==0:
print(M-1)
exit()
for i in range(N+M):
if A[i]=="1":
X[a][0]=i
a+=1
if B[i]=="1":
X[b][1]=i
b+=1
X=[sorted(X[i]) for i in range(M)]
#0-start
p=X[0][1]
c=1
for i in range(1,M):
if X[i][0]>p+1:
c+=2
p=X[i][1]
else:
p+=1
if p!=N+M-1:
c+=1
#1-start
p=-1
d=1
for i in range(M):
if X[i][0]>p+1:
d+=2
p=X[i][1]
else:
p+=1
if p!=N+M-1:
d+=1
print(N+M-min(c,d)-1)
N,M=map(int,input().split())
A=input()
B=input()
X=[[0,0] for _ in range(M)]
a=0
b=0
if M==0:
print(N-1)
exit()
elif N==0:
print(M-1)
exit()
for i in range(N+M):
if A[i]=="1":
X[a][0]=i
a+=1
if B[i]=="1":
X[b][1]=i
b+=1
X=[sorted(X[i]) for i in range(M)]
#0-start
p=X[0][1]
c=1
for i in range(1,M):
if X[i][0]>p+1:
c+=2
p=X[i][1]
else:
p+=1
if p!=N+M-1:
c+=1
#1-start
p=-1
d=0
for i in range(M):
if X[i][0]>p+1:
d+=2
p=X[i][1]
else:
p+=1
if p!=N+M-1:
d+=1
print(N+M-min(c,d)-1)
|
ConDefects/ConDefects/Code/arc132_d/Python/28174907
|
condefects-python_data_2646
|
n, m = map(int, input().split())
s = input()
t = input()
d = []
j = 0
cj = 0
ci = 0
for i in range(n + m):
if s[i] == '0':
ci += 1
else:
while t[j] != '1':
cj += 1
j += 1
j += 1
p = (ci, cj) if ci < cj else (cj, ci)
d.append(p)
ans = 0
for _ in range(2):
res = n - 1
frm = 0
if _ == 1:
cnt = 0
while frm < len(d) and d[frm][0] == 0:
frm += 1
cnt += 1
if cnt == 0:
continue
res += cnt - 1
nxt = 10 ** 9
now = 0
# print(d, frm, res)
for (l, r) in d[frm:]:
# print(l, r, now, res)
if nxt < l:
res += now - 1 - 1
now = 1
nxt = r
else:
nxt = min(nxt, r)
now += 1
if now:
# print('a', r)
if nxt >= n:
res += now - 1
else:
res += now - 1 - 1
# print(res)
ans = max(ans, res)
print(ans)
n, m = map(int, input().split())
s = input()
t = input()
d = []
j = 0
cj = 0
ci = 0
for i in range(n + m):
if s[i] == '0':
ci += 1
else:
while t[j] != '1':
cj += 1
j += 1
j += 1
p = (ci, cj) if ci < cj else (cj, ci)
d.append(p)
ans = 0
for _ in range(2):
res = max(0, n - 1)
frm = 0
if _ == 1:
cnt = 0
while frm < len(d) and d[frm][0] == 0:
frm += 1
cnt += 1
if cnt == 0:
continue
res += cnt - 1
nxt = 10 ** 9
now = 0
# print(d, frm, res)
for (l, r) in d[frm:]:
# print(l, r, now, res)
if nxt < l:
res += now - 1 - 1
now = 1
nxt = r
else:
nxt = min(nxt, r)
now += 1
if now:
# print('a', r)
if nxt >= n:
res += now - 1
else:
res += now - 1 - 1
# print(res)
ans = max(ans, res)
print(ans)
|
ConDefects/ConDefects/Code/arc132_d/Python/28175955
|
condefects-python_data_2647
|
n = int(input())
a = list(map(int, input().split()))
ans_list = []
for i in range(n - 1):
# print(a[i + 1] - a[i])
if a[i + 1] >= a[i]:
ans_list.extend(i for i in range(a[i], a[i + 1]))
elif a[i + 1] < a[i]:
ans_list.extend(i for i in range(a[i], a[i + 1], -1))
ans_list.append(a[-1])
print(ans_list)
n = int(input())
a = list(map(int, input().split()))
ans_list = []
for i in range(n - 1):
# print(a[i + 1] - a[i])
if a[i + 1] >= a[i]:
ans_list.extend(i for i in range(a[i], a[i + 1]))
elif a[i + 1] < a[i]:
ans_list.extend(i for i in range(a[i], a[i + 1], -1))
ans_list.append(a[-1])
print(*ans_list)
|
ConDefects/ConDefects/Code/abc301_b/Python/46199451
|
condefects-python_data_2648
|
n = int(input())
a = list(map(int,input().split()))
b = []
for i in range(n-1):
if a[i] <= a[i+1]:
b += list(range(a[i],a[i+1]))
if a[i] >= a[i+1]:
b += list(range(a[i],a[i+1],-1))
b.append(a[-1])
print(b)
n = int(input())
a = list(map(int,input().split()))
b = []
for i in range(n-1):
if a[i] <= a[i+1]:
b += list(range(a[i],a[i+1]))
if a[i] >= a[i+1]:
b += list(range(a[i],a[i+1],-1))
b.append(a[-1])
print(*b)
|
ConDefects/ConDefects/Code/abc301_b/Python/45340910
|
condefects-python_data_2649
|
# B
n = int(input())
a = list(map(int, input().split()))
#n = 4
#a = [2, 5, 1, 2]
b = []
i_bef = 0
#print(a)
for i in a:
print(i)
if i_bef == 0:
b.append(i)
i_bef = i
continue
dif = i - i_bef
#print("dif:", dif)
if abs(dif) > 1:
if dif > 0:
for j in range(1,abs(dif)):
#print("j", j)
b.append(i_bef + j)
b.append(i)
else:
for j in range(1,abs(dif)):
#print("j", j)
b.append(i_bef - j)
b.append(i)
else:
b.append(i)
i_bef = i
#print("i_bef", i_bef)
print(*b)
# B
n = int(input())
a = list(map(int, input().split()))
#n = 4
#a = [2, 5, 1, 2]
b = []
i_bef = 0
#print(a)
for i in a:
#print(i)
if i_bef == 0:
b.append(i)
i_bef = i
continue
dif = i - i_bef
#print("dif:", dif)
if abs(dif) > 1:
if dif > 0:
for j in range(1,abs(dif)):
#print("j", j)
b.append(i_bef + j)
b.append(i)
else:
for j in range(1,abs(dif)):
#print("j", j)
b.append(i_bef - j)
b.append(i)
else:
b.append(i)
i_bef = i
#print("i_bef", i_bef)
print(*b)
|
ConDefects/ConDefects/Code/abc301_b/Python/45970658
|
condefects-python_data_2650
|
import math
N=int(input())
poi=[list(map(int,input().split())) for _ in range(N)]
for x,y in poi:
ans=0
dist=0
for i,(x_i,y_i) in enumerate(poi,1):
if dist<math.sqrt((x-x_i)**2+(y-y_i)**2):
dist=math.sqrt((x-x_i)**2+(y-y_i)**2)
ans=i
print(ans)
import math
N=int(input())
poi=[list(map(int,input().split())) for _ in range(N)]
for x,y in poi:
ans=0
dist=0
for i,(x_i,y_i) in enumerate(poi,1):
if dist<math.sqrt((x-x_i)**2+(y-y_i)**2):
dist=math.sqrt((x-x_i)**2+(y-y_i)**2)
ans=i
print(ans)
|
ConDefects/ConDefects/Code/abc348_b/Python/54985226
|
condefects-python_data_2651
|
N=int(input())
X=[None for _ in range(N+1)]
Y=[None for _ in range(N+1)]
for n in range(1,N+1):
X[n],Y[n]=map(int,input().split())
for i in range(1,N+1):
k,d=0,0
for j in range(1,N+1):
dn=(X[i]-X[j])**2+(Y[i]-Y[j])**2
if dn<d:
k,d=j,dn
print(k)
N=int(input())
X=[None for _ in range(N+1)]
Y=[None for _ in range(N+1)]
for n in range(1,N+1):
X[n],Y[n]=map(int,input().split())
for i in range(1,N+1):
k,d=0,0
for j in range(1,N+1):
dn=(X[i]-X[j])**2+(Y[i]-Y[j])**2
if dn>d:
k,d=j,dn
print(k)
|
ConDefects/ConDefects/Code/abc348_b/Python/55140212
|
condefects-python_data_2652
|
import numpy as np
# 点の数を入力
N = int(input("点の数を入力してください: "))
# 各点の座標を入力
points = np.array([list(map(float, input().split())) for _ in range(N)])
# 距離を計算する関数
def calculate_distance(point1, point2):
return np.linalg.norm(point1 - point2)
for i in range(N):
xi, yi = points[i]
far_d, far_id = -1, -1
for j in range(N):
if i == j: continue
xj, yj = points[j]
d = calculate_distance(points[i], points[j])
if d > far_d:
far_d, far_id = d, j + 1
print(far_id)
import numpy as np
# 点の数を入力
N = int(input())
# 各点の座標を入力
points = np.array([list(map(float, input().split())) for _ in range(N)])
# 距離を計算する関数
def calculate_distance(point1, point2):
return np.linalg.norm(point1 - point2)
for i in range(N):
xi, yi = points[i]
far_d, far_id = -1, -1
for j in range(N):
if i == j: continue
xj, yj = points[j]
d = calculate_distance(points[i], points[j])
if d > far_d:
far_d, far_id = d, j + 1
print(far_id)
|
ConDefects/ConDefects/Code/abc348_b/Python/54681082
|
condefects-python_data_2653
|
S = input()
for i in range(len(S)):
if S[-i] == ".":
print(S[-i+1:])
break
S = input()
for i in range(1,len(S)+1):
if S[-i] == ".":
print(S[-i+1:])
break
|
ConDefects/ConDefects/Code/abc339_a/Python/55124019
|
condefects-python_data_2654
|
S = input()
for i in range(len(S)-1,0,-1):
if S[i] == ".":
print(S[i+1:])
break
S = input()
for i in range(len(S)-1,-1,-1):
if S[i] == ".":
print(S[i+1:])
break
|
ConDefects/ConDefects/Code/abc339_a/Python/54618072
|
condefects-python_data_2655
|
from collections import Counter
p, g, ig = 998244353, 3, 332748118
W = [pow(g, (p - 1) >> i, p) for i in range(24)]
iW = [pow(ig, (p - 1) >> i, p) for i in range(24)]
def fft(f_, k):
f = f_[:]
for l in range(k, 0, -1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * W[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t]) % p, U[j] * (f[s] - f[t]) % p
return f
def ifft(f_, k):
f = f_[:]
for l in range(1, k + 1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * iW[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t] * U[j]) % p, (f[s] - f[t] * U[j]) % p
return f
def convolve(a, b):
def fft(f):
for l in range(k, 0, -1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * W[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t]) % p, U[j] * (f[s] - f[t]) % p
def ifft(f):
for l in range(1, k + 1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * iW[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t] * U[j]) % p, (f[s] - f[t] * U[j]) % p
n0 = len(a) + len(b) - 1
if len(a) < 50 or len(b) < 50:
ret = [0] * n0
if len(a) > len(b): a, b = b, a
for i, aa in enumerate(a):
for j, bb in enumerate(b):
ret[i+j] = (ret[i+j] + aa * bb) % p
return ret
k = (n0).bit_length()
n = 1 << k
a = a + [0] * (n - len(a))
b = b + [0] * (n - len(b))
fft(a), fft(b)
for i in range(n):
a[i] = a[i] * b[i] % p
ifft(a)
invn = pow(n, p - 2, p)
for i in range(n0):
a[i] = a[i] * invn % p
del a[n0:]
return a
P = 998244353
nn = 1001001
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
N, M = map(int, input().split())
A = Counter([int(a) for a in input().split()])
def plus(A, B):
if len(A) < len(B):
A, B = B, A
L = A[:]
for i, b in enumerate(B):
L[i] = (L[i] + b) % P
return L
def minus(A, B):
L = A[:]
L += [0] * (len(B) - len(A))
for i, b in enumerate(B):
L[i] = (L[i] - b) % P
return L
t = 10
nnn = 1 << t
Fe = fft([1] + [0] * (nnn - 1), t)
Fo = fft([1] + [0] * (nnn - 1), t)
for k, c in A.items():
# print(k, c)
fe = [0] * nnn
fo = [0] * nnn
for i in range(c + 1):
if i * k >= nnn:
break
fe[i*k] = C(c, i)
if i % 2:
fo[i*k] = C(c, i)
else:
fo[i*k] = (-C(c, i)) % P
fft_fe = fft(fe, t)
fft_fo = fft(fo, t)
Fe = [a * b % P for a, b in zip(Fe, fft_fe)]
Fo = [a * b % P for a, b in zip(Fo, fft_fo)]
Fe = ifft(Fe, t)
Fo = ifft(Fo, t)
F = minus(Fe, Fo)
print(pow(2, (P - 2) * (t + 1), P) * F[M] % P if M < len(F) else 0)
from collections import Counter
p, g, ig = 998244353, 3, 332748118
W = [pow(g, (p - 1) >> i, p) for i in range(24)]
iW = [pow(ig, (p - 1) >> i, p) for i in range(24)]
def fft(f_, k):
f = f_[:]
for l in range(k, 0, -1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * W[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t]) % p, U[j] * (f[s] - f[t]) % p
return f
def ifft(f_, k):
f = f_[:]
for l in range(1, k + 1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * iW[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t] * U[j]) % p, (f[s] - f[t] * U[j]) % p
return f
def convolve(a, b):
def fft(f):
for l in range(k, 0, -1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * W[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t]) % p, U[j] * (f[s] - f[t]) % p
def ifft(f):
for l in range(1, k + 1):
d = 1 << l - 1
U = [1]
for i in range(d):
U.append(U[-1] * iW[l] % p)
for i in range(1 << k - l):
for j in range(d):
s = i * 2 * d + j
t = s + d
f[s], f[t] = (f[s] + f[t] * U[j]) % p, (f[s] - f[t] * U[j]) % p
n0 = len(a) + len(b) - 1
if len(a) < 50 or len(b) < 50:
ret = [0] * n0
if len(a) > len(b): a, b = b, a
for i, aa in enumerate(a):
for j, bb in enumerate(b):
ret[i+j] = (ret[i+j] + aa * bb) % p
return ret
k = (n0).bit_length()
n = 1 << k
a = a + [0] * (n - len(a))
b = b + [0] * (n - len(b))
fft(a), fft(b)
for i in range(n):
a[i] = a[i] * b[i] % p
ifft(a)
invn = pow(n, p - 2, p)
for i in range(n0):
a[i] = a[i] * invn % p
del a[n0:]
return a
P = 998244353
nn = 1001001
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
N, M = map(int, input().split())
A = Counter([int(a) for a in input().split()])
def plus(A, B):
if len(A) < len(B):
A, B = B, A
L = A[:]
for i, b in enumerate(B):
L[i] = (L[i] + b) % P
return L
def minus(A, B):
L = A[:]
L += [0] * (len(B) - len(A))
for i, b in enumerate(B):
L[i] = (L[i] - b) % P
return L
t = 20
nnn = 1 << t
Fe = fft([1] + [0] * (nnn - 1), t)
Fo = fft([1] + [0] * (nnn - 1), t)
for k, c in A.items():
# print(k, c)
fe = [0] * nnn
fo = [0] * nnn
for i in range(c + 1):
if i * k >= nnn:
break
fe[i*k] = C(c, i)
if i % 2:
fo[i*k] = C(c, i)
else:
fo[i*k] = (-C(c, i)) % P
fft_fe = fft(fe, t)
fft_fo = fft(fo, t)
Fe = [a * b % P for a, b in zip(Fe, fft_fe)]
Fo = [a * b % P for a, b in zip(Fo, fft_fo)]
Fe = ifft(Fe, t)
Fo = ifft(Fo, t)
F = minus(Fe, Fo)
print(pow(2, (P - 2) * (t + 1), P) * F[M] % P if M < len(F) else 0)
|
ConDefects/ConDefects/Code/abc267_h/Python/35794099
|
condefects-python_data_2656
|
s=input()
n=len(s)
answer=0
for i in range(n):
if s[i]=="W":
answer+=1
print(answer+n)
s=input()
n=len(s)
answer=0
for i in range(n):
if s[i]=="w":
answer+=1
print(answer+n)
|
ConDefects/ConDefects/Code/abc279_a/Python/45494790
|
condefects-python_data_2657
|
s=list(map(str,input()))
ans=0
for i in range(len(s)):
if s[i]=="W":
ans+=2
else:
ans+=1
print(ans)
s=list(map(str,input()))
ans=0
for i in range(len(s)):
if s[i]=="w":
ans+=2
else:
ans+=1
print(ans)
|
ConDefects/ConDefects/Code/abc279_a/Python/44934608
|
condefects-python_data_2658
|
def string(s):
if 1<=len(s)<=100:
bot=0
for i in s:
if i=='w':
bot+=2
elif i=='v':
bot+=1
return bot
print(string('wwwvvvvvv'))
def string(s):
if 1<=len(s)<=100:
bot=0
for i in s:
if i=='w':
bot+=2
elif i=='v':
bot+=1
return bot
print(string(input()))
|
ConDefects/ConDefects/Code/abc279_a/Python/45107250
|
condefects-python_data_2659
|
# ABC266 B - Modulo Number
n = int(input())
print(n-998244353)
# ABC266 B - Modulo Number
n = int(input())
print(n%998244353)
|
ConDefects/ConDefects/Code/abc266_b/Python/44372589
|
condefects-python_data_2660
|
# coding: utf-8
from functools import partial
try:
dummy = src
minp = partial(src.pop, 0)
except NameError:
minp = input
def ints():
return list(map(int, minp().rstrip().split(' ')))
def int1():
return int(minp().rstrip())
#@psecs
def main():
n = int1()
d = 998244353
print(n % d)
# coding: utf-8
from functools import partial
try:
dummy = src
minp = partial(src.pop, 0)
except NameError:
minp = input
def ints():
return list(map(int, minp().rstrip().split(' ')))
def int1():
return int(minp().rstrip())
#@psecs
def main():
n = int1()
d = 998244353
print(n % d)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc266_b/Python/45028295
|
condefects-python_data_2661
|
import sys
input = sys.stdin.readline
from bisect import bisect_left
class Compress:
def __init__(self, vs):
self.xs = list(set(vs))
self.xs.sort()
def compress(self, x):
return bisect_left(self.xs, x)
def decompress(self, i):
return self.xs[i]
def size(self):
return len(self.xs)
N, M, Q = map(int, input().split())
elevators = [[] for _ in range(N)]
xs = []
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
elevators[A].append((B, C))
xs.append(B)
xs.append(C)
queries = []
for _ in range(Q):
X, Y, Z, W = map(int, input().split())
if Y > W:
X, Z = Z, X
Y, W = W, Y
queries.append((X-1, Y, Z-1, W))
xs.append(Y)
xs.append(W)
comp = Compress(xs)
for a in range(N):
elevators[a].sort()
res = []
for b, c in elevators[a]:
b = comp.compress(b)
c = comp.compress(c)
if not res or res[-1][1] < b:
res.append((b, c))
else:
b2, c2 = res.pop()
c2 = max(c, c2)
res.append((b2, c2))
elevators[a] = res
L = 20
n = comp.size()
table = [[0] * n for _ in range(L)]
for a in range(N):
for b, c in elevators[a]:
table[0][b] = max(table[0][b], c)
m = 0
for i in range(n):
m = max(m, i, table[0][i])
table[0][i] = m
for k in range(L-1):
for i in range(n):
table[k+1][i] = table[k][table[k][i]]
for x, y, z, w in queries:
ans = w - y
y = comp.compress(y)
w = comp.compress(w)
k = bisect_left(elevators[x], (y+1, -1)) - 1
if k >= 0 and elevators[x][k][0] <= y <= elevators[x][k][1]:
y = elevators[x][k][1]
l = bisect_left(elevators[z], (w+1, -1)) - 1
if l >= 0 and elevators[z][l][0] <= w <= elevators[z][l][1]:
w = elevators[z][l][0]
if y >= w:
if x != z:
ans += 1
print(ans)
continue
for k in range(L)[::-1]:
if table[k][y] < w:
y = table[k][y]
ans += 2**k
if table[0][y] >= w:
ans += 1
print(ans)
else:
print(-1)
import sys
input = sys.stdin.readline
from bisect import bisect_left
class Compress:
def __init__(self, vs):
self.xs = list(set(vs))
self.xs.sort()
def compress(self, x):
return bisect_left(self.xs, x)
def decompress(self, i):
return self.xs[i]
def size(self):
return len(self.xs)
N, M, Q = map(int, input().split())
elevators = [[] for _ in range(N)]
xs = []
for _ in range(M):
A, B, C = map(int, input().split())
A -= 1
elevators[A].append((B, C))
xs.append(B)
xs.append(C)
queries = []
for _ in range(Q):
X, Y, Z, W = map(int, input().split())
if Y > W:
X, Z = Z, X
Y, W = W, Y
queries.append((X-1, Y, Z-1, W))
xs.append(Y)
xs.append(W)
comp = Compress(xs)
for a in range(N):
elevators[a].sort()
res = []
for b, c in elevators[a]:
b = comp.compress(b)
c = comp.compress(c)
if not res or res[-1][1] < b:
res.append((b, c))
else:
b2, c2 = res.pop()
c2 = max(c, c2)
res.append((b2, c2))
elevators[a] = res
L = 20
n = comp.size()
table = [[0] * n for _ in range(L)]
for a in range(N):
for b, c in elevators[a]:
table[0][b] = max(table[0][b], c)
m = 0
for i in range(n):
m = max(m, i, table[0][i])
table[0][i] = m
for k in range(L-1):
for i in range(n):
table[k+1][i] = table[k][table[k][i]]
for x, y, z, w in queries:
ans = w - y
y = comp.compress(y)
w = comp.compress(w)
k = bisect_left(elevators[x], (y+1, -1)) - 1
if k >= 0 and elevators[x][k][0] <= y <= elevators[x][k][1]:
y = elevators[x][k][1]
l = bisect_left(elevators[z], (w+1, -1)) - 1
if l >= 0 and elevators[z][l][0] <= w <= elevators[z][l][1]:
w = elevators[z][l][0]
if y >= w:
if x != z:
ans += 1
print(ans)
continue
for k in range(L)[::-1]:
if table[k][y] < w:
y = table[k][y]
ans += 2**k
if table[0][y] >= w:
ans += 2
print(ans)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc254_g/Python/32247391
|
condefects-python_data_2662
|
from bisect import bisect, bisect_left
from collections import defaultdict
n, m, q = map(int, input().split())
elevators = [[] for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
elevators[a].append((b, c))
# 同じビルで範囲が被ってるものを集約
bbb = []
ccc = []
max_c = defaultdict(int)
for a in range(n):
elevators[a].sort()
elb = []
elc = []
for b, c in elevators[a]:
if len(elb) == 0:
elb.append(b)
elc.append(c)
elif elc[-1] < b:
elb.append(b)
elc.append(c)
else:
elc[-1] = max(elc[-1], c)
bbb.append(elb)
ccc.append(elc)
for b, c in zip(elb, elc):
max_c[b] = max(max_c[b], c)
# 全エレベーターを通しても行き来できない区間で分割するとともに、
# 他のエレベーターに内包されるやつを除く
all_elevators = sorted(max_c.items())
all_segmented_elevators = []
cur_segment = []
all_segment_start_floors = []
for b, c in all_elevators:
if len(cur_segment) == 0:
cur_segment.append((b, c))
elif cur_segment[-1][1] < b:
all_segmented_elevators.append(cur_segment)
all_segment_start_floors.append(cur_segment[0][0])
cur_segment = [(b, c)]
elif cur_segment[-1][1] < c:
cur_segment.append((b, c))
if cur_segment:
all_segmented_elevators.append(cur_segment)
all_segment_start_floors.append(cur_segment[0][0])
# 各エレベーターから 2^k 台の利用で行ける最高階層を求める
segment_start_floors = []
doubling_max_floor = []
for segment in all_segmented_elevators:
m = len(segment)
seg_max_floor = segment[-1][1]
cur_start_floors = [b for b, c in segment]
cur_doubling = [[c for b, c in segment]]
while cur_doubling[-1][0] < seg_max_floor:
cur = cur_doubling[-1]
nxt = [0] * m
for i in range(m):
el = bisect(cur_start_floors, cur[i]) - 1
nxt[i] = cur[el]
cur_doubling.append(nxt)
segment_start_floors.append(cur_start_floors)
doubling_max_floor.append(cur_doubling)
# やっとクエリに答えるよ！
for i in range(q):
x, y, z, w = map(int, input().split())
x -= 1
z -= 1
res = 0
if y == w:
if x == z:
print(0)
else:
print(1)
continue
if y > w:
x, y, z, w = z, w, x, y
si = bisect(all_segment_start_floors, y) - 1
if si == -1 or all_segmented_elevators[si][-1][1] < w:
print(-1)
continue
# 出発ビル・到着ビルのエレベーターで近づける分は近づく
xi = bisect(bbb[x], y)
if xi > 0:
xc = ccc[x][xi - 1]
# print(bbb[x], ccc[x], xi, xc, y)
if xc >= y:
if xc >= w:
print(w - y + (x != z))
continue
res += xc - y
y = xc
zi = bisect_left(ccc[z], w)
if zi < len(ccc[z]):
zb = bbb[z][zi]
# print(bbb[z], ccc[z], zi, zb, w)
if zb <= w:
if zb <= y:
print(res + w - y + (x != z))
continue
res += w - zb
w = zb
# 出発・到着ビル内で最大限近づいた後、まだ y<w なので、
# その間の距離と、あと必ず2回は乗り換える必要がある
res += w - y + 2
ssf = segment_start_floors[si]
dmf = doubling_max_floor[si]
lim = len(dmf)
el = bisect(ssf, y) - 1
for k in range(lim - 1, -1, -1):
if dmf[k][el] < w:
res += 1 << k
y = dmf[k][el]
print(res)
from bisect import bisect, bisect_left
from collections import defaultdict
n, m, q = map(int, input().split())
elevators = [[] for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
elevators[a].append((b, c))
# 同じビルで範囲が被ってるものを集約
bbb = []
ccc = []
max_c = defaultdict(int)
for a in range(n):
elevators[a].sort()
elb = []
elc = []
for b, c in elevators[a]:
if len(elb) == 0:
elb.append(b)
elc.append(c)
elif elc[-1] < b:
elb.append(b)
elc.append(c)
else:
elc[-1] = max(elc[-1], c)
bbb.append(elb)
ccc.append(elc)
for b, c in zip(elb, elc):
max_c[b] = max(max_c[b], c)
# 全エレベーターを通しても行き来できない区間で分割するとともに、
# 他のエレベーターに内包されるやつを除く
all_elevators = sorted(max_c.items())
all_segmented_elevators = []
cur_segment = []
all_segment_start_floors = []
for b, c in all_elevators:
if len(cur_segment) == 0:
cur_segment.append((b, c))
elif cur_segment[-1][1] < b:
all_segmented_elevators.append(cur_segment)
all_segment_start_floors.append(cur_segment[0][0])
cur_segment = [(b, c)]
elif cur_segment[-1][1] < c:
cur_segment.append((b, c))
if cur_segment:
all_segmented_elevators.append(cur_segment)
all_segment_start_floors.append(cur_segment[0][0])
# 各エレベーターから 2^k 台の利用で行ける最高階層を求める
segment_start_floors = []
doubling_max_floor = []
for segment in all_segmented_elevators:
m = len(segment)
seg_max_floor = segment[-1][1]
cur_start_floors = [b for b, c in segment]
cur_doubling = [[c for b, c in segment]]
while cur_doubling[-1][0] < seg_max_floor:
cur = cur_doubling[-1]
nxt = [0] * m
for i in range(m):
el = bisect(cur_start_floors, cur[i]) - 1
nxt[i] = cur[el]
cur_doubling.append(nxt)
segment_start_floors.append(cur_start_floors)
doubling_max_floor.append(cur_doubling)
# やっとクエリに答えるよ！
for i in range(q):
x, y, z, w = map(int, input().split())
x -= 1
z -= 1
res = 0
if y == w:
if x == z:
print(0)
else:
print(1)
continue
if y > w:
x, y, z, w = z, w, x, y
si = bisect(all_segment_start_floors, y) - 1
if si == -1 or all_segmented_elevators[si][-1][1] < w:
print(-1)
continue
# 出発ビル・到着ビルのエレベーターで近づける分は近づく
xi = bisect(bbb[x], y)
if xi > 0:
xc = ccc[x][xi - 1]
# print(bbb[x], ccc[x], xi, xc, y)
if xc >= y:
if xc >= w:
print(w - y + (x != z))
continue
res += xc - y
y = xc
zi = bisect_left(ccc[z], w)
if zi < len(ccc[z]):
zb = bbb[z][zi]
# print(bbb[z], ccc[z], zi, zb, w)
if zb <= w:
if zb <= y:
print(res + w - y + (x != z))
continue
res += w - zb
w = zb
# 出発・到着ビル内で最大限近づいた後、まだ y<w なので、
# その間の距離と、あと必ず2回は乗り換える必要がある
res += w - y + 2
ssf = segment_start_floors[si]
dmf = doubling_max_floor[si]
lim = len(dmf)
for k in range(lim - 1, -1, -1):
el = bisect(ssf, y) - 1
if dmf[k][el] < w:
res += 1 << k
y = dmf[k][el]
print(res)
|
ConDefects/ConDefects/Code/abc254_g/Python/32287222
|
condefects-python_data_2663
|
word = input()
string = list(word)
num = 0
for i in range(0, len(string)):
if (string[i].isupper()):
num += 1
if (num % 2 == 1):
print(word.upper())
else:
print(word.lower())
word = input()
string = list(word)
num = 0
for i in range(0, len(string)):
if (string[i].isupper()):
num += 1
if (num > len(string) - num):
print(word.upper())
else:
print(word.lower())
|
ConDefects/ConDefects/Code/abc357_b/Python/55161071
|
condefects-python_data_2664
|
s = input()
lower = 0
capital = 0
for i in range(len(s)):
if s[i].islower() == True:
lower = lower+1
elif s[i].isupper():
capital = capital + 1
if lower >= capital:
print(s.lower())
else:
print(s.capitalize())
s = input()
lower = 0
capital = 0
for i in range(len(s)):
if s[i].islower() == True:
lower = lower+1
elif s[i].isupper():
capital = capital + 1
if lower >= capital:
print(s.lower())
else:
print(s.upper())
|
ConDefects/ConDefects/Code/abc357_b/Python/54959918
|
condefects-python_data_2665
|
s=input()
count=0
for c in s:
if(c.isupper()):
count+=1
if(count>0):
s=s.upper()
else:
s=s.lower()
print(s)
s=input()
count=0
for c in s:
if(c.isupper()):
count+=1
else:
count-=1
if(count>0):
s=s.upper()
else:
s=s.lower()
print(s)
|
ConDefects/ConDefects/Code/abc357_b/Python/54923363
|
condefects-python_data_2666
|
class segtree():
n=1
size=1
log=2
d=[0]
op=None
e=10**15
def __init__(self,V,OP,E):
self.n=len(V)
self.op=OP
self.e=E
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
for i in range(self.n):
self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):
self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
self.d[p]=x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
return self.d[p+self.size]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if (l&1):
sml=self.op(sml,self.d[l])
l+=1
if (r&1):
smr=self.op(self.d[r-1],smr)
r-=1
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):
return self.d[1]
def max_right(self,l,f):
assert 0<=l and l<=self.n
assert f(self.e)
if l==self.n:
return self.n
l+=self.size
sm=self.e
while(1):
while(l%2==0):
l>>=1
if not(f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if f(self.op(sm,self.d[l])):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:
break
return self.n
def min_left(self,r,f):
assert 0<=r and r<=self.n
assert f(self.e)
if r==0:
return 0
r+=self.size
sm=self.e
while(1):
r-=1
while(r>1 and (r%2)):
r>>=1
if not(f(self.op(self.d[r],sm))):
while(r<self.size):
r=(2*r+1)
if f(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r& -r)==r:
break
return 0
def update(self,k):
self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def __str__(self):
return str([self.get(i) for i in range(self.n)])
def func(x,y):
a,b = x
c,d = y
z = (a+c,b+d)
return z
N = int(input())
A = []
B = []
S = set()
for i in range(N):
a,b = map(int,input().split())
A.append(a)
B.append(b)
S.add(a)
Q = int(input())
query = []
for i in range(Q):
q = list(map(int,input().split()))
if q[0] == 1:
y = q[2]
S.add(y)
query.append(q)
S = list(S)
S.sort()
n = len(S)
d = {}
for i in range(n):
d[S[i]] = i
seg = segtree([(0,0) for i in range(n)],func,(0,0))
for i in range(N):
a,b = A[i],B[i]
c,s = seg.get(d[a])
c += a
s += a*b
seg.set(d[a],(c,s))
for q in query:
x = q[1]
if q[0] != 3:
x -= 1
y = q[2]
if q[0] == 1:
a,b = A[x],B[x]
A[x] = y
c,s = seg.get(d[a])
c -= b
s -= b*a
seg.set(d[a],(c,s))
c,s = seg.get(d[y])
c += b
s += b*y
seg.set(d[y],(c,s))
elif q[0] == 2:
a,b = A[x],B[x]
B[x] = y
c,s = seg.get(d[a])
c += (y - b)
s += (y - b)*a
seg.set(d[a],(c,s))
else:
def f(y):
u,v = y
if u <= x:
return True
else:
False
l = seg.min_left(n,f)
c,s = seg.prod(l,n)
if x - c > 0 and l == 0:
print(-1)
else:
s += S[l-1] * (x-c)
print(s)
class segtree():
n=1
size=1
log=2
d=[0]
op=None
e=10**15
def __init__(self,V,OP,E):
self.n=len(V)
self.op=OP
self.e=E
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
for i in range(self.n):
self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):
self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
self.d[p]=x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
return self.d[p+self.size]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if (l&1):
sml=self.op(sml,self.d[l])
l+=1
if (r&1):
smr=self.op(self.d[r-1],smr)
r-=1
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):
return self.d[1]
def max_right(self,l,f):
assert 0<=l and l<=self.n
assert f(self.e)
if l==self.n:
return self.n
l+=self.size
sm=self.e
while(1):
while(l%2==0):
l>>=1
if not(f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if f(self.op(sm,self.d[l])):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:
break
return self.n
def min_left(self,r,f):
assert 0<=r and r<=self.n
assert f(self.e)
if r==0:
return 0
r+=self.size
sm=self.e
while(1):
r-=1
while(r>1 and (r%2)):
r>>=1
if not(f(self.op(self.d[r],sm))):
while(r<self.size):
r=(2*r+1)
if f(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r& -r)==r:
break
return 0
def update(self,k):
self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def __str__(self):
return str([self.get(i) for i in range(self.n)])
def func(x,y):
a,b = x
c,d = y
z = (a+c,b+d)
return z
N = int(input())
A = []
B = []
S = set()
for i in range(N):
a,b = map(int,input().split())
A.append(a)
B.append(b)
S.add(a)
Q = int(input())
query = []
for i in range(Q):
q = list(map(int,input().split()))
if q[0] == 1:
y = q[2]
S.add(y)
query.append(q)
S = list(S)
S.sort()
n = len(S)
d = {}
for i in range(n):
d[S[i]] = i
seg = segtree([(0,0) for i in range(n)],func,(0,0))
for i in range(N):
a,b = A[i],B[i]
c,s = seg.get(d[a])
c += b
s += a*b
seg.set(d[a],(c,s))
for q in query:
x = q[1]
if q[0] != 3:
x -= 1
y = q[2]
if q[0] == 1:
a,b = A[x],B[x]
A[x] = y
c,s = seg.get(d[a])
c -= b
s -= b*a
seg.set(d[a],(c,s))
c,s = seg.get(d[y])
c += b
s += b*y
seg.set(d[y],(c,s))
elif q[0] == 2:
a,b = A[x],B[x]
B[x] = y
c,s = seg.get(d[a])
c += (y - b)
s += (y - b)*a
seg.set(d[a],(c,s))
else:
def f(y):
u,v = y
if u <= x:
return True
else:
False
l = seg.min_left(n,f)
c,s = seg.prod(l,n)
if x - c > 0 and l == 0:
print(-1)
else:
s += S[l-1] * (x-c)
print(s)
|
ConDefects/ConDefects/Code/abc287_g/Python/50037780
|
condefects-python_data_2667
|
import sys
input = sys.stdin.readline
class BIT:
def __init__(self,N):
self.s = (N-1).bit_length()
self.N = 1<<self.s
self.data = [0]*(self.N+1)
def build(self,A):
for i in range(1,self.N+1):
self.data[i] += A[i-1]
if i+(i&-i) <= self.N:
self.data[i+(i&-i)] += self.data[i]
def add(self,i,x):
i += 1
while i <= self.N:
self.data[i] += x
i += i&-i
def fold(self,l,r):
res = 0
while r > 0:
res += self.data[r]
r -= r&-r
while l > 0:
res -= self.data[l]
l -= l&-l
return res
def all_prod(self):
return self.data[self.N]
def max_right_(self,x):
i = self.N
if self.data[i] <= x:
return self.N
tmp = 0
for j in range(self.s-1,-1,-1):
if tmp+self.data[i] <= x:
tmp += self.data[i]
i += 1<<j
else:
i -= 1<<j
if tmp+self.data[i] <= x:
return i
else:
return i-1
def max_right(self,l,x):
return self.max_right_(self.fold(0,l)+x)
N = int(input())
X_ = set()
data = [[0,0] for _ in range(N)]
for i in range(N):
a,b = map(int,input().split())
data[i][0],data[i][1] = a,b
X_.add(a)
Q = int(input())
query = [list(map(int,input().split())) for _ in range(Q)]
for q in range(Q):
qu = query[q]
if qu[0] == 1:
x,y = qu[1:]
X_.add(y)
M = len(X_)
X = sorted(X_)
X.reverse()
co = {x : i for i,x in enumerate(X)}
bit0 = BIT(M)
bit1 = BIT(M)
for i in range(N):
a,b = data[i][0],data[i][1]
bit0.add(co[a],a*b)
bit1.add(co[a],b)
for i in range(Q):
qu = query[i]
if qu[0] == 1:
x,y = qu[1:]
a,b = data[x-1]
bit0.add(co[a],-a*b)
bit1.add(co[a],-b)
bit0.add(co[y],y*b)
bit1.add(co[y],b)
data[x-1][0] = y
if qu[0] == 2:
x,y = qu[1:]
a,b = data[x-1]
bit0.add(co[a],a*y-a*b)
bit1.add(co[a],y-b)
data[x-1][1] = y
if qu[0] == 100:
x = qu[1]
if bit1.all_prod() < x:
print(-1)
continue
r = bit1.max_right_(x)
res = bit0.fold(0,r)
if r < M:
res += X[r]*(x-bit1.fold(0,r))
print(res)
import sys
input = sys.stdin.readline
class BIT:
def __init__(self,N):
self.s = (N-1).bit_length()
self.N = 1<<self.s
self.data = [0]*(self.N+1)
def build(self,A):
for i in range(1,self.N+1):
self.data[i] += A[i-1]
if i+(i&-i) <= self.N:
self.data[i+(i&-i)] += self.data[i]
def add(self,i,x):
i += 1
while i <= self.N:
self.data[i] += x
i += i&-i
def fold(self,l,r):
res = 0
while r > 0:
res += self.data[r]
r -= r&-r
while l > 0:
res -= self.data[l]
l -= l&-l
return res
def all_prod(self):
return self.data[self.N]
def max_right_(self,x):
i = self.N
if self.data[i] <= x:
return self.N
tmp = 0
for j in range(self.s-1,-1,-1):
if tmp+self.data[i] <= x:
tmp += self.data[i]
i += 1<<j
else:
i -= 1<<j
if tmp+self.data[i] <= x:
return i
else:
return i-1
def max_right(self,l,x):
return self.max_right_(self.fold(0,l)+x)
N = int(input())
X_ = set()
data = [[0,0] for _ in range(N)]
for i in range(N):
a,b = map(int,input().split())
data[i][0],data[i][1] = a,b
X_.add(a)
Q = int(input())
query = [list(map(int,input().split())) for _ in range(Q)]
for q in range(Q):
qu = query[q]
if qu[0] == 1:
x,y = qu[1:]
X_.add(y)
M = len(X_)
X = sorted(X_)
X.reverse()
co = {x : i for i,x in enumerate(X)}
bit0 = BIT(M)
bit1 = BIT(M)
for i in range(N):
a,b = data[i][0],data[i][1]
bit0.add(co[a],a*b)
bit1.add(co[a],b)
for i in range(Q):
qu = query[i]
if qu[0] == 1:
x,y = qu[1:]
a,b = data[x-1]
bit0.add(co[a],-a*b)
bit1.add(co[a],-b)
bit0.add(co[y],y*b)
bit1.add(co[y],b)
data[x-1][0] = y
if qu[0] == 2:
x,y = qu[1:]
a,b = data[x-1]
bit0.add(co[a],a*y-a*b)
bit1.add(co[a],y-b)
data[x-1][1] = y
if qu[0] == 3:
x = qu[1]
if bit1.all_prod() < x:
print(-1)
continue
r = bit1.max_right_(x)
res = bit0.fold(0,r)
if r < M:
res += X[r]*(x-bit1.fold(0,r))
print(res)
|
ConDefects/ConDefects/Code/abc287_g/Python/50462471
|
condefects-python_data_2668
|
class Segtree:#入力は全て0-indexedでok.
def __init__(self,n,operator,identity):
num=1<<((n-1).bit_length())
self.tree=[identity]*(2*num-1)
self.identity=identity
self.operator=operator
self.num=num
def update(self,i,val):#i番目をvalに変える(変えた後、上の方に更新を伝播)
i+=self.num-1
self.tree[i]=val
while i>=0:
i=(i-1)//2
if i>=0:
self.tree[i]=self.operator(self.tree[i*2+1],self.tree[i*2+2])
def plus(self,i,val):#i番目にval足す
now=self.q(i,i+1)
self.update(i,val+now)
def q(self,l,r):#[l,r)のoperate値を求める
l+=self.num#ここは1-indexになってる
r+=self.num#ここは1-indexになってる
s=self.identity#こいつに計算していく
while l<r:
if r & 1:
r -= 1
s = self.operator(s, self.tree[r-1])#１引いて0-indexedに戻す
if l & 1:
s = self.operator(s, self.tree[l-1])#同上
l += 1
l >>= 1; r >>= 1
return s
def a(x,y):
return x+y
#ABC287 G
#クエリ先読み、何もわからん
N=int(input())
card=[tuple(map(int,input().split())) for _ in range(N)]
Q=int(input())
query=[tuple(map(int,input().split())) for _ in range(Q)]
v=set()
for i in range(N):
v.add(card[i][0])
for i in range(Q):
if query[i][0]==1:
v.add(query[i][2])
v=list(v)
v.sort(reverse=True)
n=len(v)
d=dict()
for i in range(n):
d[v[i]]=i
X=Segtree(n,a,0)
Y=Segtree(n,a,0)
v_now=[-1]*N
l_now=[-1]*N
for i in range(N):
a,b=card[i]
X.plus(d[a],b)
Y.plus(d[a],a*b)
v_now[i]=a
l_now[i]=b
for i in range(Q):
tup=query[i]
if tup[0]==1:
x,y=tup[1:]
x-=1
a,b=v_now[x],l_now[x]
X.plus(d[a],-b)
Y.plus(d[a],-a*b)
X.plus(d[y],b)
Y.plus(d[y],y*b)
v_now[x]=y
if tup[0]==2:
x,y=tup[1:]
x-=1
a,b=v_now[x],l_now[x]
X.plus(d[a],-b)
Y.plus(d[a],-a*b)
X.plus(d[a],y)
Y.plus(d[a],a*y)
l_now[x]=y
if tup[0]==3:
x=tup[1]
#つらい
if X.q(0,n)<x:
print(-1)
elif X.q(0,n)==x:
print(Y.q(0,n))
else:
l=0
r=n-1
while r-l!=1:
now=(r+l)//2
if X.q(0,now+1)<=x:
l=now
else:
r=now
ans=Y.q(0,l+1)
num=X.q(0,l+1)
t=x-num
ans+=t*v[l+1]
print(ans)
class Segtree:#入力は全て0-indexedでok.
def __init__(self,n,operator,identity):
num=1<<((n-1).bit_length())
self.tree=[identity]*(2*num-1)
self.identity=identity
self.operator=operator
self.num=num
def update(self,i,val):#i番目をvalに変える(変えた後、上の方に更新を伝播)
i+=self.num-1
self.tree[i]=val
while i>=0:
i=(i-1)//2
if i>=0:
self.tree[i]=self.operator(self.tree[i*2+1],self.tree[i*2+2])
def plus(self,i,val):#i番目にval足す
now=self.q(i,i+1)
self.update(i,val+now)
def q(self,l,r):#[l,r)のoperate値を求める
l+=self.num#ここは1-indexになってる
r+=self.num#ここは1-indexになってる
s=self.identity#こいつに計算していく
while l<r:
if r & 1:
r -= 1
s = self.operator(s, self.tree[r-1])#１引いて0-indexedに戻す
if l & 1:
s = self.operator(s, self.tree[l-1])#同上
l += 1
l >>= 1; r >>= 1
return s
def a(x,y):
return x+y
#ABC287 G
#クエリ先読み、何もわからん
N=int(input())
card=[tuple(map(int,input().split())) for _ in range(N)]
Q=int(input())
query=[tuple(map(int,input().split())) for _ in range(Q)]
v=set()
for i in range(N):
v.add(card[i][0])
for i in range(Q):
if query[i][0]==1:
v.add(query[i][2])
v=list(v)
v.sort(reverse=True)
n=len(v)
d=dict()
for i in range(n):
d[v[i]]=i
X=Segtree(n,a,0)
Y=Segtree(n,a,0)
v_now=[-1]*N
l_now=[-1]*N
for i in range(N):
a,b=card[i]
X.plus(d[a],b)
Y.plus(d[a],a*b)
v_now[i]=a
l_now[i]=b
for i in range(Q):
tup=query[i]
if tup[0]==1:
x,y=tup[1:]
x-=1
a,b=v_now[x],l_now[x]
X.plus(d[a],-b)
Y.plus(d[a],-a*b)
X.plus(d[y],b)
Y.plus(d[y],y*b)
v_now[x]=y
if tup[0]==2:
x,y=tup[1:]
x-=1
a,b=v_now[x],l_now[x]
X.plus(d[a],-b)
Y.plus(d[a],-a*b)
X.plus(d[a],y)
Y.plus(d[a],a*y)
l_now[x]=y
if tup[0]==3:
x=tup[1]
#つらい
if X.q(0,n)<x:
print(-1)
elif X.q(0,n)==x:
print(Y.q(0,n))
else:
l=-1
r=n-1
while r-l!=1:
now=(r+l)//2
if X.q(0,now+1)<=x:
l=now
else:
r=now
ans=Y.q(0,l+1)
num=X.q(0,l+1)
t=x-num
ans+=t*v[l+1]
print(ans)
|
ConDefects/ConDefects/Code/abc287_g/Python/40891564
|
condefects-python_data_2669
|
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N - 1):
u,v = map(int,input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
A = list(map(int,input().split()))
from collections import defaultdict
S = [defaultdict(int) for _ in range(N)]
num = [defaultdict(int) for _ in range(N)]
child = [1] * N
hight = [0] * N
stack = [(0,-1),(~0,-1)]
ans = 0
while stack:
now,parent = stack.pop()
if now < 0:
now = ~now
for v in G[now]:
if v != parent:
stack.append((v,now))
stack.append((~v,now))
continue
a = A[now]
l = []
for v in G[now]:
if v != parent:l.append(v)
if len(l) == 0:
S[now][a] = 0
num[now][a] = 1
continue
v = l[0]
ans += S[v][a] + num[v][a] * (hight[v] + 1)
S[now] = S[v]
num[now] = num[v]
num[now][a] += 1
hight[now] = hight[v] + 1
S[now][a] -= hight[now]
child[now] += child[v]
for v in l[1:]:
if child[now] >= child[v]:
for b in S[v]:
ans += (S[now][b] + num[now][b] * hight[now]) * num[v][b] + (S[v][b] + num[v][b] * (hight[v] + 1)) * num[now][b]
num[now][b] += num[v][b]
S[now][b] += S[v][b] + num[v][b] * (hight[v] + 1) - num[v][b] * hight[now]
else:
for b in S[now]:
ans += (S[now][b] + num[now][b] * hight[now]) * num[v][b] + (S[v][b] + num[v][b] * (hight[v] + 1)) * num[now][b]
num[v][b] += num[now][b]
S[v][b] += S[now][b] + num[now][b] * hight[now] - num[now][b] * hight[v]
S[now] = S[v]
hight[now] = hight[v] + 1
num[now] = num[v]
child[now] += child[v]
print(ans)
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N - 1):
u,v = map(int,input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
A = list(map(int,input().split()))
from collections import defaultdict
S = [defaultdict(int) for _ in range(N)]
num = [defaultdict(int) for _ in range(N)]
child = [1] * N
hight = [0] * N
stack = [(0,-1),(~0,-1)]
ans = 0
while stack:
now,parent = stack.pop()
if now < 0:
now = ~now
for v in G[now]:
if v != parent:
stack.append((v,now))
stack.append((~v,now))
continue
a = A[now]
l = []
for v in G[now]:
if v != parent:l.append(v)
if len(l) == 0:
S[now][a] = 0
num[now][a] = 1
continue
v = l[0]
ans += S[v][a] + num[v][a] * (hight[v] + 1)
S[now] = S[v]
num[now] = num[v]
num[now][a] += 1
hight[now] = hight[v] + 1
S[now][a] -= hight[now]
child[now] += child[v]
for v in l[1:]:
if child[now] >= child[v]:
for b in S[v]:
ans += (S[now][b] + num[now][b] * hight[now]) * num[v][b] + (S[v][b] + num[v][b] * (hight[v] + 1)) * num[now][b]
num[now][b] += num[v][b]
S[now][b] += S[v][b] + num[v][b] * (hight[v] + 1) - num[v][b] * hight[now]
else:
for b in S[now]:
ans += (S[now][b] + num[now][b] * hight[now]) * num[v][b] + (S[v][b] + num[v][b] * (hight[v] + 1)) * num[now][b]
num[v][b] += num[now][b]
S[v][b] += S[now][b] + num[now][b] * hight[now] - num[now][b] * (hight[v] + 1)
S[now] = S[v]
hight[now] = hight[v] + 1
num[now] = num[v]
child[now] += child[v]
print(ans)
|
ConDefects/ConDefects/Code/abc359_g/Python/54889351
|
condefects-python_data_2670
|
S = list(set(input()))
les = len(S)
if les == 3:
print(6)
if les == 2:
print(3)
else:
print(1)
S = list(set(input()))
les = len(S)
if les == 3:
print(6)
elif les == 2:
print(3)
else:
print(1)
|
ConDefects/ConDefects/Code/abc225_a/Python/44983533
|
condefects-python_data_2671
|
S = input()
if S[0]==S[1] and S[0]==S[2]:
print("1")
elif S[0]!=S[1] and S[0]==S[2]:
print("3")
elif S[0]==S[1] and S[0]!=S[2]:
print("3")
elif S[0]!=S[1] and S[0]!=S[2]:
print("6")
S = input()
if S[0]==S[1] and S[0]==S[2]:
print("1")
elif S[0]!=S[1] and S[0]==S[2]:
print("3")
elif S[0]==S[1] and S[0]!=S[2]:
print("3")
elif S[0]!=S[1] and S[1]==S[2]:
print("3")
elif S[0]!=S[1] and S[0]!=S[2]:
print("6")
|
ConDefects/ConDefects/Code/abc225_a/Python/44786662
|
condefects-python_data_2672
|
S = input()
if S[0] == S[1] and S[1] == S[2]:
print(1)
if S[0] == S[1] or S[0] == S[2] or S[1] == S[2]:
print(3)
else:
print(6)
S = input()
if S[0] == S[1] and S[1] == S[2]:
print(1)
elif S[0] == S[1] or S[0] == S[2] or S[1] == S[2]:
print(3)
else:
print(6)
|
ConDefects/ConDefects/Code/abc225_a/Python/44428733
|
condefects-python_data_2673
|
import sys
N,A,B = (int(x) for x in input().split())
C = list(map(int,input().split()))
sumAB = A + B
for i in range(len(C)):
#print("{} {}".format(i,C[i]))
if C[i] == sumAB:
print(i)
exit
import sys
N,A,B = (int(x) for x in input().split())
C = list(map(int,input().split()))
sumAB = A + B
for i in range(len(C)):
#print("{} {}".format(i,C[i]))
if C[i] == sumAB:
print(i+1)
exit
|
ConDefects/ConDefects/Code/abc300_a/Python/46003187
|
condefects-python_data_2674
|
N, A, B = map(int, input().split())
C = list(map(int, input().split()))
print(C)
for i in range(len(C)):
if C[i] == A + B:
print(i+1)
N, A, B = map(int, input().split())
C = list(map(int, input().split()))
#print(C)
for i in range(len(C)):
if C[i] == A + B:
print(i+1)
|
ConDefects/ConDefects/Code/abc300_a/Python/45457940
|
condefects-python_data_2675
|
from collections import defaultdict
from typing import Dict, Iterable, List, Optional
class TrieNodeWithParent:
__slots__ = ("wordCount", "preCount", "children", "parent")
def __init__(self, parent: Optional["TrieNodeWithParent"] = None):
self.wordCount = 0 # 以当前节点为结尾的单词个数
self.preCount = 0 # 以当前节点为前缀的单词个数
self.parent = parent
self.children: Dict[str, TrieNodeWithParent] = defaultdict(lambda: TrieNodeWithParent(self))
class TrieWithParent:
__slots__ = "root"
def __init__(self, words: Optional[Iterable[str]] = None):
self.root = TrieNodeWithParent()
for word in words or ():
self.insert(word)
def insert(self, s: str) -> None:
if not s:
return
node = self.root
for char in s:
node = node.children[char]
node.preCount += 1
node.wordCount += 1
def countWord(self, s: str) -> List[int]:
"""对s的每个非空前缀pre,返回trie中有多少个等于pre的单词"""
if not s:
return []
res = []
node = self.root
for char in s:
if char not in node.children:
return []
node = node.children[char]
res.append(node.wordCount)
return res
def countWordStartsWith(self, s: str) -> List[int]:
"""对s的每个非空前缀pre,返回trie中有多少个单词以pre为前缀"""
if not s:
return []
res = []
node = self.root
for char in s:
if char not in node.children:
return []
node = node.children[char]
res.append(node.preCount)
return res
def countWordAsPrefix(self, s: str) -> List[int]:
"""对s的每个非空前缀pre,返回trie中有多少个单词是pre的前缀"""
node = self._find(s)
if node is None:
return []
diff = []
while node.parent is not None:
node = node.parent
diff.append(node.wordCount) # !重复的单词统计为多次而不是1次
res, cur = [], 0
for i in range(len(diff) - 1, -1, -1):
cur += diff[i]
res.append(cur)
return res
def remove(self, s: str) -> None:
"""从前缀树中移除`1个`s 需要保证s在前缀树中"""
if not s:
return
node = self.root
for char in s:
if char not in node.children:
raise ValueError(f"word {s} not in trie")
node = node.children[char]
node.preCount -= 1
node.wordCount -= 1
def _find(self, s: str) -> Optional[TrieNodeWithParent]:
"""返回s所在结点"""
if not s:
return None
node = self.root
for char in s:
if char not in node.children:
return None
node = node.children[char]
return node
if __name__ == "__main__":
MOD = 998244353
INV2 = 499122177
n = int(input())
names = [input() for _ in range(n)]
trie = TrieWithParent(names)
for name in names:
count1 = trie.countWordStartsWith(name)[-1] # name是多少个单词的前缀
count2 = trie.countWordAsPrefix(name)[-1] # 有多少个单词是name的前缀
other = n - 1 - count1 - count2 # 互相没有前缀关系
print((1 + count2 + other * INV2) % MOD)
from collections import defaultdict
from typing import Dict, Iterable, List, Optional
class TrieNodeWithParent:
__slots__ = ("wordCount", "preCount", "children", "parent")
def __init__(self, parent: Optional["TrieNodeWithParent"] = None):
self.wordCount = 0 # 以当前节点为结尾的单词个数
self.preCount = 0 # 以当前节点为前缀的单词个数
self.parent = parent
self.children: Dict[str, TrieNodeWithParent] = defaultdict(lambda: TrieNodeWithParent(self))
class TrieWithParent:
__slots__ = "root"
def __init__(self, words: Optional[Iterable[str]] = None):
self.root = TrieNodeWithParent()
for word in words or ():
self.insert(word)
def insert(self, s: str) -> None:
if not s:
return
node = self.root
for char in s:
node = node.children[char]
node.preCount += 1
node.wordCount += 1
def countWord(self, s: str) -> List[int]:
"""对s的每个非空前缀pre,返回trie中有多少个等于pre的单词"""
if not s:
return []
res = []
node = self.root
for char in s:
if char not in node.children:
return []
node = node.children[char]
res.append(node.wordCount)
return res
def countWordStartsWith(self, s: str) -> List[int]:
"""对s的每个非空前缀pre,返回trie中有多少个单词以pre为前缀"""
if not s:
return []
res = []
node = self.root
for char in s:
if char not in node.children:
return []
node = node.children[char]
res.append(node.preCount)
return res
def countWordAsPrefix(self, s: str) -> List[int]:
"""对s的每个非空前缀pre,返回trie中有多少个单词是pre的前缀"""
node = self._find(s)
if node is None:
return []
diff = []
while node.parent is not None:
diff.append(node.wordCount) # !重复的单词统计为多次而不是1次
node = node.parent
res, cur = [], 0
for i in range(len(diff) - 1, -1, -1):
cur += diff[i]
res.append(cur)
return res
def remove(self, s: str) -> None:
"""从前缀树中移除`1个`s 需要保证s在前缀树中"""
if not s:
return
node = self.root
for char in s:
if char not in node.children:
raise ValueError(f"word {s} not in trie")
node = node.children[char]
node.preCount -= 1
node.wordCount -= 1
def _find(self, s: str) -> Optional[TrieNodeWithParent]:
"""返回s所在结点"""
if not s:
return None
node = self.root
for char in s:
if char not in node.children:
return None
node = node.children[char]
return node
if __name__ == "__main__":
MOD = 998244353
INV2 = 499122177
n = int(input())
names = [input() for _ in range(n)]
trie = TrieWithParent(names)
for name in names:
count1 = trie.countWordStartsWith(name)[-1] # name是多少个单词的前缀
count2 = trie.countWordAsPrefix(name)[-1] # 有多少个单词是name的前缀
other = n - 1 - count1 - count2 # 互相没有前缀关系
print((1 + count2 + other * INV2) % MOD)
|
ConDefects/ConDefects/Code/abc268_g/Python/34968864
|
condefects-python_data_2676
|
N = int(input())
C = []
A = []
for _ in range(N):
c = int(input())
a = list(map(int, input().split()))
C.append(c)
A.append(a)
X = int(input())
p = []
for i in range(N):
if X in A[i]:
p.append(C[i])
if len(p) == 0:
print(0)
exit()
else:
min = min(p)
ans = []
for j in range(N):
if C[j] == min:
ans.append(str(j + 1))
print(len(ans))
print(' '.join(ans))
N = int(input())
C = []
A = []
for _ in range(N):
c = int(input())
a = list(map(int, input().split()))
C.append(c)
A.append(a)
X = int(input())
p = []
for i in range(N):
if X in A[i]:
p.append(C[i])
if len(p) == 0:
print(0)
exit()
else:
min = min(p)
ans = []
for j in range(N):
if C[j] == min and X in A[j]:
ans.append(str(j + 1))
print(len(ans))
print(' '.join(ans))
|
ConDefects/ConDefects/Code/abc314_b/Python/45977913
|
condefects-python_data_2677
|
N = int(input())
C = []
A = []
kouho = []
for i in range(N):
c = int(input())
a = list(map(int, input().split()))
C.append(c)
A.append(a)
X = int(input())
min_C = max(C)
for i in range(N):
if X in A[i]:
kouho.append(i)
if min_C > C[i]:
min_C = C[i]
count = 0
ans = []
for i in kouho:
if C[i] == min(C):
count += 1
ans.append(i+1)
print(count)
for i in ans:
print(i, end=" ")
N = int(input())
C = []
A = []
kouho = []
for i in range(N):
c = int(input())
a = list(map(int, input().split()))
C.append(c)
A.append(a)
X = int(input())
min_C = max(C)
for i in range(N):
if X in A[i]:
kouho.append(i)
if min_C > C[i]:
min_C = C[i]
count = 0
ans = []
for i in kouho:
if C[i] == min_C:
count += 1
ans.append(i+1)
print(count)
for i in ans:
print(i, end=" ")
|
ConDefects/ConDefects/Code/abc314_b/Python/45932176
|
condefects-python_data_2678
|
N = int(input())
C, A = [], []
for i in range(N):
C.append(int(input()))
A.append(list(map(int, input().split())))
X = int(input())
R = []
min = 37
for i in range(N):
for a in A[i]:
if a == X:
if len(A[i]) == min:
R.append(i+1)
break
elif len(A[i]) < min:
min = len(A[i])
R = []
R.append(i+1)
break
print(len(R))
for r in R:
print(r, end = "")
N = int(input())
C, A = [], []
for i in range(N):
C.append(int(input()))
A.append(list(map(int, input().split())))
X = int(input())
R = []
min = 37
for i in range(N):
for a in A[i]:
if a == X:
if len(A[i]) == min:
R.append(i+1)
break
elif len(A[i]) < min:
min = len(A[i])
R = []
R.append(i+1)
break
print(len(R))
for r in R:
print(r, end = " ")
|
ConDefects/ConDefects/Code/abc314_b/Python/45979954
|
condefects-python_data_2679
|
#再帰はCpython,その他はpypy
import sys
sys.setrecursionlimit(1000000)
from collections import deque
from collections import defaultdict
n = int(input())
s = str(input())
s = list(s)
sakuzyo = deque([])
ans = []
for i,mozi in enumerate(s):
#print(sakuzyo)
if mozi == "(":
sakuzyo.append(i)
ans.append(mozi)
elif mozi == ")":
if sakuzyo:
del ans[sakuzyo.pop():]
else:
ans.append(mozi)
else:
ans.append(mozi)
print("".join(ans))
#再帰はCpython,その他はpypy
import sys
sys.setrecursionlimit(1000000)
from collections import deque
from collections import defaultdict
n = int(input())
s = str(input())
s = list(s)
sakuzyo = deque([])
ans = []
for i,mozi in enumerate(s):
#print(sakuzyo)
if mozi == "(":
sakuzyo.append(len(ans))
ans.append(mozi)
elif mozi == ")":
if sakuzyo:
del ans[sakuzyo.pop():]
else:
ans.append(mozi)
else:
ans.append(mozi)
print("".join(ans))
|
ConDefects/ConDefects/Code/abc307_d/Python/45446603
|
condefects-python_data_2680
|
from collections import deque
N = int(input())
S = input()
L = deque()
temp = []
for s in S:
if s != "(" and s != ")":
temp.append(s)
elif s == "(":
if temp:
L.append("".join(temp))
temp.clear()
temp.append("(")
elif s == ")":
if temp:
L.append("".join(temp))
temp.clear()
if L and L[-1][0] == "(":
L.pop()
else:
L.append(")")
if temp:
L.append("".join(temp))
print("".join(L))
from collections import deque
N = int(input())
S = input()
L = deque()
temp = []
for s in S:
if s != "(" and s != ")":
temp.append(s)
elif s == "(":
if temp:
L.append("".join(temp))
temp.clear()
temp.append("(")
elif s == ")":
if temp:
L.append("".join(temp))
temp.clear()
if L and L[-1][0] == "(":
L.pop()
if L:
temp = list(L.pop())
else:
L.append(")")
if temp:
L.append("".join(temp))
print("".join(L))
|
ConDefects/ConDefects/Code/abc307_d/Python/45471496
|
condefects-python_data_2681
|
N = int(input())
S = input()
T = input()
CS = [[] for i in range(26)]
ns = [0]*26
nt = [0]*26
for i in range(N):
CS[ord(S[i])-97].append(i)
ns[ord(S[i])-97] += 1
nt[ord(T[i])-97] += 1
if ns != nt:
print(-1)
exit()
ans = N
cnt = N+1
for i in range(N):
tmp = T[-i-1]
ntmp = ord(tmp)-97
if CS[ntmp] == []:
print(ans)
exit()
if CS[ntmp][0] >= cnt:
print(ans)
exit()
if CS[ntmp][-1] < cnt:
cnt = CS[ntmp][-1]
ans -= 1
continue
p = 0
q = len(CS[ntmp])-1
while q -p >= 2:
m = (p+q)//2
if CS[ntmp][m] >= cnt:
q = m
else:
p = m
cnt = CS[ntmp][p]
ans -= 1
print(ans)
N = int(input())
T = input()
S = input()
CS = [[] for i in range(26)]
ns = [0]*26
nt = [0]*26
for i in range(N):
CS[ord(S[i])-97].append(i)
ns[ord(S[i])-97] += 1
nt[ord(T[i])-97] += 1
if ns != nt:
print(-1)
exit()
ans = N
cnt = N+1
for i in range(N):
tmp = T[-i-1]
ntmp = ord(tmp)-97
if CS[ntmp] == []:
print(ans)
exit()
if CS[ntmp][0] >= cnt:
print(ans)
exit()
if CS[ntmp][-1] < cnt:
cnt = CS[ntmp][-1]
ans -= 1
continue
p = 0
q = len(CS[ntmp])-1
while q -p >= 2:
m = (p+q)//2
if CS[ntmp][m] >= cnt:
q = m
else:
p = m
cnt = CS[ntmp][p]
ans -= 1
print(ans)
|
ConDefects/ConDefects/Code/arc154_b/Python/44381459
|
condefects-python_data_2682
|
N = int(input())
S = input()
T = input()
T = T + " "
S_count = [0]*26
T_count = [0]*26
for i in range(N):
S_count[ord(S[i])-ord('a')] += 1
T_count[ord(T[i])-ord('a')] += 1
for i in range(26):
if S_count[i] != T_count[i]:
print(-1)
exit()
cur = N-1
count = 0
for i in range(N-1, -1, -1):
while S[i] != T[cur]:
if cur != -1:
break
cur -= 1
else:
count += 1
cur -= 1
print(N-count)
N = int(input())
S = input()
T = input()
T = T + " "
S_count = [0]*26
T_count = [0]*26
for i in range(N):
S_count[ord(S[i])-ord('a')] += 1
T_count[ord(T[i])-ord('a')] += 1
for i in range(26):
if S_count[i] != T_count[i]:
print(-1)
exit()
cur = N-1
count = 0
for i in range(N-1, -1, -1):
while S[i] != T[cur]:
if cur == -1:
break
cur -= 1
else:
count += 1
cur -= 1
print(N-count)
|
ConDefects/ConDefects/Code/arc154_b/Python/43315013
|
condefects-python_data_2683
|
N=int(input())
S=input()
T=input()
S1=list(S)
T1=list(T)
S1.sort()
T1.sort()
res=0
if S1!=T1:
print(-1)
else:
S2=list(S)
T2=list(T)
i=N-1
while i>=0:
a=S2.pop()
while a!=T[i]:
i-=1
if i<0:
break
i-=1
if i>=0:
res+=1
print(N-res)
N=int(input())
S=input()
T=input()
S1=list(S)
T1=list(T)
S1.sort()
T1.sort()
res=0
if S1!=T1:
print(-1)
else:
S2=list(S)
T2=list(T)
i=N-1
while i>=0:
a=S2.pop()
while a!=T[i]:
i-=1
if i<0:
break
i-=1
if i>=-1:
res+=1
print(N-res)
|
ConDefects/ConDefects/Code/arc154_b/Python/40904177
|
condefects-python_data_2684
|
n = int(input())
s = input()
t = input()
s2 = sorted(s)
t2 = sorted(s)
if s2 != t2:
print(-1)
exit()
if s == t:
print(0)
exit()
def check(x):
s_cut = s[x:]
l = len(s_cut)
s_idx = 0
for i in range(n):
if t[i] == s_cut[s_idx]:
s_idx += 1
if s_idx == l:
return True
return False
ok = n
ng = 0
while ok-ng >= 2:
mid = (ok+ng)//2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
n = int(input())
s = input()
t = input()
s2 = sorted(s)
t2 = sorted(t)
if s2 != t2:
print(-1)
exit()
if s == t:
print(0)
exit()
def check(x):
s_cut = s[x:]
l = len(s_cut)
s_idx = 0
for i in range(n):
if t[i] == s_cut[s_idx]:
s_idx += 1
if s_idx == l:
return True
return False
ok = n
ng = 0
while ok-ng >= 2:
mid = (ok+ng)//2
if check(mid):
ok = mid
else:
ng = mid
print(ok)
|
ConDefects/ConDefects/Code/arc154_b/Python/40787964
|
condefects-python_data_2685
|
n=int(input())
s=input()
t=input()
sl=[]
tl=[]
for i in range(n):
sl.append(s[i])
tl.append(t[i])
sl.sort()
tl.sort()
if sl!=tl:
print('No')
exit()
now=n-1
ans=0
for i in reversed(range(n)):
while True:
if s[i]==t[now]:
ans+=1
now-=1
break
now-=1
if now<0:
break
if now<0:
break
print(n-ans)
n=int(input())
s=input()
t=input()
sl=[]
tl=[]
for i in range(n):
sl.append(s[i])
tl.append(t[i])
sl.sort()
tl.sort()
if sl!=tl:
print(-1)
exit()
now=n-1
ans=0
for i in reversed(range(n)):
while True:
if s[i]==t[now]:
ans+=1
now-=1
break
now-=1
if now<0:
break
if now<0:
break
print(n-ans)
|
ConDefects/ConDefects/Code/arc154_b/Python/43795529
|
condefects-python_data_2686
|
from collections import deque
n=int(input())
s=list(input())
t=list(input())
if sorted(s)!=sorted(t):
print(-1)
else:
ok=n
ng=0
while True:
#print(ng,ok)
k=(ok+ng)//2
j=0
p=s[k:]
g=0
if k==n:
g=1
else:
for i in range(n):
if t[i]==p[j]:
j+=1
if j==len(p):
g+=1
break
# p=s[:n-k]
# j=0
# for i in range(n):
# if t[i]==p[j]:
# j+=1
# if j==len(p):
# g+=1
# break
if g==1:
ok=k
else:
ng=k
if abs(ok-ng)<=1:
#print(ng,ok)
print((ok+ng)//2+1)
break
from collections import deque
n=int(input())
s=list(input())
t=list(input())
if sorted(s)!=sorted(t):
print(-1)
else:
ok=n
ng=0
while True:
#print(ng,ok)
k=(ok+ng)//2
j=0
p=s[k:]
g=0
if k==n:
g=1
else:
for i in range(n):
if t[i]==p[j]:
j+=1
if j==len(p):
g+=1
break
# p=s[:n-k]
# j=0
# for i in range(n):
# if t[i]==p[j]:
# j+=1
# if j==len(p):
# g+=1
# break
if g==1:
ok=k
else:
ng=k
if abs(ok-ng)<=1:
#print(ng,ok)
print(ok)
break
|
ConDefects/ConDefects/Code/arc154_b/Python/43504981
|
condefects-python_data_2687
|
N = int(input())
S = input()
T = input()
alp2num = lambda x : ord(x) - ord("a")
num_s = [0] * 26
num_t = [0] * 26
for i in range(N):
num_s[alp2num(S[i])] += 1
num_t[alp2num(T[i])] += 1
for i in range(26):
if num_s[i] != num_t[i] : exit(print(-1))
cnt = 0
i = N-1
j = N
while i >= 0:
s = S[i]
while j >= 0:
j -= 1
if T[j] == s : cnt += 1; break
i -= 1
print(N - cnt)
N = int(input())
S = input()
T = input()
alp2num = lambda x : ord(x) - ord("a")
num_s = [0] * 26
num_t = [0] * 26
for i in range(N):
num_s[alp2num(S[i])] += 1
num_t[alp2num(T[i])] += 1
for i in range(26):
if num_s[i] != num_t[i] : exit(print(-1))
cnt = 0
i = N-1
j = N
while i >= 0:
s = S[i]
while j > 0:
j -= 1
if T[j] == s : cnt += 1; break
i -= 1
print(N - cnt)
|
ConDefects/ConDefects/Code/arc154_b/Python/43180385
|
condefects-python_data_2688
|
n = int(input())
s = input()
t = input()
if sorted(list(s)) != sorted(list(t)):
print(-1)
exit()
idx = n - 1
for j, i in enumerate(s[::-1]):
while idx >= 0 and t[idx] != i:
idx -= 1
idx -= 1
if idx < 0:
print(n - j)
exit()
print(0)
n = int(input())
s = input()
t = input()
if sorted(list(s)) != sorted(list(t)):
print(-1)
exit()
idx = n - 1
for j, i in enumerate(s[::-1]):
while idx >= 0 and t[idx] != i:
idx -= 1
if idx < 0:
print(n - j)
exit()
idx -= 1
print(0)
|
ConDefects/ConDefects/Code/arc154_b/Python/43445291
|
condefects-python_data_2689
|
from atcoder.dsu import DSU
from heapq import heappop, heappush
from collections import deque
N, M = map(int, input().split())
A = list(map(int, input().split()))
G = [[0] * N for _ in range(N)]
for i in range(N):
for j in range(i+1, N):
G[i][j] = (pow(A[i], A[j], M) + pow(A[j], A[i], M)) % M
G[j][i] = G[i][j]
edges = []
for i in range(N):
for j in range(i+1, N):
edges.append(((pow(A[i], A[j], M) + pow(A[j], A[i], M)) % M, i, j))
edges.sort()
ans = 0
uf = DSU(N)
for p, i, j in edges:
if uf.same(i, j): continue
ans += p
uf.merge(i, j)
print(ans)
from atcoder.dsu import DSU
from heapq import heappop, heappush
from collections import deque
N, M = map(int, input().split())
A = list(map(int, input().split()))
G = [[0] * N for _ in range(N)]
for i in range(N):
for j in range(i+1, N):
G[i][j] = (pow(A[i], A[j], M) + pow(A[j], A[i], M)) % M
G[j][i] = G[i][j]
edges = []
for i in range(N):
for j in range(i+1, N):
edges.append(((pow(A[i], A[j], M) + pow(A[j], A[i], M)) % M, i, j))
edges.sort(reverse=True)
ans = 0
uf = DSU(N)
for p, i, j in edges:
if uf.same(i, j): continue
ans += p
uf.merge(i, j)
print(ans)
|
ConDefects/ConDefects/Code/abc282_e/Python/45514577
|
condefects-python_data_2690
|
import itertools
import math
m = []
for i in range(3):
x, y,z = map(int, input().split())
m.append(x)
m.append(y)
m.append(z)
print(m)
cklist = [[[2,3],[4,7],[5,9]] \
,[[1,3],[5,8]] \
,[[1,2],[6,9],[5,7]] \
,[[1,7],[5,6]] \
,[[2,8],[4,6],[1,9],[3,7]] \
,[[3,9],[4,5]] \
,[[1,4],[3,5],[8,9]] \
,[[2,5],[7,9]] \
,[[1,5],[3,6],[7,8]]]
lp = [0,1,2,3,4,5,6,7,8]
def gakkari(c,v,w):
for i in cklist[c]:
s = 10* w[i[0]-1] + w[i[1]-1]
#print(s,c,v,i,w)
if s == v or s == 10*v :
return True
return False
kei =math.factorial(9)
cnt = 0
for s in itertools.permutations(lp, 9 ):
l = list(s)
w = [0 for _ in range(9)]
for i in l:
w[i] = m[i]
## gakkari chk
if gakkari(i,m[i],w) :
break
else:
cnt += 1
#print(w)
#print(cklist)
print(cnt/kei )
import itertools
import math
m = []
for i in range(3):
x, y,z = map(int, input().split())
m.append(x)
m.append(y)
m.append(z)
#print(m)
cklist = [[[2,3],[4,7],[5,9]] \
,[[1,3],[5,8]] \
,[[1,2],[6,9],[5,7]] \
,[[1,7],[5,6]] \
,[[2,8],[4,6],[1,9],[3,7]] \
,[[3,9],[4,5]] \
,[[1,4],[3,5],[8,9]] \
,[[2,5],[7,9]] \
,[[1,5],[3,6],[7,8]]]
lp = [0,1,2,3,4,5,6,7,8]
def gakkari(c,v,w):
for i in cklist[c]:
s = 10* w[i[0]-1] + w[i[1]-1]
#print(s,c,v,i,w)
if s == v or s == 10*v :
return True
return False
kei =math.factorial(9)
cnt = 0
for s in itertools.permutations(lp, 9 ):
l = list(s)
w = [0 for _ in range(9)]
for i in l:
w[i] = m[i]
## gakkari chk
if gakkari(i,m[i],w) :
break
else:
cnt += 1
#print(w)
#print(cklist)
print(cnt/kei )
|
ConDefects/ConDefects/Code/abc319_c/Python/45783074
|
condefects-python_data_2691
|
class LazySegmentTree:
def __init__(self, op, e, mapping, composition, id_, n):
self._n = len(n) if isinstance(n, list) else n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id_
self.log = (self._n - 1).bit_length()
self.size = 1 << self.log
self.d = [e for _ in range(2 * self.size)]
self.lz = [id_ for _ in range(self.size)]
if isinstance(n, list): self.d[self.size: self.size + self._n] = n
for i in reversed(range(1, self.size)): self._update(i)
def __repr__(self):
l, r = 1, 2
res = []
np_T = lambda x: [list(x) for x in zip(*x)]
while r <= self.size:
res.append(f'{np_T([self.d[l: r], self.lz[l: r]])}')
l, r = r, r << 1
res.append(f'{self.d[l: r]}')
return '\n'.join(res)
def __setitem__(self, p, x):
self.set(p, x)
def __getitem__(self, p):
return self.get(p)
def set(self, p, x): # O(log n)
p += self.size
for i in reversed(range(1, self.log + 1)): self._push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1): self._update(p >> i)
def get(self, p): # O(log n)
p += self.size
for i in reversed(range(1, self.log + 1)): self._push(p >> i)
return self.d[p]
def prod(self, l, r): # [l, r) O(log n)
if l == r: return self.e
l += self.size
r += self.size
for i in reversed(range(1, self.log + 1)):
if ((l >> i) << i) != l: self._push(l >> i)
if ((r >> i) << i) != r: self._push((r - 1) >> i)
sml, smr = self.e, self.e
while (l < r):
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self): # O(1)
return self.d[1]
def apply(self, p, f): # O(log n)
p += self.size
for i in reversed(range(1, self.log + 1)): self._push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1): self._update(p >> i)
def apply_seg(self, l, r, f): # O(log n)
if l == r: return
l += self.size
r += self.size
for i in reversed(range(1, self.log + 1)):
if ((l >> i) << i) != l: self._push(l >> i)
if ((r >> i) << i) != r: self._push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
self._all_apply(l, f)
l += 1
if r & 1:
r -= 1
self._all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self._update(l >> i)
if ((r >> i) << i) != r: self._update((r - 1) >> i)
def max_right(self, l, f): # O(log n)
if l >= self._n: return self._n
l = max(l, 0) + self.size
for i in reversed(range(1, self.log + 1)):
self._push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not f(self.op(sm, self.d[l])):
while l < self.size:
self._push(l)
l <<= 1
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if l & -l == l: break
return self._n
def min_left(self, r, f): # O(log n)
if r <= 0: return 0
r = min(r, self._n) + self.size
for i in reversed(range(1, self.log + 1)):
self._push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not f(self.op(self.d[r], sm)):
while r < self.size:
self._push(r)
r = 2 * r + 1
if f(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if r & -r == r: break
return 0
def _update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def _all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size: self.lz[k] = self.composition(f, self.lz[k])
def _push(self, k):
if self.lz[k] == self.id: return
self._all_apply(2 * k, self.lz[k])
self._all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
INF = 10 ** 16
mod = 998244353
# from operator import add
# f = lambda x, y: y if x == INF else x
def mapping(x, y):
a, b = x
return (a*y+b) % mod
def composition(y, x):
if x == y == INF:
return INF
elif x == INF:
return y
elif y == INF:
return x
a1, b1 = x
a2, b2 = y
return (a1*a2 % mod, (a2*b1+b2) % mod)
segadd = lambda x, y: (x[0] + y[0], x[1] + y[1])
# seg = LazySegmentTree(min, INF, f, f, INF, W) # 区間更新・区間最小値取得
# seg = LazySegmentTree(min, INF, add, add, 0, W) # 区間加算・区間最小値取得
# seg = LazySegmentTree(max, -INF, add, add, 0, W) # 区間加算・区間最大値取得
# seg = LazySegmentTree(segadd, (0, 0), lambda f, x: (x[0] + f * x[1], x[1]), add, 0, [(0, 1) for _ in range(W)]) # 区間加算・区間和取得
# seg = LazySegmentTree(segadd, (0, 0), lambda f, x: (f * x[1], x[1]) if f < INF else x, f, INF, [(0, 1) for _ in range(W)]) # 区間更新・区間和取得
n, m = map(int, input().split())
a = list(map(int, input().split()))
seg = LazySegmentTree(max, -INF, mapping, composition, INF, a) # 区間更新・区間最大値取得
for _ in range(m):
l, r, x = map(int, input().split())
l -= 1
LEN = r-l
seg.apply_seg(l, r, ((LEN-1)*pow(LEN, -1, mod), x*pow(LEN, -1, mod)))
ans = []
for i in range(n):
ans.append(seg.get(i))
print(*ans)
class LazySegmentTree:
def __init__(self, op, e, mapping, composition, id_, n):
self._n = len(n) if isinstance(n, list) else n
self.op = op
self.e = e
self.mapping = mapping
self.composition = composition
self.id = id_
self.log = (self._n - 1).bit_length()
self.size = 1 << self.log
self.d = [e for _ in range(2 * self.size)]
self.lz = [id_ for _ in range(self.size)]
if isinstance(n, list): self.d[self.size: self.size + self._n] = n
for i in reversed(range(1, self.size)): self._update(i)
def __repr__(self):
l, r = 1, 2
res = []
np_T = lambda x: [list(x) for x in zip(*x)]
while r <= self.size:
res.append(f'{np_T([self.d[l: r], self.lz[l: r]])}')
l, r = r, r << 1
res.append(f'{self.d[l: r]}')
return '\n'.join(res)
def __setitem__(self, p, x):
self.set(p, x)
def __getitem__(self, p):
return self.get(p)
def set(self, p, x): # O(log n)
p += self.size
for i in reversed(range(1, self.log + 1)): self._push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1): self._update(p >> i)
def get(self, p): # O(log n)
p += self.size
for i in reversed(range(1, self.log + 1)): self._push(p >> i)
return self.d[p]
def prod(self, l, r): # [l, r) O(log n)
if l == r: return self.e
l += self.size
r += self.size
for i in reversed(range(1, self.log + 1)):
if ((l >> i) << i) != l: self._push(l >> i)
if ((r >> i) << i) != r: self._push((r - 1) >> i)
sml, smr = self.e, self.e
while (l < r):
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.d[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self): # O(1)
return self.d[1]
def apply(self, p, f): # O(log n)
p += self.size
for i in reversed(range(1, self.log + 1)): self._push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1): self._update(p >> i)
def apply_seg(self, l, r, f): # O(log n)
if l == r: return
l += self.size
r += self.size
for i in reversed(range(1, self.log + 1)):
if ((l >> i) << i) != l: self._push(l >> i)
if ((r >> i) << i) != r: self._push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1:
self._all_apply(l, f)
l += 1
if r & 1:
r -= 1
self._all_apply(r, f)
l >>= 1
r >>= 1
l, r = l2, r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self._update(l >> i)
if ((r >> i) << i) != r: self._update((r - 1) >> i)
def max_right(self, l, f): # O(log n)
if l >= self._n: return self._n
l = max(l, 0) + self.size
for i in reversed(range(1, self.log + 1)):
self._push(l >> i)
sm = self.e
while True:
while l % 2 == 0: l >>= 1
if not f(self.op(sm, self.d[l])):
while l < self.size:
self._push(l)
l <<= 1
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if l & -l == l: break
return self._n
def min_left(self, r, f): # O(log n)
if r <= 0: return 0
r = min(r, self._n) + self.size
for i in reversed(range(1, self.log + 1)):
self._push((r - 1) >> i)
sm = self.e
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not f(self.op(self.d[r], sm)):
while r < self.size:
self._push(r)
r = 2 * r + 1
if f(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if r & -r == r: break
return 0
def _update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def _all_apply(self, k, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size: self.lz[k] = self.composition(f, self.lz[k])
def _push(self, k):
if self.lz[k] == self.id: return
self._all_apply(2 * k, self.lz[k])
self._all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id
INF = 10 ** 16
mod = 998244353
# from operator import add
# f = lambda x, y: y if x == INF else x
def mapping(x, y):
a, b = x
return (a*y+b) % mod
def composition(y, x):
if x == y == INF:
return INF
elif x == INF:
return y
elif y == INF:
return x
a1, b1 = x
a2, b2 = y
return (a1*a2 % mod, (a2*b1+b2) % mod)
segadd = lambda x, y: (x[0] + y[0], x[1] + y[1])
# seg = LazySegmentTree(min, INF, f, f, INF, W) # 区間更新・区間最小値取得
# seg = LazySegmentTree(min, INF, add, add, 0, W) # 区間加算・区間最小値取得
# seg = LazySegmentTree(max, -INF, add, add, 0, W) # 区間加算・区間最大値取得
# seg = LazySegmentTree(segadd, (0, 0), lambda f, x: (x[0] + f * x[1], x[1]), add, 0, [(0, 1) for _ in range(W)]) # 区間加算・区間和取得
# seg = LazySegmentTree(segadd, (0, 0), lambda f, x: (f * x[1], x[1]) if f < INF else x, f, INF, [(0, 1) for _ in range(W)]) # 区間更新・区間和取得
n, m = map(int, input().split())
a = list(map(int, input().split()))
seg = LazySegmentTree(max, -INF, mapping, composition, INF, a) # 区間更新・区間最大値取得
for _ in range(m):
l, r, x = map(int, input().split())
l -= 1
LEN = r-l
seg.apply_seg(l, r, ((LEN-1)*pow(LEN, -1, mod), x*pow(LEN, -1, mod)))
ans = []
for i in range(n):
ans.append(seg.get(i)%mod)
print(*ans)
|
ConDefects/ConDefects/Code/abc332_f/Python/50121141
|
condefects-python_data_2692
|
class lazy_segtree():
def update(self,k):
self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def all_apply(self,k,f):
self.d[k]=self.mapping(f,self.d[k])
if (k<self.size):
self.lz[k]=self.composition(f,self.lz[k])
def push(self,k):
self.all_apply(2*k,self.lz[k])
self.all_apply(2*k+1,self.lz[k])
self.lz[k]=self.identity
def __init__(self,V,OP,E,MAPPING,COMPOSITION,ID):
self.n=len(V)
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
self.lz=[ID for i in range(self.size)]
self.e=E
self.op=OP
self.mapping=MAPPING
self.composition=COMPOSITION
self.identity=ID
self.length=[1]*(2*self.size)
for k in range(self.size-1,0,-1):
self.length[k]=self.op(self.length[2*k],self.length[2*k+1])
for i in range(self.n):
self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):
self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):
self.push(p>>i)
self.d[p]=x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):
self.push(p>>i)
return self.d[p]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
if l==r:
return self.e
l+=self.size
r+=self.size
for i in range(self.log,0,-1):
if (((l>>i)<<i)!=l):
self.push(l>>i)
if (((r>>i)<<i)!=r):
self.push(r>>i)
sml,smr=self.e,self.e
while(l<r):
if l&1:
sml=self.op(sml,self.d[l])
l+=1
if r&1:
r-=1
smr=self.op(self.d[r],smr)
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):
return self.d[1]
def apply_point(self,p,f):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):
self.push(p>>i)
self.d[p]=self.mapping(f,self.d[p])
for i in range(1,self.log+1):
self.update(p>>i)
def apply(self,l,r,f):
assert 0<=l and l<=r and r<=self.n
if l==r:
return
l+=self.size
r+=self.size
for i in range(self.log,0,-1):
if (((l>>i)<<i)!=l):
self.push(l>>i)
if (((r>>i)<<i)!=r):
self.push((r-1)>>i)
l2,r2=l,r
while(l<r):
if (l&1):
self.all_apply(l,f)
l+=1
if (r&1):
r-=1
self.all_apply(r,f)
l>>=1
r>>=1
l,r=l2,r2
for i in range(1,self.log+1):
if (((l>>i)<<i)!=l):
self.update(l>>i)
if (((r>>i)<<i)!=r):
self.update((r-1)>>i)
################################
#opの単位元 op(data1, e) = data1
e=0
#区間演算
def op(x,y):
return (x+y)%mod
#上のlazy→下のdata
def mapping(lazy_upper,data_lower):
a,b=lazy_upper
return (a*data_lower+b)%mod
#上のlazy→下のlazy
def composition(lazy_upper,lazy_lower):
a1,b1=lazy_upper
a2,b2=lazy_lower
return (a1*a2)%mod,(b1*a2+b2)%mod
#mapping(_id, data_lower) = data_lower
_id=(1,0)
#V,OP,E,MAPPING,COMPOSITION,ID
N,M=map(int,input().split())
A=list(map(int,input().split()))
mod=998244353
seg=lazy_segtree(A,op,e,mapping,composition,_id)
for i in range(M):
l,r,x=map(int,input().split())
l-=1
v=r-l
d=pow(v,-1,mod)
seg.apply(l,r,((1-d)%mod,(d*x)%mod))
for i in range(N):
print(seg.get(i)%mod)
class lazy_segtree():
def update(self,k):
self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def all_apply(self,k,f):
self.d[k]=self.mapping(f,self.d[k])
if (k<self.size):
self.lz[k]=self.composition(f,self.lz[k])
def push(self,k):
self.all_apply(2*k,self.lz[k])
self.all_apply(2*k+1,self.lz[k])
self.lz[k]=self.identity
def __init__(self,V,OP,E,MAPPING,COMPOSITION,ID):
self.n=len(V)
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
self.lz=[ID for i in range(self.size)]
self.e=E
self.op=OP
self.mapping=MAPPING
self.composition=COMPOSITION
self.identity=ID
self.length=[1]*(2*self.size)
for k in range(self.size-1,0,-1):
self.length[k]=self.op(self.length[2*k],self.length[2*k+1])
for i in range(self.n):
self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):
self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):
self.push(p>>i)
self.d[p]=x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):
self.push(p>>i)
return self.d[p]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
if l==r:
return self.e
l+=self.size
r+=self.size
for i in range(self.log,0,-1):
if (((l>>i)<<i)!=l):
self.push(l>>i)
if (((r>>i)<<i)!=r):
self.push(r>>i)
sml,smr=self.e,self.e
while(l<r):
if l&1:
sml=self.op(sml,self.d[l])
l+=1
if r&1:
r-=1
smr=self.op(self.d[r],smr)
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):
return self.d[1]
def apply_point(self,p,f):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):
self.push(p>>i)
self.d[p]=self.mapping(f,self.d[p])
for i in range(1,self.log+1):
self.update(p>>i)
def apply(self,l,r,f):
assert 0<=l and l<=r and r<=self.n
if l==r:
return
l+=self.size
r+=self.size
for i in range(self.log,0,-1):
if (((l>>i)<<i)!=l):
self.push(l>>i)
if (((r>>i)<<i)!=r):
self.push((r-1)>>i)
l2,r2=l,r
while(l<r):
if (l&1):
self.all_apply(l,f)
l+=1
if (r&1):
r-=1
self.all_apply(r,f)
l>>=1
r>>=1
l,r=l2,r2
for i in range(1,self.log+1):
if (((l>>i)<<i)!=l):
self.update(l>>i)
if (((r>>i)<<i)!=r):
self.update((r-1)>>i)
################################
#opの単位元 op(data1, e) = data1
e=0
#区間演算
def op(x,y):
return (x+y)%mod
#上のlazy→下のdata
def mapping(lazy_upper,data_lower):
a,b=lazy_upper
return (a*data_lower+b)%mod
#上のlazy→下のlazy
def composition(lazy_upper,lazy_lower):
a1,b1=lazy_upper
a2,b2=lazy_lower
return (a1*a2)%mod,(b2*a1+b1)%mod
#mapping(_id, data_lower) = data_lower
_id=(1,0)
#V,OP,E,MAPPING,COMPOSITION,ID
N,M=map(int,input().split())
A=list(map(int,input().split()))
mod=998244353
seg=lazy_segtree(A,op,e,mapping,composition,_id)
for i in range(M):
l,r,x=map(int,input().split())
l-=1
v=r-l
d=pow(v,-1,mod)
seg.apply(l,r,((1-d)%mod,(d*x)%mod))
for i in range(N):
print(seg.get(i)%mod)
|
ConDefects/ConDefects/Code/abc332_f/Python/50495500
|
condefects-python_data_2693
|
mod=998244353
class SegTreeLazy():
def __init__(self, a):
# 初期化
n=len(a)
self.n = n
self.a = a
self.ans=[0]*n
self.logN=(n-1).bit_length()
self.n0 = 1<<self.logN
self.ktree=[1]*2*self.n0
self.dtree=[0]*2*self.n0
for i in range(n):
self.dtree[self.n0-1+i]=a[i]
self.ktree[self.n0-1+i]=0
self.lazy=[None]*2*self.n0
# [l,r)の上にある親ノード全てを返す
def gindex(self,l, r):
L = (l + self.n0) >> 1; R = (r + self.n0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.logN):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
# 遅延伝搬処理
def propagates(self,*ids):
for i in reversed(ids):
v = self.lazy[i-1]
if v is None:
continue
self.lazy[2*i-1] = self.lazy[2*i]=1
self.ktree[2*i-1] = self.ktree[i-1]*self.ktree[2*i-1]%mod
self.ktree[2*i] = self.ktree[i-1]*self.ktree[2*i]%mod
self.dtree[2*i-1] = (self.ktree[i-1]*self.dtree[2*i-1]%mod+self.dtree[i-1])%mod
self.dtree[2*i] = (self.ktree[i-1]*self.dtree[2*i]%mod+self.dtree[i-1])%mod
self.lazy[i-1] = None
self.ktree[i-1] = 1
self.dtree[i-1] = 0
# 区間[l, r)をk,dで更新
def update(self,l, r, k,d):
*ids, = self.gindex(l, r)
self.propagates(*ids)
L = self.n0 + l; R = self.n0 + r
while L < R:
if R & 1:
R -= 1
self.ktree[R-1] =self.ktree[R-1]*k%mod
self.dtree[R-1] = (self.dtree[R-1]*k%mod+d)%mod
self.lazy[R-1]=1
if L & 1:
self.ktree[L-1] = self.ktree[L-1]*k%mod
self.dtree[L-1] = (self.dtree[L-1]*k%mod+d)%mod
self.lazy[L-1]=1
L += 1
L >>= 1; R >>= 1
def query(self):
ans=[0]*n
for i in range(1,self.n0):
v = self.lazy[i-1]
if v is None:
continue
self.lazy[2*i-1] = self.lazy[2*i]=1
self.ktree[2*i-1] = self.ktree[i-1]*self.ktree[2*i-1]%mod
self.ktree[2*i] = self.ktree[i-1]*self.ktree[2*i]%mod
self.dtree[2*i-1] = (self.ktree[i-1]*self.dtree[2*i-1]%mod+self.dtree[i-1])%mod
self.dtree[2*i] = (self.ktree[i-1]*self.dtree[2*i]%mod+self.dtree[i-1])%mod
self.lazy[i-1] = None
self.ktree[i-1] = 1
self.dtree[i-1] = 0
return self.dtree[self.n0-1:self.n0-1+self.n]
def modinv(a):
return pow(a,mod-2,mod)
n,m=map(int,input().split())
A=list(map(int,input().split()))
st=SegTreeLazy(A)
p=[0]*n
q=[0]*n
for i in range(n):
p[i]=modinv(i+1)
q[i]=(1-p[i])%mod
for i in range(m):
l,r,x=map(int,input().split())
st.update(l-1,r,q[r-l],p[r-l]*x%mod)
ans=st.query()
print(*ans)
mod=998244353
class SegTreeLazy():
def __init__(self, a):
# 初期化
n=len(a)
self.n = n
self.a = a
self.ans=[0]*n
self.logN=(n-1).bit_length()
self.n0 = 1<<self.logN
self.ktree=[1]*2*self.n0
self.dtree=[0]*2*self.n0
for i in range(n):
self.dtree[self.n0-1+i]=a[i]%mod
self.ktree[self.n0-1+i]=0
self.lazy=[None]*2*self.n0
# [l,r)の上にある親ノード全てを返す
def gindex(self,l, r):
L = (l + self.n0) >> 1; R = (r + self.n0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.logN):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
# 遅延伝搬処理
def propagates(self,*ids):
for i in reversed(ids):
v = self.lazy[i-1]
if v is None:
continue
self.lazy[2*i-1] = self.lazy[2*i]=1
self.ktree[2*i-1] = self.ktree[i-1]*self.ktree[2*i-1]%mod
self.ktree[2*i] = self.ktree[i-1]*self.ktree[2*i]%mod
self.dtree[2*i-1] = (self.ktree[i-1]*self.dtree[2*i-1]%mod+self.dtree[i-1])%mod
self.dtree[2*i] = (self.ktree[i-1]*self.dtree[2*i]%mod+self.dtree[i-1])%mod
self.lazy[i-1] = None
self.ktree[i-1] = 1
self.dtree[i-1] = 0
# 区間[l, r)をk,dで更新
def update(self,l, r, k,d):
*ids, = self.gindex(l, r)
self.propagates(*ids)
L = self.n0 + l; R = self.n0 + r
while L < R:
if R & 1:
R -= 1
self.ktree[R-1] =self.ktree[R-1]*k%mod
self.dtree[R-1] = (self.dtree[R-1]*k%mod+d)%mod
self.lazy[R-1]=1
if L & 1:
self.ktree[L-1] = self.ktree[L-1]*k%mod
self.dtree[L-1] = (self.dtree[L-1]*k%mod+d)%mod
self.lazy[L-1]=1
L += 1
L >>= 1; R >>= 1
def query(self):
ans=[0]*n
for i in range(1,self.n0):
v = self.lazy[i-1]
if v is None:
continue
self.lazy[2*i-1] = self.lazy[2*i]=1
self.ktree[2*i-1] = self.ktree[i-1]*self.ktree[2*i-1]%mod
self.ktree[2*i] = self.ktree[i-1]*self.ktree[2*i]%mod
self.dtree[2*i-1] = (self.ktree[i-1]*self.dtree[2*i-1]%mod+self.dtree[i-1])%mod
self.dtree[2*i] = (self.ktree[i-1]*self.dtree[2*i]%mod+self.dtree[i-1])%mod
self.lazy[i-1] = None
self.ktree[i-1] = 1
self.dtree[i-1] = 0
return self.dtree[self.n0-1:self.n0-1+self.n]
def modinv(a):
return pow(a,mod-2,mod)
n,m=map(int,input().split())
A=list(map(int,input().split()))
st=SegTreeLazy(A)
p=[0]*n
q=[0]*n
for i in range(n):
p[i]=modinv(i+1)
q[i]=(1-p[i])%mod
for i in range(m):
l,r,x=map(int,input().split())
st.update(l-1,r,q[r-l],p[r-l]*x%mod)
ans=st.query()
print(*ans)
|
ConDefects/ConDefects/Code/abc332_f/Python/49265039
|
condefects-python_data_2694
|
#ABC332F Random Update Query
#結局双対セグ木はソラで書けばよいため
#入力受取
N, M = map(int, input().split())
A = list(map(int, input().split()))
MOD = 998244353
#push機能付きの双対セグ木を書く
#遅延は(ax + b)の形で保持する
logN = (N - 1).bit_length()
size = 1 << logN
lazy = [(1, 0) for _ in range(2 * size)]
for i in range(N):
lazy[i + size] = (1, A[i])
def lazy_f(lazy1, lazy2):
a1, b1 = lazy1
a2, b2 = lazy2
return (a1 * a2 % MOD, (b1 * a2 + b2) % MOD)
def push(i):
i += size
for h in range(logN - 1, 0, -1):
j = i >> h
if lazy[j] != (1, 0):
Lt, Rt = j << 1, j << 1 | 1
lazy[Lt] = lazy_f(lazy[Lt], lazy[j])
lazy[Rt] = lazy_f(lazy[Rt], lazy[j])
lazy[j] = (1, 0)
def change(Lt, Rt, X):
diff = Rt - Lt
a = (diff - 1) * pow(diff, -1, MOD) % MOD
b = X * pow(diff, -1, MOD) % MOD
#区間[Lt, Rt)に(ax + b)を作用させる
push(Lt)
push(Rt)
Lt += size
Rt += size
while Lt < Rt:
if Lt & 1:
lazy[Lt] = lazy_f(lazy[Lt], (a, b))
Lt += 1
if Rt & 1:
Rt -= 1
lazy[Rt] = lazy_f(lazy[Rt], (a, b))
Lt >>= 1
Rt >>= 1
#クエリを実行
for _ in range(M):
Lt, Rt, X = map(int, input().split())
Lt -= 1
change(Lt, Rt, X)
#遅延を全部pushしてからクエリに回答
ans = [0] * N
for i in range(N):
push(i)
ans[i] = lazy[i + size][1]
print(*ans)
#ABC332F Random Update Query
#結局双対セグ木はソラで書けばよいため
#入力受取
N, M = map(int, input().split())
A = list(map(int, input().split()))
MOD = 998244353
#push機能付きの双対セグ木を書く
#遅延は(ax + b)の形で保持する
logN = (N - 1).bit_length()
size = 1 << logN
lazy = [(1, 0) for _ in range(2 * size)]
for i in range(N):
lazy[i + size] = (1, A[i] % MOD) #また除算忘れたせいで1ペナ しょうもな
def lazy_f(lazy1, lazy2):
a1, b1 = lazy1
a2, b2 = lazy2
return (a1 * a2 % MOD, (b1 * a2 + b2) % MOD)
def push(i):
i += size
for h in range(logN - 1, 0, -1):
j = i >> h
if lazy[j] != (1, 0):
Lt, Rt = j << 1, j << 1 | 1
lazy[Lt] = lazy_f(lazy[Lt], lazy[j])
lazy[Rt] = lazy_f(lazy[Rt], lazy[j])
lazy[j] = (1, 0)
def change(Lt, Rt, X):
diff = Rt - Lt
a = (diff - 1) * pow(diff, -1, MOD) % MOD
b = X * pow(diff, -1, MOD) % MOD
#区間[Lt, Rt)に(ax + b)を作用させる
push(Lt)
push(Rt)
Lt += size
Rt += size
while Lt < Rt:
if Lt & 1:
lazy[Lt] = lazy_f(lazy[Lt], (a, b))
Lt += 1
if Rt & 1:
Rt -= 1
lazy[Rt] = lazy_f(lazy[Rt], (a, b))
Lt >>= 1
Rt >>= 1
#クエリを実行
for _ in range(M):
Lt, Rt, X = map(int, input().split())
Lt -= 1
change(Lt, Rt, X)
#遅延を全部pushしてからクエリに回答
ans = [0] * N
for i in range(N):
push(i)
ans[i] = lazy[i + size][1]
print(*ans)
|
ConDefects/ConDefects/Code/abc332_f/Python/50678043
|
condefects-python_data_2695
|
import sys, io
import math, heapq, bisect
from collections import deque, defaultdict as ddict
from itertools import product
from typing import TypeVar, Callable, Sequence
TypeS = TypeVar('TypeS')
TypeT = TypeVar('TypeT')
class LazySegmentTreeInjectable:
def __init__(
self,
n: int,
operation: Callable[[TypeS, TypeS], TypeS],
mapping: Callable[[TypeS, TypeT, int], TypeS],
composition: Callable[[TypeT, TypeT], TypeT],
e_factory: Callable[[], TypeS],
id_factory: Callable[[], TypeT], ):
n2 = 1 << (n - 1).bit_length()
self.offset = n2
self.operation = operation
self.mapping = mapping
self.composition = composition
self.e_factory = e_factory
self.id_factory = id_factory
self.data = [e_factory() for _ in range(n2 << 1)]
self.lazy = [id_factory() for _ in range(n2 << 1)]
@classmethod
def from_array(
cls,
arr: Sequence[TypeS],
operation: Callable[[TypeS, TypeS], TypeS],
mapping: Callable[[TypeS, TypeT, int], TypeS],
composition: Callable[[TypeT, TypeT], TypeT],
e_factory: Callable[[], TypeS],
id_factory: Callable[[], TypeT], ):
ins = cls(len(arr), operation, mapping, composition, e_factory, id_factory)
data = ins.data
op = ins.operation
data[ins.offset:ins.offset + len(arr)] = arr
for i in range(ins.offset - 1, 0, -1):
l = i << 1
data[i] = op(data[l], data[l + 1])
return ins
def _propagate(self, i):
data = self.data
lazy = self.lazy
if i < self.offset:
l = i << 1
r = l + 1
lazy[l] = self.composition(lazy[l], lazy[i])
lazy[r] = self.composition(lazy[r], lazy[i])
k = self.offset >> (i.bit_length() - 1)
data[i] = self.mapping(data[i], lazy[i], k)
lazy[i] = self.id_factory()
def _recalculate(self, i):
if i >= self.offset:
return
l = i << 1
r = l + 1
k = self.offset >> i.bit_length()
l_dat = self.mapping(self.data[l], self.lazy[l], k)
r_dat = self.mapping(self.data[r], self.lazy[r], k)
self.data[i] = self.operation(l_dat, r_dat)
def _get_overhead_indices(self, l, r):
""" l, r are already added offset """
result = []
#kisuu ni naru made agatteiku kisuu no sono ikkoue wo sasu
l0 = (l // (l & -l)) >> 1
r0 = (r // (r & -r)) >> 1
while l0 != r0:
if l0 > r0:
result.append(l0)
l0 >>= 1
else:
result.append(r0)
r0 >>= 1
while l0:
result.append(l0)
l0 >>= 1
return result
def apply(self, l: int, r: int, x: TypeT):
lazy = self.lazy
cp = self.composition
l = max(0, l)
r = min(self.offset + 1, r)
l += self.offset
r += self.offset
#kodomo ga kawaru node no list (sita kara ue)
rc_indices = self._get_overhead_indices(l, r)
#kokohanakutemo ikeru (kakann)
#seiyaku toshite ue ni huruinowo yurusanai -> ueni kakono ga aru baai ha oroshite kuru
#"""
for i in reversed(rc_indices):
self._propagate(i)
#"""
while l < r:
if l & 1:
lazy[l] = cp(lazy[l], x)
l += 1
if r & 1:
r -= 1
lazy[r] = cp(lazy[r], x)
l >>= 1
r >>= 1
for i in rc_indices:
self._recalculate(i)
def query(self, l: int, r: int) -> TypeS:
data = self.data
lazy = self.lazy
op = self.operation
mp = self.mapping
l += self.offset
r += self.offset
rc_indices = self._get_overhead_indices(l, r)
for i in reversed(rc_indices):
self._propagate(i)
res_l = self.e_factory()
res_r = self.e_factory()
k = 1
#rikai (1~15, [9, 14)) de ez
while l < r:
if l & 1:
res_l = op(res_l, mp(data[l], lazy[l], k))
l += 1
if r & 1:
r -= 1
res_r = op(mp(data[r], lazy[r], k), res_r)
l >>= 1
r >>= 1
k <<= 1
return op(res_l, res_r)
def debug_print(self):
i = 1
while i <= self.offset:
print(self.data[i:2 * i])
i <<= 1
print('--------')
i = 1
while i <= self.offset:
print(self.lazy[i:2 * i])
i <<= 1
print()
inf = float("inf")
sys.setrecursionlimit(10**8)
DIV = 998244353
input=lambda: sys.stdin.readline().strip()
N, M = map(int, input().split())
A = list(map(int, input().split()))
def op(x, y):
if x is None:
return y
if y is None:
return x
return x
def mapping(x, f, k):
f, ff = f
if f is None:
return x
return (f * x + ff) % DIV
def create_f(l, r, x):
f = r - l + 1
return ((f - 1) * pow(f, -1, DIV)) % DIV, (x*pow(f, -1, DIV)) % DIV
def composition(f, g):
f, x = f
g, y = g
if f is None:
return g, y
if g is None:
return f, x
return (f*g) % DIV, (g*x + y) % DIV
def e_factory():
return None
def id_factory():
return None, None
lst = LazySegmentTreeInjectable.from_array(A, op, mapping, composition, e_factory, id_factory)
for _ in range(M):
l, r, x = map(int, input().split())
l -= 1
r -= 1
lst.apply(l, r+1, create_f(l, r, x))
print(*[lst.query(i, i+1) for i in range(N)])
import sys, io
import math, heapq, bisect
from collections import deque, defaultdict as ddict
from itertools import product
from typing import TypeVar, Callable, Sequence
TypeS = TypeVar('TypeS')
TypeT = TypeVar('TypeT')
class LazySegmentTreeInjectable:
def __init__(
self,
n: int,
operation: Callable[[TypeS, TypeS], TypeS],
mapping: Callable[[TypeS, TypeT, int], TypeS],
composition: Callable[[TypeT, TypeT], TypeT],
e_factory: Callable[[], TypeS],
id_factory: Callable[[], TypeT], ):
n2 = 1 << (n - 1).bit_length()
self.offset = n2
self.operation = operation
self.mapping = mapping
self.composition = composition
self.e_factory = e_factory
self.id_factory = id_factory
self.data = [e_factory() for _ in range(n2 << 1)]
self.lazy = [id_factory() for _ in range(n2 << 1)]
@classmethod
def from_array(
cls,
arr: Sequence[TypeS],
operation: Callable[[TypeS, TypeS], TypeS],
mapping: Callable[[TypeS, TypeT, int], TypeS],
composition: Callable[[TypeT, TypeT], TypeT],
e_factory: Callable[[], TypeS],
id_factory: Callable[[], TypeT], ):
ins = cls(len(arr), operation, mapping, composition, e_factory, id_factory)
data = ins.data
op = ins.operation
data[ins.offset:ins.offset + len(arr)] = arr
for i in range(ins.offset - 1, 0, -1):
l = i << 1
data[i] = op(data[l], data[l + 1])
return ins
def _propagate(self, i):
data = self.data
lazy = self.lazy
if i < self.offset:
l = i << 1
r = l + 1
lazy[l] = self.composition(lazy[l], lazy[i])
lazy[r] = self.composition(lazy[r], lazy[i])
k = self.offset >> (i.bit_length() - 1)
data[i] = self.mapping(data[i], lazy[i], k)
lazy[i] = self.id_factory()
def _recalculate(self, i):
if i >= self.offset:
return
l = i << 1
r = l + 1
k = self.offset >> i.bit_length()
l_dat = self.mapping(self.data[l], self.lazy[l], k)
r_dat = self.mapping(self.data[r], self.lazy[r], k)
self.data[i] = self.operation(l_dat, r_dat)
def _get_overhead_indices(self, l, r):
""" l, r are already added offset """
result = []
#kisuu ni naru made agatteiku kisuu no sono ikkoue wo sasu
l0 = (l // (l & -l)) >> 1
r0 = (r // (r & -r)) >> 1
while l0 != r0:
if l0 > r0:
result.append(l0)
l0 >>= 1
else:
result.append(r0)
r0 >>= 1
while l0:
result.append(l0)
l0 >>= 1
return result
def apply(self, l: int, r: int, x: TypeT):
lazy = self.lazy
cp = self.composition
l = max(0, l)
r = min(self.offset + 1, r)
l += self.offset
r += self.offset
#kodomo ga kawaru node no list (sita kara ue)
rc_indices = self._get_overhead_indices(l, r)
#kokohanakutemo ikeru (kakann)
#seiyaku toshite ue ni huruinowo yurusanai -> ueni kakono ga aru baai ha oroshite kuru
#"""
for i in reversed(rc_indices):
self._propagate(i)
#"""
while l < r:
if l & 1:
lazy[l] = cp(lazy[l], x)
l += 1
if r & 1:
r -= 1
lazy[r] = cp(lazy[r], x)
l >>= 1
r >>= 1
for i in rc_indices:
self._recalculate(i)
def query(self, l: int, r: int) -> TypeS:
data = self.data
lazy = self.lazy
op = self.operation
mp = self.mapping
l += self.offset
r += self.offset
rc_indices = self._get_overhead_indices(l, r)
for i in reversed(rc_indices):
self._propagate(i)
res_l = self.e_factory()
res_r = self.e_factory()
k = 1
#rikai (1~15, [9, 14)) de ez
while l < r:
if l & 1:
res_l = op(res_l, mp(data[l], lazy[l], k))
l += 1
if r & 1:
r -= 1
res_r = op(mp(data[r], lazy[r], k), res_r)
l >>= 1
r >>= 1
k <<= 1
return op(res_l, res_r)
def debug_print(self):
i = 1
while i <= self.offset:
print(self.data[i:2 * i])
i <<= 1
print('--------')
i = 1
while i <= self.offset:
print(self.lazy[i:2 * i])
i <<= 1
print()
inf = float("inf")
sys.setrecursionlimit(10**8)
DIV = 998244353
input=lambda: sys.stdin.readline().strip()
N, M = map(int, input().split())
A = list(map(int, input().split()))
def op(x, y):
if x is None:
return y
if y is None:
return x
return x
def mapping(x, f, k):
f, ff = f
if f is None:
return x
return (f * x + ff) % DIV
def create_f(l, r, x):
f = r - l + 1
return ((f - 1) * pow(f, -1, DIV)) % DIV, (x*pow(f, -1, DIV)) % DIV
def composition(f, g):
f, x = f
g, y = g
if f is None:
return g, y
if g is None:
return f, x
return (f*g) % DIV, (g*x + y) % DIV
def e_factory():
return None
def id_factory():
return None, None
lst = LazySegmentTreeInjectable.from_array(A, op, mapping, composition, e_factory, id_factory)
for _ in range(M):
l, r, x = map(int, input().split())
l -= 1
r -= 1
lst.apply(l, r+1, create_f(l, r, x))
print(*[lst.query(i, i+1)%DIV for i in range(N)])
|
ConDefects/ConDefects/Code/abc332_f/Python/51643425
|
condefects-python_data_2696
|
def find_unique_char_position(S):
# 最初の3文字をチェックして異なる文字を特定
if S[0] == S[1]:
common_char = S[0]
elif S[2] == S[1]:
common_char = S[1]
else :
return S[1]
# 異なる1文字の位置を特定
for i, char in enumerate(S):
if char != common_char:
return i + 1 # 1-based index
# 入力
S = input().strip()
# 異なる文字の位置を特定して出力
print(find_unique_char_position(S))
def find_unique_char_position(S):
# 最初の3文字をチェックして異なる文字を特定
if S[0] == S[1]:
common_char = S[0]
elif S[2] == S[1]:
common_char = S[1]
else :
return 2
# 異なる1文字の位置を特定
for i, char in enumerate(S):
if char != common_char:
return i + 1 # 1-based index
# 入力
S = input().strip()
# 異なる文字の位置を特定して出力
print(find_unique_char_position(S))
|
ConDefects/ConDefects/Code/abc342_a/Python/54737286
|
condefects-python_data_2697
|
S = input()
for i in range(len(S)-1):
if S[i-1] != S[i] and S[i] != S[i+1]:
print(i+1)
S = input()
for i in range(len(S)-1):
if S[i-1] != S[i] and S[i] != S[i+1]:
print(i+1)
exit()
print(len(S))
|
ConDefects/ConDefects/Code/abc342_a/Python/54672989
|
condefects-python_data_2698
|
S = input()
if S.count(S[0])==1:
print("1")
else:
for i in range(1, len(S)-1):
if S[i] != S[0]:
print(i+1)
S = input()
if S.count(S[0])==1:
print("1")
else:
for i in range(1, len(S)):
if S[i] != S[0]:
print(i+1)
|
ConDefects/ConDefects/Code/abc342_a/Python/54772316
|
condefects-python_data_2699
|
s= input()
if s.count(s[0])==1:
print(0)
else:
for i in range(1,len(s)):
if s[0] != s[i]:
print(i+1)
s= input()
if s.count(s[0])==1:
print(1)
else:
for i in range(1,len(s)):
if s[0] != s[i]:
print(i+1)
|
ConDefects/ConDefects/Code/abc342_a/Python/54911256
|
condefects-python_data_2700
|
N,S,K = map(int,input().split())
x = 0
for i in range (N):
P,Q = map(int,input().split())
x += P*Q
if S >= x:
x += K
print(x)
N,S,K = map(int,input().split())
x = 0
for i in range (N):
P,Q = map(int,input().split())
x += P*Q
if S > x:
x += K
print(x)
|
ConDefects/ConDefects/Code/abc332_a/Python/55010620
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.