076 - Cake Cut（★3）

尺取り法のめも

import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int,input().split()))
s = sum(a)/10
a += a

now = [0,0]
f = False
for i in a:
  if now[0] < s:
    now[0] += i
  elif now[0] == s:
    f = True
    break
  else:
    v = now[1]
    for j in range(v,2*n):
      now[0] -= a[j]
      now[1] += 1
      if now[0] == s:
        f = True
        break
      elif now[0] < s:
        break
    now[0] += i
    
  #print(now)
  
if f:
  print('Yes')
else:
  print('No')

063 - Monochromatic Subgrid（★4）(python)

bit全探索、横の列を固定して、縦ごとに見る、defaultdict の操作、などのメモ

import sys
input = sys.stdin.readline
from collections import deque, defaultdict

h,w = map(int,input().split())
s = [list(map(int,input().split())) for i in range(h)]

ans = 0
for i in range(1,2**h):
  chk = []
  ok = defaultdict(int)
  ok[-1] = 1
  cnt = 0
  for j in range(h):
    if i>>j&1 == 1:
      chk.append(j)
      cnt += 1
  for x in range(w):
    ss = s[chk[0]][x]
    flag = True 
    for j in chk:
      if s[j][x] != ss:
        flag = False
        break
    if flag:
      ok[ss] += cnt 
  ans = max(ans, max(ok.values()))
  
print(ans)

K - Range Affine Range Sum (python)

"""
query_0 が Σ A[i] (l≤i≤r-1) を出力
query_1 が l≤i≤r-1 について A[i] を A[i]*b + c に更新する

X[l,r): Σ A[l,r)
lazy[i] (更新を保存しておく配列) の２つの配列をもち、

・op_data: X＊X →X (X[l≤i<r] から X[l,r) を求める）
・op_lazy: lazy＊lazy→lazy (lazy[i] を更新）
・op_merge: X＊lazy→X (lazy[i] を使って X[l,r) を更新、この時 l≤i<r について lazy[i] は全て同じ更新をしたと考える）

の3式と X と lazy の単位元が求まればライブラリにぶち込んで終わり。

query_0 より op_data は X[l,r) =X[l,m) + X[m,r) とすればよく、
query_1 については A[i] に query_1 を２回作用させると
A'[i] = A[i]*b1+c1
A”[i] = A'[i]*b2+c2 = A[i] * b2*b1 + c1*b2+c2 となるので
op_lazy は、lazy_old[i] = (b1,c1), 更新クエリ = (b2,c2) とすると、
lazy_new[i] =   (b2*b1, c1*b2+c2) とすればよい。

また、lazy[i] = (b,c) とすると、op_merge は
Σ X'[l,r)  = Σ X[l,r) * b + c * len[l,r) で計算できる

またこのとき、X の単位元 u_data は X[i] + u_data = x[i] より u_data = 0
M の単位元 u_lazy は X[i] * b + c = X[i] より u_lazy(b,c) = (1,0)
"""

import sys
input = sys.stdin.buffer.readline
# sys.setrecursionlimit(10 ** 7)
mod = 998244353


class SegTree(object):
    def __init__(self, N, op_data, u_data):
        self._n = N
        self.log = (N-1).bit_length()
        self.size = 1 << self.log

        self.op = op_data
        self.e = u_data

        self.data = [u_data] * (2 * self.size)
        self.len = [1] * (2 * self.size)

    def _update(self, i):
        self.data[i] = self.op(self.data[i << 1], self.data[i << 1 | 1])

    def initialize(self, arr):
        """ segtreeをarrで初期化する。len(arr) == Nにすること """
        for i, a in enumerate(arr, self.size):
            self.data[i] = a
        for i in reversed(range(1, self.size)):
            self._update(i)
            self.len[i] = self.len[i << 1] + self.len[i << 1 | 1]

    def update(self, p, x):
        """ data[p] = x とする (0-indexed)"""
        p += self.size
        self.data[p] = x
        for i in range(1, self.log + 1):
            self._update(p >> i)

    def get(self, p):
        """ data[p]を返す """
        return self.data[p + self.size]

    def prod(self, l, r):
        """
        op_data(data[l], data[l+1], ..., data[r-1])を返す (0-indexed)
        """
        sml = self.e
        smr = self.e
        l += self.size
        r += self.size

        while l < r:
            if l & 1:
                sml = self.op(sml, self.data[l])
                l += 1
            if r & 1:
                r -= 1
                smr = self.op(self.data[r], smr)
            l >>= 1
            r >>= 1
        return self.op(sml, smr)

    def all_prod(self):
        """ op(data[0], data[1], ... data[N-1])を返す """
        return self.data[1]

class LazySegTree(SegTree):
    def __init__(self, N, op_data, u_data, op_lazy, u_lazy, op_merge):
        super().__init__(N, op_data, u_data)
        self.composition = op_lazy
        self.mapping = op_merge
        self.id = u_lazy

        self.lazy = [u_lazy] * self.size

    def _all_apply(self, i, F):
        self.data[i] = self.mapping(F, self.data[i], self.len[i])
        if i < self.size:
            self.lazy[i] = self.composition(F, self.lazy[i])

    def _push(self, i):
        self._all_apply(i << 1, self.lazy[i])
        self._all_apply(i << 1 | 1, self.lazy[i])
        self.lazy[i] = self.id

    def update(self, p, x):
        """ data[p] = x とする (0-indexed)"""
        p += self.size
        for i in reversed(range(1, self.log + 1)):
            self._push(p >> i)
        self.data[p] = x
        for i in range(1, self.log + 1):
            self._update(p >> i)

    def apply(self, p, F):
        """ data[p]にFを作用させる(data[p] = op_merge(F, data[p])とする, 0-indexed) """
        p += self.size
        for i in reversed(range(1, self.log + 1)):
            self._push(p >> i)
        self.data[p] = self.mapping(F, self.data[p], self.len[p])
        for i in range(1, self.log + 1):
            self._update(p >> i)

    def range_apply(self, l, r, F):
        """ i = l, l+1, ..., r-1 について、Fを作用させる(op_merge(F, data[i]), 0-indexed) """
        if l == r:
            return

        l += self.size
        r += self.size
        for i in reversed(range(1, self.log + 1)):  # too->down
            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 get(self, p):
        """ data[p]を返す """
        p += self.size
        for i in reversed(range(1, self.log + 1)):
            self._push(p >> i)
        return self.data[p]

    def prod(self, l, r):
        """
        op_data(data[l], data[l+1], ..., data[r-1])を返す (0-indexed)
        l == rの時は単位元u_dataを返す
        """
        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 >> i)

        sml = self.e
        smr = self.e
        while l < r:
            if l & 1:
                sml = self.op(sml, self.data[l])
                l += 1
            if r & 1:
                r -= 1
                smr = self.op(self.data[r], smr)
            l >>= 1
            r >>= 1
        return self.op(sml, smr)

    def max_right(self, l, func):
        """
        func(l, l+1, ..., r-1) = True,
        func(l, l+1, ..., r-1, r) = Falseとなる r を返す
        """
        if l == self._n:
            return self._n
        l += 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 func(self.op(sm, self.data[[l]])):
                while l < self.size:
                    self._push(l)
                    l <<= 1
                    if func(self.op(sm, self.data[l])):
                        sm = self.op(sm, self.data[l])
                        l += 1
                return l - self.size
            sm = self.op(sm, self.data[l])
            l += 1
            if (l & -l) == l:
                break
        return self._n

    def min_left(self, r, func):
        """
        func(     l, l+1, ..., r-1) = True,
        func(l-1, l, l+1, ..., r-1) = Falseとなる l を返す
        """
        if r == 0:
            return 0
        r += 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 & 1:
                r >>= 1
            if not func(self.op(self.data[r], sm)):
                while r < self.size:
                    self._push(r)
                    r = r << 1 | 1
                    if func(self.op(self.data[r], sm)):
                        sm = self.op(self.data[r], sm)
                        r -= 1
                return r + 1 - self.size
            sm = self.op(self.data[r], sm)
            if (r & -r) == r:
                break
        return 0
      
u_data = 0 # data の単位元
u_lazy = (1, 0) # lazy の単位元

def op_data(l, r): # d_Lとd_Rの二項演算, dataを返す
    return (l + r) % mod

def op_lazy(new, old): # lz_oidにlz_newを作用させる, lazyを返す
    return new[0] * old[0] % mod, (old[1] * new[0] + new[1]) % mod

def op_merge(lz, d, size): # dにlzを作用させる, dataを返す
    b, c = lz
    return (b * d + size * c) % mod


N, Q = map(int, input().split())
A = list(map(int, input().split()))
seg = LazySegTree(N, op_data, u_data, op_lazy, u_lazy, op_merge)
seg.initialize(A) # A を遅延セグ木化

for _ in range(Q):
    k, *arg = map(int, input().split())
    if k == 0:
        l, r, b, c = arg
        seg.range_apply(l, r, (b, c))
    else:
        l, r = arg
        print(seg.prod(l, r))

AGC 010 B - Boxes (python)

数列から等差数列を引いていって [0]*n にできるかを答える問題
n = 5 の場合、引く候補は [1,2,3,4,5], [2,3,4,5,1], [3,4,5,1,2], [4,5,1,2,3], [5,1,2,3,4] の 5 つあるが、
どれも総和は 15 であり、引ける回数 k は sum(a) // 15 になる
引いた後の遷移について考えると、等差数列を引くときは元の数列の隣り合う差を考えると上手くいくことがある。
D[i] = A[i+1] - A[i] とすると、D[i] は一回等差数列を引くごとに、１減るか、n-1増える。
よって k 回操作を行い m 回 n-1 増える場合、D[i] = D[i] - k + m*n となる
よってこの問題の必要十分条件は、全ての D[i] について D[i] - k % n = 0 かつ D[i] - k ≤ 0 かつ Σ m ≤ k となる

n = int(input())
a = list(map(int,input().split()))
d = []
for i in range(n-1):
  d.append(a[i+1]-a[i])
  
f = True
if sum(a) % (n*(n+1)//2) != 0:
  f = False
  k = 0
else:
  k = sum(a)//(n*(n+1)//2)
  
cnt = 0
for i in d:
  j = i-k
  if j > 0 or j % n != 0:
    f = False
  else:
    cnt -= j//n
    
if cnt > k:
  f = False
  
if f:
  print('YES')
else:
  print('NO')

abc 188 F - +1-1x2 (python)

気づくこと
一回でも x を操作する途中で２倍した後は、二回連続で +1, -1 を使わない。
理由
p 回 +1 した後に、２倍して q 回 +1 すると、
(x + p)*2 + q = 2x + 2*p + q
q ≧ 2 のとき 2x + 2*p + q = 2x + 2*p + 2*s + t(s ≧１, t は 0 or 1) となり
p + s 回 +1 してから２倍して 0 または 1 回 +1 した方が
p + s + t < p + 2*s + t = p + q となるので少ない回数で同じ結果を得ることができる。

そこで Y から X を作ることを考える。そうすると考察から、
Y から X を作る時の最適な操作は、
X : 偶数　X → X/2 (x' とする)
X : 奇数　X → X+1 or X-1 → (X+1)/2 or (X-1)/2 (x' とする)
という操作で X から x' を作り、また x' を X と操作することを繰り返し、最後の÷２の操作の後は、|Y-x'| 回 +1 か -1 を適当に行えば求まる。

よって f (y) : y から X を作るのにかかる最小回数とすれば、
f (y) = min( f(y+1/2)+2, f(y-1/2)+2, |y-X| )　y : 奇数のとき
f (y) = min( f(y/2)+1, |y-X| ) y : 偶数のとき
のように遷移する
あとは終了条件に y = 1 のときを書いておいたらおわり。

import sys
sys.setrecursionlimit(10**7)
from functools import lru_cache
X,Y = map(int,input().split())

@lru_cache(maxsize=None)
def f(y):
  global X
  if y == 1:
      return abs(1-X)
  elif y%2 == 1:
    return min(f((y+1)//2)+2,f((y-1)//2)+2,abs(y-X))
  else:
    return min(f(y//2)+1,abs(y-X))    
            
print(f(Y))

abc 184 D - increment of coins (python)

期待値でも遷移さえわかれば dp で求まるというやつ。
dp と メモ化再帰の両方で解いてみた。

a,b,c = map(int,input().split())
dp = [[[0]*101 for _ in range(101)] for i in range(101)]
for i in range(100,a-1,-1):
  for j in range(100,b-1,-1):
    for k in range(100,c-1,-1):
      if i == 100 or j == 100 or k == 100:
        continue
      else:
        dp[i][j][k] = (dp[i+1][j][k]+1)*i/(i+j+k)\
                    + (dp[i][j+1][k]+1)*j/(i+j+k)\
                    + (dp[i][j][k+1]+1)*k/(i+j+k)\
            
      
print(dp[a][b][c])

import sys
sys.setrecursionlimit(10**7)
from functools import lru_cache
a,b,c = map(int,input().split())

@lru_cache(maxsize=None)
def f(i,j,k):
    if i == 100 or j == 100 or k == 100:
        return 0
    return (f(i+1,j,k)+1)*i/(i+j+k)\
          +(f(i,j+1,k)+1)*j/(i+j+k)\
          +(f(i,j,k+1)+1)*k/(i+j+k)\
            
print(f(a,b,c))

abc 184 E - Third Avenue (python)

久しぶりに bfs やら ord を書いたのでメモ。

import sys
input = sys.stdin.readline
h,w = map(int,input().split())
s = [list(input().rstrip()) for i in range(h)]
to = [[] for i in range(26)]
for i in range(h):
  for j in range(w):
    if 96 < ord(s[i][j]) < 124:
      to[ord(s[i][j])-97].append((i,j))
    if s[i][j] == 'S':
      sh = i; sw = j
    if s[i][j] == 'G':
      gh = i; gw = j
      
dh = [1, 0, -1, 0]
dw = [0, 1, 0, -1]
d = [[4*10**6]*w for i in range(h)]

from collections import deque

que = deque()
que.append((sh,sw,0))
d[sh][sw] = 0
while que:
    y,x,p = que.popleft()
    #print(y,x,p)
    if s[y][x] == 'G':
      break
    for i in range(4):
      nw = x + dw[i]
      nh = y + dh[i]

      if 0 <= nw < w and 0 <= nh < h and d[nh][nw] > p+1:
        if s[nh][nw] == "." or s[nh][nw] == "G":
          que.append((nh,nw,p+1))
          d[nh][nw] = p+1
        
      if 0 <= nw < w and 0 <= nh < h and 96 < ord(s[nh][nw]) < 124 and d[nh][nw] > p+1:
        d[nh][nw] = p+1
        que.append((nh,nw,p+1))
        for hh,ww in to[ord(s[nh][nw])-97]:
          if d[hh][ww] > p+2:
            que.append((hh,ww,p+2))
            d[hh][ww] = p+2
        to[ord(s[nh][nw])-97] = []
        
        
#print(d)
if d[gh][gw] == 4*10**6:
  print(-1)
else:
  print(d[gh][gw])