最近Pythonを勉強しはじめました。本を読み続けてページが進んでいくと充実感があるのですが、本を読んでるだけでは実は何も身についてないという厳しい現実に対して危機感があり、適度に課題を見つけて実践しようと努力しています。勉強が進んでないような焦りも感じますが、そうした中でしか得られない発見があると言い聞かせています。

「Wordleをやっててふと思いついた問題をPythonで解く」という記事は、そんな取り組みの1つです。この記事を書いたときに、noteの他のプログラミング記事をいろいろ読んでいると、AtCoderをやっている人が結構いて興味がわき、AtCoder Beginner Contest 266に初めて参加してみました。勉強になったので、自分のためという性質が強いですが、メモを書きます。今後参加したときもこの記事に追記していきます。上記、Wordleの記事で処理時間の長いプログラムを書きましたが、AtCoderをやっているうちに、一瞬で処理できるアルゴリズムが見つかるのではないかと思えてきて、探しています。

AtCoder Beginner Contest 266

時間内に正解したのはA、B、C、Eの4問でした。Aの時点で10分かかり、type(4/2)の結果が、<class 'float'>だったのがまず勉強になりました。Cまで正解したあと、Dの問題文を読んでおもしろい問題のように感じましたが、全く解き方の見当がつかず、あきらめてEに進むとEはすぐに解けました。Dが400点でEが500点なので、Eの方が難易度が高いのでしょうか？その後Fのコードを書いているときに制限時間となりました。G、Exはまだ問題も読んでいませんが、問題も理解できないかも知れません。

D - Snuke Panic (1D)

問題を読んでおもしろそうだと思い、なんとかしたかったですが、残念ながら全く解き方の見当がつきませんでした。解説を読むと動的計画法（Dynamic Programming, DP）と書いてあり、発想に驚きました。この問題を見るまで、でかい配列を作ってしまっていい（作らなくてもいいですが）という考えが、ぼくにはありませんでした。DPを知ると確かに簡単かもしれません。DPの他のパターンもいろいろ勉強しておきたいです。 2022-08-27

n = int(input())
t_max = 10**5
dp = [[-10**10]*5 for _ in range(t_max+1)]
sunuke = [[0]*5 for _ in range(t_max+1)]
t_last = 1
for _ in range(n):
    t, x, a = map(int, input().split())
    sunuke[t][x] = a
    if t > t_last:
        t_last = t
dp[0][0] = 0
for t in range(1,t_last+1):
    for x in range(5):
        dp[t][x] = dp[t-1][x]
        if x < 4 and dp[t-1][x+1] > dp[t][x]:
            dp[t][x] = dp[t-1][x+1]
        if x > 0 and dp[t-1][x-1] > dp[t][x]:
            dp[t][x] = dp[t-1][x-1]
        dp[t][x] += sunuke[t][x]
print(max(dp[t]))

追記1。問題Exを読んだところ、すぬけ君の出現領域がでかすぎて全領域メモリ確保は無理だったのでここに戻ってきました。最初にメモリ確保せず、すぬけくんの出現位置での情報だけで解いてみます。時間tに影響するのはt-3以降の影響があるものと、t-4以前の最大値という考え方で解きました。実行時間とメモリ使用量の最大値が242ms/103152KBから280ms/114388KBに増えたのが気になります（あれ？）が、全領域でDPやらなくても正常に動作しました。コードも上のよりスッキリしないですが、すぬけ君出現位置だけに注目して解ける感覚は得られました。問題Exに戻る。 2022-08-31

n = int(input())
sunuke = {}
bests = {}
ts = []
for _ in range(n):
    t, x, a = map(int, input().split())
    if x > t:
        continue
    sunuke[t] = (x, a)
    bests[t] = [0,0] # best at sunuke point and best so far
    ts.append(t)
best_so_far = 0
for i in range(len(ts)):
    j = i - 1
    max_effect = 0
    while j >= 0 and ts[j] > ts[i] - 4:
        if ts[i] - ts[j] >= sunuke[ts[j]][0] - sunuke[ts[i]][0] >= ts[j] - ts[i]:
            if bests[ts[j]][0] > max_effect:
                max_effect = bests[ts[j]][0]
        j -= 1
    if j >= 0 and bests[ts[j]][1] > max_effect:
        max_effect = bests[ts[j]][1]
    bests[ts[i]][0] = max_effect + sunuke[ts[i]][1]
    if bests[ts[i]][0] > best_so_far:
        best_so_far = bests[ts[i]][0]
    bests[ts[i]][1] = best_so_far
print(best_so_far)

F - Well-defined Path Queries on a Namori

xからyに行く単純パスが一意に定まるか？という問題。最初、xから同じ頂点を通らないルートを全探索して、2通り見つかった時点でNoとするコードを書いていましたが、当然それでは実行時間制限3秒に収まらずNGでした。グラフに関する数学的な知識を前提に解く必要があります。解説によるとN頂点N辺の連結なグラフのことを「なもりグラフ」といい、閉路が必ず1つのグラフになるそうです。なぜ閉路が1つになるのか考えてみました。3頂点では明らかに閉路1つです。N頂点で閉路0のグラフを作れたとすると、その枝の先の頂点と辺を除くことでN-1頂点で閉路0のグラフを作れることになり、3角形が閉路1つであることと矛盾します。閉路2つの場合については、枝があれば閉路0の場合と同じロジックで説明でき、枝がなければグラフは閉路2つだけとなり、連結であることに矛盾します。ということで、この問題の条件は「なもりグラフ」であることなので、1つの閉路とそこから木が生えた構造であり、同じ木に属する頂点同士は単純パスが一意に定まり、そうでなければ定まらないです。このような問題が出題されるのであれば、グラフ関連のこともいろいろ勉強しておきたいです。しかし「N頂点N辺の連結なグラフ」という前提条件が恣意的な感じもしてしまいますが、現実世界でよくあるのでしょうか？ 2022-08-28

グラフの問題を見直しているので久しぶりにやってみたら、難しかった。巡回路ノータッチで、サブツリーの部分を検出してやる。しかし処理速度が他の人より遅いのが気になるな。みんなどうやってんだろう？ぼくの提出は1826msから1506msになっただけ。この時から経験積んだからこなれたかもしれないけど、処理内容あまり変わってない？ 2022-12-17

N = int(input())
g = [set() for _ in range(N)]
for _ in range(N):
    u, v = map(int, input().split())
    g[u-1].add(v-1)
    g[v-1].add(u-1)
leaves = []
for i in range(N):
    if len(g[i]) == 1:
        leaves.append(i)
subtrees = {}
for leaf in leaves:
    cur = leaf
    v_subtree = set()
    while len(g[cur]) == 1:
        v_subtree.add(cur)
        next = g[cur].pop()
        if next in subtrees:
            v_subtree |= subtrees[next]
            subtrees.pop(next)
        g[next].remove(cur)
        cur = next
    v_subtree.add(cur)
    subtrees[cur] = v_subtree
sub = [-1]*N
for root, vs in subtrees.items():
    for v in vs:
        sub[v] = root
Q = int(input())
for _ in range(Q):
    x, y = map(int, input().split())
    if sub[x-1] != -1 and sub[x-1] == sub[y-1]:
        print('Yes')
    else:
        print('No')

G - Yet Another RGB Sequence

ついに、問題Gを解説を見ずに自力でACできました！比較的易しい問題ではありましたが、それでも今後の意識の変化につながる大きな一歩です。実は直前にABC267 Gで「挿入DP」を学んだ直後で、「数列に挿入していく」という見方が身についていたため、ぼくの頭が、この問題の解き方を思いつきやすい状態になっていた可能性はあります。DPかなと思わせてDPではありませんでしたが、ちゃんとひらめくことができました。しかもPythonでの提出が160くらいあって、処理速度が5位でした。高速化のノウハウが身についてきているのでしょうか？RGをKで置き換えると、まず、K、B、Rを並べたあとで、Rの後ろ以外にGを挿入すればよいことがわかります。最近、過去に参加したABCのGまでの問題を埋めていってたのですが、この問題が最後でした。 2022-12-16

M = 998244353
R, G, B, K = map(int, input().split())
R -= K
G -= K
N = max(K+B+R, K+B+G)
fact = [0]*(N+1)
invfact = [0]*(N+1)
fact[0] = 1
for i in range(1, N+1):
    fact[i] = fact[i-1] * i % M
invfact[N] = pow(fact[N], M-2, M)
for i in range(N-1, 0, -1):
    invfact[i] = invfact[i+1] * (i+1) % M
invfact[0] = 1
def choose(n, r):
    return fact[n] * invfact[r] * invfact[n-r] % M
ans = choose(K+B+R, K)
ans *= choose(B+R, B)
ans %= M
ans *= choose(K+B+G, G)
ans %= M
print(ans)

Ex - Snuke Panic (2D)

問題Dの2D版ということでおもしろそうです。問題読みましたが、問題Dで学んだDPが使えない。すぬけ君の出現範囲が問題Dでは5x10^5だったのに対し、Exでは10^9x10^9x10^9、全領域のメモリ確保できません。ですよねぇ。Dの解法でも気になってたポイントなので。ひとまず、問題Dに戻り、すぬけ君の位置だけの情報で解くプログラムを作ってからExに戻ってきます。この問題はそれだけでは済まないですが。一旦問題Dに戻る。 2022-08-31

問題Dから戻ってきました。別の解き方をしたことで、全領域メモリ確保せずにすぬけ君の位置だけに注目して解く考え方がわかりました。現在のすぬけ君の位置でのポイントの最大値を求めるには、その位置に到達しうるすぬけ君の位置全部の最大値+現在のすぬけ君の大きさを求めればよいです。問題Dでは出現範囲が5しかないので4秒以上前のすぬけ君全部の影響を受けることになり、4秒以上前の最大値を順次更新していけば解けましたが、問題Exは出現領域が広すぎて単純化できません。かと言って他のすぬけ君の位置全部に対して影響するかどうか調べているとそれだけでO(N^2)になってしまいます。解説を見ると2次元セグメントツリーという言葉が書いてありましたので、セグメントツリーについて勉強しました。なるほど、2分木を使うことで範囲の最大値の更新も取り出しもO(log(N))ででき、感動です。これを2次元にするというのは、イメージするのに苦労します。2次元でO(log(N)^2)で取り出せます。しかしメモリがN^2になってしまうなら結局解けねぇじゃねぇかという疑問が残ります。これ、データが入ってるところだけ確保することでN log(N)^2になるとの説明。確かに辞書を使えばできるので感動モノです。そこまで理解しても、すぬけ君の位置はtもあり、3次元領域なのでどうやって解けばいいかわからず、解説を見ました。(t, x, y) -> (a=t-x-y, b=t+x-y, y) と座標変換することで、aとbとyの値がすべて現在のすぬけ君以下のものの影響を受ける、と言い換えることができます。2次元セグメントツリーなどの高速アルゴリズムを知っている場合、この座標変換の方が問題を解くときの肝になりそうです。解説では不等式を変形していってaとbにたどり着いていますが、影響を受けるすぬけ君の位置と影響を受けない位置の境界において、t-x-yとt+x-yは一定となるため、意味的に考えてもしっくり来る変換です。でも機械的に式を変形して導けた方が良いようにも思います。実装するにあたり、解説のC++実装例を参考にしました。何日も気になって考えていたら疲れており、何かで行き詰まったときに参考にできるコードがないと、がんばるエネルギーがもう残ってないです。読み始めて気づいたんですが、これセグメントツリーじゃないです。まず、サイズがnで変だなと思いました。セグメントツリーならサイズ2nになるはず。あとx&-xというなぞのビット演算。フェニック木（Binary Indexed Tree、BIT）というものでした。x&-xは最下位ビットを取り出す処理になります。なぜそうなるかというと、x+(-x)が0になるということは、xと-xは最下位ビットが同じで、それより上位のビットは全部逆になるからですね。これを足したり引いたりしていますが原理がわかるとすごいです。作った人、定式化した時に興奮したんじゃないかなと感じました。自分でBITを実装するときは1から7くらいまでバイナリ表現で紙に書いてみるといつでも思い出せます。最初に作ったバージョンは制限時間の5秒を0.5秒くらいオーバーしました。もう改善できるところないよ、Pythonでは無理なのか？とあきらめかけましたが、defaultdictやsetdefaultを使っているところで、いらないノードを追加してしまっていることに気づき（！）if文やgetに変更して無事正解しました。BIT.set、BIT.prod、BIT2D.set、BIT2D.prodの中でsetdefaultやgetやif分岐を使い分けているところです。不十分な検討でむやみにdefaultdictとかsetdefaultとか使ってしまっていたことがわかり、勉強になりました。 2022-09-03

class BIT():
    def __init__(self, n):
        self.n = n
        self.maxima = {}
    def set(self, i, input):
        while i <= self.n:
            if input > self.maxima.setdefault(i, 0):
                self.maxima[i] = input
            i += i&-i
    def prod(self, i):
        res = 0
        while i > 0:
            if self.maxima.get(i, 0) > res:
                res = self.maxima[i]
            i -= i&-i
        return res
class BIT2D():
    def __init__(self, n, m):
        self.n = n
        self.m = m
        self.bits = {}
    def set(self, i, j, input):
        while i <= self.n:
            if i in self.bits:
                if input > self.bits[i].prod(j):
                    self.bits[i].set(j, input)
            else:
                self.bits[i] = BIT(self.m)
                self.bits[i].set(j, input)
            i += i&-i
    def prod(self, i, j):
        res = 0
        while i > 0:
            if i in self.bits:
                max1d = self.bits[i].prod(j)
                if max1d > res:
                    res = max1d
            i -= i&-i
        return res

n = int(input())
sunuke = []
pset = set()
qset = set()
for _ in range(n):
    t, x, y, a = map(int, input().split())
    if t >= x + y:
        p = t-x-y
        q = t+x-y
        sunuke.append((y, t, p, q, a))
        pset.add(p)
        qset.add(q)
pmap = {p:i+1 for i, p in enumerate(sorted(pset))}
qmap = {q:i+1 for i, q in enumerate(sorted(qset))}
sunuke.sort(key=lambda x: (x[0], x[1]))
pnum = len(pset)
qnum = len(qset)
bit2d = BIT2D(pnum, qnum)
for item in sunuke:
    p_compress = pmap[item[2]]
    q_compress = qmap[item[3]]
    max_pq = bit2d.prod(p_compress, q_compress)
    bit2d.set(p_compress, q_compress, max_pq + item[4])
print(bit2d.prod(pnum, qnum))

2次元セグメント木でもやっておきたいと気になっていたので、作ってみましたが、半分のテストケースで時間制限をクリアできません。厳しいですねぇ。いろいろ手を打ったけど、これ以上どこを改善できるのか？ただ、トライすることで、いろいろ気づきがあります。フェニック木は1から始まってたけど、このセグメント木は0からだなぁとか、無駄な処理いっぱいしてたなぁとか、デフォルト値は何かな？とか、更新するときに必ず更新するか、変更が入るときだけ更新するかみたいなのは問題によって変わるのかなぁとか。そういうことを考えているとライブラリーを使うってのも、何も考えずに適用できるわけではなく、問題に合わせて設定を変えたりする必要があって、なかなかむずかしいと認識しました。ACしないと意味ないですね。このコードでは、時間制限に引っかかってACできていないです。なんとかしたいけど、ここは一旦あきらめます。 2022-09-26

ABC283 Fをやっていて、初めてセグメントツリーで1問ACできた中で、改善点が見つかったので、ちょっと2次元セグメントツリーでのAC可能性でてきた？と思い修正してみました。再帰呼び出しをスタックに変更したり、無駄に子要素両方のmax値を計算し直していたのをやめたりしました。ていうか昔書いたコードってだめなところ見つかるもので、学習が進んでる証拠なのでいいですね。上にコピペしていたコードは問題があったので、コードは消して、提出リンクに変更しました。ていうか9月26日って始めてから1ヶ月のころです。それにしてはがんばっていて、時間間隔が変に感じます。が、確かに若干スピードアップしたものの、TLEx19がTLEx16になったに過ぎませんでした。正しく動いてそうなのは喜ばしいことですが。他のPythonでACしてる人の中で、フェニック木ではなくセグメントツリーを使っている人たちは、なぜか2次元部分を領域木というもので実装していそうです。領域木に秘密がありそうなので、領域木というものを別途学ぶ必要がありそうです。 2023-01-09

その後、ABC285 Fを通じて、さらにqueryの処理を改善し、またこの問題のTLE解消を期待しましたが、処理速度は速くなったものの、TLEの数は減りませんでした。 2023-01-16

AtCoder Beginner Contest 267

直前まで266のExをやってて頭が死んでる状態で、悩みましたが参加。A、B、Cまで解いて、Dがわかりませんでした。解説を見て驚愕。前回と同じでDPに持ち込む問題でしたがそのように見えてませんでした。まずは4問解くのが目標になりそうです。勉強になるのでおもしろいしやりたいけど、他の生活もあるので、続けてたらたぶん頭と体がもたないです。ある程度のレベルに達したらそんなことないのでしょうが。

B - Split?

問題がビットフラグで書かれていると影響受けます。 2022-09-04

D - Index × A(Not Continuous ver.)

ABC 266 Dと同じでDPで解ける問題と解説で知りましたが、気づきませんでした。こういった問題をDPに持ち込める頭になる必要がありそうです。あと負数もありうるということのあつかいは要注意でした。0と比較して0を最大値として採用してしまってバグりました。 2022-09-04

n, m = map(int, input().split())
a = [0]
a.extend(list(map(int, input().split())))
dp = [[-10**12]*(m+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(1,n+1):
    dp[i][0] = 0
    for j in range(max(1, m-n+i), min(i+1, m+1)):
        dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + j * a[i])
print(dp[n][m])

E - Erasing Vertices 2

解説に、「「現時点でコストが最も低い頂点に対して操作を行う」を N回繰り返すのが最適であることがわかります」と書かれています。頂点を全部消さないといけないし、操作のたびに他の頂点に対する操作のコストはどんどん減っていくだけなので、言われてみると当たり前なのですが、これにすぐ気づけません。こういったことに短時間で気づけるにはどのように頭を使えばよいのでしょうか？とりあえず問題文にグラフと書かれているからと言ってなにか複雑な理論が必要だとは思い込まないようにします。そしてプライオリティーキューというものが使われていました。Pythonではheapqというライブラリになっています。ヒープ領域のヒープと全く関係なく、ヒープ木を使うアルゴリズムとのことです。最小のものをO(1)で取り出すことができますが、最小以外の要素に簡単に操作ができません。そこで、同じ頂点の以前登録した情報を残したまま、コストが小さくなった頂点の情報を、どんどんプライオリティーキューに追加していってます。そして頂点を消したかどうかは別のところで管理しておき、heapqからすでに消した頂点が取れたときは無視するという方法を取っています。コードだけ見ると「あれ？」と思いましたが理由があるんですね。理由があるにせよ、古くなった情報はキューから消さねば…という思い込みがあるので、これでいいんだ！というのは頭を刺激されました。 2022-09-04

import heapq
from collections import defaultdict
n, m = map(int, input().split())
a = tuple(map(int, input().split()))
removed = [False for _ in range(len(a))]
nexts = defaultdict(set)
costs = defaultdict(int)
for _ in range(m):
    u, v = map(int, input().split())
    iu = u-1
    iv = v-1
    nexts[iu].add(iv)
    nexts[iv].add(iu)
    costs[iu] += a[iv]
    costs[iv] += a[iu]
pq = [(item[1],item[0]) for item in costs.items()]
heapq.heapify(pq)
maxcost = 0
while pq:
    item = heapq.heappop(pq)
    id = item[1]
    if removed[id]:
        continue
    if item[0] > maxcost:
        maxcost = item[0]
    for next in nexts[id]:
        nexts[next].remove(id)
        costs[next] -= a[id]
        heapq.heappush(pq, (costs[next],next))
    nexts.pop(id)
    removed[id] = True
print(maxcost)

F - Exactly K Steps

この問題、むずかしいと思うのですが、自力で解くことができました。ABC281、ABC268に続いて問題Fを自力で解けたのは3回目です。それが3日以内に急に起きているので、力がついてきたのではないか？とうれしいです。ぼくはグラフ理論における、木の直径という概念を全く知りませんでしたが、この問題においてそれを求めれば良いと気づき、かつ、DFSを2回やれば求められることまで自力でたどり着けました。ABCに初めて参加した3ヶ月半前には考えられなかったようなことです。最長のパスをstem、それ以外をbranchと名付けて処理しました。Uのrootからの距離がK以上の場合は、K代上の先祖、Uがstemにあって最長パスの末端からの距離がK以上の場合は、K代子孫、Uがstemにあって最長パスの末端からの距離がK未満の場合は、なし、Uがbranchにあってbranch root（stem上のbranchの分かれ目）経由で末端までの距離がK以上の場合は、branch rootからK-(branch内距離)子孫、Uがbranchにあってbranch root（stem上のbranchの分かれ目）経由で末端までの距離がK未満の場合は、なし。と場合分けしました。すべての場合について、頂点が存在する場合はn世代上の先祖を求める問題に帰着し、nを2のべき乗に分解してアクセスできるようにしました。かなり複雑になりましたが、ここまで自分で導いてACできたことは、喜びたいと思います。提出時に最初ほとんどのケースでREとなってしまい、調査が難航し、バグ修正に何時間もかかってしまいました。コメントアウトなどして提出を繰り返してREの位置を特定して確認したところ、リストの要素に()でアクセスしており、not callableエラーが発生していたようでした。ローカルではよく起きるミスですが、AtCoderで起きてもエラーメッセージが見れないため、気づくのがかなり大変です。RE発生時のあるあるパターンとして、記憶しておかなければなりません。せっかくこのような難しい問題を自力で解けてうれしいのに、バグ調査に時間がかかって気分が萎え萎えになってしまいました。解説に良い方法が説明されていそうですが、今は読む気が起きません。しかしぼくのこのコード、長いししんどいです。いつかコンテスト時間内にこんなのも書けるときがくるのでしょうか？答えを求めるための処理の流れの方針を決めて紙一枚に書き出し、その方法で処理を組み立てるために必要なデータは何か？ということを抽出し、ようやくコードを書き始めました。苦労して完成したコードでACできるって達成感がありますね。 2022-12-13

import math
N = int(input())
nexts = [[] for _ in range(N)]
for _ in range(N-1):
    a, b = map(int, input().split())
    nexts[a-1].append(b-1)
    nexts[b-1].append(a-1)
root = N // 2 # arbitrary
longest = [root, 0]
used = [False]*N # need for undirected graph
stack = [(root, 0)]
while stack:
    cur, dist = stack.pop()
    used[cur] = True
    if dist > longest[1]:
        longest[0] = cur
        longest[1] = dist
    for next in nexts[cur]:
        if not used[next]:
            stack.append((next, dist+1))
root = longest[0] # reset root
dists = [-1]*N
# doubling [2^k][v]
max_double = math.floor(math.log2(N))
parents = [[-1]*N for _ in range(max_double + 1)]
longest = [root, 0]
stack = [(root, 0)]
# dfs again
while stack:
    cur, dist = stack.pop()
    dists[cur] = dist
    if dist > longest[1]:
        longest[0] = cur
        longest[1] = dist
    for next in nexts[cur]:
        if dists[next] != -1:
            # already accessed
            continue
        parents[0][next] = cur
        x = 0
        while x < max_double:
            if parents[x][parents[x][next]] == -1:
                break
            parents[x+1][next] = parents[x][parents[x][next]]
            x += 1
        stack.append((next, dist+1))
cur = longest[0] # this is longest end
used = [False]*N
branch_root = [-1]*N
while cur != root:
    used[cur] = True
    parent = parents[0][cur]
    for next in nexts[cur]:
        if used[next] or next == parent:
            continue
        stack = [next]
        while stack:
            branch_cur = stack.pop()
            # set branch root
            branch_root[branch_cur] = cur
            used[branch_cur] = True
            for branch_next in nexts[branch_cur]:
                if not used[branch_next]:
                    stack.append(branch_next)
    cur = parent
def ask_ancestor(v, step):
    i = 0
    cur = v
    while step:
        if step % 2 == 1:
            cur = parents[i][cur]
        step //= 2
        i += 1
    return cur
Q = int(input())
for _ in range(Q):
    u, k = map(int, input().split())
    u -= 1
    if dists[u] >= k:
        print(ask_ancestor(u, k)+1)
    else: # dists[u] < k
        if branch_root[u] == -1: # u on stem
            dist_from_end = longest[1] - dists[u]
            if dist_from_end >= k:
                print(ask_ancestor(longest[0], dist_from_end-k) + 1)
            else:
                print(-1)
        else: # u on branch
            local_root = branch_root[u]
            local_root_dist = dists[local_root]
            local_dist = dists[u] - local_root_dist
            # must < k
            dist_on_stem = k - local_dist
            dist_from_end = longest[1] - local_root_dist - dist_on_stem
            if dist_from_end >= 0:
                print(ask_ancestor(longest[0], dist_from_end)+1)
            else:
                print(-1)

G - Increasing K Times

問題Gを初めて自力で解くべく、DPだろうと思ったので、過去にやったDPの問題をすべてふりかえって、ヒントを抽出しました。インスピレーションを得たうえで、しばらくこの問題を考えてみましたが、結局なにもひらめかず、断念しました。解説によると「挿入DP」というようで、見たことがない全く新しい手法でした。それを使って苦労して解きましたが、提出した解答の処理時間は遅めで、TLEを回避するのにも苦労しました。でもなんか、むちゃくちゃ速い解答提出してる人いっぱいいるんですよね。どういう考え方で解いてるんでしょうか？問題Gって、ひらめけば一瞬で解ける問題が結構混じってるんでしょうか？ABC279 Gもそうでした。ABC279 Gは理解できましたが、この問題も理解したいです。 2022-12-15

from collections import defaultdict
M = 998244353
N, K = map(int, input().split())
acount = defaultdict(int)
for a in map(int, input().split()):
    acount[a] += 1

# https://atcoder.jp/contests/abc267/submissions/37291675
# 階乗やchooseの処理省略

alist = list(acount.items())
alist.sort(key=lambda x:x[0])
alen = len(alist)
dp = [0]*(K+2)
dp[0] = 1
total = 1 # gap number
shuffle = 1
for i, a_n in enumerate(alist):
    ii = i + 1 # ii is idx for a
    n = a_n[1]
    dp_new = [0]*(K+2)
    for j in range(min(K+2, total+1)):
        if not dp[j]:
            continue
        # j -> j + x <= K + 1
        for x in range(min(n+1, total-j+1, K+2-j)):
            if n-x > n+j-1:
                continue
            dp_new[j+x] += dp[j] * choose(total-j, x) * choose(n+j-1, n-x)
            dp_new[j+x] %= M
    dp = dp_new
    total += n
    shuffle *= fact[n]
    shuffle %= M
print(dp[K+1] * shuffle % M)

上記の通り、昨日提出したコードが遅いのが気になったので、やり直したところ、なんと、ぼくの提出が一気に最速となりました。速い人が特殊なことをやっていたわけではなく、同じく「挿入DP」ですが、同じ値の数字をまとめて挿入せず、1つずつ挿入しているだけのようです。あまりにもコードの様子が変わるので、すごいことしてるように見えてました。上のコードを提出した時は、まとめて挿入する方が自然だと感じてそのように実装したのですが、1つずつ挿入することによって複雑にならないし、むしろコードがむちゃくちゃシンプルになって速くなりました。Chooseを何度も計算するために、事前に階乗を計算しておくとか、必要なくなり、いいですね。シンプル・イズ・ベストです。やはりコードがシンプルなのは気持ちいいですね。ってまあ、場合によるのでしょうが。また、DPのリストをループの中で作り直していません。数字を挿入したときにAi<Ai+1となる箇所の個数は増えるだけなので、挿入したときにリストの中で影響を受けるインデックスは、より大きなインデックスとなります。より大きなインデックスにしか影響しないのであれば、大きい方から順に計算することで、DPのリストを直接更新することが可能となります。これは、ABC269 Gから学んだことです。DPの高速化では、非常に有効な方法ですね。早速使えてうれしいです。もう1つの高速化ポイントは、DPの状態遷移がi->i+1としたとき、iからi+1の状態を計算するのではなく、i+1の状態を、関係するiから引っ張ってきて計算しています。このことによって、i+1での新しい値が1回の足し算でも止まっています。これもポイントですね。ということで学んだノウハウが生きて、ぼくの提出が現在最速の132mとなりました。昨日の1666msから大幅に改善です。しかし「挿入DP」とはまたクレイジーです。この問題のような並べ替えの場合、左から確定していくと、残りの値を覚えておく必要があって破綻します。それを解決する秩序ある処理順が、小さい順に挿入していく方法だったというわけですね。 2022-12-16

from collections import defaultdict
M = 998244353
N, K = map(int, input().split())
acount = defaultdict(int)
for a in map(int, input().split()):
    acount[a] += 1
alist = list(acount.items())
alist.sort(key=lambda x:x[0])
alen = len(alist)
# init
dp = [0]*(K+2)
fact_a0num = 1
for i in range(2, alist[0][1]+1):
    fact_a0num = fact_a0num * i % M
dp[1] = fact_a0num
aida = alist[0][1] + 1
for a, n in alist[1:]:
    for acount in range(n):
        for k in range(min(aida+2, K+1), 0, -1):
            dp[k] = (dp[k] * (k+acount) + dp[k-1] * (aida-k+1-acount)) % M
        aida += 1
print(dp[K+1])

Ex - Odd Sum

数列の並び順は関係なく、どの数字を何個使うかだけ。ということに気づいてプログラミング脳になってきたか？いけるかも。とちょっと期待してランニングしながら頭の中で解き方を考えていたけど、どうしても計算量減らせず断念。解説を見てすげぇと思ったけど、高速フーリエ変換のしくみを思い出せないので一旦保留。高速フーリエ変換を勉強し直して戻ってきたいです。 2022-09-04

1ヶ月かかって高速フーリエ変換を勉強し、戻ってきました。1ヶ月と言ってもコンテストにたまに参加したりすると毎回毎回新しいことが出てきてそれを勉強しなければならず、高速フーリエ変換なんて勉強してるヒマがありませんでした。しかし解けてない問題はずっと気になるので、よしと思って一気にやった感じです。週末こんなのを理解しようとしてたら、久しぶりにとんでもなく頭が疲れたのを感じて、そのあとパワーナップしたら気持ち良すぎました。仕事でこの感覚を味わうことはできないのでいいですね。AtCoderに出てくるどのアルゴリズムを見てもクレイジーだと感じていますが、高速フーリエ変換は群を抜いてクレイジーだと思いました。1ヶ月前に読んで理解した解説を思い出しながら自力で動的計画法の実装をし、畳み込みの部分はmaspy氏のnumpyのfftを使った畳み込みを使い、サンプルに正解できました。サンプル問題で正解が出力された時は脳内物質が出てむちゃくちゃ興奮しました。たぶん、1ヶ月放置してた反動ですね。しかし提出したら実行エラーが発生しました。コードテストでModuleNotFoundError: No module named 'numpy'と出力されたので何かと思ったら、PyPyではnumpyが使えないけど、Pythonでは使えるということらしいです。今まで無意識にPyPy使ってました。PyPyは速いらしいので、numpyを取るかPyPyを取るかみたいな選択をせまられるんですね。 2022-10-02

ようやく正解できました。maspy氏のnumpyのfftを使った畳み込み、確かにconvolve2を使わないと不正解になっちゃいますね。最後ギリギリのところでの速度改善をしていて、大変でした。といっても今回numpyをはじめて使い、全く詳しくなかったので無駄に標準のlistを作ってからnumpyのarrayに変換したりしてたのをやめたら結構改善しました。combination計算のために階乗と階乗の逆元を事前に計算しておくところは、解説を参考にしましたが、逆元を1回しか計算しないのは効率的ですね。階乗計算のnはちゃんと一番多い数字の個数までしか計算しないようにしました。高速フーリエ変換をする時は、できるだけ係数のリストが小さくなるように、i*(iの個数)と、Mの小さい方の値までとしました。最後の最後でTLEがあと7つのテストケースとなったところで、入れた改善は、1から10まで順に計算するのではなく、i*(iの個数)が小さい順に計算するようにしたことです。畳み込みのたびにどんどんリストは大きくなるはずなので、できるだけ小さい状態を維持するには、係数リストが小さい順に計算したほうがよいはずです。この修正で十分速くなる保証はなかったですが、なんと、残りの7つのテストケースも間に合うことに成功しました。解説のC++コードが全く気にしていないところに気を使ってギリギリAC、やったぜ！って感じです。Pythonでの正解はぼくが11人目でしたが、ぼく以外全員PyPyでした。 2022-10-08

# fftコード省略

mod = 998244353
n, m = map(int, input().split())
from collections import Counter
counter = Counter(map(int, input().split()))
count_max = counter.most_common(1)[0][1]

# https://atcoder.jp/contests/abc267/submissions/35459588
# 階乗やchooseは省略

odd_prev = np.array([])
even_prev = np.array([])
is_first = True
counter_list = list(counter.items())
counter_list.sort(key=lambda x: (x[0]*x[1]))
for i, num in counter_list:
    coef_maxidx = min(i*num, m)
    odd_cur = np.zeros(coef_maxidx+1, dtype=np.int64)
    even_cur = np.zeros(coef_maxidx+1, dtype=np.int64)
    sum = 0
    even_cur[0] = 1
    is_even = False
    for n in range(1, num+1):
        sum += i # iをn個
        if sum > coef_maxidx:
            break
        if is_even:
            even_cur[sum] = choose(num, n) % mod
            is_even = False
        else:
            odd_cur[sum] = choose(num, n) % mod
            is_even = True
    if is_first:
        odd_prev = odd_cur
        even_prev = even_cur
        is_first = False
    else:
        new0 = convolve2(odd_prev, even_cur, mod) \
             + convolve2(even_prev, odd_cur, mod)
        new1 = convolve2(odd_prev, odd_cur, mod) \
             + convolve2(even_prev, even_cur, mod)
        odd_prev = new0[:m+1] if new0.size > m+1 else new0
        even_prev = new1[:m+1] if new1.size > m+1 else new1
if odd_prev.size >= m+1:
    print(odd_prev[m] % mod)
else:
    print(0)

AtCoder Beginner Contest 268

他にやることがあってリアルタイム参加はあきらめました。翌日、ワイン1杯飲んでましたが、バーチャル参加しました。時間内にはA、B、Cだけ解けました。Cが結構むずかしいと感じ、Cを解いた時点で35分くらいでした。それでも1時間以上残っているのでなんとか目標の4問を目指しましたが、D、Eがどちらもむずかしく、4問正解なりませんでした。過去問を6問やって解けるのも増えてきたかなと感じてましたがまだまだダメでした。D、Eの解説をみてやりましたが、実際むずかしかったです。

D - Unique Username

Tと一致しないことを短時間で判定できればよい。あとはこの条件に従ってユーザー名を生成したときにどれくらい作られるのか？ということが気になります。多すぎると処理が終わりません。まさにそれが解説に書かれていました。十分少ないとのこと。そして計算しなくてもプログラムを動かしてカウントしてみても良いと書かれていました。これは役に立つノウハウです。ぼくが、この問題を解けなかった原因は他にあり、そもそもどのようにユーザー名の候補を生成すればよいかで行き詰まってました。Xの文字数が3以上16以下ということで'_'を使う数に幅があり、それをどうあつかえばよいかわからず、行き詰まりました。不覚です。16文字ギリギリまで用意しておいて、右端の'_'列だけ捨てれば良いとのこと。これは気づけなかったのが悔しい。まあ'_'の数でループしても良いですが、頭疲れてます。そこまでわかれば、解けます。あとはユーザー名が3文字以上という条件を入れないと不正解になってしまうテストケースもあったので要注意でした。 2022-09-12

import sys
from itertools import permutations
from itertools import combinations
n, m = map(int, input().split())
ss = [input() for _ in range(n)]
ts = {input() for _ in range(m)}
s_all_len = len(''.join(ss))
us_split_point_num = 16 - s_all_len
for s_per in permutations(ss):
    for us_split_combi in combinations(range(us_split_point_num), n-1):
        us_lens = []
        id_cur = -1
        for id_temp in us_split_combi:
            us_lens.append(id_temp - id_cur)
            id_cur = id_temp
        res = ''
        for i in range(n-1):
            res += s_per[i]
            res += '_'*us_lens[i]
        res += s_per[n-1]
        if res not in ts and len(res) >= 3:
            print(res)
            sys.exit()
print(-1)

E - Chinese Restaurant (Three-Star Version)

頭の中にギザギザの不満度グラフがn個思い浮かんでいましたが、これをどう処理すればO(N^2)より小さくできるのかさっぱりわからず、公式解説を見ました。「いもす法」を使うと書かれていました。すべての場所で全データ処理しなくても、変化するところだけ覚えておいて、あとで走査すればO(N)で処理できるというものです。大事です。この問題のすごいところは、1次関数の次数ごとに「いもす法」を使うというところでした。クレイジーです。そこまでわかったとしても、同じ人の不満度を表す1次関数が範囲ごとに変化しギザギザになるので、それを正確に表現するのがむずかしく感じました。nが偶数だったら、nが奇数だったら、など考えました。実際最初バグっていて、1つだけ不正解が出て、整理し直してなんとか正解できました。今の実力で、時間内にこれを正解できる気はしません。むちゃくちゃ大変だと感じました。それにしても明らかにロジックに誤りがあるのに、1つを除いて正解になってしまったのは驚きました。この1つがなかったらバグを見つけられなかったと思うと、06_corner_03.txtはナイステストケースです。 2022-09-12

n = int(input())
ps = [p for p in map(int, input().split())]
imosu = [[0]*2 for _ in range(n)]
c = [[0]*2 for _ in range(n)]
for i, p in enumerate(ps):
    t = (p-i) % n
    if t < int(n/2):
        imosu[0][1] += -1
        imosu[0][0] += t
        imosu[t][1] += 2
        imosu[t][0] -= 2*t
        imosu[t+int((n-1)/2)+1][1] -= 2
        imosu[t+int((n-1)/2)+1][0] += (2*t + n)
    else:
        imosu[0][1] += 1
        imosu[0][0] += (-t + n)
        imosu[t-int(n/2)][1] -= 2
        imosu[t-int(n/2)][0] += (2*t - n)
        imosu[t][1] += 2
        imosu[t][0] -= 2*t
c[0][1] = imosu[0][1]
c[0][0] = imosu[0][0]
for x in range(1, n):
    c[x][1] = c[x-1][1] + imosu[x][1]
    c[x][0] = c[x-1][0] + imosu[x][0]
min = 10**11
for x in range(n):
    cur = x*c[x][1] + c[x][0]
    if cur < min:
        min = cur
print(min)

F - Best Concatenation

遡って解くぞシリーズ。この問題は自力で解くことができ、ABC281 Fに続いて2つ目の自力で解けた問題Fとなりました。ABC281は先週土曜日に開催され、今日は火曜日です。そして実はABC267 Fも、難しかったと思いますが、この問題のあとで自力で解けました。問題Fを初めて自力で解いてから、急に3日で3問、自力で解けたことになります。急に力がついたんでしょうか？うれしいです。この問題の考え方は、まず数字だけの文字列がXの前にあってもスコアになりませんから、全部まとめて後ろだなーと気づきました。よって、Xを含む文字列の順序だけ考えればよいとわかります。数字の区別は必要でしょうか？数字がそのままスコアになるので、区別せずに、全部足して考えればよいと気づけます。i番目とj番目の文字列のどちらを前に持ってこればよいでしょうか？i番目が前の場合と、j番目が前の場合、それぞれスコアを計算して大きくなる方の順序にすればよいです。Xの個数をnXi、nXjとし、数字の合計をFi、Fjとすると、スコアは、iが前の場合nXi*Fj、jが前の場合、nXj*Fiとなります。iを前にした方が良くなる、nXi*Fj > nXj*Fiを変形してFj/nXj > Fi/nXiということがわかり、F/nXでソートした順序が正解であることがわかります。最初に述べたように、nXが0のときは全部後ろでよいので、ソートのキーを最大値にしておきます。それぞれの文字列の中でもXの後ろに数字があればスコアになりますので、それも加えて答えを出力すればよいです。よし！解けるぞ！ 2022-12-13

N = int(input())
ans = 0
# X count, fugure sum
ss = [[0,0] for _ in range(N)]
for i in range(N):
    s = input()
    n_X = 0
    sum_fig = 0
    for c in s:
        if c == 'X':
            n_X += 1
        else:
            fig = int(c)
            ans += fig * n_X
            sum_fig += fig
    ss[i][0] = n_X
    ss[i][1] = sum_fig
ss.sort(key=lambda x:10**7 if x[0] == 0 else x[1]/x[0])
n_X = 0
for item in ss:
    ans += n_X * item[1]
    n_X += item[0]
print(ans)

G - Random Student ID

解説を読むだけの仕事になってしまってますが、時間を区切って解説を見ることにしないと体が持ちません。ていうかもう持ってないです。学籍番号の期待値を計算するということで、計算方法が全く検討つかなかったわけですが、解説によると、iさんの学籍番号の期待値を計算するには、jさんの名前がiさんの名前の接頭辞ならjさんは確実に前にいるので+1、iさんの名前がjさんの名前の接頭辞なら確実に後ろにいるので0、それ以外は1/2で計算すると。クレイジーです。期待値ってこうやって計算するんだということにまず驚き、そしてiさんとjさんの名前の何文字目かが異なる場合は前か後ろかの確率が1/2っていうのも驚きです。そして、トライ木（Trie）という構造を使うと、お互いに接頭辞になる人の人数を高速で数えられると書いてありましたので、素直に実装しました。ようやく提出したら、005.txtと015.txtだけ実行時エラー。同じ結果になってる人もいてなんだろうと思ったのですが、長い名前のテストケースを作って実行してみたら「RecursionError: maximum recursion depth exceeded」が発生し、原因がわかりました。深くなる再帰関数を使わないでおこうと思ってstackとかqueueを使ってたのですが、あきらめて、sys.setrecursionlimit(10**6)としました。これで無事正解です。ところで再帰回数が限界を超えたのはTrie.addです。別オブジェクトを作ってから呼んでるので、RecursionErrorが発生するまで、ぼくは再帰関数と認識していませんでした。Pythonってオブジェクトは引数のselfなんですよね。つまりオブジェクトを関数に渡して呼んでるだけなのでTrie.addを再帰的に呼び出していることになるという気づきが得られました。この問題では、有理数の答えをmod 998244353で出力するということで、これも厄介な話で、分子に分母の逆元（フェルマーの小定理により分母のm-2乘）をかけるとのこと。 2022-09-13

import sys
from collections import deque
sys.setrecursionlimit(10**6)
class Trie():
    def __init__(self, c='', parent=None):
        self.c = c
        self.parent = parent
        self.children = {}
        self.name = ''
        self.anc_num = 0
        self.desc_num = 0
        self.visited = False # for dfs
    def add(self, idx, name):
        if not self.c:
            if name[0] not in self.children:
                self.children[name[0]] = Trie(name[0], self)
            self.children[name[0]].add(0, name)
        elif idx == len(name) - 1:
            self.name = name
        else:
            if name[idx+1] not in self.children:
                self.children[name[idx+1]] = Trie(name[idx+1], self)
            self.children[name[idx+1]].add(idx+1, name)

m = 998244353
inv = pow(2, m-2, m)
n = int(input())
root = Trie()
ss = {} # s and answer
for i in range(n):
    s = input()
    ss[s] = 0
    root.add(0, s)
s = deque([])
s.append(root)
while s:
    trie = s.pop()
    if not trie.visited:
        trie.visited = True
        s.append(trie)
        for child in trie.children.values():
            child.anc_num = trie.anc_num
            if trie.name:
                child.anc_num += 1
            s.append(child)
    else:
        if trie.name:
            ss[trie.name] = ((1 + trie.anc_num - trie.desc_num + n) * inv) % m
        if trie.parent:
            trie.parent.desc_num += trie.desc_num
            if trie.name:
                trie.parent.desc_num += 1
for res in ss.values():
    print(res)

Ex - Taboo

Sを1文字目から順番に調べていき、Tが見つかったらその終端位置を覚える。その終端位置の中で一番手前のものを*に変える。という考え方でいけそうです。問題Gで覚えたばかりのトライ木で、最初に見つかるTの終端位置を見つけ、プライオリティキューに入れていけば一番手前をすぐに取り出せます。どう考えても計算量に無理がありますが、無駄な処理はいろいろ減らせるのでとりあえずやってみました。そして、不正解と時間切れになったのを確認して迷わず解説へ。公式解説のSuffix Arrayというクレイジーなアイデアに驚きつつ、SA-IS法がマジでわけがわからない（といいつつDNAとかの研究でも使うらしくむちゃくちゃ大事、O(N)でSuffix Arrayが作れるらしい）ので、別の方法を見ていると、エイホ–コラシック法（Aho-Corasick）というので解けるらしいと知りました。これはトライ木を発展させたものであり、大変わかりやすいです。Aho-Corasickは、トライ木の各ノードがSuffixが最も長く一致するノードへのリンクを持っている構造です。これを使うと、Sの文字を1文字進めるごとに最初からTと一致しているか調べ直さなくても、トライ木の途中から始まっているTもいっしょに調べることができてしまいます。Aho-Corasickは、トライ木のルートから幅優先で走査して生成できます。苦労してACしました。他の人よりメモリ使用量が多いのが解せません。 2022-09-18

import sys
sys.setrecursionlimit(10**6)
class Aho():
    def __init__(self, c=''):
        self.c = c # c is '' only when this is root
        self.children = {}
        self.is_word = False
        self.link = None
    def add(self, s, idx):
        if not self.c: # root
            if s[0] not in self.children:
                self.children[s[0]] = Aho(s[0])
            self.children[s[0]].add(s, 0)
        elif idx == len(s)-1:
            self.is_word = True
        else: # len(s) > 1
            if s[idx+1] not in self.children:
                self.children[s[idx+1]] = Aho(s[idx+1])
            self.children[s[idx+1]].add(s, idx+1)

from collections import deque
s = input()
n = int(input())
root = Aho()
for _ in range(n):
    t = input()
    root.add(t, 0)
q = deque([])
for rootchild in root.children.values():
    rootchild.link = root
    q.append(rootchild)
while q:
    node = q.popleft()
    cs = set(node.children)
    linkcand = node.link
    while cs:
        clist = list(cs)
        for c in clist:
            if c in linkcand.children:
                node.children[c].link = linkcand.children[c]
                if not node.children[c].is_word:
                    node.children[c].is_word = linkcand.children[c].is_word
                cs.remove(c)
            elif linkcand == root:
                node.children[c].link = root
                cs.remove(c)
        linkcand = linkcand.link
    q.extend(node.children.values())

i = 0
count = 0
aho = root
while True:
    if i == len(s):
        break
    if s[i] in aho.children:
        aho = aho.children[s[i]]
        if aho.is_word:
            count += 1
            aho = root
    else:
        while aho.c:
            aho = aho.link
            if s[i] in aho.children:
                aho = aho.children[s[i]]
                if aho.is_word:
                    count += 1
                    aho = root
                break
    i += 1
print(count)

AtCoder Beginner Contest 269

ABC268 Exが解けていなかったので、参加していません。その前のABC267 Exもまだ時間がかかりそうで、これ以上解けてない問題が増えるのは精神的にきついです。仕事もありつつ、Exの問題は1週間で理解できるレベルではないので、参加するエネルギーないです。その後日曜日にABC268 Exがなんとか解けたので、懲りずにABC269の問題を見てしまう。しんどいです。ググる回数が減るように、使った機能の復習はざっとした方が良さそうです。

B - Rectangle Detection

PyPyって文字列扱うのやたら遅いのでしょうか？なぜかPython勢もPyPyではなく、普通のPythonを使っている人が多く、その人達が実行速度上位でした。ムカついたので、C言語でテキトーに書いて2msにしました。1msは無理でしょうか。 2023-01-25

C - Submask

2022-09-19

n = int(input())
ans = [0]
while n:
    smallest = n & -n
    new = [i + smallest for i in ans]
    ans.extend(new)
    n -= smallest
for i in ans:
    print(i)

D - Do use hexagon grid

こういう連結成分の個数を出力する問題あるよなぁと思いながら、やったことがなかったです。ちょっと遠回りな感じもしますが、とりあえず隣同士のものを最初に見つけておいてから、幅優先でたどって全部のグリッドを見ればよいでしょうか？x, y, x-yの値が全部+-1の範囲にあるものが隣なので、そのように実装しました。最初bisectを使って-1から1の範囲を取り出していましたが、自分の環境では動くのに、AtCoderの環境では全テストケース実行エラーとなってしまいました。何かと思ったら、bisect.bisect()の引数のkeyを使っており、これはPython 3.10で追加されたので、AtCoderではまだ使えないようです。bisectなど使わず、座標の辞書を作ってもいけそうだったので、書き直して正解しました。 2022-09-19

from collections import defaultdict
from collections import deque
n = int(input())
nexts = {}
grids = []
c_dict = [defaultdict(set), defaultdict(set), defaultdict(set)]
for i in range(n):
    x, y = map(int, input().split())
    grids.append((x, y, x-y))
    c_dict[0][x].add(i)
    c_dict[1][y].add(i)
    c_dict[2][x-y].add(i)
for i in range(n):
    nextset = set()
    for dir in range(3):
        c = grids[i][dir]
        if dir == 0:
            nextset = c_dict[dir][c-1] | c_dict[dir][c] | c_dict[dir][c+1]
        else:
            nextset &= c_dict[dir][c-1] | c_dict[dir][c] | c_dict[dir][c+1]
    nextset.remove(i)
    nexts[i] = nextset
s = set(range(n))
count = 0
while s:
    count += 1
    q = deque([])
    x = s.pop()
    q.append(x)
    while q:
        cur = q.pop()
        for next in nexts[cur]:
            if next in s:
                s.remove(next)
                q.append(next)
print(count)

E - Last Rook

遡って解いていこうシリーズ。インタラクティブな問題は、Grundy数を使ってゲームに勝つ問題だったABC278 G以来、2回目です。今回は自力でいけました。が、i方向で絞り込んだ値をそのままj方向を調べるときにも使ってしまい、1ペナしてしまいました。1辺が1000なので、2^10より小さく、行列合計20回の2分探索で見つけることができ、質問回数の上限に設定されています。他の人より妙に遅いのが気になります。コードに違いがあるようには見えないのですが。 2022-12-10

N = int(input())
imin = 1
imax = N
while imin < imax:
    imid = (imin+imax) // 2
    print('?', imin, imid, 1, N, flush=True)
    T = int(input())
    if T < imid - imin + 1:
        imax = imid
    else:
        imin = imid + 1
# imin = imax
jmin = 1
jmax = N
while jmin < jmax:
    jmid = (jmin+jmax) // 2
    print('?', 1, N, jmin, jmid, flush=True)
    T = int(input())
    if T < jmid - jmin + 1:
        jmax = jmid
    else:
        jmin = jmid + 1
# jmin = jmax
print('!', imin, jmin)

F

めんどうなので、スキップ。 2022-12-11

G - Reversible Cards 2

問題Gを自力で解きたいと思ってやってますが、達成できず。これは相当難しかったです。そして非常に勉強になりました。いつものようにシンプルな問題ですが、公式解説にいろいろ書いてあって深いです。愚直に自分なりにDPをやるとこのようになりました。b-aの絶対値が同じものをまとめておき、負数の場合はマイナス回裏返すというように考えて、まとめて処理しています。この実装ではDPのリストをループ中で作り直しているので、b-aの絶対値が同じものに関しては、DPのリストの作り直し1回で済ませており、そこが高速化ポイントになっていると思ったのですが、これはTLEx8です。

解説の実装例を見ると、DPのリストを作り直していないんですよね。1つのリストを更新し続けて処理しています。これがものすごく不思議に見えました。ぼくは、カードの合計値のループの中で、裏返す回数のループを回していた上に、減るときをマイナス回にしてまとめて処理してたので、DPリストを作り直すしかないと思っていたんです。でも解説では、裏返す回数のループの内側で、カードの合計値のループを回し、かつ、裏返して合計値が増えるパターンのときはreverseした順序でループを回すことで、DPリストの作り直しが不要となっていました。リスト1つでも、処理順を工夫することで、排他的に実行しなければならないDPの更新処理が、互いに影響しないようにできるということです。それだけではなく、c増える操作をn回やる場合の処理を驚くべき方法で、高速化していました。自然数nをこのように分解していました。このループでnを分解したmの組み合わせで、1からnまでの自然数をすべて生成できることは、考えればわかります。n回裏返す処理が、log(N)回裏返す処理の組み合わせで表現できてしまいます。

x = 1
while n:
    m = min(n, x)
    # do something
    n -= m
    x *= 2

最終的なぼくのコードは、いろいろとがんばってこれで、1209msになりました。が、まだまだ速いコードが複数提出されています。中身を見ても何が違うんだかさっぱりわかりません。処理速度の違い、なぞなことが多いんですよねぇ。解説には|b-a|の種類が高々√M程度であることが、示されています。√M個の数字を小さい順にびっしり詰めると、1,2,3,4,…,√Mとなりますが、すべて加えると(√M(√M+1))/2です。負数も加えるとMを超えます。しかしΣb+Σa=Mであることから、Σ|b-a|は、明らかにM以下ですので、√M個 小さい順に詰めてもMを超えてしまうのであれば、|b-a|の種類は√M種類より小さくなければならないとわかります。つまり、Nが大きければb-aが同じものが大量に発生するので、今回のような高速化が可能です。入れ子ループのどちらを内側にするのかによって、自然数を分解した今回の高速化が可能になることや、ループの順序を工夫することでDPのリストは作り直す必要がなくなることなど、クレイジーな学びのある問題でした。あ、解説でreversed(range(l,r+1))というような書き方がされていましたが、range(r,l-1,-1)とした方が効率的なようです。 2022-12-12

import sys
input = sys.stdin.readline
from collections import defaultdict
N, M = map(int, input().split())
INF = N + 1
suma = 0
sub_count = defaultdict(int)
for _ in range(N):
    a, b = map(int, input().split())
    suma += a
    c = b - a
    if c != 0: # skip 0
        sub_count[c] += 1
dp = [INF]*(M+1)
dp[suma] = 0
l = r = suma
sub_ordered = list(sub_count.items())
sub_ordered.sort(key=lambda x:abs(x[0]*x[1]))
for sub, n in sub_ordered:
    x = 1
    while n:
        m = min(n, x) # m step at once
        for k in (range(r, l-1, -1) if sub > 0 else range(l, r+1)):
            if dp[k] == INF:
                continue
            k_ = k + sub * m
            dp[k_] = min(dp[k_], dp[k] + m)
        if sub > 0:
            r = r + sub * m
        else:
            l = l + sub * m
        n -= m
        x *= 2
for k in range(M+1):
    print(-1 if dp[k] == INF else dp[k])

Ex

理解するのきつそう。FFTはまた出てきたけどそれ以外のところ。 2022-09-19

AtCoder Beginner Contest 270

4問正解を目指して過去問などもやっていますが、基礎的なことを勉強していないせいで解説を読むたびに毎回度肝を抜かれ、ネットなどで調べて勉強しようとし、精神的にしんどいです。みんな基礎的な知識を身につけてやっているようで、どうやって身につけているんだろう？と調べてみると、蟻本に知りたかったことがいろいろ書かれていそうと気づきました。そこで今は蟻本を読み始めています。蟻本、問題に関連するアルゴリズムなど、気になったところを読めばいいと思ってましたが、全部読んだほうが良さそうです。いろいろと解けてない問題を抱えていてしんどいですが、そんなこと言ってたら永久に参加できないので今回のABCは参加しました。Cまでで1時間かかりました。Cのような、いかにも基本的な問題でも0から考えてる感じで時間がかかります。とはいえ、あと40分もあります。しかしDはまんまと引っかかって貪欲でいってしまい、正解できませんでした。むずかしいです。

C - Simple path

グラフの初級編のところを今蟻本で読んでるんですが、むずかしいです。この問題はいかにも基本って感じがしますが、ぼくにとっては0から考えてる感じでしんどいす。隣接リストを作り、そこから1を根とした木（各頂点の親と深さをメモ）を作り、xとyからLCA（Lowest Common Ancestor）まで親をたどっていきました。良いやり方なのかはわかりません。LCAに関連するアルゴリズムは今勉強したいと思っていることの1つで、この問題に関しては複雑なことをせずに解けましたが、気になっていることがいろいろあります。あと、この問題ではjoinで数値のlistを文字列化しようとしたときに失敗して手こずりました。strにしてからjoinしないといけないようです。' '.join([str(n) for n in [3,4,5]])。と思ったらリストを引数にアンパックして渡せるので、print(*l)でいいらしい。解説に書いてあったんですが、yを根にすればxから登っていくだけでよかったのか。なるほど！ 2022-09-24

from collections import defaultdict
from collections import deque
n, x, y = map(int, input().split())
par = [0 for _ in range(n+1)] # 0,1,2,..,n
depth = [-1 for _ in range(n+1)]
nexts = defaultdict(set)
for _ in range(n-1):
    u, v = map(int, input().split())
    nexts[u].add(v)
    nexts[v].add(u)
q = deque([])
q.append(1)
par[1] = 1 # root
depth[1] = 0
while q:
    cur = q.popleft()
    depth_cur = depth[cur]
    par_cur = par[cur]
    for c in nexts[cur]:
        if par[c] != 0:
            continue
        depth[c] = depth_cur + 1
        par[c] = cur
        q.append(c)
xline = [x]
yline = [y]
while True:
    if depth[x] > depth[y]:
        x = par[x]
        xline.append(x)
    else:
        y = par[y]
        yline.append(y)
    if x == y:
        yline.pop(-1)
        yline.reverse()
        xline.extend(yline)
        print(*xline)
        break

D - Stones

正解できませんでした。4問正解ならず。解説にこのように書いてあります。「「各手番で石を取れるだけ取る」という貪欲法で解くことはできません」反例を思いつかず、ひっかかりました。最初に提出したコードはこれです。半分のテストケースで不正解となりました。Sampleのテストケースでは気づけないようになっていたので厳しく、むずかしいです。

正しくはこのように動的計画法で解くとのことです。この感覚がまだ身についておらず、不思議な感じが抜けません。dp[n]はn個から始めて先手が取れる個数。その時後手の取れる個数はn - dp[n]。よって、先手が取れるのは、max(Ai + (n-Ai) - dp[n-Ai]) = max(n - dp[n-Ai])となる。0からnまで計算していく。 2022-09-24

n, k = map(int, input().split())
alist = []
for a in map(int, input().split()):
    alist.append(a)
dp = [0]*(n+1)
for i in range(n+1):
    for j in range(k):
        if alist[j] > i:
            break
        dp[i] = max(dp[i], i - dp[i-alist[j]])
print(dp[n])

E - Apple Baskets on Circle

これは特殊なことが不要で、愚直に回転数を重ねていくだけで正解できました。Dを飛ばしてこれを解いたほうが良かったようです。ただ、処理の流れを整理するのは苦労したので、短時間で整理できるように訓練が必要だと感じました。解説ではm回転したときの食べた個数をΣmin(a,m)で計算し、kになるところを2分探索していて勉強になりました。 2022-09-25

n, k = map(int, input().split())
alist = []
a_nonzero = []
for a in map(int, input().split()):
    alist.append(a)
    if a != 0:
        a_nonzero.append(a)
a_nonzero.sort()
i = 0
rot = 0
basket_num = len(a_nonzero)
a_prev = 0
while True:
    a = a_nonzero[i]
    if (a - a_prev) * basket_num >= k:
        rot += int(k / basket_num)
        amari = k % basket_num
        break
    k -= (a - a_prev) * basket_num # k > 0
    rot = a
    a_prev = a
    while a == a_nonzero[i]:
        i += 1
    basket_num = len(a_nonzero) - i
for i in range(len(alist)):
    alist[i] -= rot
    if alist[i] <= 0:
        alist[i] = 0
    elif amari:
        alist[i] -= 1
        amari -= 1
print(*alist)

復習なう。2分探索でやってみました。1回でACできて良かったですが、2分探索に慣れてないせいか、ループの終了条件がこれでいいのか？ちょっと悩んでしまいました。処理時間遅めです。 2023-01-05

F - Transportation

最小全域木の問題っぽい、ですが道路だけでなく、空港と港の建設によってつなぐこともできるため、解き方の見当がつきません。解説を読むと、空というノードを考え、空港建設のコストを、島と空をつなぐ道路のコストと考えればよいと書いてありました。港の場合は海をノードと捉えるのです。最初から空をノードにして最小全域木を作ってしまうと、必ず空港を建設するのが前提になってしまいますから、道路のみの場合と、空だけを追加する場合と、海だけを追加する場合と、空と海を両方追加する場合の4通りで最小全域木を計算し、一番コストが小さいものを回答すればよいです。またまた発想がクレイジー過ぎます。しかしこれを読むだけで、あー解けるなと思えるすごいトリックです。最小全域木はクラスカル法を使って解きます。新たに追加するエッジの両端ノードがすでに作られた木を通してつながっているかどうかは、Union-Findを使って判定します。このあたりは蟻本を見ながらUnionクラスとして実装しました。ノードの最大インデックス+1で初期化しているのでこれが無駄にでかくなると嫌ですが、まあ今後も使えると思います。この問題は道路だけですべての島をカバーできる前提ではないので、道路の最小全域木を求めても、答えになっていない場合が半分以上あるので注意が必要です。 2022-11-04

class Union():
    # 省略
n, m = map(int, input().split())
aircosts = [(x, i, n) for i, x in enumerate(map(int, input().split()))]
portcosts = [(y, i, n+1) for i, y in enumerate(map(int, input().split()))]
roads = []
road_cover = set()
for _ in range(m):
    a, b, z = map(int, input().split())
    roads.append((z, a-1, b-1))
    road_cover.add(a)
    road_cover.add(b)
# sky
es = roads + aircosts
es.sort(key=lambda x: x[0])
u = Union(n+1)
res = 0
for e in es:
    if not u.same_tree(e[1], e[2]):
        u.unite(e[1], e[2])
        res += e[0]
# sea
es = roads + portcosts
es.sort(key=lambda x: x[0])
u = Union(n+2)
cost_cur = 0
for e in es:
    if not u.same_tree(e[1], e[2]):
        u.unite(e[1], e[2])
        cost_cur += e[0]
if cost_cur < res:
    res = cost_cur
# sky and sea
es = roads + aircosts + portcosts
es.sort(key=lambda x: x[0])
u = Union(n+2)
cost_cur = 0
for e in es:
    if not u.same_tree(e[1], e[2]):
        u.unite(e[1], e[2])
        cost_cur += e[0]
if cost_cur < res:
    res = cost_cur
# when roads cover all islands
if len(road_cover) == n:
    roads.sort(key=lambda x: x[0])
    u = Union(n)
    cost_cur = 0
    for e in roads:
        if not u.same_tree(e[1], e[2]):
            u.unite(e[1], e[2])
            cost_cur += e[0]
    if cost_cur < res:
        res = cost_cur
print(res)

G - Sequence in mod P

遡ってGまで解くぞシリーズ！また新しい、あたおかな武器を手に入れてしまった。「Baby-step Giant-step」という。例によって自力で解こうとして、取りうる値は高々P個だからループするなぁ、そのループの中にGが含まれているのか？どうなのか？という問題だなぁ、一般項は求められるなぁ、などと考え行き詰まり、何か使える情報はないかと、ググって整数論の定理の記事などを苦しみながら読んでも、解決には結びつきませんでした。「Baby-step Giant-step」！いやぁクレイジーですね。理解して問題に適用するのに苦労しました。Wikipediaに書いてある例のように、Pがバカでかいときに、A^x≡B (mod P)となるxを求めるテクニックのようです。mを√P以上の数とします。x=im+jとすると、0<=i,j<mとすれば、xで0からP-1までカバーできます。A^j≡B(A^-m)^iと変形できます。A^jをj=0からmまで計算しておきます。A^-mを計算し、(A^-m)^iを、iを0からmまで変化させて計算します。先程計算したA^jの中のどれかと一致すれば、見つかったことになります。これまた、なんでこれで速くなってるの？とすごく不思議です。なぜか、ちょっと「半分全列挙」を思い出します。この離散対数問題を解く方法を見ると、A^-mを計算できていますが、この問題では逆関数m回の処理を計算していません。どう計算すればよいかも、よくわかりません。「Baby-step Giant-step」は、この問題のようなループする数列に対して適用できます。Baby-stepは数列を1歩ずつ進むことです。Giant-stepはm歩進むことです。Giant-stepでmずつm歩進むと、Baby-stepで0からm-1まで1歩ずつ進んだとき通った場所に、必ず当たるという性質を利用しています。√Pというのはどこから出てきたのか考えてみます。mは√Pでなくても、Babyでm歩、GiantでP/m歩歩けば同じ性質が得られます。BabyとGiantの歩数の合計であるm+P/mを最小化しようと思うと、m=√Pが導かれますので、そのような理由で√Pが採用されているのだと思います。この問題ではXi=S*A^i+B*(A^i-1)/(A-1)ですので、Giant-stepであるXmを直接計算することができます。あとはS=GやA=1やB=0のときを特別扱いする必要があって注意が必要でした。エグいです。最近の目標は、問題Gを自力で解くことになってますが、なかなか実現できません。 2022-12-09

import math
T = int(input())
for _ in range(T):
    P, A, B, S, G = map(int, input().split())
    if G == S:
        print(0)
        continue
    if A == 0:
        print(1 if G == B else -1)
        continue
    if A == 1:
        if B == 0:
            print(-1)
        else:
            print((G - S) * pow(B, P-2, P) % P)
        continue
    giant = math.ceil(P**0.5)
    cur = G
    babies = {cur:0}
    for i in range(1, giant):
        cur = (A * cur + B) % P
        babies[cur] = i # set biggest ok
    A_giant = pow(A, giant, P)
    A_giants = A_giant
    A_inv_1 = pow(A-1, P-2, P)
    for i in range(1, giant+1):
        val = (A_giants * S + (A_giants-1) * A_inv_1 * B) % P
        if val in babies:
            print(i*giant - babies[val])
            break
        A_giants *= A_giant
        A_giants %= P
    else:
        print(-1)

AtCoder Beginner Contest 271

Cでハマって過去最低の2問正解で終了し、無理かと思いましたが、入茶しました！。しかし、勉強続けてるのに点数が右肩下がりで納得いきません。

C - Manga

時間中、なんとか正解したいと粘りましたが解けず、ついに過去最低の2問正解で終わってしまいました。解説によるとx冊読めるかどうか簡単に計算できるので、2分探索すればよいと。問題がかなりシンプルに整理されて素晴らしいです。サンプル問題で「高橋君は同じ巻を 2 冊以上持っているかもしれません。」と書いてあり、いじわるだと思いましたが、高橋君が持ってる巻の数列が単調増加じゃないテストケースもありそうです。（たぶん。）だとするとユニークな巻を取り出すにはsetを使わなければならないので、問題を整理しきれてないから解けないんだとがんばっていたのに、これはさすがに悪意が強く、ひどい引っかけだと感じました。考えても意味がないことで時間を無駄にしたくないです。2分探索のコードは、はじめて書きましたが、自力で書いたら解説と同じになっていて良かったです。Pythonで、/で整数の割り算をするとfloatになってしまうことに気づいていたので、これまでint(n/2)というような書き方をしていましたが、切り捨て除算が別に用意されており、n//2と書けることを初めて学びました。 2022-10-01

n = int(input())
a_set = set(map(int, input().split()))
def can_read(x):
    global n
    i = len(set(range(1, x+1)) & a_set)
    return i + (n-i) // 2 >= x
l = 0
r = n+1
while r > l + 1:
    x = (l+r) // 2
    if can_read(x):
        l = x
    else:
        r = x
print(l)

上に書いた、高橋君が持っている巻の数列が単調増加じゃない引っかけテストケースを考慮し、ソートを1回入れたら最初の方針で正解できました。同じ巻を複数冊持っている場合はどんどん後ろに回し、持ってない巻があれば後ろから売って埋め合わせていくという割と愚直な方法です。1回目のsortを実行しないと、02_srnd_03、02_srnd_04、03_rnd_00、03_rnd_01、03_rnd_02、03_rnd_03のテストケースで不正解となりました。問題の条件を見れば単調増加じゃない可能性があることはわかるのですが、そこで引っかけても参加者にとって勉強にならないので、できればやめて欲しいです。笑。上の2分探索コードは892ms、このコードは179msで処理が終わりました。 2022-10-01

復習なうです。今のところこのコンテストが唯一の2完ですが、この問題C確かにむずかしいですね。やっかいなので2完も納得です。もう一度やってみたらこうなりました。2分探索おもしろいけど、自然に考えたらこうなりますよね。 2023-01-06

N = int(input())
alist = list(map(int, input().split()))
alist.sort()
amari = 0
auniq = [alist[0]]
for i in range(1, N):
    if alist[i] == alist[i-1]:
        amari += 1
    else:
        auniq.append(alist[i])
auniq.extend([-1]*amari)
book = 1
i = 0
while i < N:
    if auniq[i] != book: # need to sell
        if N - i >= 2:
            N -= 2
            book += 1
        else: # not enough
            break
    else:
        book += 1
        i += 1
print(book-1)

D - Flip and Adjust

またもやわからん。解説に、できるかできないかを動的計画法でという説明があります。dpの範囲は100x10000。たしかに十分小さいです。そして、dpのマトリックスを作ってしまえば、逆向きにたどることで表か裏か決められるなぁ。クレイジーだなぁ。できる気がしないことをできてしまうマジック。ふぅ。 2022-10-01

import sys
n, s = map(int, input().split())
cards = []
for _ in range(n):
    a, b = map(int, input().split())
    cards.append((a,b))
dp = [[0]*(s+1) for _ in range(n+1)]
dp[0][0] = 1
for i in range(1, n+1):
    for j in range(s+1):
        x = dp[i-1][j-cards[i-1][0]] if j-cards[i-1][0] >= 0 else 0
        y = dp[i-1][j-cards[i-1][1]] if j-cards[i-1][1] >= 0 else 0
        dp[i][j] = x | y
if dp[n][s] == 0:
    print('No')
    sys.exit()
else:
    print('Yes')
i = n
res = ''
while True:
    if i == 0:
        break
    if dp[i-1][s-cards[i-1][0]] == 1:
        s -= cards[i-1][0]
        res += 'H'
    else:
        s -= cards[i-1][1]
        res += 'T'
    i -= 1
print(res[::-1])

E - Subsequence Path

古いのを遡ってやり始めています。考えすぎてわからなかったのですが、コードを見ての通り、かなり簡単な処理で解ける問題です。くやしいです。数列Eを順番に処理して、その道を使ったときに次の都市に低いコストでたどり着ければ距離を更新する。それだけです。しかも同じリスト上で更新していくだけでOKです。こんなにシンプルなのに考え込んでしまってわからないってくやしいなぁ。長い文字列が入力されるので、input = sys.stdin.readlineでの高速化が有効に働く問題です。 2022-12-03

import sys
input = sys.stdin.readline
N, M, K = map(int, input().split())
A = [0]
B = [0]
C = [0]
for _ in range(M):
    a, b, c = map(int, input().split())
    A.append(a)
    B.append(b)
    C.append(c)
costs = [10**15]*(N+1)
costs[1] = 0
for e in map(int, input().split()):
    cnext = C[e] + costs[A[e]]
    costs[B[e]] = min(cnext, costs[B[e]])
print(-1 if costs[N]==10**15 else costs[N])

F - XOR on Grid Path

「半分全列挙」というらしいですが、そこまでは、なぜか自力でたどり着けました。(1,1)から対角線上にある、i+j=N+1のマスまでの通り道の組み合わせは、最大2^20通りなので100万程度になることがわかります。ということは、そのまま(N,N)まで行く組み合わせはその2乗で1兆ということになり、すべて計算できません。しかし(N,N)から逆に進んで来て対角線にたどり着く場合はまた100万程度の計算で済み、出会ったところで比べれば良いのではないでしょうか？問題のマス目を見ていて自然に思いついたのですが、1兆通り計算しなければならないところを、√1兆=100万の計算で済んでしまうなんて、なんでそんなことが可能なのか？これまた化かされたような気分です。気づけたにも関わらず、あれ？なんでこんなに計算量減るんだ？と不思議でした。とはいえ、それがわかったあとの実装も結構大変でした。コードを見るとなんかサラッと書いてるように見えますが、ループを回すときのインデックスの値をちゃんと決めるのに苦労してました。こういったループ中の変数の値の整理を短時間で行うのは、まだまだ苦手だなぁと思います。XORが0になるのは、同じ値同士の場合だけです。なので(1,1)から来た値と(N,N)から来た値が一致している組み合わせ数を調べればよいです。そこはCounterを使って計算しました。pythonのCounter、めっちゃ便利ですね。 2022-12-04

N = int(input())
alist = []
for _ in range(N):
    alist.append(list(map(int, input().split())))
# print(alist)
res1 = [[[] for _ in range(N)] for _ in range(N)]
res1[0][0].append(alist[0][0])
for i in range(1, N):
    j = i-1
    while j >= 0:
        k = i-1-j # j+k = i-1
        res1[j+1][k].extend([val^alist[j+1][k] for val in res1[j][k]])
        res1[j][k+1].extend([val^alist[j][k+1] for val in res1[j][k]])
        j -= 1
res2 = [[[] for _ in range(N)] for _ in range(N)]
res2[N-1][N-1].append(alist[N-1][N-1])
for i in range(N-1, 0, -1):
    j = i
    while j <= N-1:
        k = i+N-1-j
        if i == 1:
            res2[j-1][k].extend(res2[j][k])
            res2[j][k-1].extend(res2[j][k])
        else:
            res2[j-1][k].extend([val^alist[j-1][k] for val in res2[j][k]])
            res2[j][k-1].extend([val^alist[j][k-1] for val in res2[j][k]])
        j += 1
from collections import Counter
ans = 0
for i in range(N):
    j = N-1-i
    count1 = Counter(res1[i][j])
    count2 = Counter(res2[i][j])
    for n in count1:
        if n in count2:
            ans += count1[n]*count2[n]
print(ans)

G - Access Counter

勉強になるので、参加し始めてからのABCの問題Gまでを、遡ってやっています。問題Gを自力で解けるようになりたいですが、まだまだです。半分くらいは自力で進むのですが、最後の1手がわからないというような感覚があります。その1手に毎回驚いて刺激を受けるのでやめられません。この問題は、i時にアクセスが発生してから次にj時にアクセスが発生する確率が無限級数で計算でき、24個の状態が次にどこに遷移するかの確率が計算できるということまで自力でたどり着けました。1回目は24通り計算すればいいです。2回目は24x24通り計算すれば良い。これくらいなら計算できるなぁということまでわかりましたが、Nの最大値が10^18と書いてあるのを見て行き詰まりました。1ステップずつ進む方法しか思いつかなかったからです。これだけNがでかいと、毎回24x24通り計算するのは無理です。と、ここまで自分でたどり着けるだけでもずいぶん成長した気がします。解説を見てやられたと思いました。「繰り返し二乗法」という名前がついているようです。そういえば、べき乗の計算の中身がこういうやり方で、なるほどと思ったことがあるのですが、この問題は複雑だったので、思いつけませんでした。気づけるようになりたいものです。 2022-12-08

MOD = 998244353
inv100 = pow(100, MOD-2, MOD)
N, X, Y = map(int, input().split())
# X:T高橋, Y:A青木
S = input()
p = [(X if c=='T' else Y)*inv100%MOD for c in S] # access
q = [(100-X if c=='T' else 100-Y)*inv100%MOD for c in S] # noaccess
rate_next = [0]*(24*24)
rates = [rate_next]
for i in range(24): # prev access is i
    noaccess_sum = 1
    for j in range(1,25):
        t_next = (i + j) % 24
        ij = i * 24 + t_next
        rate_next[ij] = noaccess_sum * p[t_next] % MOD
        noaccess_sum = noaccess_sum * q[t_next] % MOD
infx = pow(1-noaccess_sum, MOD-2, MOD)
for i in range(24*24):
    rate_next[i] = rate_next[i] * infx % MOD
def multiply(l, r):
    ret = [0]*(24*24)
    for i in range(24):
        for j in range(24):
            idx = i * 24 + j
            for k in range(24):
                ret[idx] = (ret[idx] + l[i*24+k]*r[k*24+j]) % MOD
    return ret
count = 1
N_half = N // 2
while count <= N_half:
    rates.append(multiply(rates[-1], rates[-1]))
    count *= 2
digit = 0
first = True
while N:
    if N % 2 == 1:
        N -= 1
        if first:
            total_multiply = rates[digit]
            first = False
        else:
            total_multiply = multiply(total_multiply, rates[digit])
    N //= 2
    digit += 1
ans = 0
for i, c in enumerate(S):
    if c == 'A':
        ans = (ans + total_multiply[24*23+i]) % MOD
print(ans)

AtCoder Beginner Contest 272

前回に続き、問題Cで罠にハマってしまい5回も不正解を提出して、時間をロス。Cはなんとか解けましたが、Dは間に合わず、3問正解でした。前回2問正解で入茶したのに、早速脱落しかけています。直前までABC267 Ex Odd Sumをがんばっていて、なんとか正解できた直後の参加でした。解けない問題が積み上がっていると疲れますね。完全消化してから次のコンテストに臨めるようになりたいものですが、今の実力では無理です。いずれできるようになるのでしょうか？

C - Max Even

大きい順に3つの数字を選べば、その中の2つの和に必ず偶数が現れるなぁ、と思い、その値を回答すれば良いと思いこんでしまいました。実際には2番目と3番目の和より、1番目と4番目の和の方が大きい可能性があります。このことになかなか気づけず、なんとか正解したときには1時間以上経っていました。つらい。偶数の上位2つの和と奇数の上位2つの和を比較して大きい方を回答すればよかったのですね。それならシンプルでわかりやすいです。でも思いこんでしまうと抜け出せないなぁ。 2022-10-08

リベンジ。今となってはこうとしか思えないな。 2023-01-06

import sys
input = sys.stdin.readline
N = int(input())
even = []
odd = []
for a in map(int, input().split()):
    if a % 2 == 0:
        even.append(a)
    else:
        odd.append(a)
ans = [-1]
if len(even) >= 2:
    even.sort()
    ans.append(even[-1]+even[-2])
if len(odd) >= 2:
    odd.sort()
    ans.append(odd[-1]+odd[-2])
print(max(ans))

D - Root M Leaper

間に合わなかったけど、Cでハマらずに十分時間が取れたら正解できたかもなぁと思っています。 2022-10-08

from collections import deque
n, m = map(int, input().split())
import math
move = set()
for i in range(m):
    j2 = m - i**2
    if j2 < 0:
        break
    root_j2 = int(math.sqrt(j2))
    if root_j2**2 == j2:
        move.add((i,root_j2))
        move.add((i,-root_j2))
        move.add((-i,root_j2))
        move.add((-i,-root_j2))
        move.add((root_j2,i))
        move.add((-root_j2,i))
        move.add((root_j2,-i))
        move.add((-root_j2,-i))
grid = [[-1]*n for _ in range(n)]
q = deque([])
grid[0][0] = 0
q.append((0, 0))
while q:
    x, y = q.popleft()
    for delta in move:
        x_next = x + delta[0]
        y_next = y + delta[1]
        if 0 <= x_next < n and 0 <= y_next < n:
            if grid[x_next][y_next] == -1:
                grid[x_next][y_next] = grid[x][y] + 1
                q.append((x_next, y_next))
for i in range(n):
    print(*grid[i])

E - Add and Mex

これは無理だろ、M回の操作すらできないよ。と思って解説を見たら0からNまでの範囲内には、調和級数により、O(N log(N))しか入ってこないのだとか。調和級数なんて普段考えることないと、衝撃を受けますね。その情報を元にやってみると正解できました。考え方はむちゃくちゃ普通ですが、いけるという判断をするのがむずかしいですね。 2022-10-08

import math
n, m = map(int, input().split())
alist = list(map(int, input().split()))
val_list = [set() for _ in range(m+1)]
for i, a in enumerate(alist):
    i += 1
    if a > n:
        continue
    l = max(1, math.ceil(-(a/i)))
    r = min(m, math.floor((n-a)/i))
    for j in range(l, r+1):
        val_list[j].add(a + i*j)
for i in range(1, m+1):
    for j in range(n+1):
        if j in val_list[i]:
            continue
        print(j)
        break

F - Two Strings

ABCに参加するようになってから、Suffix Array（接尾辞配列）という言葉に何度かめぐりあっています。Suffix Arrayという概念に最初に触れた時は「マジかよ」と思いました。そこソートすんのかよ！と。しかもSA-ISという方法を使うとO(N)で計算できるようです。エグすぎます。ぼくは問題を解くときに、必要なアルゴリズムを一応理解して、自分なりに実装して解こうと試みるのが、基本姿勢としてあります。SA-ISも理解しようとはしましたが、こればかりは意味不明だったため、処理の流れを追ったところで自分で実装するエネルギーなどなく、「Suffix Arrayで解けます」と書かれている問題には、なかなか手を付けられずにいました。蟻本ではSA-ISの実装は説明されていません。ダブリングの実装が書かれています。しかしダブリングでは間に合わない問題が出題されてるっぽいですよね。もうSA-ISはブラックボックスとして使うしかないと腹をくくりました。「SA-IS Python」でググるとyaketake08さんの実装がヒットしますのでこれを使わせていただきました。で、普通に解けました。今後は苦手意識を持たずにSA-ISを使えるようになっていきたいです。解説では、SS、'a'をN回連続、TT、'z'をN回連続をつなげた文字列Xを考え、これのSuffix Arrayを構築すればよいと書いてありました。しかし、a-zだけを使うことにこだわらなければ、SS`TT{という文字列Xでいけると思いましたので、そのように実装しました。SA-ISを使う問題が解けたのは気持ちいいです。文字列Xを作ってSuffix Array、かなりおもしろい解き方だと思いました。 2022-11-04

# https://tjkendev.github.io/procon-library/python/string/sa_sa-is.html
# SA-ISコード省略

n = int(input())
s = input()
t = input()
x = s + s + chr(ord('a')-1) + t + t + chr(ord('z')+1)
res = 0
count_t = 0
for i in sais(x):
    if 2*n+1 <= i <= 3*n:
        count_t += 1
    elif 0 <= i <= n-1:
        res += (n-count_t)
print(res)

蟻本を読んで作ったダブリングバージョンも載せておきます。ACx9、TLEx63でした。だめだこりゃ。SA-ISがないとやってられねぇ。 2022-11-04

def sa_doubling(x):
    n = len(x)
    sa = [0]*(n+1)
    rank = [0]*(n+1)
    tmp = [0]*(n+1)
    def compare_sa(i, j, k):
        if rank[i] != rank[j]:
            return rank[i] < rank[j]
        else:
            ri = rank[i+k] if i+k <= n else -1
            rj = rank[j+k] if j+k <= n else -1
            return ri < rj
    for i in range(n+1):
        sa[i] = i
        rank[i] = ord(x[i]) if i < n else -1
    k = 1
    while True:
        if k > n:
            break
        sa.sort(key=lambda x: (rank[x], rank[x+k] if (x+k) <= n else -1))
        tmp[0] = 0
        for i in range(1, n+1):
            tmp[sa[i]] = tmp[sa[i-1]] \
            + (1 if compare_sa(sa[i-1], sa[i], k) else 0)
        for i in range(n+1):
            rank[i] = tmp[i]
        k *= 2
    return sa

n = int(input())
s = input()
t = input()
x = s + s + chr(ord('a')-1) + t + t + chr(ord('z')+1)
res = 0
count_t = 0
for i in sa_doubling(x):
    if 2*n+1 <= i <= 3*n:
        count_t += 1
    elif 0 <= i <= n-1:
        res += (n-count_t)
print(res)

G - Yet Another mod M

自力でたどり着けたのは、Mは素数と4だけで良いな、というところまででした。解説を見ると、「確率的にほぼ正解が出る」という解法が書かれており、みんなそれを使って高速なプログラムを書いていることに驚きました。一般的なやり方なのでしょうね。もう一方の解法は確実性のある方法だったのでこちらの方法で解くことにします。過半数がmod Mで一致するという条件から、もしもMが存在するなら、隣同士の数字の差の約数の中に含まれることがわかります。これ、気づけませんでした。なるほどです。確かに過半数の中に、必ず隣あうものが存在するはずです。3以上の素数と4のみでよいということまでは、わかっているので、見つかった素数で全探索しています。速度は出ませんが、これでACできました。この問題で、素因数分解のプログラムも勉強できたので、良かったです。 2022-12-01

import sys
from collections import defaultdict
N = int(input())
half = N // 2 + 1
alist = list(map(int, input().split()))
# return set of prime or 4 except for 2
def prime_factorization(n):
    res = set()
    count2 = 0
    while n % 2 == 0:
        count2 += 1
        n //= 2
    if count2 >= 2:
        res.add(4)
    a = 3
    while a*a <= n:
        while n % a == 0:
            res.add(a)
            n //= a
        a += 1
    if n != 1:
        res.add(n)
    return res
# return True if found
def checkall(p):
    counter = defaultdict(int)
    countmax = 0
    for i in range(N):
        a = alist[i]
        x = a % p
        counter[x] += 1
        if counter[x] == half:
            return True
        if counter[x] > countmax:
            countmax = counter[x]
        if countmax + N - 1 - i < half:
            return False
    return False
checked = set()
for i in range(N):
    diff = abs(alist[i]-alist[0 if i == N-1 else i+1])
    cands = prime_factorization(diff)
    for p in (cands-checked):
        if checkall(p):
            print(p)
            sys.exit()
    checked |= cands
print(-1)

AtCoder Beginner Contest 273

京都に旅行してたので不参加でした。

この回も2022年末から2023年始にかけて問題Gまでやりました。 2023-01-03

D - LRUD Instructions

書き方をミスるだけでわかりにくいコードになってしまいそうな問題です。整理してわかりやすく書ければ良いと思いました。境界部分は全部壁と思えば良いので、defaultdictのdefault値をlambda関数で渡してdefaultdict(lambda: [0,W+1])としているあたりや、1方向の移動後の位置を、壁の前と壁がない場合に到達する位置の近い方、というように表現したことでわかりやすくなったと思います。 2022-12-30

import sys
input = sys.stdin.readline
from collections import defaultdict
import bisect
H, W, ti, tj = map(int, input().split())
N = int(input())
blocks_hori = defaultdict(lambda: [0,W+1])
blocks_vert = defaultdict(lambda: [0,H+1])
for _ in range(N):
    i, j = map(int, input().split())
    blocks_hori[i].append(j)
    blocks_vert[j].append(i)
for i in blocks_hori:
    blocks_hori[i].sort()
for j in blocks_vert:
    blocks_vert[j].sort()
Q = int(input())
ans = []
for _ in range(Q):
    d, c = input().split()
    c = int(c)
    if d == 'L':
        blocks = blocks_hori[ti] if ti in blocks_hori else [0,W+1]
        idx = bisect.bisect(blocks, tj)
        tj = max(tj - c, blocks[idx-1] + 1)
    elif d == 'R':
        blocks = blocks_hori[ti] if ti in blocks_hori else [0,W+1]
        idx = bisect.bisect(blocks, tj)
        tj = min(tj + c, blocks[idx] - 1)
    elif d == 'U':
        blocks = blocks_vert[tj] if tj in blocks_vert else [0,H+1]
        idx = bisect.bisect(blocks, ti)
        ti = max(ti - c, blocks[idx-1] + 1)
    elif d == 'D':
        blocks = blocks_vert[tj] if tj in blocks_vert else [0,H+1]
        idx = bisect.bisect(blocks, ti)
        ti = min(ti + c, blocks[idx] - 1)
    ans.append('{} {}'.format(ti, tj))
print(*ans, sep='\n')

E - Notebook

問題文を素直に読むと、SAVEで整数列Aを丸ごとノートにコピーしたり、LOADでノートからAに丸ごとコピーしてきたりと、膨大な処理が必要になるように読めますが、Aを整数のツリーで管理すると、SAVEはツリーNodeにタグをつけることに、LOADはツリーNodeにポインタを移動することに対応し、膨大な操作は不要となります。問題の読み替えができるかどうかにかかっている、おもしろい問題です。 2022-12-30

import sys
input = sys.stdin.readline
class Node():
    def __init__(self, c, p):
        self.p = p # parent
        self.c = c
        self.children = {} # c -> Node
    def add(self, c): # return added Node
        if c not in self.children:
            self.children[c] = Node(c, self)
        return self.children[c]
note = {} # int -> Node
Q = int(input())
cur = ROOT = Node('', None) # root
ans = []
for _ in range(Q):
    q = input().split()
    if q[0] == 'ADD':
        cur = cur.add(int(q[1]))
    elif q[0] == 'DELETE':
        if cur != ROOT:
            cur = cur.p
    elif q[0] == 'SAVE':
        note[int(q[1])] = cur
    elif q[0] == 'LOAD':
        if int(q[1]) in note:
            cur = note[int(q[1])]
        else:
            cur = ROOT
    ans.append(-1 if cur == ROOT else cur.c)
print(*ans)

F - Hammer 2

最初、グラフを作ってクリティカルパスを調べて解けないか？と思って考えていましたが力尽きました。その方針で解けるのか？まだ気になりますが、ここでは解説の方法でやります。区間DPという新しいDPが出てきました。最近、過去にやったDPをまとめてふり返る機会を作り、これでちょっとDPに慣れたかなぁと思ったあとで、挿入DPが出てきて、さらにこの問題で区間DPが出てきました。まだあるんかい！と衝撃を受けています。到達した両端がLとRの状態でDPする、その情報を頼りにどうやって遷移していくのか？考えて、ようやくやり方がわかるまで苦労しました。Lにいる場合とRにいる場合も分け、L+1にLから行く場合とRから行く場合、R+1にLから行く場合とRから行く場合を計算していくんですね。見ての通りif分岐が多く、コードが長くなり苦労が見えます。ハンマーのインデックスを負数にすることで、壁と区別し、また、ゴールと原点のインデックスは0としました。このあたりの実装方針がこれで良かったのか？判断がむずかしいですが、ACにたどり着くことができました。入手済みハンマーを覚えておくところもややこしいですよね。 2023-01-03

N, X = map(int, input().split())
levents = [(0, 0)]
revents = [(0, 0)] # origin id 0 posi 0
if X > 0:
    revents.append((0, X)) # set goal id 0
else:
    levents.append((0, X))
# wall idx is +
for i, y in enumerate(map(int, input().split())):
    if y > 0:
        revents.append((i+1, y))
    else:
        levents.append((i+1, y))
# hammer idx is -
for i, z in enumerate(map(int, input().split())):
    if z > 0:
        revents.append((-i-1, z))
    else:
        levents.append((-i-1, z))
revents.sort(key=lambda x:x[1])
levents.sort(key=lambda x:-x[1])
rnum = len(revents)
lnum = len(levents)
rdp = [[-1]*rnum for _ in range(lnum)]
ldp = [[-1]*rnum for _ in range(lnum)]
rdp[0][0] = 0 # [l][r]
ldp[0][0] = 0
lhammers = set()
ans = -1
for i in range(lnum):
    ni = i + 1
    l  = levents[i]
    if l[1] == X:
        break # no need to move any more
    if l[0] < 0: # hammer
        lhammers.add(l[0])
    hammers = set(lhammers)
    for j in range(rnum):
        nj = j + 1
        r  = revents[j]
        if r[1] == X:
            break # no need to move any more
        if r[0] < 0:
            hammers.add(r[0])
        if ni < lnum: # update ldp next
            nl = levents[ni]
            if nl[0] <= 0 or nl[0] > 0 and -nl[0] in hammers:
                if rdp[i][j] != -1:
                    next = rdp[i][j] + r[1] - nl[1] # r->l
                    ldp[ni][j] = next if ldp[ni][j] == -1 else min(ldp[ni][j], next)
                if ldp[i][j] != -1:
                    next = ldp[i][j] + l[1] - nl[1] # l->l
                    ldp[ni][j] = next if ldp[ni][j] == -1 else min(ldp[ni][j], next)
                if nl[1] == X and ldp[ni][j] != -1:
                    if ans == -1:
                        ans = ldp[ni][j]
                    else:
                        ans = min(ans, ldp[ni][j])
        if nj < rnum: # update rdp next
            nr = revents[nj]
            if nr[0] <= 0 or nr[0] > 0 and -nr[0] in hammers: # can break r
                if rdp[i][j] != -1:
                    next = rdp[i][j] + nr[1] - r[1] # r->r
                    rdp[i][nj] = next if rdp[i][nj] == -1 else min(rdp[i][nj], next)
                if ldp[i][j] != -1:
                    next = ldp[i][j] + nr[1] - l[1] # l->r
                    rdp[i][nj] = next if rdp[i][nj] == -1 else min(rdp[i][nj], next)
                if nr[1] == X and rdp[i][nj] != -1:
                    if ans == -1:
                        ans = rdp[i][nj]
                    else:
                        ans = min(ans, rdp[i][nj])
print(ans)

G - Row Column Sums 2

最終的にDPの問題として解きましたが、自力ではできませんでした。DPをもっと解けるようになりたいですが、問題Gを自力で解いたのは過去1回しかないですし、まだまだ困難です。この問題はDPかなぁとも思ったのですが、最初別の方法で解けるのではないか？と思って試行錯誤していました。その時に少し考えを進めたあとで、RとCの1と2が同じ個数と勘違いしていて、心折れて解説を見ました。R方向に遷移していくDPで、残り2の列の個数をインデックスにすればよいとのこと。確かに、それまでに通った行を見れば、残った数字を計算でき、よって残り2の列の個数から残り1の列の個数も得ることができるので、これでいけます。こういったDPの式を、自力で思いつけるようになりたいものです！ところで、Python3でACしている30人ほどの中で、ぼくの処理速度が下から2番目の2408msだったのは少し気になります。この問題に関しては、配るDPより貰うDPの方が効率的で、処理速度が速くなりそうです。が、思考の流れが配るDPだったので配るDPで実装しました。書き換えるのは面倒です。貰うDPでやる強い意志を持って、その方針でささっと式を書くスキルは必要な場面が多そうですね。 2023-01-03

import sys
N = int(input())
mod = 998244353

# https://atcoder.jp/contests/abc273/submissions/37708024
# 階乗やchoose省略

R = list(map(int, input().split()))
sumR = sum(R)
sumC = 0
count2 = 0
for c in map(int, input().split()):
    sumC += c
    if c == 2:
        count2 += 1
if sumR != sumC:
    print(0)
    sys.exit()
dp = [0]*(N+1) # 2 left
dp[count2] = 1
sum_left = sumR
for i in range(N): # i->i+1
    if R[i] == 0: # do nothing
        continue
    dp_next = [0]*(N+1)
    for x in range(N+1):
        if dp[x] == 0:
            continue
        y = sum_left - 2*x
        if y < 0:
            break
        if R[i] == 1:
            if x > 0:
                dp_next[x-1] += dp[x] * x
                dp_next[x-1] %= mod
            dp_next[x] += dp[x] * y
            dp_next[x] %= mod
        elif R[i] == 2:
            if x > 1:
                dp_next[x-2] += dp[x] * choose(x, 2)
                dp_next[x-2] %= mod
            if x > 0:
                dp_next[x-1] += dp[x] * x
                dp_next[x-1] += dp[x] * x * y
                dp_next[x-1] %= mod
            if y > 1:
                dp_next[x] += dp[x] * choose(y, 2)
                dp_next[x] %= mod
    sum_left -= R[i]
    dp = dp_next
print(dp[0])

AtCoder Beginner Contest 274

ようやく初回以来の4問正解できました。これまで参加したABCの正解数は4,3,3,2,3,4です。初回にビギナーズラックなのか？4問正解でベストの成績を収め、その後低迷していたので、ようやく4問正解にたどり着けて嬉しいです。問題D - Robot Arms 2で、p2​=(A1​,0)というp2だけは+方向確定という条件を見逃していて、テストケース1つ不正解になる原因がわからず、残り30秒で気づいて正解するという奇跡を演じました。ミスったら不正解のまま終了という手に汗握る状況で正解できました。この罠にハマってなかったら問題Eを30分くらい考えられたのではないか？問題Eはたまに簡単なこともあるし解けたかもしれない。と悔しかったですが、問題Eはむずかしく、時間があってもどうせできませんでしたので、今回の4問正解は実力だなと納得しています。

E - Booster

わからなくて解説見ましたが、S\{i}というのは集合Sからiを除くという意味のようですね。これを知らなかったので、解説の理解にも手こずりました。いつも考え方を理解したあと、まずは自力で実装してみるのですが、bitDPのビットフラグの部分を、通過点のセットのタプルで表現し、dictを使ってやりましたところ、順当に時間制限にひっかかりました。で、解答例を見ました。なかなかエグいです。ビット演算を使いまくってるのはビット演算に慣れるのにいいですね。注意点として覚えたのは、&などのビット演算子の優先順位は+などの演算子より低いということ。なのでビット演算子を使う時()で囲っておいたほうが無難だなと思いました。知らない言葉も覚えました。popcountというのはビットが1の桁の数のようです。この問題ではboosterの回数を調べるのに5bitの整数のpopcountが必要なので、最初に計算してリストを作成していました。作り方もおもしろいです。ちなみに、Python3.10でint.bit_count()が追加されましたが、AtCoderでは使えませんね。hypotというのは2乗和の平方根らしいです。hypotenuse（ハイポテニュース）の略で、斜辺という意味です。平方根の計算をするときにmath.sqrtを使うのが当たり前と思っていましたが、**0.5と0.5乗する方法もあることも知りました。ぼくは距離は最初に全部計算して覚えておくように実装しました。この問題で最後に気になったのはdpのループの順序がこれで問題ないのか？ということです。通過した場所のリストをn+m桁のビットフラグで持っていて、for s in range(1, 1<<(n+m))のようにループさせてdpを更新しています。これでいいのか？ということです。考えてみると、これでいいということがわかりました。現在見ている[s]を更新できる条件は、sの部分集合の[sub_s]がすでに更新されていることですが、ビットフラグで考えるとsub_sのビットはsのビットの一部であることから、sub_s < sであることは明らかです。なのでこのループ処理において、[s]を更新する時点ですべての[sub_s]は更新されていることがわかります。なので、これで良いのです。最初に自力で実装したときは、popcountが小さい順じゃなければならないのではないかと思って、popcountをインクリメントしながらループして、combinationでsを作ってましたからね。そりゃあいろいろと重い。bitDP、クレイジーですね。 2022-10-23

popcount = [0]*32
for i in range(1, 32):
    popcount[i] = popcount[i>>1] + (i&1) # + > &
n, m = map(int, input().split())
nodes = [(0,0)]
for _ in range(n+m):
    nodes.append(tuple(map(int, input().split())))
dists = [[0.0]*(n+m+1) for _ in range(n+m+1)]
for i in range(n+m+1):
    for j in range(n+m+1):
        if j == i:
            continue
        if j < i:
            dists[i][j] = dists[j][i]
        dx = nodes[i][0] - nodes[j][0]
        dy = nodes[i][1] - nodes[j][1]
        dists[i][j] = (dx*dx + dy*dy)**0.5
# initialize
dp = [[1e12]*(1<<(n+m)) for _ in range(n+m)]
for i in range(n+m):
    dp[i][1<<i] = dists[0][i+1] #index+1 in dists
for s in range(1, 1<<(n+m)):
    boost_count = popcount[s>>n]
    for i in range(n+m):
        if not s & (1<<i):
            continue
        for j in range(n+m):
            if s & (1<<j):
                continue
            # i in s, j not in s
            new_time = dp[i][s] + dists[i+1][j+1]*0.5**boost_count
            if new_time < dp[j][s|(1<<j)]:
                dp[j][s|(1<<j)] = new_time
res = 1e12
for s in range((1<<n)-1, 1<<(n+m), 1<<n):
    boost_count = popcount[s>>n]
    for i in range(n+m):
        time = dp[i][s] + dists[i+1][0]*0.5**boost_count
        if time < res:
            res = time
print(res)

F - Fishing

わからなかったので解説の考え方を見ました。ある時刻において「左端に魚が必ずいる状態を調べれば良い」ということまでは自力でわかっていたのですが、その先の発想の転換ができませんでした。「時刻tではなくfish[i]に注目する」という視点の転換は、プログラミングにおいて、あるあるパターンだと思います。「左端に魚がいる状態を見ればいい」→「左端の魚を固定してみる」これが自然に思いつくようになりたいです。で、そこまでわかっても、Pythonで時間制限を突破するのはしんどかったです。最初heapqでイベントの発生順を管理しようとしましたが、全然間に合いませんでした。しかもPythonで間に合わせるユーザー解説に書いてあるように、ぼくもタプルをheapqにつっこんでました。無駄に第2要素の重さも見てしまってるようだし、いろいろ重い。時間のsetと、時間をキーとする重さの変化のdictを別々に管理してようやく間に合いました。Pythonで正解するにはノウハウがいろいろ必要ですね。いもす法なんですが、当たり前すぎていもす法とか言わないんでしょうか。笑。  2022-10-24

from collections import defaultdict
n, a = map(int, input().split())
fish = [tuple(map(int, input().split())) for _ in range(n)]
# w x v
res = 0
for i in range(n):
    # watch fish[i]
    imosuplus = defaultdict(int)
    imosuminus = defaultdict(int)
    times = set()
    for j in range(n):
        if i == j:
            continue
        v_rel = fish[j][2] - fish[i][2]
        if v_rel == 0:
            if fish[i][1] <= fish[j][1] <= fish[i][1]+a:
                times.add(0.0)
                imosuplus[0.0] += fish[j][0]
        elif v_rel > 0: # j is faster
            if fish[j][1] <= fish[i][1]+a:
                if fish[i][1] <= fish[j][1]:
                    times.add(0.0)
                    imosuplus[0.0] += fish[j][0]
                else:
                    time = (fish[i][1]-fish[j][1])/v_rel
                    times.add(time)
                    imosuplus[time] += fish[j][0]
                timeout = (fish[i][1]+a-fish[j][1])/v_rel
                times.add(timeout)
                imosuminus[timeout] -= fish[j][0]
        elif v_rel < 0: # i is faster
            if fish[i][1] <= fish[j][1]:
                if fish[j][1] <= fish[i][1]+a:
                    times.add(0.0)
                    imosuplus[0.0] += fish[j][0]
                else:
                    time = (fish[i][1]+a-fish[j][1])/v_rel
                    times.add(time)
                    imosuplus[time] += fish[j][0]
                timeout = (fish[i][1]-fish[j][1])/v_rel
                times.add(timeout)
                imosuminus[timeout] -= fish[j][0]
    weight = fish[i][0]
    if weight > res:
        res = weight
    for time in sorted(list(times)):
        weight += imosuplus[time]
        if weight > res:
            res = weight
        weight += imosuminus[time]
print(res)

G - Security Camera 3

問題の内容がシンプルでとっつきやすいので、自力で解けるんじゃないかと錯覚しましたが、いろいろな新しいことを勉強しなければ、ぼくには解けない問題でした。右方向と下方向のカメラだけ考えれば良くて、'.'が連続して並んでるところは1つのカメラで監視できます。すべての'.'をどちらかのカメラで監視するには最低いくつのカメラが必要か？というように、問題を読み替えられます。単純だし、全部右方向だけでもそこそこいい答えが得られそうじゃないですか。でも簡単ではありませんでした。この問題を通じて新しい言葉やアルゴリズムを覚えることとなりました。右方向のカメラのノードセット1、下方向のカメラのノードセット2を考え、それらの間をエッジ（'.'に相当）でつなぐグラフの問題となります。このような、ノードが2つのグループに分けられて、同じグループ内のノードは隣接していないようなグラフを「2部グラフ」と呼びます。最小数のノードを選択することですべてのエッジをカバーするにはどうすればよいか？という問題だということがわかりますが、それを「最小点カバー」「最小点被覆」と呼びます。さらに、2部グラフの「最小点カバー」は「最大マッチング」と一致するため、「最大マッチング」を解く問題に帰着します。（追記：マッチングの片方の点を選んでカバーできるということです。）なぜ「最小点カバー」と「最大マッチング」が一致するのかというと、グループ1のマッチしていない点Aの隣接点は必ずマッチしています。なぜなら隣接点もマッチしていないなら新しいマッチングが作れるので「最大マッチング」になってなかったことになりますから。グループ2のマッチしていない点Bについても同様です。では、Aの隣接点とBの隣接点同士がマッチしていることがあるかというと、それはありません。もしそうなっていると、Aと隣接点、Bと隣接点で2つマッチを作ったほうが良いことになり、この場合も「最大マッチング」になってなかったことになりますから。そのように考えを進めると、「最小点カバー」は「最大マッチング」と一致することがわかります。では「2部グラフ」の「最大マッチング」はどのように求めるのか？Source（s）ノードからグループ1のすべてのノードにつながっており、グループ2のすべてのノードがSink（t）につながっているようなグラフを考え、「最大流」を求めることで、「最大マッチング」を得ることができます。「最大流」を求めるにはFord-Fulkersonアルゴリズムを使います。sからtに流せるルートが無くなるまで、深さ優先探索をやり続けるという方法です。すでに流したエッジは、流量を減らすことで逆方向に流すことができると考えるのが味噌です。なぜ、Ford-Fulkersonで最大流量が求まるか？処理が終わるとtまで流せなくなったので、まだ流せる頂点の集まりSを考えます。これを残余グラフと呼びます。（Sから出ていく流量）-（Sに入ってくる流量）が現在求まっている総流量のはずです。ここで（Sから出ていく流量）は、キャパ限界で、（Sに入ってくる流量）は0となっているはずです。そうでないなら、流量を減らす余地があることになり、残余グラフSをもっと広げられることになるからです。よって、Sからこれ以上出ていくことができない状態になっていることがわかりますので、化かされたようなロジックですが、最大流量は確かに求まっていることがわかります。しかしFord-Fulkersonは効率的ではなく、最初このアルゴリズムを使ってやってみたらTLE（Time Limit Exceeded）でした。Dinic法という、より速い方法があります。Ford-Fulkersonは何も考えずにDFSを繰り返しますが、Dinic法では、BFSで各頂点へのSからの距離を計算し、一番短い経路から順にDFSします。これで速くなるというのがぼくにはあまり直感的ではありませんが、Ford-Fulkersonに比べて、処理がとても秩序だっていることはわかります。Dinic法を実装することで、ようやくACすることができました。この問題は、非常にシンプルで自力でいけそうでしたが、解くために新しい言葉を覚え、苦労してアルゴリズムを理解し、何ステップも経てのACで、勉強になりました。 2022-11-02

import sys
from collections import defaultdict
h, w = map(int, input().split())
s = []
cam_wdir = [[0]*w for _ in range(h)]
cam_cur = 0 # source
g = defaultdict(list)
for i in range(h):
    gap = True
    s_row = input()
    s.append(s_row)
    for j, c in enumerate(s_row):
        if c == '.':
            if gap == True:
                cam_cur += 1
                gap = False
                g[0].append([cam_cur, 1, len(g[cam_cur])])
                g[cam_cur].append([0, 0, len(g[0])-1])
            cam_wdir[i][j] = cam_cur
        if c == '#':
            gap = True
camlist_hdir = []
for j in range(w):
    gap = True
    for i in range(h):
        if s[i][j] == '.':
            if gap == True:
                cam_cur += 1
                gap = False
                camlist_hdir.append(cam_cur)
            g[cam_wdir[i][j]].append([cam_cur, 1, len(g[cam_cur])])
            g[cam_cur].append([cam_wdir[i][j], 0, len(g[cam_wdir[i][j]])-1])
        if s[i][j] == '#':
            gap = True
cam_cur += 1 # sink
if cam_cur == 1:
    print(0)
    sys.exit()
for i in camlist_hdir:
    g[i].append([cam_cur, 1, len(g[cam_cur])])
    g[cam_cur].append([i, 0, len(g[i])-1])
from collections import deque
level = []
def bfs(s):
    global g
    global level
    level = [-1]*len(g) # initialize level
    level[s] = 0
    q = deque([s])
    while q:
        v = q.popleft()
        for e in g[v]:
            if e[1] and level[e[0]] < 0:
                level[e[0]] = level[v] + 1
                q.append(e[0])
watch = [0]*len(g)
def dfs(v, t, f):
    global g
    global watch
    global level
    if v == t:
        return f
    for i in range(watch[v], len(g[v])):
        watch[v] = i
        e = g[v][i] # e = [to, capa, rev_id in g[to]]
        if e[1] and level[e[0]] > level[v]:
            d = dfs(e[0], t, min(f, e[1])) # f=e[1]=1 in this problem
            if d > 0: # d must be 1 in this problem
                e[1] -= d
                g[e[0]][e[2]][1] += d
                return d
    return 0
flow = 0
while True:
    bfs(0)
    if level[len(g)-1] < 0:
        break
    watch = [0]*len(g)
    while True:
        f = dfs(0, len(g)-1, 1)
        if f == 0:
            break
        flow += f
print(flow)

PyPyではなく、Pythonを使えば、NetworkXというライブラリを使うことができ、NetworkXには2部グラフの最大マッチングを求める関数も用意されているようです。それも試してみました。上のコードより少し処理時間が伸びましたが、ACできました。Hopcroft–Karpアルゴリズムを使っています。速そうですが、PyPy+自分で実装したDinicには勝てませんでした。NetworkXのhopcroft_karp_matchingを利用した2部グラフの最大マッチング計算は、以下のコードの最後の部分です。matchingのdictには逆方向のエッジも含まれるため、2で割る必要があります。 2022-11-02

import networkx as nx
h, w = map(int, input().split())
s = []
cam_wdir = [[0]*w for _ in range(h)]
cam_cur = 0
cams_wdir = []
for i in range(h):
    gap = True
    s_row = input()
    s.append(s_row)
    for j, c in enumerate(s_row):
        if c == '.':
            if gap == True:
                cam_cur += 1
                gap = False
                cams_wdir.append(cam_cur)
            cam_wdir[i][j] = cam_cur
        if c == '#':
            gap = True
es = []
cams_hdir = []
for j in range(w):
    gap = True
    for i in range(h):
        if s[i][j] == '.':
            if gap == True:
                cam_cur += 1
                gap = False
                cams_hdir.append(cam_cur)
            es.append((cam_wdir[i][j], cam_cur))
        if s[i][j] == '#':
            gap = True
B = nx.Graph()
B.add_nodes_from(cams_wdir, bipartite=0)
B.add_nodes_from(cams_hdir, bipartite=1)
B.add_edges_from(es)
matching = nx.bipartite.hopcroft_karp_matching(B, cams_wdir)
print(len(matching)//2)

AtCoder Beginner Contest 275

はじめて5問正解できました！前回まで4問を目指してがんばっていて、ようやく4問解けたところでしたが、その次の回で更新できるとは、ノッているようでうれしいです。問題Cは、頂点ペアを全探索し、それを1辺とする正方形があればカウントし、最後に4で割るという方法でやりましたが、処理時間は問題ありませんでした。問題Dは、最初f(10)くらいまで書き出してなにか規則がないかなどと考え始めましたが、f(n)を求めるのに、f(n/2)とかf(n/3)の値がわかればいいので結構計算が必要なところはスカスカであることに気づき、メモしながら再帰で解けました。問題Eは、逆元が必要な問題は過去に出会って計算方法を覚えていたので、そこでは悩みませんでした。確率の計算もこなれて、できたのかもしれません。Ratingが+169で665に伸びました。 2022-10-29

F - Erase Subarrays

DPだろうと思いながらも、どうすればいいかわからず、解説を読みました。確かに解説の通り、DPの式を作ることができます。これを自力で思いつけるようになるには、いろいろなパターンを解いていくしかないように思います。解説にdp[i][j][k]で、k=0のときaiを削除し、k=1のときaiを残すと書かれていますが、そのまま実装するとTLE（Time Limit Exceeded）となってしまいました。どうもPythonは、リストの数がパフォーマンスに大きく影響するようです。dp[i][j][k]だと、3次元目の要素数2のリストがN x M個作られることになります。これをdp[i][k][j]という順序にいれかえると、3次元目の要素数がMになり、リスト数はN x 2となり、この問題では1000分の1以下に削減できることになります。実際そのようにjとkを入れ替えるだけでACすることができました。制限時間2秒に引っかかっていたのに、431msで処理が終わりました。解説でdp[i][j][k]となっているのは理解しやすくて自然ですが、Pythonで解くには罠になっていました。高速に動作するためには、小さいリストをたくさん作るのを避け、大きなリストを少なく作るようにするべきです。メモ用の多次元リストは機械的に行列入れ替えられるはずなので、そのように実装すべきです。この問題から非常に重要な知見を得ることができました。 2022-10-30

n, m = map(int, input().split())
alist = list(map(int, input().split()))
dp = [[[3000]*(m+1) for _ in range(2)] for _ in range(n)]
dp[0][0][0] = 1
if alist[0] <= m:
    dp[0][1][alist[0]] = 0
for i in range(1, n):
    for j in range(0, m+1):
        dp[i][0][j] = min(dp[i-1][1][j]+1, dp[i-1][0][j])
        j_ = j - alist[i]
        if j_ >= 0:
            dp[i][1][j] = min(dp[i-1][1][j_], dp[i-1][0][j_])
for j in range(1, m+1):
    res = min(dp[n-1][0][j], dp[n-1][1][j])
    print(-1 if res >= 3000 else res)

G - Infinite Knapsack

今日は2022年12月1日。最近ABCの7問目である問題Gまでを、コンテスト終了後にACできるようになっています。ABC276、277、278、279は、やりました。昔はできてなかったのですが、力がついてきたのか、コンテスト終了後解説を見てACできているのです。非常に勉強になっているので、遡って問題Gまでを埋めていこうかなと思います。最初がこの問題で、最終的にはABCに参加し始めたところまで戻っていければと思います。この問題ですが、全部価値が1になるようにして解けば良く、Σxi = 1の条件で、max(Σai*xi, Σbi*xi)の最小値を求める問題であるというところまで、自力で問題を言い換えられていました。そこでなんとなく、力尽きたなぁと思って解説を見に行ったところ、凸包と書いてありました。自分で書いた式をよく見たらΣxi = 1で(Σai*xi, Σbi*xi)ってたしかに(ai, bi)の凸包ですね。冴えてたら気づけたと思うとちょっとくやしいです。で、凸包はこれを使えば良いと解説にありました。ロジックはわかりやすく、コピーして使います。この問題は、凸包の経験さえあればいけそうに感じました。問題Gの自力正解もちょっと近づいてきたような気がします。 2022-11-30

N = int(input())
points = []
for _ in range(N):
    a, b, c = map(int, input().split())
    points.append((a/c, b/c))
points.sort()
def cross(o, a, b):
    return (a[0]-o[0])*(b[1]-o[1]) - (a[1]-o[1])*(b[0]-o[0])
lower = []
for p in points:
    while len(lower) >= 2 and cross(lower[-2], lower[-1], p) <= 0:
        lower.pop()
    lower.append(p)
# upper = [] # upper[:-1]
# for p in reversed(points):
#     while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:
#         upper.pop()
#     upper.append(p)
len_con = len(lower)
res = max(lower[0][0], lower[0][1])
if len_con > 1:
    for i in range(1, len(lower)):
        a, b = lower[i-1]
        c, d = lower[i]
        if d >= b:
            break
        res = min(res, max(c, d))
        t = (a-b)/(a+d-b-c)
        if 0.0 < t < 1.0:
            res = min(res, a+(c-a)*t)
print(1/res)

AtCoder Beginner Contest 276

家族で焼肉を食べに行ってたので、リアルタイム参加していません。翌日バーチャル参加し、問題A-Dの4完でした。4問解けたのは喜ばしいです。問題Cでなかなかバグを取れず45分くらいかかってしまいました。それでも問題Eに30分くらいかけられましたが、間に合いませんでした。ぼくの問題Eの方針は、壁伝いに進むというものだったのですが、うまく実装できず混乱に陥ってしまいました。笑。

E - Round Trip

上記の通り、ハマってしまったため、解説を読みました。なるほど、シンプルですばらしいです。Sの上下左右の4点を始点として行ける限り行く。つながればOKということですね。自然に思いつきたいものです。ぼくが最初にやろうとしていた「壁伝いに行く」でも解けるのでしょうか？まあちゃんとやればいけるのでしょうけれども。 2022-11-06

import sys
from collections import deque
h, w = map(int, input().split())
cs = []
for i in range(h):
    cline = input()
    cs.append(list(cline))
    j = cline.find('S')
    if j >= 0:
        si = i
        sj = j
snexts = [(si+1,sj),(si-1,sj),(si,sj+1),(si,sj-1)]
for i, snext in enumerate(snexts):
    if 0 <= snext[0] < h and 0 <= snext[1] < w:
        if cs[snext[0]][snext[1]] == '.':
            q = deque([snext])
            while q:
                cur = q.pop()
                cs[cur[0]][cur[1]] = i
                if 0 <= cur[0]+1 < h:
                    if cs[cur[0]+1][cur[1]] == '.':
                        q.append((cur[0]+1,cur[1]))
                if 0 <= cur[0]-1 < h:
                    if cs[cur[0]-1][cur[1]] == '.':
                        q.append((cur[0]-1,cur[1]))
                if 0 <= cur[1]+1 < w:
                    if cs[cur[0]][cur[1]+1] == '.':
                        q.append((cur[0],cur[1]+1))
                if 0 <= cur[1]-1 < w:
                    if cs[cur[0]][cur[1]-1] == '.':
                        q.append((cur[0],cur[1]-1))
        elif isinstance(cs[snext[0]][snext[1]], int):
            print('Yes')
            sys.exit()
print('No')

F - Double Chance

k番目のカードを袋に追加したときに、期待値がどのように変化するのかまでたどりつき、フェニック木的なので高速に計算するんだろうなぁと思いながらそれ以上考えるエネルギーがなく、力尽きて解説を見ました。解説に、フェニック木を2つ作ると書いてあります。そこまでわかれば、あ～確かにいけそうだとなって実装し、ACできました。フェニック木といえば、初めて参加したABC266のEx - Snuke Panic (2D)で覚えた構造です。あの時は終わったあとの復習で、解説を見てExまでやらないといけないという強迫観念があり、むちゃくちゃつらい苦労をして1週間でACしたのでした。初めてでよくわかっていなかったからこそできたことでしたが、その後、初参加から3回目まではExをACするまでやりました。次ExをACするのはいつだろう？ABC266 Exで使ったのは2次元フェニック木でした。前回は最大値を求めるフェニック木でしたが、今回は合計ですね。2次元フェニック木だと空間計算量がでかくなりすぎることの回避策として、リストではなく辞書で実装します。今回は1次元ですが、最初は辞書のまま実装して提出しました。時間は1141msでした。 2022-11-07

m = 998244353
class BIT():
    global m
    def __init__(self, n):
        self.n = n
        self.sums = {}
    def add(self, i, input):
        while i <= self.n:
            if i in self.sums:
                self.sums[i] += input
            else:
                self.sums[i] = input
            self.sums[i] %= m
            i += i&-i
    def prod(self, i):
        res = 0
        while i > 0:
            res += self.sums.get(i, 0)
            i -= i&-i
        return res
n = int(input())
alist = [a for a in map(int, input().split())]
a_max = 2*10**5
fnum = BIT(a_max)
fsum = BIT(a_max)
top = 0
bottom = 1
for i, a in enumerate(alist):
    num_low = fnum.prod(a)
    sum_up = fsum.prod(a_max) - fsum.prod(a)
    top += (num_low*2 + 1) * a + sum_up*2
    top %= m
    inv_bottom = pow(bottom, m-2, m)
    print(top*inv_bottom % m)
    bottom += 2*(i+1) + 1
    bottom %= m
    fnum.add(a, 1)
    fsum.add(a, a)

なんか遅いなと思い、リストで作り直したところ、459msと、かなり速くなりました。 2022-11-07

class BIT():
    global m
    def __init__(self, n):
        self.n = n
        self.sums = [0]*(n+1)
    def add(self, i, input):
        while i <= self.n:
            self.sums[i] += input
            self.sums[i] %= m
            i += i&-i
    def prod(self, i):
        res = 0
        while i > 0:
            res += self.sums[i]
            i -= i&-i
        return res

G - Count Sequences

しばらく考えた後、あきらめて解説を見ました。解説を理解するのも苦労しました。解説者と自分の思考が同調しないというかなんというか、読めばすんなり入ってくるのではなくて、自分なりに再構築してようやくわかるので、解説を読むって大変ですね。ai+1とaiの差をbiとおく時点でやられたと思いました。でも問題の条件から、差を3で割った余りが1か2になることがわかるわけですから、自然といえば自然で、慣れてくるとこのような変形はできるようになるのかもしれません。ヒントは問題の中に隠されており、素直に考えれば思いつくのではないでしょうか？a1をp、M-aNをq、bi=3*yi+1+xiとおくと、条件は、M-n+1=p+q+3*Σyi+Σxiと変形できて見通しがよくなります。p、q、yiは非負整数、xiは0か1です。これでできる！と思ったのですが、まだまだダメでした。Σyiの取りうる値でループし、残りをp+q+Σxiに振り分けます。このとき、xiのうちいくつ1があるかでループすると、2重ループになり、計算量がO(MN)とかになってしまうのです。なんとかして2重ループを避けなければなりません。でも自力で考えてもどうにもわからん。この問題に関しては、「累積和」というテクニックを使って2重ループを回避できるようです。このように考えます。xiのみで合計sとなる組み合わせ数をf(s)とするとf(s)=choose(n-1,s)です。pとxiのみで合計sとなる組み合わせ数をg(s)とすると、g(s)=Σp(0→s)f(s-p)なので、g(s)=Σp(0→s)f(p)となります。pとqとxiで合計sとなる組み合わせ数をh(s)とすると、同様にh(s)=Σq(0→s)g(q)となることがわかり、h(s)はg(s)の累積和を2回計算すると求められることがわかります。h(s)を事前にO(N)で計算しておき、参照することで内側のループは不要になります。トリッキーで化かされたような気分です。pとqとxiで合計sにするとき、ループを回して足し算してしまうよなぁと思うんですよね。1度経験したことで、これは累積和かな？って今後思うのでしょうか？ 2022-11-09

import sys
mod = 998244353
n, m = map(int, input().split())
sum = m - n + 1
if sum < 0:
    print(0)
    sys.exit()

count_max = max(n - 1, sum//3 + n -2)
fact = [0]*(count_max+1)
invfact = [0]*(count_max+1)
fact[0] = 1
for i in range(1, count_max+1):
    fact[i] = fact[i-1] * i % mod
invfact[count_max] = pow(fact[count_max], mod-2, mod)
for i in range(count_max-1, 0, -1):
    invfact[i] = invfact[i+1] * (i+1) % mod
invfact[0] = 1
def choose(a, r):
    return fact[a] * invfact[r] * invfact[a-r] % mod

two_max = min(sum, n-1)
g = [0]*(two_max+1)
for i in range(two_max+1):
    g[i] = choose(n-1, i)
for i in range(1, two_max+1):
    g[i] = (g[i] + g[i-1]) % mod
if sum > n-1:
    keep = g[n-1]
for i in range(1, two_max+1):
    g[i] = (g[i] + g[i-1]) % mod

ans = 0
for threes in range(sum//3 + 1):
    case_y = choose(threes+n-2, threes)
    left = sum - threes * 3
    ans += case_y * (g[left] if left < n else g[n-1] + keep*(left-n+1))
    ans %= mod
print(ans)

Ex - Construct a Matrix

今ならmod2の連立一次方程式であることは、2が奇数個含まれているときだけ、余り2になることからわかるので、今なら解けるかも、と、ふとこの問題を思い出してやってみたら、簡単ではありませんでした。Q=N=2000で、全頂点を変数にすると、条件だけでQN^2です。無理。XORの2次元累積和を取ることで、4隅のXOR累積和だけを変数として連立方程式を作れるとのことです。4Q^2に減ります。これは気づけない。0は、1つ含まれていれば0になってしまうから、1か2の領域と被ってないことをチェックするだけでしょ。と思ったらこれも結構大変で、2次元いもすからの2次元累積和で処理しました。その後もとにかくバグ取りが大変で、解いた連立方程式の解に自由度があると思うのですが、それによって03_smallzero_01-04あたりのテストケースはダメパターンに陥りました。0でなければならないところを、2にしてしまう解があるということです。どうやって回避すればいいのかわからないのですが、結局0でなければならないところは、無理やり0にするという処理を入れたらなぜかACできました。なぜこれでいいのかわかってないので、もしかしたらバグっているかもしれません。まあ、可能な解でループする処理を入れて、0を2にしてしまったら次の解でやってみるというのが自然な回避方法でしょうね。その処理を書いたことがないし、やったほうがいいですが、もう余力がないです。久しぶりのEx ACで勉強になるところは多かったです。 2023-03-11

AtCoder Beginner Contest 277

4完でした。問題Eに40分残っていました。問題Eは、難しいなと思いましたが、スイッチをコスト0の辺とみなすことに時間内にひらめき、なんとか解こうとがんばりましたが間に合いませんでした。始めた当初なら、これに気づけることなどありえなかったことなので、自分にとってうれしいことですが、解けてる人多すぎです。こんなトリッキーでも、ありがちなパターンなんだろうなぁと思いました。入緑を目指していましたがならず。終わったあと提出したら、なぜか実行時エラー発生。翌朝再チャレンジでACできましたが、その過程でダイクストラ法のロジックにミスっている箇所を発見し、勉強になりました。 2022-11-12

E - Crystal Switches

a=1の辺に対応する頂点を1からN、a=0の辺に対応する頂点をN+1から2*Nとなるように分離してグラフを作ります。スイッチはsとs+Nをつなぐコスト0の辺とみなします。そこからダイクストラ法を使って解きました。heapqにタプルを入れることに抵抗がありますが、そのように実装しました。最初、テストケース001.txtと003.txtがRE（実行時エラー）となって原因不明でした。翌朝やり直したときにダイクストラ法の実装に不備があることに気づきました。# needless cost maybe registered in pqとコメントを書いた箇所です。危ないです。勉強になりました。 2022-11-13

from collections import defaultdict
n, m, k = map(int, input().split())
edges = defaultdict(set)
switches = {}
for _ in range(m):
    u, v, a = map(int, input().split())
    if a == 0:
        u += n
        v += n
    edges[u].add(v)
    edges[v].add(u)
if k != 0:
    for s in map(int, input().split()):
        switches[s] = s+n
        switches[s+n] = s
costs = [-1]*(2*n + 1)
costs[1] = 0
import heapq
pq = [(0, 1)]
while pq:
    cur = heapq.heappop(pq)
    cost = cur[0]
    v = cur[1]
    if cost > costs[v]:
        # needless cost maybe registered in pq
        continue
    for next in edges[v]:
        if costs[next] == -1 or cost+1 < costs[next]:
            costs[next] = cost+1
            heapq.heappush(pq, (cost+1, next))
    if v in switches:
        next = switches[v]
        if costs[next] == -1 or cost < costs[next]:
            costs[next] = cost
            heapq.heappush(pq, (cost, next))
if costs[n] == -1:
    print(costs[2*n])
elif costs[2*n] == -1:
    print(costs[n])
else:
    print(min(costs[n], costs[2*n]))

F - Sorting a Matrix

あわよくば、自力で解けるのではないか？そんな淡い期待を胸に、次の問題、次の問題と進んでいってしまいます。そして問題は解けず、時間が溶けていきます。でも時間が溶けることはネガティブなことではありません。その時間、確実に学んでいるわけですから。この問題Fを自力で解くことはできませんでした。知らない概念が必要な問題で、とても勉強になりました。新しい問題に挑戦するたびに、知らないことがどんどん出てくるからやめられません。解けなかった問題が解けた時、確実に1歩前進しているわけですから。0は無視でいいな。H方向はなんとかなるな。W方向は置換？うーんわからん。ということで解説を読みます。グラフの問題だったんですね。驚きます。新たに学んだ言葉は、「トポロジカルソート」「DAG（Directed Acyclic Graph）（有向非巡回グラフ）」です。W方向は、列を1つの頂点と考え、小さい数字から大きい数字に有向辺を張ります。そうしてできたグラフを「トポロジカルソート」できるならば、条件を満たす置換ができます。しかしそのまま実装するとH x choose(W,2)=O(HW^2)本も辺を作ることになってしまいます。これをO(HW)にする方法が書かれていますが、エグいですね。一般的なやり方なんでしょうか？さて、「トポロジカルソート」できる条件が「DAG」である（巡回路がない）ことです。では「DAG」であることをどのように判定するのでしょうか？Kahnの方法（1962）を使います。入力がない頂点のセットSを作ります。そこから辺をたどっていき、たどった辺を消していきます。辺を消したことで入力がなくなった頂点も頂点セットSに追加し、さらにたどっていきます。頂点セットSが空になった時、まだ入力辺が残っている頂点があれば、このグラフには巡回路があり、「DAG」ではないことがわかります。逆にすべての頂点の入力辺が消えていたら「DAG」です。たしかに巡回路があると、その巡回路に含まれる頂点は、この処理が完了しても、入力辺が0になることがありません。なぜならその頂点の入力辺が0になるためには、巡回路の中の1つ前の頂点からの入力が消えなければならず、つまりその頂点がSに追加されなければなりません。そのためには巡回路の中の1つ前の頂点が…。とぐるぐる回ってしまうからです。これで「DAG」判定ができるようになりました。さて、実装したのですが、TLEが4つ出てしまいました。テストケースの002、005、006、007です。最初に、グラフなどの構造をdict（実際にはdefaultdict）を使って表現していましたが、これを全部リストにしました。これでテストケース002をACできました。IDがスカスカであれば、dictを使ってメモリ使用量を抑える効果がありますが、隙間なく頂点のIDを使うのであれば、listを使うべきですね。2次元フェニック木とかで空間計算量を抑えるためにdictを使うというようなことを覚えたせいで、なんかdictを使ってしまいがちです。無駄にdictを使わないというのは大事なことだと思います。次にinputを高速化しました。以下のように追記します。これ、本当に効くので、今後は入れたほうが良いと知りました。

import sys
input = sys.stdin.readline

それでもテストケース005、006、007がTLEのままでした。H方向のmin-max区間が被っていないことのチェックをいもす法みたいな処理でやっていたのですが、これが該当テストケースにおいて、むちゃくちゃ遅かったようです。シンプルに(min, max)のリストを作ってソートしてからループを回し、prev_max<=cur_minをチェックすればよかったのです。これで遅かった3つのテストケースが一気に短時間で処理できるようになり、結果的に現時点でPython3のACの中で、2番目の速度を出すことができました。TLEから2位へ。ちょっとした修正でこんなに速くなるとは、わけがわかりませんね。いもす法バージョンは、dictに{min:+1, max:-1}のような合計を計算しておいて、ソートして小さい順に計算し、合計が2以上になったら被っていると判定していました。dictを使っていること、それをソートするときにlistに変換されることなどオーバーヘッドは確かにありますが、こんなに効くとは。結局、最終的なコードではdictを全く使っていません。dictとlistの使い分けは、速度の観点で要注意であると、強く思いました。dictよりlistを使え。というわけで、ヨシっ！やっとACできた。この問題の解き方の、頂点を追加してグラフを作るところ、美しいし、頭の中でイメージするだけで楽しくなってしまうような解き方だなぁと感じています。 2022-11-14

import sys
input = sys.stdin.readline
h, w = map(int, input().split())
vnext = w
minmax_list = []
graph_updated = False
graph = [[] for _ in range(w)]
from_count = [0]*w
for _ in range(h):
    alist = list(map(int, input().split()))
    aset = set(alist)
    aset.discard(0)
    a_unique_num = len(aset)
    if a_unique_num > 1:
        graph_updated = True
        a_unique_sorted = sorted(aset)
        amin = a_unique_sorted[0]
        amax = a_unique_sorted[-1]
        minmax_list.append((amin,amax))
        a2v = {a : vnext+i for i, a in enumerate(a_unique_sorted)}
        graph.extend([[] for _ in range(a_unique_num-1)])
        from_count.extend([0]*(a_unique_num-1))
        for i in range(w):
            a = alist[i]
            if a == 0:
                continue
            interv = a2v[a]
            if a != amin:
                graph[interv-1].append(i)
                from_count[i] += 1
            if a != amax:
                graph[i].append(interv)
                from_count[interv] += 1
        vnext = a2v[amax]
# check h dir
minmax_list.sort()
prevmax = 0
for x in minmax_list:
    if x[0] < prevmax:
        print('No')
        sys.exit()
    prevmax = x[1]
# h dir ok, then check w dir
if not graph_updated:
    print('Yes')
    sys.exit()
starters = [v for v in range(len(from_count)) if from_count[v] == 0]
if not starters:
    print('No')
    sys.exit()
# check DAG
while starters:
    v = starters.pop()
    for next in graph[v]:
        from_count[next] -= 1
        if from_count[next] == 0:
            starters.append(next)
for count in from_count:
    if count:
        print('No')
        sys.exit()
print('Yes')

G - Random Walk to Millionaire

解説を見るしかないわけですが、またクレイジーですね。解説を理解できるまでに何ステップも「あ、そういうことか！」が必要で大変です。そして理解が進むほど「狂ってる！」と感動します。何も工夫せずにやろうとすると、レベルの状態が多すぎて、1つの行動だけでNK=9000000も状態が必要になってしまいます。通り道のCv=0の個数がX個のときレベルXとなり、Cv=1での獲得金額はX^2となります。これをX^2=choose(X,2)*2+Xと変形すると、通り道のCv=0から2つ選ぶ場合の数と、通り道のCv=0から1つ選ぶ場合の数を計算すれば、獲得金額を計算できることがわかり、各頂点に3つの状態のみ必要なDPに帰着できます。驚くべき問題の読み替えで、狐につままれたような気分です。なんでこんなことになるのでしょうか？途中で獲得するお金は、Cv=1に着くたびに確率をかけて累積していけばよいです。期待値を計算するときのこの感覚を自然だと思えるよう、身につけておきたいところです。さて、いつものようにTLEとなり、速度改善をがんばってACできました。3つの状態のリストはつなげて3*nのサイズの1つのリストにしました。dpのリストをK回の行動分一気に作らず、前回と今回のみ作ってループしました。Fromでループすると全部終わってからもう一度ループを回してansを更新する必要があるので、Toでループし、その場でansを更新できるようにしました。同じ計算を2回しないようにしました。どれが効いたのかはわかりませんが、現在Python3での提出者中、3位の速度でACできました。素直にわかりやすくコードを書くとTLEになりがちなのはPythonのつらいところです。もちろん楽しんでますが、競技プログラミングで使用するならC++も検討すべきと感じていて、今後はちょっとずつC++でも解こうと思っています。問題Fに続き、信じられないような解法で感動したし、楽しかったです。 2022-11-15

mod = 998244353
n, m, k = map(int, input().split())
nexts = [[] for _ in range(n)]
for _ in range(m):
    u, v = map(int, input().split())
    u -= 1
    v -= 1
    nexts[u].append(v)
    nexts[v].append(u)
clist = list(map(int, input().split()))
rates = [0]*n
for v in range(n):
    rates[v] = pow(len(nexts[v]), mod-2, mod)
dp = [0]*(n*3)
dp[0] = 1
ans = 0
nx2 = n*2
for _ in range(k):
    dp_next = [0]*(n*3)
    for v in range(n): # to v
        for next in nexts[v]:
            in0 = dp[next] * rates[next]
            in1 = dp[next+n] * rates[next]
            dp_next[v] += in0
            dp_next[v+n] += in1
            dp_next[v+nx2] += dp[next+nx2] * rates[next]
            if clist[v] == 0:
                dp_next[v+n] += in0
                dp_next[v+nx2] += in1
            dp_next[v] %= mod
            dp_next[v+n] %= mod
            dp_next[v+nx2] %= mod
        if clist[v] == 1: # get money
            ans += dp_next[v+nx2] * 2 + dp_next[v+n]
            ans %= mod
    dp = dp_next
print(ans)

Ex - Constrained Sums

強連結成分分解、トポロジカルソート、2-SAT、そしてこの問題自体の言い換え、と、何日かかけてがんばっていろいろ理解し、久しぶりにExをACしたいと試みましたが、サンプルケースもACできませんでした。ていうか提出したらほとんどのテストケースで、グラフを作るところだけでTLEになってました。くやしいですが一旦あきらめます。よく見たらPythonでACしてる人が2人しかいません。それだけむずかしいのでしょうか？素人のぼくがPythonで3人目のACだとすごいですが、難しいですよねぇ。消耗しました。次のABC278 Exは1人しか解けなかったりと、問題Exは、素人が手を出したらエネルギーがなくなってひどいことになりそうです。もう少し力がつくまで距離を置こうと思います。ABCに参加し始めて最初の3回はExを無理やりACしたのですが、あれは始めたばかりでまだエネルギーがあったということでしょうか？笑。いや、あの時もFFTを理解するのに1ヶ月かかったり大変だったなぁ。勉強したことは身になったはずと前向きに捉えながら。 2022-11-20

「あきらめる」とか言いつつ、考え続けてしまうのはなんなんですかね。「考える」ってコントロールできないような気がします。一度やりはじめたら、やめようと思っても「考えちゃう」んですよね。ACできました！現時点で、PythonでACしてるのが3人しかいないし、提出者も6人しかいないです。なんか少ないな。どういうことでしょうか？競プロ素人のぼくが3人しかいないPythonでのACの中に入ってるなんて、なんか自信に繋がります！ExをACしたのは、ABC268以来で久しぶりです。実は参加開始して最初の3回はExを全部がんばって解いたんですよね。でも、これやり続けたら体が持たないと思って遠ざかっていたのです。今回もやはりきつかった。この問題について書きたいことは、この問題を通じて学んだことが多いので、多いです。しかし強連結成分分解の正当性とか、絵も描かないと説明できないかもなぁと思っていますし、2-SATに関しては、完全に解明できてない部分もあるような気がしていますが、反省会ということで書いていきます。最後の最後でTLEを解決したのは、強連結成分分解のDFSを再帰関数から、スタックを使う方法に変更したところです。ていうかsys.setrecursionlimit(10**6)としたら、自動的にPyPyじゃなくてPythonになってしまうんですね。スタックを使ってPyPyを使ったほうが速いというのは重要な知見です。この問題を解くのに使用している2-SATというのは、「充足可能性問題（satisfiability problem, SAT）」のうち、(A∨B)∧(C∨D)∧…という形式で、「または」の部分の論理式が2つ以下の問題のことです。2-SATに言い換えて解いているわけですが、これが気づける気がしない言い換えになっています。L<=A+B ⇔ ¬((A<0∧B<L+1)∨(A<1∧B<L)∨(A<2∧B<L-1)∨…∨(A<L+1∧B<0)) ⇔ (A>=0∨B>=L+1)∧(A>=1∨B>=L)∧…∧(A>=L+1∨B>=0)というように2-SATに言い換えています。同様に、A+B<=R ⇔ ¬((A>=0∧B>=R+1)∨…∨(A>=R+1∧B>=0)) ⇔ (A<0∨B<R+1)∧…∧(A<R+1∨B<0)と2-SATに言い換えています。条件はL<=A+B<=Rと、LもRも「<=」を使って表現されていますが、言い換えのときに、Lの方の論理式は「>=」で表現され、Rの方の論理式は「<」で表現することによって、Xと¬Xの関係に結びつけているのです。これを狙ってやっているのが、トリッキーで驚きました。信じられません。2-SATを表現するグラフに対して、強連結成分分解を行いXと¬Xが同じ強連結成分に入っていると、解が得られないことがわかります。強連結成分の中ではすべてTrueか、すべてFalseでなければならないからです。強連結成分分解後、トポロジカルソートを行い、Xと¬Xのうち、後ろにある方をTrueにすることで、解を得ることができます。といいつつこれって自明なんですかね？自明ではないと思うので説明が必要です。すべてのXと¬Xのペアが同じ強連結成分に入っていないことがわかり、TrueとFalseを割り当てたとき、同じ強連結成分内でTrueとFalseは全部一致しているのですか？全然自明ではありません。不整合が起きるというのは、Xと¬XのペアにTrue/Falseを割り当てたあと、A→Bというエッジが存在するにも関わらず、AがTrueでBがFalseとなっているということです。A→Bというエッジが存在し、AがTrue、BがFalseであれば、トポロジカルソートの結果は¬A、A、B、¬Bの順に並んでいるはずです。しかし、2-SATのグラフ生成方法から¬B→¬Aというエッジが存在するはずです。これは先程のトポロジカルソートの順序と矛盾するのです。なので、Xと¬Xが同じ強連結成分に含まれていなければ、True、Falseを割り当てたときに、不整合は起きないことがわかります。Aが必ずTrueであるという条件は¬A→Aで表すということで、いけそうです。この議論から、2-SATのグラフはきれいな形をしていそうだな、と思います。変なエッジを適当に加えるといろいろな条件が壊れてしまうのではないでしょうか？A→Bを加えるなら、必ず¬B→¬Aも追加する必要がありそうです。（ですよね。）この問題においては、L、Rの条件以外にX>=0は常にTrue、X<M+1は常にTrueという条件もグラフに追加しています。またX>=tであれば、X>=t-1である、という条件も追加しています。これらのエッジはグラフをきれいなまま維持します。これらのエッジは必要なのでしょうか？結論としては、追加するべきなのだろうと考えています。2-SATの問題は、条件が足りないと、トポロジカルソートの結果が十分定まらず、どちらがTrueでも良いという結果になりえます。なので、人間の頭で把握している条件（1より2が大きいとか）も追加しておくべきだと考えます。（あいまいな言い方しかできませんが。）また、全ノードにエッジがつながってわかりやすくて良いとも感じました。X>=aのときにX<aがFalseとなり、よってX<a-tもFalseということが満たされるので、X>=a∧X<a-tというような、不正な状態が起きないことを保証できるのも良いです。強連結成分分解のアルゴリズムの正当性も時間を使って考えました。最初のDFSでツリーがいくつかできますよね。2回目のエッジを逆向きに進むDFSでは、1本でもエッジがつながったらそりゃぁ確かに強連結成分です。最初のDFSで作った子孫からエッジが伸びてるということですから、すぐさま巡回路の完成です。2回目のDFSで、最初のDFSで作ったツリーの外には出れません。もし出れたら最初のDFSで、その外にあるツリーに含まれてたはずですよね。だから出れません。2回目のDFSのときに、最初のDFSで作ったツリーの中の部分木がいくつか残ったとします。2回目のDFSで別の部分木につながってしまうと、強連結成分じゃなくなってしまいそうです。しかし、2回目のDFSで、部分木の外には出れません。なぜなら最初のDFSで帰りがけ順に番号を振ったからです。2回目のDFSで別の部分木に移動できてしまうと、そっちの部分木の方が帰りがけ順であとになっていたはずなので、ありえないのです。最初のDFSで帰りがけ順に番号を振るのも、帰りがけ順であとになっていた方から2回目のDFSをやるのも、意味があるのです！このように、強連結成分分解、トポロジカルソートに2-SATと、この問題でもいろいろ考えて新しいことを学びました。大変でしたが、久しぶりにExをACできてうれしい！ 2022-11-21

import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10**6)
N, M, Q = map(int, input().split())
M2 = M+2
HALF = N*M2
LENALL = 2*HALF
G = [[] for _ in range(LENALL)]
for i in range(N):
    i0 = M2*i
    G[i0+HALF].append(i0) # x>=0 is always True
    G[i0+M+1].append(i0+M+1+HALF)
    for j in range(M+1):
        ij = i0+j
        G[ij+1].append(ij) # x>=j+1 -> x>=j
        G[ij+HALF].append(ij+HALF+1)
for _ in range(Q):
    a, b, l, r = map(int, input().split())
    a -= 1
    b -= 1
    for j in range(M2): # a
        jj = l + 1 - j # b
        if 0 <= jj < M2:
            aj = M2*a+j
            bjj = M2*b+jj
            G[aj+HALF].append(bjj)
            G[bjj+HALF].append(aj)
        jj = r + 1 -j
        if 0 <= jj < M2:
            aj = M2*a+j
            bjj = M2*b+jj
            G[aj].append(bjj+HALF)
            G[bjj].append(aj+HALF)

# 省略 https://atcoder.jp/contests/abc277/submissions/36706989

ans = []
for i in range(N):
    base = i*M2
    min_ = 0
    for j in range(1, M+1): # check 1-M
        v = base + j
        if t_order[v] == t_order[v+HALF]:
            # need to check all
            print(-1)
            sys.exit()
        elif t_order[v] > t_order[v+HALF]:
            min_ = j
    ans.append(min_)
print(*ans)

AtCoder Beginner Contest 278

前回に続き、4完でした。問題Dで、ペナルティ3回食らってしまい順位を落としました。最初、クエリ1のときに毎回リストを0でリセットしてしまい、TLEでした。あ～確かに、と思い直してリセットフラグみたいなのを各要素に持たせましたが1発で処理の流れを整理しきれなかった感じです。立て直しを迅速にやる力は大事ですね。その後、問題Eに35分くらい残っていて、各数字のミニマックスボックスを作るところまでは思いついたのですが、プラスαで、なんかいもす法的なのを使わないと間に合わないと思いこんでしまい、解けませんでした。終了後にミニマックスボックスだけでやったらふつうにACできました。もったいないです。今回入緑できればと思っていましたが、残念ながらダメでした。問題Eが普通に解けていたらと思い、くやしいです。でもまあ、いつの間にか続けて4問以上解けるようになっているので、成長はしているのかな…。そういえば、今週はABC277 Exを解こうと思ってがんばっており、頭を酷使しすぎて本当にしんどいです。久しぶりにExをACするぞーと、つい始めてしまいました。まだできておらず、疲れ切って消耗しているので、数日でも競プロから距離を置いた方がいいかもしれないです。切実に。 2022-11-19

E - Grid Filling

終了後に、普通に全範囲をループして比較するだけでACできました。くやしいなぁ。ところで、この問題でdefaultdictの初期化時にlambda関数を引数で渡すというのを初めてやりました。今までdefaultdict(int)とかdefaultdict(list)とかしか作ったことなかったんですよね。指定した値で初期化されたリストを返す関数を渡すということをしました。いろいろ勉強していると、いつの間にか新しいことができるようになってますね。 2022-11-19

from collections import defaultdict
H, W, N, h, w = map(int, input().split())
grid = []
for _ in range(H):
    grid.append(list(map(int, input().split())))
# imin, imax, jmin, jmax
default_minmax = lambda : [H, -1, W, -1]
minmax = defaultdict(default_minmax)
for i in range(H):
    for j in range(W):
        a = grid[i][j]
        minmax[a][0] = min(minmax[a][0], i)
        minmax[a][1] = max(minmax[a][1], i)
        minmax[a][2] = min(minmax[a][2], j)
        minmax[a][3] = max(minmax[a][3], j)
num = len(minmax)
res = []
for i in range(H+1-h):
    imax = i + h - 1
    res_w = []
    for j in range(W+1-w):
        jmax = j + w - 1
        count = 0
        for v in minmax.values():
            if i <= v[0] and v[1] <= imax and j <= v[2] and v[3] <= jmax:
                count += 1
        res_w.append(num-count)
    res.append(res_w)
for res_w in res:
    print(*res_w)

F - Shiritori

bitDPでしょ、と思いながら自力ではできず、解説見ました。今週はABC277 Exなどチャレンジして砕け散り、エネルギーが消耗していてつらいです。ABCが毎週あると、素人にとっては毎回新しいことが出てくるので、休む暇がなくてつらいです。この問題、解説見るまでにいろいろ頭の中で考えました。しりとりって次の単語に接続していくので、グラフですよね。そして、出力がない単語を選んだら勝ちです。つまり、すべての単語に出力があるケースを考えたらいいわけですね。最近覚えたばかりの強連結成分分解か？とか、文字を頂点、単語をエッジとするグラフを考えるのか？などと、いろいろ考えておもしろかったですが、行き詰まりましたw。解説はbitDPでしたが、Pythonで提出していてやたら速い人達がたくさんいたので、中身をみると、しりとりのグラフを作ってDFSで解いていました。しかし1度使った単語を再度使わないことで1回のDFSをO(N)にしていたのですが、その正当性が理解できず、自分の中では納得できていません。でもDFSで解く方法も正しいのだと思います。これはいずれ理解しないといけないな、と思っています。以下のコードは解説の通りbitDPで実装したものです。bitDPもすでに2回目なので、すんなり実装できました。ただ、DPテーブルを次文字cから始める場合に勝てるかどうか？と決めることは、まだ容易ではありません。単語を選んだときに、後手はその単語の末尾の文字から始める必要があります。それで勝てない状態が1つでもあれば、先手は勝てることがわかり、DPテーブルを更新することができます。 2022-11-21

import sys
n = int(input())
d = {}
idx = 1
cset = set()
for _ in range(n):
    s = input()
    cset.add(s[0])
    cset.add(s[-1])
    d[idx] = [s[0], s[-1]]
    idx <<= 1
clist = list(cset)
dp = {c:[0]*(1<<n) for c in clist}
# dp[c][bit]
for s in range(1, 1<<n):
    if s in d: # 1bit
        dp[d[s][0]][s] = 1
    else:
        for c in clist:
            # update [c][s]
            scopy = s
            while scopy:
                idx = scopy&-scopy
                if d[idx][0] == c and dp[d[idx][1]][s-idx] == 0:
                    dp[c][s] = 1
                    break
                scopy -= idx
for c in clist:
    if dp[c][s] == 1:
        print('First')
        sys.exit()
print('Second')

やっぱりわからない…。これでACしてしまうけど、どう考えても、コメントアウトしたused[v] = Falseが必要。当初、他の方の回答を見て、なんでこれでACなんだろう？って思ったのが最初なんですよね。自分なりに再現させたのがこのコードです。 2023-01-10

N = int(input())
slist = []
for _ in range(N):
    slist.append(input())
g = [[] for _ in range(N)]
for i, s in enumerate(slist):
    for j, s in enumerate(slist):
        if i != j and slist[i][-1] == slist[j][0]:
            g[i].append(j)
used = [False]*(N)
def win(v):
    res = True
    used[v] = True
    for next in g[v]:
        if used[next]:
            continue
        else:
            if win(next):
                res = False
                break
    # used[v] = False # どう考えてもこれいるでしょ
    return res
for v in range(N):
    used = [False]*(N)
    if win(v):
        print('First')
        break
else:
    print('Second')

上のコードを、WA（不正解）にできるテストケースを作ることができました。こちらです。

何か得体の知れない数学の定理によって、このコードは正しいのか？と悩んでいたので、間違っていることは、テストケースを追加して証明するしかないですね。上のコードのコメントアウトによって1回のDFSが必ず頂点数、つまりこの問題では16回で終わり、処理がすぐ終わりますが、誤ったコードです。しかし、コメントアウトしたused[v] = Falseの部分を有効にすると、このままでは処理時間が膨大になってしまうケースがあります。たとえば16個の文字列がすべてaで始まってaで終わる場合、もっともエッジ数が多くなり、DFSの計算量は16!=2x10^13程度になってしまいます。エッジ数を減らすには、先頭の文字と終わりの文字の組み合わせが同じものをまとめることで、エッジ数を減らせば良いのではないでしょうか？そしてその個数を覚えておき、DFSの最中に通ったら1減らし、再帰関数を抜けるときには1増やして元に戻します。この場合、文字ペアがすべて異なるようにしつつエッジ数が最大になるテストケースは、このようなケースではないでしょうか？

この場合でもDFSの計算量は、8!=40320で済みそうです。よって、以下のコードでACすることができました。正しいはず。11月から気になってたことが解決しました。ふぅ。小ネタ、平年の2月は8!=40320分（28×24×60）らしいです。 2023-01-11

from collections import defaultdict
N = int(input())
scount = defaultdict(int)
for _ in range(N):
    s = input()
    scount[s[0]+s[-1]] += 1
g = [[1, list(range(1, len(scount)+1))]]
for i, si in enumerate(scount):
    g.append([scount[si], []]) # g[i+1]
    for j, sj in enumerate(scount):
        if si[1] == sj[0]:
            g[i+1][1].append(j+1)
def win(v):
    res = True
    g[v][0] -= 1
    for next in g[v][1]:
        if g[next][0] and win(next):
            res = False
            break
    g[v][0] += 1
    return res
if win(0):
    print('Second')
else:
    print('First')

「再帰関数をできるだけ使うな」という心の声が聞こえてきたので、スタックで書いてみました。勝ち負けをどこに保持するか？とか、あまり考えたくないコードになりました。これに関しては再帰関数のほうがシンプルでいいですね。しかも再帰関数よりちょっと遅くなってしまいました。まあ練習練習。この、ゲームの流れをDFSで調べる処理についても説明します。最初に解いた11月時点ではそれもわかってませんでした。winというのは、その手を選択した人が勝てるかどうか？です。状態が遷移する時、現在の手番の人は、好きな手を選べるので、1つでも勝てる手が存在すれば勝ち局面です。勝てる手が1つ見つかった時点で、他の手を調べる必要はなくなり、枝刈りできます。その場合、1手前の人（相手）にとっては、その手は負ける手であるわけです。これをゲーム終了状態（どちらかが勝った状態）から遡っていき、最初の1手に勝てる手があるかどうかを調べます。 2023-01-11

from collections import defaultdict
N = int(input())
scount = defaultdict(int)
for _ in range(N):
    s = input()
    scount[s[0]+s[-1]] += 1
g = [[1, list(range(1, len(scount)+1))]]
for i, si in enumerate(scount):
    g.append([scount[si], []]) # g[i+1]
    for j, sj in enumerate(scount):
        if si[1] == sj[0]:
            g[i+1][1].append(j+1)
stack = [[-1,True],[0,True]]
while stack:
    cur = stack.pop()
    v = cur[0]
    win = cur[1]
    if v >= 0:
        g[v][0] -= 1
        for next in g[v][1]:
            if g[next][0]:
                stack.extend([[~next,True],[next,True]])
    else:
        g[~v][0] += 1
        if win:
            while len(stack) >= 2 and ~stack[-1][0] == stack[-2][0]:
                stack.pop()
                stack.pop()
            if stack:
                stack[-1][1] = False
if win:
    print('Second')
else:
    print('First')

G - Generalized Subtraction Game

この問題の解説に、Grundy数という初めて聞く言葉が出てきたので、解く前に蟻本の「4-2 ゲームの必勝法を編み出せ！」を読みました。苦労しましたが、なんとか理解して帰ってきました。考え方がクレイジーすぎますね。この問題はほとんどのケースで真似っこ戦略が有効で、真似っこ戦略が使えないケースはGrundy数を使っても計算量が抑えられます。が、Grundy数の勉強のため、全パターン真似っこ戦略を使わずにやりました。対話型の問題は初めてで、デバッグがしにくいなと思いました。TLEが出まくって、やはりPythonだと厳しいか？と疑いましたが、無限ループを入れてしまっていたり、バグ取りに苦労しました。gsetmemoは、1手後の2つの数列長の和が同じ時の、Mexを計算するための遷移先Grundy数のsetをメモするために使っています。ほとんどのケースで高速化に寄与しませんでしたが、速度に大きく影響するケースもあり、gsetmemoを使わないとTLEが2つ出ました。自分の手を決めるために現在の盤面情報が必要なので、リストを作って新しい区間ができたら挿入しようとしていましたが、挿入箇所をbisectでO(log(N))で決めたり、長さが0の時は挿入不要だな～とか、めんどうな処理になるし、リストへの挿入自体O(N)かかるので、このやり方は筋が悪いのですね。おなじO(N)なら全カードの残っているかどうかのリストを用意して、左端のカードのリストと、連続数のリスト、startsとcountsは、自分の手の直前に作り直したほうがわかりやすく、速度も変わらないです。splitmemoというのは、1手進めるときに残った2山の合計枚数と、Grundy数から、2つの山の枚数の例をメモしています。自分の手を決めるときにこれを参照することで、計算せずに正しい手を決められているはずです。あと、Grundy数を使う問題を解くことでXORの性質をいろいろ学びましたね。 2022-11-25

N, L, R = map(int, input().split())
# grundy range 0-N, left 0-(N-L)
idxsm = lambda g_, left_: g_*(N-L+1) + left_
splitmemo = [() for _ in range((N-L+1)*(N+1))]
gsetmemo = [set() for _ in range(N-L+1)]
grundy = [0]*L + [-1]*(N+1-L)
for i in range(L):
    splitmemo[(idxsm(0,i))] = (0,i)
# prepare grundy
for n in range(L, N+1):
    gset = set()
    take_max = min(R, n)
    for take in range(L, take_max+1):
        left = n - take
        gset_left = set()
        if gsetmemo[left]:
            gset_left = gsetmemo[left]
        else:
            for a in range(left+1):
                b = left - a
                if a > b:
                    break
                g = grundy[a] ^ grundy[b]
                splitmemo[idxsm(g,left)] = (a,b)
                gset_left.add(g)
            gsetmemo[left] = gset_left
        gset |= gset_left
    g = 0
    while g in gset:
        g += 1
    splitmemo[idxsm(g,n)] = (0,n)
    grundy[n] = g
# cards remaining
rem = [False] + [True]*(N)
myturn = 1
if grundy[N]:
    print('First', flush=True)
else:
    myturn = 0
    print('Second', flush=True)
while True:
    if myturn:
        xorall = 0
        starts = []
        counts = []
        i = 1
        while i <= N:
            if not rem[i]:
                i += 1
            else: # rem[i]
                starts.append(i)
                while i <= N and rem[i]:
                    i += 1
                # i=N+1 or not rem[i]
                count = i - starts[-1]
                counts.append(count)
                xorall ^= grundy[count]
        # xorall must be > 0
        highbit = 1 << (len(bin(xorall))-3)
        pair_found = False
        for i in range(len(starts)):
            count = counts[i]
            if count < L:
                continue
            if highbit & grundy[counts[i]]:
                gnew = xorall ^ grundy[count]
                for take in range(min(R, count), L-1, -1):
                    left = count - take
                    t = splitmemo[idxsm(gnew,left)]
                    if t: # pair must be found at first trial
                        pair_found = True
                        remove_sta = starts[i] + t[0]
                        print(remove_sta, take, flush=True)
                        for j in range(remove_sta, remove_sta+take):
                            rem[j] = False
                        break
            if pair_found:
                break
        myturn ^= 1
    if not myturn:
        a, b = map(int, input().split())
        if a == b == 0 or a == b == -1:
            break
        for j in range(a, a+b):
            rem[j] = False
        myturn ^= 1

真似っこ戦略を使う場合のコードも載せておきます。基本、これは使うべきです。 2022-11-25

if L != R or not (N^R)&1:
    print('First', flush=True)
    y = R - ((N^R)&1)
    x = 1 + (N-y)//2
    print(x, y, flush=True)
    while True:
        a, b = map(int, input().split())
        if a == b == 0 or a == b == -1:
            break
        print(N-a-b+2, b, flush=True)

AtCoder Beginner Contest 279

2度目の5完！ペナルティは0でした。問題Dで微分を使う必要があり、微分なんて何年も使っていないので、微分の公式を思い出せず、ググらないと計算できませんでした。そのせいで、問題Dだけで30分くらいかかってしまいました。中高生の頃だったら短時間でできたのは間違いなく、くやしい思いをしました。競プロでは、こういった基礎的な数学はとっさに反応できる必要があるんだなと認識しました。問題Eは問題の内容を理解するのに苦労した印象があります。みんなこういう文章を読んでスッと頭に入ってくるんでしょうか？問題の内容を理解したあと、コードを書きながら、これだとTLEだぞ、と思って方針変更し、1回でACできたのは、経験からいろいろ学んだのを感じます。そして、ついに念願の、入緑しました！初めて参加したのがABC266で8/27の開催でした。今日は11/26なのでちょうど3ヶ月です。参加回数10回目で入緑することができました。また、はじめて1000位以内に入れました。AC数履歴は、4,3,3,2,3,4,5,4,4,5でした。 2022-11-26

F - BOX

コンテスト終了直後は、がんばれば解けたのでは？と思い、終わったあとでやり始めましたが、バグっててACにむちゃくちゃ時間かかりました。それぞれのボールがどの箱に入っているか？を短時間で答えられる構造を作る必要があります。操作タイプ1でYにたくさんボールが入っていると、全ボールの箱情報を書き換えるのが大変なので、どうするかな？という問題ということがわかります。最初なんとなく、同じ箱に入っているボールが同じリストを参照していて、その中に箱が書かれていれば、箱を書き換えられるなぁと考えました。しかし操作のたびにそのリスト自体が増えていってわけがわからなくなります。じゃあリストのリストにするか？などと考えているうちに自動的に深くなっていって、ツリー構造とわかります。そうすると、Union-Findを使えば良いと気づくことができます。same_treeを使わない、uniteするだけのUnion-Findです。これは、使えますね。で、方針変更の疲れにも耐えて書き直したのですが、ACx33、REx39みたいな状況に陥ってしまいました。どこがおかしいかなかなか見つけられず、むちゃくちゃ時間がかかってしまったのですが、じつはQ<Nと勝手に思いこんでしまっており、ボールのサイズを2*Nとしてしまっていたことがわかりました。こういう消耗は時間かかるしつらいなー。 2022-11-27

class Union():
    # 省略
N, Q = map(int, input().split())
box_ball = [i for i in range(N+1)]
ball_box = [i for i in range(N+1)] + [0 for _ in range(Q)]
union = Union(N+Q)
nextball = N
for _ in range(Q):
    q = list(map(int, input().split()))
    if q[0] == 1:
        x = q[1]
        y = q[2]
        if box_ball[y]:
            if box_ball[x]:
                union.unite(box_ball[y], box_ball[x])
            else:
                box_ball[x] = box_ball[y]
            box_ball[y] = 0
            ball_box[union.find_root(box_ball[x])] = x
    elif q[0] == 2:
        nextball += 1
        x = q[1]
        if box_ball[x]:
            union.unite(box_ball[x], nextball)
        else:
            box_ball[x] = nextball
        ball_box[union.find_root(nextball)] = x
    else:
        x = q[1]
        print(ball_box[union.find_root(x)])

G - At Most 2 Colors

こういう動的計画法、解説を理解するのがしんどいです。DPの式から意味を読み取るのがむずかしいので、まず説明の文章だけを読んで、自分でDPの式を組み立てることが多いです。kyopro_friendsさんの解説のDPでやりました。最後のK-1マスが1色の場合と、2色の場合の数をDPで計算していきます。このDPは条件があり、次のマスの色は必ず別の色になる組み合わせをカウントしていきます。そのことによって、直前のK-1マスが1色であれば次の色はC-1色から選べ、直前のK-1マスが2色であれば2色のうちの別の色から選べるので選択肢は1色だけになります。なんとか式を書き上げ、DP[0]からDP[K-1]あたりでミスらないようにコードを書き、ACできました。ACできたものの、問題は、解説を理解することではなく、自分でこの式を導けるか？ということです。動的計画法の問題を見るたび、どうやってこの式にたどりついたんだよ！と思ってしまいます。Kマスが2色である必要があるので、K-1マスまでの状況によって、Kマス目に制限がかかるだろう、というように考えればK-1という数字は自然に出てくるでしょうか？「次のマスの色は必ず変化させて考える」というのは自力で出てきますか？そんなに自然とは思えないですね。でも場合の数を数え上げる場合、加えられる制約は加えたほうが秩序が生まれるようです。DPの問題は、式を作れるかがすべてなので、これまでに出会ったDPの問題をざっと見て、一体どういう思考の流れで式を導き出せているのか？という観点でふりかえってみるのも良いかもしれないです。あ、あとこれ、累積和というやつですね。 2022-11-29

M = 998244353
N, K, C = map(int, input().split())
C = C % M
dp1 = [C]*(N+1)
dp1sum = [0]*(N+1)
for i in range(1, K):
    dp1sum[i] = C * i % M
dp2 = [0]*(N+1)
dp2sum = [0]*(N+1)
dp2sum[2] = dp2[2] = C * (C-1) % M
for i in range(3, K): # if K<=3 do nothing
    js = max(i-K+1, 0)
    je = i - 1
    dp2[i] = (dp1sum[je]-dp1sum[js]) * (C-1) + (dp2sum[je]-dp2sum[js])
    dp2[i] %= M
    dp2sum[i] = dp2sum[i-1] + dp2[i]
    dp2sum[i] %= M
for i in range(K, N+1):
    js = i - K + 1
    je = i - 1
    dp2[i] = (dp1sum[je]-dp1sum[js]) * (C-1) + (dp2sum[je]-dp2sum[js])
    dp2[i] %= M
    dp2sum[i] = dp2sum[i-1] + dp2[i]
    dp2sum[i] %= M
    dp1[i] = C + dp1sum[js] * (C-1) + dp2sum[js]
    dp1[i] %= M
    dp1sum[i] = dp1sum[i-1] + dp1[i]
    dp1sum[i] %= M
print((dp1[N]+dp2[N]) % M)

他の解答を見ていると、むちゃくちゃシンプルなものもありました。嘘みたいにシンプルですが、確かに正しいです。1色と2色のDPを分けておらず、全組み合わせを1つのDPで計算しています。その方が自然ですよね。直前のK-1マスで2色使われていれば、次に使えるのはどちらかなので2色としています。上の解答のように、「次は別の色」という制約は設けていません。自然です。で、K-1マスが1色の場合を考えます。その組み合わせの数はDP[i-(K-1)]なのです。確かに。なんかくやしい。。。その場合、i番目ののマスにはC色使えます。最初の2色使える場合の数はdp[i-1]*2と計算しますが、この中には当然、直前のK-1マスが1色の場合の数x2が含まれてしまっています。K-1マスが1色の場合であるDP[i-(K-1)]*Cから、DP[i-(K-1)]*2を引いておくことで、余計にカウントした分を打ち消すことができます。いや、すごくシンプルだけど、余計にカウントした分を打ち消すところは、美しく、難しいですよね。ひらめきさえすれば、1瞬で解ける可能性もあるのは、おもしろいです。こういうの短時間で解けるようになりたいなぁ。「次使えるのは、同じ2色のうちどっちかだよね。でも最後のK-1マスが1色ならどれ使っても良くなるね。この2つの状況を組み合わせるにはどうすればいいかな？」って考えていくことで、この式にたどり着けるんですかねぇ？ 2022-11-29

M = 998244353
N, K, C = map(int, input().split())
C = C % M
dp = [0]*(N+1)
dp[1] = C
for i in range(2, N+1):
    dp[i] = dp[i-1]*2 + dp[max(i-K+1, 1)]*(C-2)
    dp[i] %= M
print(dp[N])

AtCoder Beginner Contest 280

3度目の5完、そして初めての2連続5完でした。AC数の推移を見ると、順調に成長してることが感じられ、うれしいです。問題Eに70分近く残っていたのですが、勘違いバグをなかなか修正できず、ACできたのは98分くらいでギリギリでした。終了間際は緊張感があり、ACしたときは「ヨッシ！」と叫びました。終了後、問題Fを見ましたが難しく、時間があっても解けなかったであろうことを確認しました。 2022-12-04

E - Critical Hit

終了間際に解けました。どのようなミスをしていたかというと、1と2の合計でN以上になるまでの回数の期待値ということで、2をn2回、1をn1回でN以上となるn2、n1の組み合わせを求めましたが、そのときにまず2をn2回加え、残りは1というような数え方をしてしまっていました。それだと合計N+1で初めてN以上になるパターンが、全部2のときだけになってしまっていました。よく考えたら合計N+1になるのは、N-1になった次に2が出るパターンすべてですね。N-1までは1でも2でもいいのです。貪欲に2ばかりを先に足して残りを1で埋めると、漏れているパターンが大量発生していました。そのことに気づいたのが、残り15分くらいだったでしょうか？では、どのように計算すればよいのか？緊張しながら考え、N-1ちょうどになるときは、次なにが出てもN以上になるので、すべて合算。N-2ちょうどになるときは、次2が出てNになるものだけ合算する。なぜなら、N-2の次に1が出るパターンはN-1のときに、すでに考慮済みです。緊張しながら、なんとか解きましたが、「1と2の合計がN以上になる」というのはいかにも典型的な問題っぽいので、経験を積んだ人は何度も見たことがあり、今回ぼくがやったようなミスでハマったりはしないかもしれません。 2022-12-04

mod = 998244353
N, P = map(int, input().split())

# https://atcoder.jp/contests/abc280/submissions/36995423
# 階乗やchoose省略

ans = 0
inv100 = pow(100, mod-2, mod)
p1 = (100-P) * inv100 % mod
p2 = P * inv100 % mod
n2 = 0
while True:
    # just N-1
    if n2 * 2 > N - 1:
        break
    n1 = N - 1 - n2 * 2
    ans += (n1+n2+1) \
        * pow(p1, n1, mod) * pow(p2, n2, mod) * choose(n1+n2, n2)
    ans %= mod
    n2 += 1
n2 = 0
while True:
    # just N-2
    if n2 * 2 > N - 2:
        break
    n1 = N - 2 - n2 * 2
    ans += (n1+n2+1) \
        * pow(p1, n1, mod) * pow(p2, n2, mod) * p2 * choose(n1+n2, n2)
    ans %= mod
    n2 += 1
print(ans)

F - Pay or Receive

最近5完できるようになってきたので、次のターゲットは6問目の問題Fとなります。が、これは歯が立ちませんでした。AからBに移動するとC増加、BからAに移動するとC減少、という状況を地面の高さに例えるのは、わかりやすくてよいと思いました。「無限アップできる巡回路がない」というのは、「すでに通った頂点に再度到達したときに、高さが一致している」ことです。そうでない場合、回り続けると無限にポイントを増やせます。また、高さの整合性が取れている連結成分内では、XからYにどのように移動しても、ポイントは同じになります。そうでなければ無限アップできてしまうということだからです。よって、問題文に「所持しているポイントの最大値を出力せよ。」と書いてありますが、整合性が取れている連結成分内で移動した場合、いくつかの値の最大値というものは考えられず、確定する1つの値となります。その値は、別の街ZからYに移動したポイント - ZからXに移動したポイントとして、計算することができます。ここで、街Zは任意の街で良いですが、Union-Findのルートを使用しています。Union-Findって便利ですね。何度か使って便利さがわかってきました。 2022-12-04

XとYが同じ連結成分に属しているかどうか？瞬時に判断する必要があるため、Union-Findを使っています。Union-Findにおいて、同じ連結成分である目印は、rootですね。 2023-01-13

N, M, Q = map(int, input().split())
class Union():
    # 省略
u = Union(N+1)
g = [[] for _ in range(N+1)]
infinite_loop = set()
INF = 10**16
costs = [INF]*(N+1)
for _ in range(M):
    a, b, c = map(int, input().split())
    u.unite(a, b)
    g[a].append((b, c))
    g[b].append((a, -c))
for v in range(1, N+1):
    if u.find_root(v) == v: # find_root is cheap
        stack = [v]
        costs[v] = 0
        inf_found = False
        while stack:
            cur = stack.pop()
            for next, c in g[cur]:
                if costs[next] == INF:
                    costs[next] = costs[cur] + c
                    stack.append(next)
                else:
                    if costs[next] != costs[cur] + c:
                        infinite_loop.add(v)
                        inf_found = True
                        break
            if inf_found:
                break
for _ in range(Q):
    x, y = map(int, input().split())
    if u.find_root(x) != u.find_root(y):
        print('nan')
    elif u.find_root(x) in infinite_loop:
        print('inf')
    else:
        print(costs[y]-costs[x])

G - Do Use Hexagon Grid 2

この問題はぼくにとってかなり難しく、ACに数日かかりました。ようやく理解して提出し、多くのケースでACできたあとも、random_07.txtとrandom_15.txtの2つのケースがTLEとなって、苦労しました。最終的になんとかACした処理時間は2929msでした。この問題に関して、自力で考えられたことと言えば、1次元の場合は何通りかな？ということくらいです。まあこの考察は当然必要なのですが、2次元、3次元と次元が増えたときにどのように計算すればいいのか簡単に思いつきませんでした。1次元の場合は、左から小さい順に並んでいるとすると、一番左のマスに注目して、距離D以下のマスが右にn個あれば、n個を選ぶか選ばないかの組み合わせで、2^n通りとし、すべてのマスについて合計すればいいでしょう。一番左のマスを必ず含むようにすれば、排他的な組み合わせを作っていくことができるからです。ではこれが2次元になった場合はどうするのか？混乱して整理しきれませんでした。2次元目についても一番左を必ず選ぶことで排他的な組み合わせを作っていけばいいです。一番左に複数のマスがあったらどう処理すればいいのか？とか考えていると混乱してしまうのですが、複数あっても気にせず処理できます。まずy=YからY+Dまでで組み合わせを数え、Y+1からY+Dまでの組み合わせを数えて引けばシンプルです。このようにすれば、y=Yのマスを含む組み合わせの数だけを抽出でき、つぎはy=Y+1以上を調べるので排他的に調べることができます。3次元目も同様です。ようやくこの方針でプログラムを書いて提出したのですが、上記の通りTLEx2でした。その後も苦労し、最終的にはYからY+DのマスのリストとY+1からY+Dのマスのリストをそれぞれ0から1つずつappendして作っていたところ、YからY+DのマスのリストはY+1からY+Dのマスのリストに、y=Yのマスのリストをextendして作る、というように変更することでリストのappendなどの処理を減らしてACできました。時間はギリギリでした。YとY+Dをスライドさせていくことになるので、dequeで後ろに追加して前を消してく方法なども考えましたが、範囲のマスを抽出したあとで次の次元でソートして、ということを3次元目まで繰り返しているので、dequeからリストを新しく作って次の次元に渡すことになり、高速になりませんでした。これまでも経験則として書いてますが、Pythonはリストが増えると遅いです。この問題では6角格子（Hexagon Grid）のマスとマスの距離が必要ですが、max(|x|, |y|, |x-y|)で求められるようです。自分では導けていませんでしたが、確かにそうです。(x,y)->(x,y,x-y)と座標変換することで、距離D以下というのは2つのマスが1辺の長さがDの立方体の中に入っていることと同値になります。また、2つの点の各座標の差の最大値を「チェビシェフ距離」というようです。現時点でぼく以外のPythonでのACは7名で、黄色とオレンジの方しかいません。8人目のぼくだけ緑です。問題Gで、PythonでのACが8人しかいない上に、ぼく以外黄色以上なのを見ると、やっぱこの問題むずかしいんだよね。自分はがんばってるなぁ、と思えます。笑。 2022-12-07

MOD = 998244353
pow2 = [0]*301
pow2[0] = 1
for i in range(1, 301):
    pow2[i] = pow2[i-1] * 2 % MOD
N, D = map(int, input().split())
xyz = []
for _ in range(N):
    x, y = map(int, input().split())
    xyz.append((x, y, x-y))
def count_yrange(zs):
    zs.sort()
    lenzs = len(zs)
    ret = 0
    for i in range(lenzs):
        z = zs[i]
        ze = z + D
        j = i
        while j < lenzs and zs[j] <= ze:
            j += 1
        ret = (ret + pow2[j-i-1]) % MOD
    return ret
def count_xrange(yz):
    yz.sort(key=lambda item:item[0])
    lenyz = len(yz)
    ret = 0
    i = 0
    while True:
        if i == lenyz:
            break
        y = yz[i][0]
        ye = y + D
        zs = []
        zs1 = []
        j = i
        while j < lenyz and yz[j][0] == y:
            zs.append(yz[j][1])
            j += 1
        i = j
        while j < lenyz and yz[j][0] <= ye:
            zs1.append(yz[j][1])
            j += 1
        cy1 = count_yrange(zs1)
        zs1.extend(zs)
        cy = count_yrange(zs1)
        ret = (ret + cy - cy1) % MOD
    return ret
xyz.sort(key=lambda item:item[0])
ans = 0
i = 0
while True:
    if i == N:
        break
    x = xyz[i][0]
    xe = x + D
    yz = []
    yz1 = []
    j = i
    while j < N and xyz[j][0] == x:
        yz.append((xyz[j][1], xyz[j][2]))
        j += 1
    i = j
    while j < N and xyz[j][0] <= xe:
        yz1.append((xyz[j][1], xyz[j][2]))
        j += 1
    cx1 = count_xrange(yz1)
    yz1.extend(yz)
    cx = count_xrange(yz1)
    ans = (ans + cx - cx1) % MOD
print(ans)

この問題を解くにあたり、処理が複雑すぎてなかなか進められず参っていた間、別の楽な方法がないか逃げていた時間があって、その時に新しいグラフの用語を覚えました。最大300マスなので、すべての2つのマス間の距離を計算できます。よって、距離がD以下のマス間をエッジを結んでグラフを作って解く方法があるのではないか？と考えました。「選んだマスのうちどの2マスの距離もD以下になる」ことは「どの頂点間にもエッジがある」と言い換えられます。「どの頂点間にもエッジがある」グラフのことを完全グラフというようです。知りませんでした。そして完全グラフである誘導部分グラフ（あるグラフから、一部の頂点を取り出し、その頂点対の辺の有無が元のグラフと一致するグラフ）のことを、クリーク（clique）と言います。するとこの問題は、クリークの数を求める問題と言い換えられることがわかります。NetworkXにfind_cliquesという関数があり、最大クリークを得ることができることを知りました。これを使って、クリーク数を求められないか？考えてみましたが、断念しました。グラフとグラフの積をいろんな最大クリーク間で何重にも求めなければいけないような処理になりそうでした。グラフの問題として解く方法はあるのでしょうか？以下はfind_cliquesだけ呼んで終了するコードです。Python (3.8.2)で、ここまでの処理時間は2154msでした。 2022-12-07

import sys
import networkx as nx
g = nx.Graph()
N, D = map(int, input().split())
nodes = []
for _ in range(N):
    x, y = map(int, input().split())
    nodes.append((x, y))
for i in range(N-1):
    x1, y1 = nodes[i]
    for j in range(i+1, N):
        x2, y2 = nodes[j]
        dx = x2 - x1
        dy = y2 - y1
        if max(abs(dx), abs(dy), abs(dy-dx)) <= D:
            g.add_edge(i, j)
for i in nx.find_cliques(g):
    pass
sys.exit()

AtCoder Beginner Contest 281

4完でした。問題Bでトラブって15分経ちました。問題DはDPでしたが、自分にとってはまだ難しい部類で、終わった時点で80分。これを解ききれたことは喜びたいと思います。問題Eを少しやり始めて、プライオリティキュー使ったらできるでしょと思いながらコンテスト終了しましたが、実際にACできたのは翌日でした。このようなプライオリティキューの使い方を頭に入れられたので良い勉強になったと思います。前回まで2連続5完していましたので、4完に減ると残念ですが、内容をふりかえると実力だったと納得できました。問題Bと問題Dで、デバッグ時のprintを残して提出してしまい、それぞれ1ペナルティ食らったのはもったいないので、今後、気をつけたいです。Ratingはかろうじて上昇しました。

B - Sandwich Number

罠にハマってしまいました。読み込みの高速化でinput = sys.stdin.readlineとすることを最近覚えました。副作用はないと思っていたのですが、stdin.readlineだと終端文字が取れるようです。8文字の入力なのにlenを取ると9が返ってきて、なんだこれは？と思っているうちに時間が経ってしまいました。意味もなく使わないようにしたいと思います。入力をsplitする場合は問題なさそうですが。 2022-12-10

D - Max Multiple

コンテスト中にACできましたが、ぼくにとっては結構難しいと感じます。最近5問解けることも出てきて、4完で終わると残念に感じてしまいますが、この4問目がコンテスト中に解けたことは喜ばしいことで、満足したいです。最初からDPと思わず、全く解ける気がしないと感じましたが、「あれ？DPでいけるのか？」と気づいて頭が働き始めました。DPは、できる気がしないような問題が解けてしまうところがあり、いまだにマジックのような感じがしています。そのロジックを自分で組み立てられるのですから、これが解けることは、大きな喜びです。これまでに選択した個数と、Dで割った余りごとに最大値を計算していけばよいです。aiを選択すると個数が1つ増え、Dで割った余りも計算することができます。初期状態は0個、余り0の状態で、最大値が0のみです。存在しない状態から次の状態に遷移してはいけないので、他の初期値を-1としておき、-1でない値が入っていたときだけ、次の状態を計算するようにします。最初存在しない状態を別扱いできておらず、デバッグにも時間を使ってしまい、この問題が解けたのは、開始から80分くらいでした。 2022-12-10

N, K, D = map(int, input().split())
alist = [0] + list(map(int, input().split()))
idx = lambda m,p:p*(K+1)+m # m ko, amari p
dp = [[-1]*((K+1)*D) for _ in range(N+1)]
dp[0][idx(0,0)] = 0
for i in range(N): # i -> i+1
    for j in range((K+1)*D):
        dp[i+1][j] = dp[i][j]
    for m in range(min(i+1,K)):
        for p in range(D):
            if dp[i][idx(m,p)] != -1:
                nextval = dp[i][idx(m,p)] + alist[i+1]
                dp[i+1][idx(m+1,(p+alist[i+1])%D)] \
                    = max(dp[i+1][idx(m+1,(p+alist[i+1])%D)], nextval)
print(dp[N][idx(K,0)])

E - Least Elements

昇順で最初のK個と残りのM-K個をそれぞれ別管理し、スライドさせていったときに消すものと追加するものだけ処理していけば良いな、K個の最大とM-K個の最小の値が必要になるので、プライオリティキューでやれば良いかな？というところまでは、コンテスト時間内に思っていました。終了後に、それでできるだろーと思ってやっていましたが、かなり苦労しました。その苦労は、プライオリティキューの使い方に慣れておらず、整理できずに混乱したのが原因と思っています。03_m_small_00.txtだけREという状態がしばらく続きましたが、プライオリティキューの先頭にアクセスするときに存在確認しておらず、不正アクセスしていたことが原因でした。これは基本でしょう。そして、プライオリティキューは先頭のpopしかできないので、他の要素を削除するときはremovedフラグを別途用意して維持する必要があります。削除するときは先頭であればpopし、先頭をpopしたあとは、removedである限りpopし続けることによって、先頭はremovedではない状態を維持する必要があるでしょう。プライオリティキューは先頭が大事ですから。removedが先頭に残っていてはいけません。また、存在確認も必要でしたので、setを使いました。pushしたとき、remvoedフラグを更新したときは、必ずsetも更新します。ということで、プライオリティキューを使いますが、補助的にremovedフラグのリストと要素setをあわせて使う必要がありました。このような使い方はよくあるだろうと思いますので、この問題を通して学んだことで、今後混乱せずに使うことができるようになったのではないかと思います。 2022-12-11

復習です。小さい方K個と大きい方M-K個のIDのsetを持っておいて、とりあえず消すものは消します。setからは消せるが、heapqからは消せないので、removedリストで管理しておく必要があります。heapqから消さないというのは直感的ではないですが、removedリストを見ればすでに消えているかどうかはわかるので、これを自然にやれるようになるべきでしょう。問題は追加するときに、大きさの整合性が取れている必要があること。これはheapqを使って境界を確認し、整合性が取れる方に追加する必要があります。K個のグループのmax値以下なら、K個のグループに追加するということで良いでしょう。消したグループに追加したなら、そのままでOK。異なるグループに追加した場合は、数をK個とM-K個になるように、1つ移動して調整しなければなりません。このときも最大値、もしくは最小値に相当するものをheapqの先頭を確認して移動すれば良いです。setとremovedリストはやはり必要だということを確認しました。 2023-01-12

import heapq
N, M, K = map(int, input().split())
alist = list(map(int, input().split()))
_m = [(alist[i], i) for i in range(M)] # val, idx
_m.sort(key = lambda x:x[0])
_k = [(-_k[i][0], _k[i][1]) for i in range(K)]
big = _m[K:M]
heapq.heapify(_k)
heapq.heapify(big)
kidset = {x[1] for x in _k}
bigidset = {x[1] for x in big}
ans = sum([-x[0] for x in _k])
anss = [ans]
l = 0
r = M
removed = [False]*N
while r < N:
    minus = alist[l]
    plus = alist[r]
    remove_from_k = True
    removed[l] = True
    # remove
    if l in bigidset:
        bigidset.remove(l)
        remove_from_k = False
        if big[0][1] == l:
            heapq.heappop(big)
            while big and removed[big[0][1]]:
                heapq.heappop(big)
    else:
        kidset.remove(l)
        ans -= minus
        if _k[0][1] == l:
            heapq.heappop(_k)
            while _k and removed[_k[0][1]]:
                heapq.heappop(_k)
    # add
    if not _k or plus <= -_k[0][0]: # check _k empty at first!
        # add to _k
        kidset.add(r)
        ans += plus
        heapq.heappush(_k, (-plus, r))
        if not remove_from_k:
            # removed from big
            # need to move from _k to big
            while True:
                hoge = heapq.heappop(_k)
                if not removed[hoge[1]]:
                    ans -= -hoge[0]
                    kidset.remove(hoge[1])
                    while _k and removed[_k[0][1]]:
                        heapq.heappop(_k)
                    bigidset.add(hoge[1])
                    heapq.heappush(big, (-hoge[0], hoge[1]))
                    break
    else:
        # add to big
        bigidset.add(r)
        heapq.heappush(big, (plus, r))
        if remove_from_k:
            # removed from _k
            # need to move from big to _k
            while True:
                hoge = heapq.heappop(big)
                if not removed[hoge[1]]:
                    ans += hoge[0]
                    bigidset.remove(hoge[1])
                    while big and removed[big[0][1]]:
                        heapq.heappop(big)
                    kidset.add(hoge[1])
                    heapq.heappush(_k, (-hoge[0], hoge[1]))
                    break
    anss.append(ans)
    l += 1
    r += 1
print(*anss)

F - Xor Minimization

この問題は、初めて自力で解けた6問目となり、成長を感じられてうれしいです。わりと早い段階でこうやればいいなぁということは思いついたのですが、1発ではサンプルケースがうまくいかず、minimax関数の戻り値のところの細かい処理など、修正してのACとなりました。 なんかGrundy数を勉強してからXOR好きですね。 2022-12-11

import sys
input = sys.stdin.readline
N = int(input())
alist = list(map(int, input().split()))
alist.sort()
inf = alist[-1] + 1
# return possible minimum of max
def minimax(bitmask, s, e):
    '''s != e'''
    if bitmask == 1:
        if bitmask & alist[s] == bitmask & alist[e-1]:
            return 0
        else:
            return 1
    i = s
    while i != e and bitmask & alist[i] == 0:
        i += 1
    res = inf
    if s != i:
        res = min(res, minimax(bitmask>>1, s, i))
    if i != e:
        res = min(res, minimax(bitmask>>1, i, e))
    if s == i or i == e:
        return res
    return bitmask + res
topbit = 1 << len(bin(alist[-1]))-3
print(minimax(topbit, 0, N))

G - Farthest City

DPに持ち込むのだろうと思いながら、持ち込めず解説を見ました。問題Gを初めて自力で解けるのはいつになるのでしょうか？条件を満たすグラフをどのように作るかまでは、自分で導くことができました。そこはうれしいです。そして総数を求める式も作れるなぁと思い、でも1から同じ距離の頂点グループの組み合わせが膨大にあり過ぎて計算できないなぁと思い、よってDPでなんとかするんだろうなぁ、というところまで考えましたが、力尽きて解説を見ました。DPに持ち込めることがすごく大事ですね。今までいろいろなDPの問題を解いてきたので、考え方のノウハウを抽出したいです。実行時間が3286msと遅めなのですが、改善の余地があるのかはちょっとわからないです。Combinationを計算しているところは左右対称なので無駄ですが、これは大した計算ではないです。 2022-12-12

N, M = map(int, input().split())
combi = [[1]*(i+1) for i in range(N-1)]
for i in range(1, N-1): # max N-2 is necessary
    for j in range(1, i):
        combi[i][j] = (combi[i-1][j-1] + combi[i-1][j]) % M
    combi[i][-1] = 1
pow2 = [1]*(N*N)
for i in range(1, N*N):
    pow2[i] = pow2[i-1] * 2 % M
dp = [[0]*(N-1) for _ in range(N-1)]
# init
for i in range(1, N-1):
    dp[i][i] = combi[N-2][i] * pow2[i*(i-1)//2] % M
for i in range(1, N-1): # used i
    for j in range(1, i+1): # prev group
        pow2_j_1 = pow2[j] - 1
        pow2_j_1_pow_k = 1
        for k in range(1, N-1-i): # next group
            pow2_j_1_pow_k = pow2_j_1_pow_k * pow2_j_1 % M
            count = dp[i][j] * combi[N-2-i][k] \
                * pow2_j_1_pow_k * pow2[k*(k-1)//2] % M
            dp[i+k][k] = (dp[i+k][k] + count) % M
ans = 0
for j in range(1, N-1):
    ans = (ans + dp[N-2][j] * (pow2[j] - 1)) % M
print(ans)

AtCoder Beginner Contest 282

くやしい結果となりました。何度か5問解けたことで、力がついてきた気がしていたのですが、今回は、極めてシンプルな、3問目の問題CでTLEに陥りました。しかし、何がまずいのかピンとこず、一旦スキップして問題Dに進んだのですが、問題Cが解けなかったことで動揺していてうまくいきませんでした。考え方がわかったにも関わらず、落ち着いてバグを直せませんでした。なによりも問題Cでつまずいたことがショックで、終わったあと、かなりイライラしてしまいました。連続で参加して疲れているし、休めばよかったかなぁとも後悔しましたが、失敗したからこそ、学ぶことが多かったとも、言えそうです。これがCやC++を使っていく転機にもなりえます。

ここに来て順位が過去最低。そして、問題Cを99:59にACするという奇跡w

C - String Delimiter

※最初に書きます。この問題でTLEを出してイライラしていましたが、解決しました。PEP 8 Programming Recommendationsにこのことが書かれています。

いや、まさに。performance sensitiveなところで、文字結合に+=じゃなくて''.join()を使えと。これ常識なんですかね。Pythonを使うなら、知っておかなければならない常識なのでしょう。こういうの知らずに失敗するのは、くやしいですね。 2022-12-20

この問題Cが、ABC282の重大問題でした。わからないことも多いので、事実を書きます。以下のコード、PyPy3 (7.3.0)でACx6、TLEx14となります。最初に提出したのはこのようなコードでした。01_test_04.txtから01_test_17.txtまで全部TLE、2秒超えです！これで動揺しまくって問題Cをスキップし、落ち着かないまま問題Dにいって、惨敗のきっかけとなりました。

N = int(input())
outer = 1
ans = ''
for c in input():
    if c == '"':
        outer ^= 1
    if outer and c == ',':
        c = '.'
    ans += c
print(ans)

今このnoteを書いてる途中で気づいたのですが、同じコードがPython (3.8.2)で、74ms！ACできてしまいます。Pythonの方が圧倒的に速いのかよ！イラつかせるなぁ。なぜ気づいたかというと、自分のマシン上で、この問題の調査のために以下のコードを実行すると0.1秒で終了しました。自分のローカル環境はPyPyではなく、Pythonなのです。PyPy、2秒超えるってどういうことだよ。ふざけんな。

import time
time_sta = time.time()
s = ''
for _ in range(1000000):
    s += 'a'
print(time.time()- time_sta)

もう1つ気になることは、リストに1文字ずつappendしておいて、最後にjoinすると、速いのです。ふざけんな。このコードがPyPyで86ms！なんでやねん！てあれ？Pythonで63ms！これもPythonの方が速いのかよ！PyPyざけんな。しかし公式解説がなぜかPythonで、しれっとjoinを使って実装しているのです。正直""の内外判定はどうでもよく、なぜjoinで実装しているのか？を書くべきではないかとモヤモヤする解説です。

N = int(input())
outer = 1
ans = []
for c in input():
    if c == '"':
        outer ^= 1
    if outer and c == ',':
        c = '.'
    ans.append(c)
print(''.join(ans))

ちなみに、このC言語のコードで実行時間4msを出すことができ、全提出の4位に入ることができ、少し溜飲を下げることができました。3ms1人、4ms3人です。いや、普通インデックスで指定してダイレクトに書き換えますよね。Pythonではこれができない。TypeError: 'str' object does not support item assignment.というエラーが出ます。なんでやねん。今後2度と、速度問題でロジックと無関係なところで苦労し、ストレスを感じたくありません。簡単な問題ではC言語も使えたら、爆速実行時間をたたき出し、溜飲を下げられる可能性があります。今後のために準備しておきたいです。この問題は、C、C++を取り入れるきっかけになるのでしょうか？だとしたら、あとでふりかえって良かったと思える日が来るかもしれません。 2022-12-19

D - Make Bipartite 2

コンテスト時間内に解答したかったですが、バグをとれませんでした。問題Cで動揺していたせいでしょうか？コンテスト終了後に落ち着いてやり直してもTLEとなり、連結成分間の辺の数を全連結成分ペアに対してかけ算で計算していたことで、計算量がO(N^2)になってしまっていたことが原因でした。不覚です。N頂点全体の最大エッジ数N(N-1)/2から、2部グラフが崩れるエッジ数、すなわち同一連結成分内の同じグループの頂点間のエッジ数と、はじめからあるエッジ数Mを引くことで、ぼくがやってしまったようなO(N^2)の計算を回避しつつ、答えを得ることができます。気づけずくやしいです。DFSで連結成分を抽出する処理もなんか落ち着いて実装できず、最初バグだらけになってました。usedフラグやcolorリストを更新するのは、stackからpopするときか、appendするときか？といったこともブレブレで、反省です。ABC282、ダメダメです。 2022-12-17

import sys
N, M = map(int, input().split())
g = [[] for _ in range(N)]
for _ in range(M):
    u, v = map(int, input().split())
    g[u-1].append(v-1)
    g[v-1].append(u-1)
used = [False]*N
color = [-1]*N
ans = N*(N-1)//2 - M
for v in range(N):
    if used[v]:
        continue
    stack = [(v,0)] # color 0
    used[v] = True
    color[v] = 0
    countcol = [0,0]
    while stack:
        cur = stack.pop()
        curv = cur[0]
        curc = cur[1]
        colnext = curc^1
        countcol[curc] += 1
        for next in g[curv]:
            if used[next]:
                if color[next] != colnext:
                    print(0)
                    sys.exit()
                continue
            used[next] = True
            color[next] = colnext
            stack.append((next,colnext))
    for count in countcol:
        if count > 1:
            ans -= count*(count-1)//2
print(ans)

E - Choose Two and Eat One

ボール数が500なので、全ボール間の得点を計算し、完全木を作れます。このように考えました。頂点の辺の重みの最大値でソートし、それが小さい順に消していけばいいのでは？と。最大が最小であれば、その頂点を消しても他の頂点に対する、より重みの大きな辺を残すことができるはずだからです。辺の重みの最大値が一致していて、その辺を共有している2頂点の場合は、2番目に大きな重みが大きい方を後で消すようにします。と考えてましたが、行き詰まって解説を見ると、最大全域木を求めればよいとのことです。2つのボールを選ぶ操作は、1本の辺を選ぶことと同値です。1つずつ頂点を消すので、連結成分の中で残っている点は常に1つだけであり、閉路をつくることは不可能です。つまり、この操作はどのような順序であっても、全域木を作る操作に等しいです。であれば、最大全域木の合計得点が答えです。こういうの、気づきたいものです。 2022-12-18

class Union():
    # 省略
N, M = map(int, input().split())
alist = list(map(int, input().split()))
es = []
for i in range(N-1):
    for j in range(i+1, N):
        es.append(((pow(alist[i],alist[j],M)+pow(alist[j],alist[i],M))%M,i,j))
es.sort(key=lambda e:-e[0])
u = Union(N)
ans = 0
for e in es:
    if not u.same_tree(e[1], e[2]):
        u.unite(e[1], e[2])
        ans += e[0]
print(ans)

F - Union of Two Sets

Sparse Tableそのものとのことでした。Sparse Tableを知りませんが、意味するところがわかれば、すぐにコードを書くことはできます。任意区間を、2つの2べき幅の区間の和でカバーできるという発想です。気づける人は気づけるかもしれません。 2022-12-18

import math
N = int(input())
maxdouble = math.floor(math.log2(N))
leftidx = []
count = 0
lrs = []
for i in range(maxdouble+1):
    leftidx.append(count+1)
    width = 2**i-1 # r-l
    lrs.extend([(l,l+width) for l in range(1, N-width+1)])
    count += N - width
print(count, flush=True)
for lr in lrs:
    print(*lr, flush=True)
Q = int(input())
for _ in range(Q):
    L, R = map(int, input().split())
    log2LR = math.floor(math.log2(R-L+1))
    l = leftidx[log2LR] + L - 1
    r = leftidx[log2LR] + R - 2**log2LR
    print(l, r, flush=True)

G - Similar Permutation

解説にEDPC T - Permutationが参考になるとあったので、まずそちらをやりました。EDPC T、理解するのに苦労しました。すごい問題です。そしてこの問題に戻ってきても、同じ考え方であると納得するのに時間がかかりました。1からiまでの並べ替えで、もとの昇順の数列(1,2,3,4,….,N)内での前後関係を表現しており、その発想はクレイジーだと思いました。途中の段階で実際にどの数字が割り当てられるのかわからず、Nまで挿入して初めて実際の数字が決まることが、理解するのに時間がかかる原因かなぁと思っています。使った数字の個数、類似度、Aの最後の挿入位置、Bの最後の挿入位置、という4次元のDPになります。4次元は初めてです。紙に描いて考え、なんとか遷移の処理を整理し、ACすることができました。2次元累積和の計算も、ぼくは初めてでした。どのように計算するべきか考える機会を得られたのは良かったです。数列Aで、0からi-1までの数字を挿入済で、最後に挿入したi-1が[j]の位置にあるとき、iを、[0]から[j]までの位置に挿入すれば[i]<[i-1]、[j+1]から[i]までの位置に挿入すれば[i]>[i-1]となります。Bの<>と一致するには…という風に考えていくと、どのような累積和を計算する必要があるのか、整理することができます。O(100^4)になるので、TLEしないか不安になりますが、遷移処理を高速化すればいけましたね。このコードは1080msで、現時点でPythonの中で2番目の処理速度が出ていました！しかしコンテスト時間内にここまで整理して、ちゃんと実装できる気がしないです。120人も解いてるの半端ないです。。 2022-12-19

N, K, P = map(int, input().split())
dp = [[1]] # dp is list of matrix
for i in range(1, N): # previously inserted i numbers
    ni = i + 1 # i -> ni
    kmax = min(ni-1, K) # max similarity to calculate next
    ni2 = ni*ni
    dp_next = [[0]*(ni2) for _ in range(kmax+1)] 
    for j, mtx in enumerate(dp):
        tempsum = [0]*(i*i)
        cur = 0
        for x in range(i): # right dir tempsum
            xi = x*i
            tempsum[xi] = mtx[xi]
            for y in range(1, i):
                tempsum[xi+y] = tempsum[xi+y-1] + mtx[xi+y]
                tempsum[xi+y] %= P
        mtx_next = dp_next[j]
        for x in range(i): # up dir
            memo = 0
            idx = i * (i-1) + x
            idxnext = ni * (i-1) + x + 1
            for _ in range(i):
                memo += tempsum[idx]
                mtx_next[idxnext] += memo
                mtx_next[idxnext] %= P
                idx -= i
                idxnext -= ni
        if j + 1 <= K:
            mtx_next = dp_next[j+1]
            for x in range(i): # down dir
                memo = 0
                idx = x
                idxnext = ni + x + 1
                for _ in range(i):
                    memo += tempsum[idx]
                    mtx_next[idxnext] += memo
                    mtx_next[idxnext] %= P
                    idx += i
                    idxnext += ni
        for x in range(i): # left dir tempsum
            xi = x*i
            tempsum[xi+i-1] = mtx[xi+i-1]
            for y in range(i-2, -1, -1):
                tempsum[xi+y] = tempsum[xi+y+1] + mtx[xi+y]
                tempsum[xi+y] %= P
        mtx_next = dp_next[j]
        for x in range(i): # down dir
            memo = 0
            idx = x
            idxnext = ni + x
            for _ in range(i):
                memo += tempsum[idx]
                mtx_next[idxnext] += memo
                mtx_next[idxnext] %= P
                idx += i
                idxnext += ni
        if j + 1 <= K:
            mtx_next = dp_next[j+1]
            for x in range(i): # up dir
                memo = 0
                idx = i * (i-1) + x
                idxnext = ni * (i-1) + x
                for _ in range(i):
                    memo += tempsum[idx]
                    mtx_next[idxnext] += memo
                    mtx_next[idxnext] %= P
                    idx -= i
                    idxnext -= ni
    dp = dp_next
print(sum(dp[K]) % P)

上と同じコードを、C言語で書いてみました。Pythonとは違って配列とか最大サイズで全確保してます。上のPythonが1080ms、このC言語が1352msでした。ACはできて良かったですが、むちゃくちゃ速くなってしまうことをどこかで期待してましたが、そうはいきませんでした。言語ごとの特徴とらえて高速化必要ですね。 2022-12-21

Ex - Min + Sum

1ヶ月前にやったABC277以来のExです。しばらくExは時間がかかるので見ないようにし、参加したABCのGまでを埋め続けていましたが、そちらは完了したので、この問題をなんとなく見始めました。自力で考えたことはというと、ある区間内では、Aの最小値は動かないので、まず区間とAの最小値を固定し、lとrでそれをはさみこむような（つまり、そのようにl,rを選べば、Aの最小値は変化しない）組み合わせを数えれば良いかなぁということでした。l,rの2次元グラフを描きました。l<=rなので、直角二等辺三角形の領域となります。Aの最小値のインデックスをmとすると、上記方針でl<=m、m<=rの長方形部分を調べることができ、その長方形を消すと、2つの小さい直角二等辺三角形が残ります。残った三角形に対して再帰的に数えていけばよいです。しかし、残った区間のAの最小値のインデックスを高速に求める方法がわからず、諦めました。よくあるように、最後のピースが足りないですが、まあここまで考えられたのはうれしいです。Cartesian treeという構造を使うことで、残った区間のAの最小値のインデックスは、グラフをたどるだけで得られることがわかりました。Cartesian treeを作るのは、テキトーにやろうとするとコストが高そうですが、O(N)で求めることができます。これは驚きでしたし、Cartesian tree構築の短いプログラムを、なぜこれでいいのか理解するのは苦労しました。で、Cartesian treeを構築したあとも2つ苦労しまして、1つはBの右端を[m,r]内でループしながら、条件を満たすBの左端を求める部分です。if r-m >= m-l:のelse:のところがそれにあたりますが、ifの方の、左から調べるコードよりちょっとややこしくなってしまっています。累積和のリストが与えられて、右から左に合計値maxsum以下になる左端を求めるの、混乱します。もう1つ苦労したのは、いつものようにTLEです。テストケース013.txtのTLEがなかなか取れませんでした。最初再帰呼び出しを使って実装して2秒の制限を超えていたのですが、スタックを使うように変更することで処理時間が513msとなってACすることができました。再帰呼び出しとえらい違いです。再帰呼び出しは遅いので要注意ですね。 2022-12-24

import sys
input = sys.stdin.readline
import bisect
N, S = map(int, input().split())
alist = [0] + list(map(int, input().split()))
cartesian_tree = [[] for _ in range(N+1)]
parent = [-1 for _ in range(N+1)]
stack = []
for i in range(1, N+1):
    prev = -1
    while stack and alist[i] < alist[stack[-1]]:
        prev = stack.pop()
    if prev != -1:
        parent[prev] = i
    if stack:
        parent[i] = stack[-1]
    stack.append(i)
root = -1
for i in range(1, N+1):
    if parent[i] != -1:
        cartesian_tree[parent[i]].append(i)
    else:
        root = i
bsum = [0]
for b in map(int, input().split()):
    bsum.append(bsum[-1] + b)
stack = [(1, N, root)]
count = 0
while stack:
    l, r, m = stack.pop()
    maxsum = S - alist[m]
    if r-m >= m-l:
        for i in range(l, m+1):
            maxidx = bisect.bisect_right(bsum, bsum[i-1] + maxsum)
            if maxidx > m:
                count += min(r+1, maxidx) - m
    else:
        for i in range(m, r+1):
            target = bsum[i] - maxsum
            minidx = bisect.bisect_right(bsum, target)
            if bsum[minidx-1] < target:
                minidx += 1
            if minidx <= m:
                count += m + 1 - max(l, minidx)
    for i in cartesian_tree[m]:
        if i < m:
            stack.append((l, m-1, i))
        else:
            stack.append((m+1, r, i))
print(count)

AtCoder Beginner Contest 283

クリスマスイブ、4完でした。問題Eの時点で1時間残っており、30分くらいでわかった！と思って提出したのですが、最後までWAx12が取れませんでした。なにがおかしいのか？コンテスト時間中に全く気づけないという状況で、完敗です。Ratingもほぼ横ばいでした。大晦日はないので、年内最後ですよね…。連続で参加し続けて疲れており、そろそろ休みたかったのでうれしいです。

E - Don't Isolate Elements

最初の方針はこうです。1行目に孤立要素があるか調べる、なければ、そのまま2行目に進む、1行目に孤立要素があったら2行目を反転、1行目の孤立要素がなくなったら2行目に進む…、これをN-1行目まで続けて、最後にN行目に孤立要素がなければOK。これでいいと思いこんでしまい、サンプルは正解しましたが、提出結果はACx18、WAx12でした。コンテスト時間中になにがおかしいのか全く気づきませんでした。まだまだダメダメだぁという感想しかありません。どこが間違っていたかというと、「そのまま2行目に進む」って書いてるところですね。2行目を反転させてもさせなくても1行目に孤立要素がない場合もあり、その場合は両方のパターンを考慮する必要がありました。なので、i行目まで確定した時点で、i-1行目と、i行目を反転させたかどうかで、(0,0),(0,1),(1,0),(1,1)の4通りのパターンそれぞれである場合の操作回数の最小値を更新する、DPで解く必要があります。i行目に孤立要素があるかどうかは、i-1行目の状態に影響を受けるためです。というわけで「できた！」と思ったのは完全に勘違いで、あらためてやり直してみると、普通に複雑でむずかしい問題だと思いました。こちら、1度目の提出でACできましたが、書いててイライラするような複雑さです。わかりにくいのでコメントも結構書いています。コンテスト時間内に解き切れる気がしません。適切なデータ構造や変数名を使うことで、解答にかかる時間を短くするスキルが足りないのだと感じます。 2022-12-25

import sys
H, W = map(int, input().split())
A = [[] for _ in range(2)] # 0 original 1 flip
F = {0:(0,0), 1:(0,1), 2:(1,0), 3:(1,1)}
F_ = {(0,0):0, (0,1):1, (1,0):2, (1,1):3}
for _ in range(H):
    A[0].append(list(map(int, input().split())))
    A[1].append([1-a for a in A[0][-1]])
def check_isolate(x, y, flip):
    f0, f1, f2 = flip
    this = A[f1][x][y]
    if 0 < x and A[f0][x-1][y] == this:
        return False
    if 0 < y and A[f1][x][y-1] == this:
        return False
    if x <= H-2 and A[f2][x+1][y] == this:
        return False
    if y <= W-2 and A[f1][x][y+1] == this:
        return False
    return True
dp = [[-1]*H for _ in range(4)]
# check 0
# 0 -> 1
for j in range(4): # flip 1 or not
    flip = (0, *F[j])
    for k in range(W):
        if check_isolate(0, k, flip):
            break
    else: # ok
        dp[j][1] = flip[1] + flip[2]
# check 1 - H-2
for i in range(1, H-1): # i -> i+1
    # try i+1 to make i not isolated
    for j in range(4): # status of i-1 and i
        if dp[j][i] == -1:
            continue
        for f in range(2): # flip i+1
            flip = (*F[j], f)
            for k in range(W):
                if check_isolate(i, k, flip):
                    break # ng
            else: # ok
                count = dp[F_[(flip[0], flip[1])]][i]+1 if f \
                            else dp[F_[(flip[0], flip[1])]][i]
                if dp[F_[(flip[1], flip[2])]][i+1] == -1:
                    dp[F_[(flip[1], flip[2])]][i+1] = count
                else:
                    if count < dp[F_[(flip[1], flip[2])]][i+1]:
                        dp[F_[(flip[1], flip[2])]][i+1] = count
# check H-1
res = 2000
for j in range(4):
    if dp[j][H-1] == -1:
        continue
    for k in range(W):
        flip = (*F[j], 0)
        if check_isolate(H-1, k, flip):
            break
    else: # ok
        if dp[j][H-1] < res:
            res = dp[j][H-1]
if res == 2000:
    print(-1)
else:
    print(res)

さすがに上の解答はACしてもキビシイと思うので、わかりやすく書き直してみます。dpをkeyが(0,0),(0,1),(1,0),(1,1)のdictに変えてみます。上では、0,1,2,3と(0,0),(0,1),(1,0),(1,1)を相互変換するためだけにdpを用意し、ループは0-3でやってタプルに変換したり、逆にタプルを0-3に戻したりしていました。これ、[]のなかで変換用dictにアクセスしたりして手間がかかってミスの温床になりそうでした。はじめからタプルをkeyにします。4つだけですし、この方が明らかにわかりやすいですよね。また、0からH-1の行を表す添字はi、0からW-1の列を表す添字はjで統一します。こういうの流れて変えちゃうのもミスの温床になりそうです。i+1はniという変数に、i+1を反転させるかどうか？は、nfという変数名にしました。niはi+1でアクセスしたり、片方だけnextって付けたりしちゃうこともある気がしますが、こうやって統一感出します。i-1とiのflipのタプル、i-1,i,i+1のflipのタプル、i,i+1のflipのタプルなど相互に作ったりするので、要素数を2のタプルに3つ目の要素を追加するときは、(*f, 1)のように、要素数3のタプルから2つのタプルを作るときは、f[1:]とか、f[:2]のように書くべきですね。 2022-12-25

見直しているときに思ったんですが、たとえば、直近3行のフリップ状態が0,1,0のときに、真ん中の行に孤立要素がない場合、1,0,1でも孤立要素はないですね。なので、計算量半分にはできそうです。まあ半分どころではなく速い提出もちらほらあるようで、そちらはどうなってるのかわかりません。 2023-01-14

import sys
H, W = map(int, input().split())
A = [[] for _ in range(2)] # 0 original 1 flip
for _ in range(H):
    A[0].append(list(map(int, input().split())))
    A[1].append([1-a for a in A[0][-1]])
def check_isolate(x, y, flip):
    f0, f1, f2 = flip
    this = A[f1][x][y]
    if 0 < x and A[f0][x-1][y] == this:
        return False
    if 0 < y and A[f1][x][y-1] == this:
        return False
    if x <= H-2 and A[f2][x+1][y] == this:
        return False
    if y <= W-2 and A[f1][x][y+1] == this:
        return False
    return True
dp = {(0,0):[-1]*H, (0,1):[-1]*H, (1,0):[-1]*H, (1,1):[-1]*H}
# check 0 line isolated
for f in dp: # line 0 and 1 flip status
    for j in range(W):
        if check_isolate(0, j, (0, *f)): # 0 is dummy
            break
    else: # ok
        dp[f][1] = f[0] + f[1]
# check 1 - H-2
for i in range(1, H-1):
    # try ni to make i not isolated
    ni = i + 1
    for f in dp: # status of i-1 and i
        if dp[f][i] == -1:
            continue
        for nf in range(2): # flip ni or not
            flip = (*f, nf)
            for j in range(W):
                if check_isolate(i, j, flip):
                    break # ng
            else: # ok
                count = dp[f][i]+1 if nf else dp[f][i]
                if dp[flip[1:]][ni] == -1:
                    dp[flip[1:]][ni] = count
                else:
                    if count < dp[flip[1:]][ni]:
                        dp[flip[1:]][ni] = count
# check H-1
res = INF = 2000
for f in dp:
    if dp[f][H-1] == -1:
        continue
    for j in range(W):
        if check_isolate(H-1, j, (*f, 0)):
            break
    else: # ok
        if dp[f][H-1] < res:
            res = dp[f][H-1]
if res == INF:
    print(-1)
else:
    print(res)

F - Permutation Distance

解説を見ると場合分けしてセグ木を使うと書いてあったり、マンハッタン距離の最小全域木を求めると言ってる人もいましたが、なかなかむずかしいです。あとで、勉強のためにそちらで解く必要があると思いますが、愚直に近い方から調べて枝刈りしてるだけでACしてる人も多く、まずそれでACしました。シンプルに考えて、この回答に気づけるべき、なのは間違いないですね。 2022-12-25

import sys
input = sys.stdin.readline
N = int(input())
P = [0] + list(map(int, input().split()))
ans = []
for i in range(1, N+1):
    di = 1
    res = N # next farthest
    while True:
        if 0 < i - di:
            res = min(res, di + abs(P[i-di] - P[i]))
        if i + di <= N:
            res = min(res, di + abs(P[i+di] - P[i]))
        di += 1
        if res <= di + 1:
            break
    ans.append(res)
print(*ans)

セグメントツリーで解くのが正攻法のはずなので、セグメントツリーの勉強も兼ねてやってみたのですが、ACx35、TLEx20から全く改善できません。他のPythonとセグメントツリーで解いてる人と、違いがあるように見えないので、ムカつきますがあきらめました。結局ぼくは今まで、セグメントツリーでまともにACした問題がありません。これで1回ACしておくはずだったのですが、腹立つなぁ。 2023-01-09

import sys
input = sys.stdin.readline
INF = 1000000
class SEGT():
    DEFAULT = -INF # need update
    # 省略
    def query(self, a, b, k, l, r):
        if r <= a or b <= l:
            return self.DEFAULT
        if a <= l and r <= b:
            return self.maxima[k]
        else:
            vl = self.query(a, b, k*2+1, l, int((l+r)/2))
            vr = self.query(a, b, k*2+2, int((l+r)/2), r)
            return max(vl, vr)

N = int(input())
P = [0] + list(map(int, input().split()))
D = [INF]*(N+1)
segt = SEGT(N+1)
for i in range(1, N+1):
    D[i] = min(D[i], P[i] + i - segt.query(0, P[i], 0, 0, segt.n))
    segt.update(P[i], P[i] + i)
segt = SEGT(N+1)
for i in range(N, 0, -1):
    D[i] = min(D[i], P[i] - i - segt.query(0, P[i], 0, 0, segt.n))
    segt.update(P[i], P[i] - i)
segt = SEGT(N+1)
for i in range(1, N+1):
    D[i] = min(D[i], -segt.query(P[i]+1, N+1, 0, 0, segt.n) - P[i] + i)
    segt.update(P[i], i - P[i]) # register minus
segt = SEGT(N+1)
for i in range(N, 0, -1):
    D[i] = min(D[i], -segt.query(P[i]+1, N+1, 0, 0, segt.n) - P[i] - i)
    segt.update(P[i], - P[i] - i)
print(*D[1:])

あきらめた。などと言ってあきらめたことはないですね。どうしても気になり続けてしまっていて、コーヒーでも飲んでるときに、ふと改善できる箇所に気づきます。今回は、queryが再帰関数になってるところが遅そうと気づけました。再帰関数をstackに書き直したらACできました。stackに書き直すのも、ササッとこなれたものです。祝、セグ木初AC。最初に書いたのが蟻本のC++をPythonに翻訳して書いたもので、再帰関数やまだ慣れてなかったころの表現がそのままになってました。徐々にわかってくることがあるし、解けない問題に遭遇することで、ライブラリがまともなものに更新されていきます。うまくいかないとき、ちゃんと解決しておくことで、次解ける問題が増えていくので、あきらめるのはNGです。ABC266 Ex - Snuke Panic (2D)は、2次元フェニック木で解けたけど、2次元セグメント木ではTLEでした。これも今ならACできるのか？ちょっと気になります。→ダメ、その後さらに高速化してもダメ。 2023-01-09

import sys
input = sys.stdin.readline
INF = 1000000
class SEGT():
    DEFAULT = -INF # need update
    # 省略

    def query(self, a, b):
        ret = self.DEFAULT
        stack =[(0, 0, self.n)]
        while stack:
            k, l, r = stack.pop()
            if r <= a or b <= l:
                pass
            elif a <= l and r <= b:
                ret = max(ret, self.maxima[k])
            else:
                stack.extend([(k*2+1, l, (l+r)//2), (k*2+2, (l+r)//2, r)])
        return ret

N = int(input())
P = [0] + list(map(int, input().split()))
D = [INF]*(N+1)
segt = SEGT(N+1)
for i in range(1, N+1):
    D[i] = min(D[i], P[i] + i - segt.query(0, P[i]))
    segt.set(P[i], P[i] + i)
segt = SEGT(N+1)
for i in range(N, 0, -1):
    D[i] = min(D[i], P[i] - i - segt.query(0, P[i]))
    segt.set(P[i], P[i] - i)
segt = SEGT(N+1)
for i in range(1, N+1):
    D[i] = min(D[i], -segt.query(P[i]+1, N+1) - P[i] + i)
    segt.set(P[i], i - P[i]) # register minus
segt = SEGT(N+1)
for i in range(N, 0, -1):
    D[i] = min(D[i], -segt.query(P[i]+1, N+1) - P[i] - i)
    segt.set(P[i], - P[i] - i) # register minus
print(*D[1:])

G - Partial Xor Enumeration

参加し始めたABC266から、問題Gを埋めていましたが、2022年ラストABCの問題G、かなり苦労してようやくACしました。知らないことが多すぎて勉強が大変でした。線形代数の教科書も出してきて、読んでました。現在Python3での提出中、なぜか最速の287msで、ちょっとうれしいです。遅いとなんで遅いのか？とまた気になってしまいますからね。この問題を解くために「XOR基底」というものを勉強しました。1度それを勉強してしまうと、この問題はXOR基底を求めて解く問題としか思えなくなります。「XOR基底」とは、数列A内の部分列のXORが作る空間の基底のことですから。基底とは何かというと、数列AのXOR空間をすべてカバーできる線形独立な集合です。それを求めるにはnoshi基底という方法を使いす。Pythonならこうなります。シンプル！

base = []
for a in alist:
    for e in base:
        if a^e < a:
            a ^= e
    if a:
        base.append(a)

XOR基底自体初めて勉強したので、最初見たときは、ちんぷんかんぷん過ぎたのですが、今現在ぼくがnoshi基底をどのように理解しているか？書いてみます。この方法で得られたbaseは、最上位bitがすべて異なります。if a^e < a:のところを見てください。このif文の条件を満たすのは、aの中の、すでに登録済みの基底の最上位bitの桁が1から0になる時だけです。つまり、aの中の、すでに登録済みの基底の最上位bitの桁を、全部0にする処理なのです。その処理が終わって0でなければ、aを新しい基底として登録します。この時点でaの最上位bitは、登録済みのすべての基底の最上位bitと異なります。同じであれば、if文の処理で、0に変えられてしまうからです。よって、この処理が終わった時点で、baseに登録された基底は最上位bitがすべて異なることがわかります。基底を成すために、最上位bitがすべて異なる必要があるのかどうかは、わかりません。しかし、最上位bitが異なる値の集合が線形独立であることは明らかです。（明らかではないかもしれないので、下に追記があります。）つまり確実に線形独立な集合が作られることはわかります。ではここで作られた線形独立なbaseは、数列AのXOR空間をすべてカバーしているのかどうか？最初不思議に感じましたが、実は数列Aのすべての要素をbaseに登録された基底で作ることができれば、カバーできていると言えます。何が不思議と感じたかって、たとえば、ai^aj^akが基底の組み合わせだけで表現されないといけないわけですが、ai=e1、aj=e1^e2、ak=e1^e3だった場合、「あれ？e1が3つも出てきたぞ！使えるのは1つまでなのに！」って疑問が湧きませんか？でもそんな心配は不要です。XORの性質から、e1^e1^e1=e^1なのです。2つ使うと必ず0個に戻ってくれるので、何個使っても1つ以上使えないのです。これはXORの不思議な性質で、楽しいですね。よって、すべてのaを基底から作ることができれば、基底の作るXOR空間は数列AのXOR空間と一致します。さて、すべてのaはbase内の基底のXORで作れるのか？これはnoshi基底の処理中、a^=eという処理しかしていないことから、当然eのXORでaを作れるように処理を進めているのです。（eはaそのものか、aといくつかのeとXORを取って作られています。処理中0になって基底に登録されなかったものは当然ながら、eの組み合わせでできています。）よって、上記で得られたnoshi基底は、確かに数列AのXOR空間の基底を成しています。どうやっても同じ変数を2個以上XORできないという、XORの気持ちいい性質、すばらしいですよね。eはaを元にしてXORだけを使って作っているのだから、aを組み合わせてXORすればそれぞれのeを作れるし、（あ、これはeの中にaから作れないような余計なものがないことの証明として大事ですね。）aで作ったeを組み合わせてXORすればそれぞれのaを作れるわけです。もう一度証明を一言でまとめると、「noshi基底は最上位bitが異なることから線形独立であり、数列Aのすべての要素をnoshi基底のXORで作れることから、AのXOR空間とnoshi基底のXOR空間が一致するため、XOR基底となっていることがわかる。」この問題では、AのXOR空間の要素を小さい順に列挙する必要がありますので、すでに登録した基底要素の中に新しい基底要素の最上位bitの桁が1のものが含まれていた場合、消す処理を、追加でほどこしています。このようにすることで、確実に昇順に列挙することができています！いやー大変だった。 2023-01-04

noshi基底の証明で「最上位bitが異なるので線形独立」と書いた部分が本当か？と、ちょっともやもやしたので追記します。この問題においては、基底を作る処理中で新しい基底要素を追加するときに、最上位bitと同じ桁が1の登録済み基底要素があれば、0にし、最上位bitは絶対に1つしかない状態にしています。この方が線形独立であることは明らかでわかりやすいように思います。元のnoshi基底の生成では110を登録したあとで10が登録されうるように、ある基底要素の最上位bitと同じbitが立っている他の基底要素が存在しうるので、本当に大丈夫か？とちょっと不安になるかもしれません。しかしやはり最上位bitが異なれば、その組み合わせのXORで生成される値はすべて異なることを示せます。e1,e2,e3,..と基底要素を昇順に並べたとします。小さい順に使うか使わないか？を決めて値を生成すると、0→e1→e2,(e1,e2)→e3,(e1,e3),(e2,e3),(e1,e2,e3)→…というように倍々で新しい値を生成できますが、新しい基底要素を追加したときに初めてその最上位bitが立つはずなので、同じ値が作られることは、やはりありえません。「最上位bitが異なるので線形独立」というのは正しいです。安心です。 2023-01-04

import sys
input = sys.stdin.readline
N, L, R = map(int, input().split())
base = []
for a in map(int, input().split()):
    for e in base:
        if a^e < a:
            a ^= e
    if a:
        for i, e in enumerate(base):
            if a^e < e:
                base[i] ^= a
        base.append(a)
base.sort()
def calc(i):
    res = 0
    keta = 0
    while i:
        if i&1:
            res ^= base[keta]
        i //= 2
        keta += 1
    return res
ans = []
for i in range(L-1, R):
    ans.append(calc(i))
print(*ans)

AtCoder Beginner Contest 284

新年最初のABC。4回ぶり4度目の5完でした。1ヶ月、5完から遠ざかってましたがようやくです。今回は6問目の問題Fに50分近く残っていて、初めて解けるかもしれないと緊張しましたが、解けませんでした。SA-ISで、いけるかなー？という方針を思いつき、やってましたが、ロジックが煩雑になってしまいました。

D - Happy New Year 2023

素因数分解の典型的なやり方だとTLEでした。ひっかけで初笑いです。Nはq*p^2で表せるという条件があるので、1つ目の素因数が見つかった時点で、ループを打ち切って残りを計算すればよいです。3つの素数の積なので、最も小さいものは、9*10^18の3乗根、すなわち約200万より小さいことがわかるので、短時間で見つかりますね。pかqが比較的小さくて、もう一方を見つけるためにループを回し続けると、計算量が膨大になってしまいますね。qが先に見つかったときに、pを計算するところで、平方根を小数で計算したものをintに変換していますが、これは安全なのでしょうか？不安なら+1、-1の値で正当性検証した方が良いかもしれません。 2023-01-07

T = int(input())
for _ in range(T):
    N = int(input())
    a = 2
    while a*a <= N:
        if N % a == 0:
            N //= a
            if N % a == 0:
                print(a, N//a)
            else:
                print(int(N**0.5), a)
            break
        a += 1

E - Count Simple Paths

DFSで、帰りがけにusedをFalseにすることで正しくカウントできました。コンテスト中に解けてスッキリです。 2023-01-07

N, M = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(M):
    u, v = map(int, input().split())
    G[u-1].append(v-1)
    G[v-1].append(u-1)
stack = [-1, 0]
used = [False]*N
ans = 0
while stack:
    cur = stack.pop()
    if cur >= 0:
        used[cur] = True
        ans += 1
        if ans == 1000000:
            break
        for next in G[cur]:
            if not used[next]:
                stack.extend([~next, next])
    else:
        used[~cur] = False
print(ans)

F - ABCBAC

コンテスト時間中にSA-ISで解こうとして時間切れになりました。解説によるとZ algorithmというものが使えるようです。名前だけ聞いたことがありましたが、この機会に初めて勉強できました。文字列のすべての接尾辞について、その文字列の先頭からと何文字一致しているか？をO(N)で計算できます。考え方もコードもシンプルで、すごくいいです。これを知ってしまうと、この問題はZ algorithmで解くとしか思えなくなってしまいました。Z algorithmを知ることができて良かったです。 2023-01-07

import sys

def z_algorithm(s):
    n = len(s)
    z = [0]*(n)
    z[0] = n
    i = 1
    j = 0
    while i < n:
        while i+j < n and s[j] == s[i+j]:
            j += 1
        z[i] = j
        if j == 0:
            i += 1
            continue
        k = 1
        while i+k < n and k+z[k] < j:
            z[i+k] = z[k]
            k += 1
        i += k
        j -= k
    return z

N = int(input())
N2 = 2*N
T = input()
mae = T[:N]
ato_rev = T[N:][::-1]
if mae == ato_rev:
    print(mae)
    print(N)
    sys.exit()
X = mae + ato_rev
Y = ato_rev + mae
ZX = z_algorithm(X)
ZY = z_algorithm(Y)
for i in range(1, N):
    if ZX[N2-i] == i and ZY[N+i] == N-i:
        print(T[:i]+T[i:N][::-1])
        print(i)
        break
else:
    print(-1)

ローリングハッシュを使ったことがないので、ローリングハッシュでもやってみました。ABCに参加し始めて、比較的早い段階でこの言葉に出会っていましたが、その時は、他の方法でも解けたので後回しにして、ずっと気になっていました。まず、蟻本の該当ページを読みましたが、これだと文字列中の固定幅のハッシュ値しか計算していませんね。この問題では、幅を変動させながら調べる必要があるので、接頭辞全体のハッシュ値を求めておき、指定した範囲のハッシュ値は左右の値から計算する必要があります。やってみました！最初蟻本に書いてあった通りmodを計算するH=2^64として実行したところ、WAx5、TLEx19となってしまいました。どうも2^64を使うとハッシュ値が衝突するような意地悪問題を作れるらしいです。さらに遅い。そこで、ネットで見つけたH=2^61-1を使用したところ、なんとACです。こういうのやってみないとわからないし、ローリングハッシュで初めてトライしてみて良かったです！ 2023-01-08

import sys
B = 100000007
# H = 2**64
H = 2**61 - 1
N = int(input())
N2 = 2*N
T = input()
mae = T[:N]
ato_rev = T[N2-1:N-1:-1]
if mae == ato_rev:
    print(mae)
    print(N)
    sys.exit()
X = mae + ato_rev
hash = [0]*(N2+1) # 0 is empty 1-N2 is char
Bexp = [0]*(N2+1)
Bexp[0] = 1
for i, c in enumerate(X): # X[i] -> hash[i+1]
    hash[i+1] = (hash[i] * B + ord(c)) % H
    Bexp[i+1] = Bexp[i] * B % H
def hash_range(l, r):
    return (hash[r] - hash[l] * Bexp[r-l]) % H
for i in range(1, N):
    if hash_range(0,i) == hash_range(N2-i,N2) \
    and hash_range(i,N) == hash_range(N,N2-i):
        print(T[:i]+T[N-1:i-1:-1])
        print(i)
        break
else:
    print(-1)

G - Only Once

なもりグラフができて、巡回するまでの個数、ということまではわかったんですが、対称性があるのでB1だけ考えて、N倍すればいいってことに気づけませんでした。気づきたいですし、この問題は解けたいですね。問題Gの壁はなかなか破れません。 2023-01-08

N, M = map(int, input().split())
# for x 1-N
# where x is reachable num count from 1
perm = [0]*(N+1)
perm[1] = 0
if N > 1:
    perm[2] = (N-1) % M
    for x in range(3, N+1):
        perm[x] = perm[x-1] * (N-x+1) % M
expo = [0]*(N+1)
expo[N] = 1
for x in range(N-1, 0, -1):
    expo[x] = expo[x+1] * N % M
ans = 0
for x in range(1, N+1):
    ans += perm[x] * (x*(x-1)//2) * expo[x]
    ans %= M
print(ans*N%M)

AtCoder Regular Contest 153

これまで土曜日にABCに参加していましたが、今週はARCが土曜日でABCが日曜日ということで、この機会にとARCに初参加しました。「なぜABCとARCの曜日が逆？」と思ったのですが、ぼくが参加し始めてから、たまたましばらくARCの日曜開催が続いていただけで、曜日が決まってるわけではないみたいです。で、結果はA1完。洗礼を受けました。ARCの感想ですが、まず、ABCより難しいです。そしてコンテスト終了後、問題B、Cしかやってませんが、アルゴリズム適用したらいけます的な問題ではなく、考えてひらめくことの方に重点があるように感じました。

B - Grid Rotations

問題は2次元の180度回転ですが、1次元の区間反転の問題として解けば良い、ということまではわかり、間に合わないのが明らかであるにも関わらず、数列をスライスで反転してました。当然のごとく、ACx19、TLEx13から前に進めず、諦めました。解説に書いてあることがぶっ飛んでいて、両端もつながっていると考えれば、実はこの操作を何度やっても、数列が崩れないとのことでした。Q回の操作は、全体のスライドと反転を1回やる操作と考えられるのです。なので、0の位置だけ追いかければ、最後の状態を簡単に復元できます。うーん、どうやったら気づけるのかなぁ？そういえばこの問題を解いているときに「え？」って思ったことがありました。これなんですけど、リストのスライスで、l2=[4,3,2,1]が欲しいとき、最後を-1で表現できないんですね。空のリストになってしまいちょっと驚きました。rangeだと0までの値を返してくれるのですが。 2023-01-15

import sys
input = sys.stdin.readline
H, W = map(int, input().split())
alist = []
for _ in range(H):
    alist.append(input())
Q = int(input())
h0 = 0
w0 = 0
for _ in range(Q):
    a, b = map(int, (input().split()))
    h0 = (0 if h0 < a else H) + a - 1 - h0
    w0 = (0 if w0 < b else W) + b - 1 - w0
if Q & 1 == 0:
    hindex = (list(range(H))*2)[H-h0:2*H-h0]
    windex = (list(range(W))*2)[W-w0:2*W-w0]
else:
    hindex = (list(range(H-1,-1,-1))*2)[H-h0-1:2*H-h0-1]
    windex = (list(range(W-1,-1,-1))*2)[W-w0-1:2*W-w0-1]
for i in hindex:
    line = []
    for j in windex:
        line.append(alist[i][j])
    print(''.join(line))

C - ± Increasing Sequence

解説を見ても、懇切丁寧に説明されているわけではなく理解に苦しみました。狭義単調増加の数列を、隣同士の差の数列に置き換えることで自然数列にするというのはよくあると思います。が、やっても、ぼくには何も見えてこなかったです。解説は、「実際にこのように考えれば目的の数列を生成することができます。」ということをやっています。自然数列のベースとしてまず全部1にしてみる、というのも良い手なのかもしれません。全部1を入れておいて、合計0に足りない分や、多すぎた分を1箇所で調整するということをしていました。場合分けが妙で、数列Aの後ろからの累積和を作っており、合計が0かどうかでも分岐しています。0でない場合は、全部1以外の値を設定して、最初の値だけ別の値を入れて調整していました。いや逆だな、blist[0]が0でない場合をやって、0の時どうするんだ？という思考順序ですね。今の自分には、コンテスト中に思いつける気がしないというのが正直な感想です。 2023-01-15

import sys
input = sys.stdin.readline
N = int(input())
alist = list(map(int, input().split()))
blist = [0]*N
blist[N-1] = alist[N-1]
for i in range(N-2, -1, -1):
    blist[i] = blist[i+1] + alist[i]
bsum2 = sum(blist[1:])
ans = [0]*N
if blist[0] != 0:
    ans[0] = (-1 if blist[0] > 0 else 1) * bsum2
    absb0 = abs(blist[0])
    for i in range(1, N):
        ans[i] = ans[i-1] + absb0
else: # blist[0] == 0
    id1 = -1
    id_1 = -1
    for i in range(N):
        if blist[i] == 1:
            id1 = i
        elif blist[i] == -1:
            id_1 = i
    if id1 == -1 or id_1 == -1:
        print('No')
        sys.exit()
    ans[0] = 1
    for i in range(1, N):
        ans[i] = ans[i-1] + 1
        if i == id_1 and bsum2 >= 0:
            ans[i] += bsum2
        elif i == id1 and bsum2 < 0:
            ans[i] -= bsum2
print('Yes')
print(*ans)

D - Sum of Sum of Digits

★ 理解するのに、今までで一番苦労した問題となりました。大変でしたが、桁でDPする問題を「桁DP」と呼ぶらしく、初めての桁DPとして、どうしてもACしたかったのでがんばりました。xlistに登録されている値は、10^i-a%(10^i)、すなわち10^iの桁に繰り上がるためにに必要な値ということになります。それに0（0個繰り上がる値）も要素として追加しています。解説にあるように、N個のうち、何個の値が繰り上がるのか？をDPのキーとしますが、x%(10^i)の値を決めたときに、xlistのどこにあるのかを確認すれば、何個繰り上がるのかわかることになります。x%(10^i)=0であれば0個、最大値ならN個繰り上がることがわかります。DPの遷移中、m_carryは10^iに繰り上がる個数、n_carryは10^(i+1)に繰り上がる個数で、それぞれ別の求め方をしています。i=0のところは面倒ですが、ちょっと特別扱いしています。一度ACしてしまうと、ACするまでの苦労が何もなかったかのように忘れてしまうし、自分で読んでもわからなくなりそうですが、記録のためになんとか思い出せることを書きたいと思います。DPのところで、x%(10^i)からx%(10^(i+1))を作るところ、i桁目をkとし、k*10^i+x%(10^i)としています。これでいいのか？って結構悩みました。というのも、x%(10^i)ってm個繰り上がるための最小値ですよね。なので、xlist[i]の中で、「次に小さい値未満」なら、繰り上がる個数は同じmです。その値に対してk*10^i+x%(10^i)からn_carryを求めると、n_carryが増える可能性があるのではないか？という疑問です。これ、結局のところありえないということがわかったので、bisect_right1回でn_carryを求めています。なぜありえないのかというと、よく考えたらxlist[i+1]の要素って、xlist[i]の要素+k*10^iしかありえないんです。ということは、m_carryが同じx%(10^i)の値に対して、n_carryの値が異なるということはありえないんです。その部分はxlist[i+1]でも、xlist[i]と同じように必ず空白になっているはずなんです。もしかすると、桁DPで必要な重要な感覚かもしれまえん。下の桁で抜けてる部分はその上の桁がどんな値でも抜けたままだよ、と。というわけで、全部書こうとしてもあれなので、終わりとします。ものすごく苦労したことで、今後「桁DP」に出会ったときに、少しでも自力でACできる可能性が高まりますように。そうでなければ割に合わないしんどさでした。それにしても、解けてない問題を抱えて過ごすのってストレスですね。 2023-02-04

import bisect
N = int(input())
alist = list(map(int, input().split()))
digimax = len(str(max(alist)))

pow10 = [1]*(digimax+1)
for i in range(1, digimax+1):
    pow10[i] = pow10[i-1] * 10

xlist = [[0]*(N+1)] + [sorted([pow10[i] - a % pow10[i] for a in alist] + [0]) for i in range(1, digimax+1)]

dp = [{} for _ in range(digimax+1)]
for i in range(N+1):
    dp[digimax][i] = i
for i in range(0, digimax)[::-1]:
    asum = 0
    for j in range(N):
        asum += alist[j] // pow10[i]
        alist[j] %= pow10[i]
    prev = -1
    for j in range(N+1)[::-1]:
        if xlist[i][j] != prev:
            x = xlist[i][j]
            prev = x
            m_carry = j if i > 0 else 0
            curmin = 10**9
            # xの上の桁kでループする
            for k in range(10):
                # n_carry = 1つ上の桁で何個繰り上がったか？kが決まると決まる
                n_carry = bisect.bisect_right(xlist[i+1], k*pow10[i]+x) - 1
                # asum = 1つ上の桁の合計
                # それに桁上りm_carryを加えて、xはkがN個全体に加えられて、その上にさらに上がった分10*n_carryは引く
                curmin = min(curmin, dp[i+1][n_carry] + asum + m_carry - 10*n_carry + k*N)
            dp[i][m_carry] = curmin

print(dp[0][0])

AtCoder Beginner Contest 285

4完。参加し始めて、初めての日曜開催のABCです。4ヶ月もやってるので、てっきり例外的な日曜開催なのかと思いましたが、たまたまらしいです。開始時刻に間違ってABC286のページを開いており「あれ？はじまらねーぞ？」と、あわててABC285の参加登録をするというハプニングがあり、しばらく動揺してしまいました。そのせいでパフォーマンス落ちた？わかりませんが。問題E、DPのコードを書いて、終わりかけの時間に提出しましたが、NGでした。よくないDPを設計して実装してしまいましたが、解説見ると、解けた問題だったかもなぁと、くやしい。というのも、5問解けていたらどんなに遅くても、過去最高順位とパフォーマンスが出ていたっぽいんですよね。甘くないです。

B - Longest Uncommon Prefix

ABCの問題文は、読んでてたまに発狂しそうになりますが、この問題が今までで最悪だったかもしれません。思考停止しました。開始時刻のトラブルのせいなのか？わかりませんが、同じような感想も見かけました。今見てもちょっと混乱してしまうんですが、breakしたら、1つ前まで≠なのでl=k-1が答え、breakしなかったら最後まで≠なので、l=kが答えってことでいいですね。気づいてませんでしたが、タイトルをよく見たらLongest Uncommon Prefixですか。LCPから着想を得た問題と思うと、意味を理解しやすい可能性があり。タイトルも有益な情報源。 2023-01-15

N = int(input())
S = ' ' + input()
for i in range(1, N):
    for k in range(1, N-i+1):
        if S[k] == S[i+k]:
            break
    else:
        print(k)
        continue
    print(k-1)

D - Change Usernames

変更先のユーザ名が、現在存在する場合は、変更できないので、そっちを先に変更する必要があります。その変更先のユーザ名が、存在する場合、そっちを先に変更する必要があります。これが元のユーザに戻ってきてしまうと、どれも変更できないので、グラフを作って順回路の存在チェックをする問題でした。そこまでくると基本的な問題に帰着したと思いますが、何度かデバッグして修正が必要だったので、まだまだです。 2023-01-15

import sys
N = int(input())
g = [[] for _ in range(2*N)]
sdict = {} # name -> id
tlist = []
for i in range(N):
    s, t = input().split()
    sdict[s] = i
    g[i].append(i + N)
    tlist.append(t)
for i, t in enumerate(tlist):
    if t in sdict:
        g[i + N].append(sdict[t])
used = [False for _ in range(2*N)]
for i in range(2*N):
    if used[i]:
        continue
    stack = [i]
    used[i] = True
    while stack:
        cur = stack.pop()
        for next in g[cur]:
            if not used[next]:
                stack.append(next)
                used[next] = True
            elif next == i:
                print('No')
                sys.exit()
print('Yes')

E - Work or Rest

コンテスト時間中、DPでやろうと思い、連続する平日の生産性をまず、事前に計算して用意しました。ここまでは正しい流れです。DPをどのように設計するか？ですが、横軸iを設定した休日の数、としてしまいました。その状態での生産性をDPの値とし、その翌日からN日までの間の曜日に休日を設定する時に、最後の連続する平日の生産性を引いて、分割した平日の生産性を2つ足してDPが遷移していくというような設計です。なんか気持ち悪いと思ってましたが、時間内に提出した回答は、TLEが大量発生しました。解説の方法はスマートですね。i曜日まで、確定したということを横軸にしていました。i曜日までしか見たくないですよねー。という感じです。自然にこのDPを思いついて、時間内に解きたかったです(T_T) 2023-01-15

import sys
N = int(input())
if N == 1:
    print(0)
    sys.exit()
alist = list(map(int, input().split()))
asum = [0]*N
asum[0] = alist[0] # production sum from 0-i
for i in range(1, N):
    asum[i] = asum[i-1] + alist[i]
between = [0]*N
between[1] = asum[0] # 1day
for i in range(2, N):
    if i % 2 == 0:
        between[i] = 2*asum[i//2-1]
    else: # odd
        x = i // 2
        between[i] = asum[x] + asum[x-1]
dp = [0]*(N+1)
for i in range(1, N): # i -> i+1
    dp_new = [0]*(N+1)
    for j in range(0, i):
        dp_new[0] = max(dp_new[0], dp[j] + between[j])
        dp_new[j+1] = dp[j]
    dp = dp_new
ans = 0
for i in range(N):
    ans = max(ans, dp[i] +between[i])
print(ans)

F - Substring of Sorted String

解説を見たんですが、この問題を通じてセグメントツリーの速度改善ができたので、良かったです。セグメントツリーでやると書いてあり、自分のセグメントツリーを使ってやったところ、TLEが解消できなかったんです。そして他の方のセグメントツリーを見て、queryの効率的な実装を知ることができました。これまでのABCでの経験から、セグメントツリーが遅いと思っていて苦手意識があったんです。遡れば、セグメントツリーとの出会いは、初めて参加したABC266 Exでした。そのとき、セグメントツリーを知らないのに、いきなり最初から2次元セグメントツリーを使って、TLEでした。フェニック木ではACできたのに！セグメントツリーの印象が悪くなりました。セグメントツリーに次に出会ったのは、もう最近で、ABC283 Fです。このときもTLEしたのですが、なんとしてもセグメントツリーで1問解くんだ！と思い、蟻本を見て実装したqueryが再帰関数であることに気づき、stackに変更することで初めてセグメントツリーでACできました。ライブラリーを改善できたんだと思って臨んだこの問題でまたもやTLEで、気が滅入りましたが、他の方の提出を見ていて、全く無駄のないqueryの実装を組み込むことができました。これきれいですね。蟻本ではrootから下っていきながらqueryを処理していますが、この方法では、下から親に上っていき、無駄が全くありません。でも1度知ってしまうと、極めて自然な実装と思え、蟻本がなんであんな実装になっているのか不思議なくらいです。蟻本を見て実装したコードは再帰呼び出しをしていました。k, l, rという引数があり、kはノードのインデックスで、[k]が[l, r)の範囲を持っているという意味です。呼び出し時には、(k, l, r) = (0, 0, n)などとして呼び出します。

def query(self, a, b, k, l, r):
    if r <= a or b <= l:
        return self.DEFAULT
    if a <= l and r <= b:
        return self.maxima[k]
    else:
        vl = self.query(a, b, k*2+1, l, int((l+r)/2))
        vr = self.query(a, b, k*2+2, int((l+r)/2), r)
        return max(vl, vr)

ABC283 Fで再帰呼び出しが遅いと気づき、自分でstackで書き直しました。引数のk, l, rいらないじゃん、と思いました。ABC283 Fは再帰呼び出しでTLE、stackでACで、改善したと思い喜んでいました。

def query(self, a, b):
    ret = self.DEFAULT
    stack =[(0, 0, self.n)]
    while stack:
        k, l, r = stack.pop()
        if r <= a or b <= l:
            pass
        elif a <= l and r <= b:
            ret = max(ret, self.maxima[k])
        else:
            stack.extend([(k*2+1, l, (l+r)//2), (k*2+2, (l+r)//2, r)])
    return ret

そして今回の改善したコードに至ります。本問題、ABC285 FがTLEからACとなりました。いや～確かにこれでいいですよね。ボトムアップで無駄なし。

def query(self, a, b):
    resL = resR = self.DEFAULT
    a += self.n - 1
    b += self.n - 1
    while a < b:
        if a & 1 == 0:
            resL = max(resL, self.maxima[a])
            a += 1
        if b & 1 == 0:
            b -= 1
            resR = max(resR, self.maxima[b])
        a >>= 1
        b >>= 1
    return max(resL, resR)

2023-01-16

import sys
input = sys.stdin.readline
class SEGT():
    DEFAULT = 0 # need update
    def __init__(self, n):
        '''input n is maxid+1, this is 0 start'''
        self.n = 1
        while self.n < n:
            self.n *= 2
        self.sums = [self.DEFAULT]*(2*self.n)
    def set(self, k, a):
        k += self.n - 1
        diff = a - self.sums[k]
        if diff == 0: # not changed
            return
        self.sums[k] += diff
        while k > 0:
            k = (k-1) // 2
            self.sums[k] += diff
    def query(self, a, b):
        resL = resR = self.DEFAULT
        a += self.n - 1
        b += self.n - 1
        while a < b:
            if a & 1 == 0:
                resL += self.sums[a]
                a += 1
            if b & 1 == 0:
                b -= 1
                resR += self.sums[b]
            a >>= 1
            b >>= 1
        return resL + resR

N = int(input())
ORDA = ord('a')
S = [0] + [ord(c)-ORDA for c in input()]
Q = int(input())
alphabets = [SEGT(N+1) for _ in range(26)]
count = [0]*26
ascend = SEGT(N+1) # [i] = [i-1]<[i]
for i in range(1, N+1):
    c = S[i]
    count[c] += 1
    alphabets[c].set(i, 1)
    ascend.set(i, 1 if S[i-1] <= S[i] else 0)
for _ in range(Q):
    q = input().split()
    if q[0] == '1':
        x = int(q[1])
        c = ord(q[2]) - ORDA
        if c != S[x]:
            prec = S[x]
            S[x] = c
            count[prec] -= 1
            alphabets[prec].set(x, 0)
            count[c] += 1
            alphabets[c].set(x, 1)
            ascend.set(x, 1 if S[x-1] <= S[x] else 0)
            if x < N:
                ascend.set(x+1, 1 if S[x] <= S[x+1] else 0)
    else:
        l = int(q[1])
        r = int(q[2])
        if ascend.query(l+1, r+1) == r - l:
            for c in range(S[l]+1, S[r]):
                if alphabets[c].query(l+1, r+1) != count[c]:
                    print('No')
                    break
            else:
                print('Yes')
        else:
            print('No')

G - Tatami

★ ものすごい苦労しました。ABC274 G以来の2部マッチングですが、とにかく時間制限が厳しかったです。2部グラフの問題かなぁと、問題を読んだ時点でなんとなく想像できるのですが、わかりません。2部グラフかなぁ？と言いつつも、まず1x2のどっちのマスをどっちのグループに入れればいいのかわからないじゃん！というのが素人にとっての壁です。これは隣同士は必ず逆のグループになるので、チェック柄にして2つに分けてしまえばよいのです。素人にとっては、こんな些細なことも、割と重要な事実です。その気持を忘れないように、ここに記載しておかなければなりません。解説を読むと、「最小流量制限つき最大流問題」と書かれています。これが説明を読んでも全く理解できず、なかなか前に進めませんでした。なにか手がかりはないか？と別解の方を見ると、2部グラフの最大マッチング問題に帰着できると書かれています。これは確かに理解できます。わかりやすい。ただし頂点数が2倍になってPythonにとっては、時間制限がかなり厳しくなります。Dinic法をABC274 Gで書いていたので、それを持ってきて実行しましたが、TLEx11をどうしても解消できませんでした。以前書いたDinic法は蟻本に書かれていたものをPythonで書いただけなので、DFSで再帰呼び出しなど使っていました。また再帰呼び出しか？と思い、いつものようにスタックに書き直しても全然速くなりません。調べていると、BFSとDFSを逆方向から行うと良いことがわかりました。これ、かなりすごいと思いました。BFSとDFSを同じ向きでやっていると、DFSの時にTを通り過ぎて、もっと深いところに行ってしまう可能性があります。が、BFSをTからやっていると、なからずTに向かって吸い込まれていくイメージなのです。すごくないでしょうか？理解したとき、ちょっと感動しました。さらに、蟻本では1つの経路が見つかるたびに、DFSを呼び直す実装でしたが、1回のDFSで全部調べきることも可能であることに気づきました。そして作ったのがこの再帰もスタックもないコードです。むちゃくちゃ速くなるんじゃないか？とちょっと興奮して提出しましたが、なんと、TLE解消できず。ショックすぎますね。そこから完全マッチングでの回答をあきらめ、「最小流量制限つき最大流問題」を理解することにしたのです。面食らいますが、最小流量bが決まっているu-vエッジはキャパから最小流量bを引いてしまい、引いたbはSSという別ソースからvへ、uからTTという別のシンクへキャパbのエッジで接続することで、SSからTTへ全部のbの合計が流れるか？調べる問題に書き換えることができます。もとのS、Tはどうするかというと、TからSに向かってキャパ無限のエッジを接続します。最初これがよくわからなかったのですが、元々最大流問題って、Sには無限に入ってくるし、Tからは無限に出ていくことができる前提なのです。そしてSから出る流量とTから出る流量は一致しています。TからSに向かってキャパ無限のエッジを接続しておくことで、この条件は自動的に満たすことになるのです。S、Tは特別なノードであることから、その性質を忘れてしまっているとちょっと驚いてしまいますが。よって、この状態でSSからTTへ最大流問題を解き、SSとTTに接続したすべてのエッジのキャパを使い尽くせるか？調べればよいです。理解して流してもTLEx2。マジで気が滅入りますが、最後はDFSの中のif文を回避するように修正してなんとかACできました。これでも提出の中で遅いですし、みんなどんなコードで最大流問題解いてんだろう？ 2023-01-20

その後進展がありまして、自分の結果が妙に遅いし、AtCoderのサーバーの調子次第なのか、ACした同じコードでもまたTLEするようになってしまいまして、さらに高速化の必要性にせまられていました。で、ヒントはないかと、他の方のコードを見ていたところ、ほぼ100%、BFSをSから、DFSをTからやっていることに気づきました。藁にもすがる思いでそのように書き直したところ、ついに少し余裕を持ってACできました。いや、なんでそれで速くなるのかはいまいちわかってないのですが。最終的に、使い回せるように書き換えてこのようになりました。細かい修正を何度もしており、試行錯誤の集大成みたいな感じです。しかしDFS1回で済ませるのとか、我ながら興奮したしがんばったのに、効果がうすいし、逆にself.nodes[0]をdummyにすることで、if文減らしたのが結構効いたり、なぜかBFSをTからではなく、Sからやるようにしたら効いたり、努力や感動と、結果が比例してなくて悲しいなぁ。ABC285はFでセグ木を、GでDinic法を洗練させる大事な回となりました。あ、あとTからSにキャパ無限のエッジを接続するのと別の方法として、TとSは接続せず、SS→TT、SS→T、S→TTの順に最大流問題を解き、それぞれf1、f2、f3流れたとすると、f1+min(f2, f3)が最小流量を満たすか調べるという方法もあります。SS、TTを優先的に流して最小流量を満たすか確認する必要があるため、この順序となります。最大流も求める場合は最後にS→Tでも最大流問題を解きますが、本問題では、最小流量を満たせるかどうか？がわかれば良いので、S→Tを流す必要はありません。また、最後に、別解の完全マッチング問題に帰着する方も修正後のDinic法でやってみましたが、TLEが減ったもののTLEx4でフィニッシュとなりました。C++でしか間に合わない別解が書かれてるのはつらいです。マッチングのみなら専用のアルゴリズムを使っている人もいるので、そっちなら間に合うのかもしれません。ABC274 GでNetworkXで使ったやつですね。 2023-01-21

H, W = map(int, input().split())
grids = [input() for _ in range(H)]
HW = H*W
S = HW
T = HW + 1
SS = HW + 2
TT = HW + 3
mf = MaxFlow(HW + 4)
count2A = 0
count2B = 0
for i in range(H):
    for j in range(W):
        if grids[i][j] == '1':
            continue
        v = i * W + j
        if (i ^ j) & 1 == 0: # v is in A
            if grids[i][j] == '2':
                count2A += 1
                mf.add_edge(SS, v, 1)
            else: # ?
                mf.add_edge(S, v, 1)
            if i > 0 and grids[i-1][j] != '1':
                mf.add_edge(v, v - W, 1)
            if i < H-1 and grids[i+1][j] != '1':
                mf.add_edge(v, v + W, 1)
            if j > 0 and grids[i][j-1] != '1':
                mf.add_edge(v, v - 1, 1)
            if j < W-1 and grids[i][j+1] != '1':
                mf.add_edge(v, v + 1, 1)
        else: # v is in B
            if grids[i][j] == '2':
                count2B += 1
                mf.add_edge(v, TT, 1)
            else: # ?
                mf.add_edge(v, T, 1)
mf.add_edge(T, S, MaxFlow.INFFLOW)
mf.add_edge(S, TT, count2A)
mf.add_edge(SS, T, count2B)
flow1 = mf.max_flow(SS, TT)
print('Yes' if flow1 == count2A+count2B else 'No')

AtCoder Beginner Contest 286

4完。5問目の問題E、全く歯が立ちませんでした。ABC285の問題Eは解けた可能性があると思いましたが、今回はできる可能性がなかった。にも関わらず問題Eの正解者は前回の2倍もいて、ぼくの順位も低いです。Ratingは最近横ばいで、伸び悩んでいます。問題Eで使用するワーシャルフロイド法は、以前蟻本で出会った時理解できず、あきらめたアルゴリズムでした。しかし様々なDPの経験を積んだことで、この奇妙な説明も、今回はすんなり頭に入ってきました。なんか早く毎回5完できるようになりたいと焦ってしまっていますが、無理なもんは無理と、謙虚さを取り戻し、リラックスして取り組む姿勢を取り戻そうと思います。今回は問題Eで「ワーシャルフロイド法」を、問題Fで「中国剰余定理」を覚えられたので、解けない焦りよりも、ABCに参加する意義を感じられると良いです。

E - Souvenir

コンテスト終了後、5問目まで解けてる人が1600人くらいいて、ショックを受けました。ぼくは全然解き方の検討がつかなかったというのに！TwitterのABC286タグを見ると「ワーシャルフロイド法」という言葉が流れてました。その名前は知ってます。蟻本の該当箇所を読んで、よくわからなくてスキップしてしまったことを覚えているのです。いずれやろうとアルゴリズムの名前だけメモっていましたが、なんか愚直な感じがするし、O(V^3)だし、使うことあるのかなぁ、と優先度を下げてしまったまま、今に至ります。改めて蟻本を読んでみたところ、普通に理解できました。いや～、わかります。昔わからなかったけど、今はわかるって感慨深いですね。以前スキップしてしまったときは、競技プログラミングを初めて間もなかった頃だったのでしょう。今のぼくは、いくつもの変なDPの問題を解いて経験を積んできたため、DPの考え方に慣れており、自然にこの奇妙な説明が頭に入ってきました。蟻本に、ワーシャルフロイド法は負の辺があっても動作すると、書かれています。これはちょっと謎です。d[i][k]=d[i][k]+d[k][k]としたときに、d[i][k]が更新されてしまうのは、困るのではないかと思いました。単に、ちゃんと終了し、負の閉路が求まる、ということだと解釈しましたが、正しいのでしょうか？ところで、コンテスト時間中、どのように回答したかというと、全クエリに対して、BFSをやりました。QがO(N^2)、BFSがO(N)だからワーシャルフロイド法といっしょでは？とちょっと思ったのですが、勘違いでした。BFSはO(E)=O(N^2)です。なので、ぼくが提出していたやり方だと、計算量がO(N^4)になってしまっていました。解けてる人が多いということは、ワーシャルフロイド法は基礎なんでしょうね。こうやって地道に勉強していくしかありません。 2023-01-22

INF = 1000
N = int(input())
alist = list(map(int, input().split()))
dist = [[INF]*N for _ in range(N)]
value = [[0]*N for _ in range(N)]
for i in range(N):
    dist[i][i] = 0
    value[i][i] = alist[i]
    for j, c in enumerate(input()):
        if c == 'Y':
            dist[i][j] = 1
            value[i][j] = alist[i] + alist[j]
for k in range(N):
    for i in range(N):
        for j in range(N):
            newdist = dist[i][k] + dist[k][j]
            if newdist < dist[i][j]:
                value[i][j] = value[i][k] + value[k][j] - alist[k]
                dist[i][j] = newdist
            elif newdist == dist[i][j] < INF:
                value[i][j] \
                    = max(value[i][j], value[i][k] + value[k][j] - alist[k])
Q = int(input())
for _ in range(Q):
    u, v = map(int, input().split())
    u -= 1
    v -= 1
    if dist[u][v] == INF:
        print('Impossible')
    else:
        print(dist[u][v], value[u][v])

F - Guess The Number 2

異なる素数個でループする数列を作って、Bの情報から余りが求まるから、そこから求めるのかなぁ？というところまでは、なんとなく思いつきます。拡張ユークリッドの互除法を少し前に見ていたので、いける感じはありましたが、「中国剰余定理」を知らなかったので、その先までは進めませんでした。yaketake08さんの実装メモのコードをそのまま使ったらACできました。「中国剰余定理」の典型問題のようです。これは、知ってたら解けてしまいますね。なんてことはなく、素数リストを2、3とすると問題の設定である10^9までカバーできないので、4、9に変えておこなうというところが、ひらめきポイントです。 2023-01-22

def extgcd(a, b):
    if b:
        d, y, x = extgcd(b, a % b)
        y -= (a // b) * x
        return d, x, y
    return a, 1, 0

def remainder(V):
    x = 0; d = 1
    for X, Y in V:
        g, a, b = extgcd(d, Y)
        x, d = (Y*b*x + d*a*X) // g, d*(Y // g)
        x %= d
    return x, d

plist = [4, 9, 5, 7, 11, 13, 17, 19, 23]
print(sum(plist), flush=True)
alist = []
first = 1
for p in plist:
    alist.extend(list(range(first+1, first+p)))
    alist.append(first)
    first += p
print(*alist, flush=True)

blist = list(map(int, input().split()))

idx = 0
amari = []
for p in plist:
    amari.append((blist[idx] + p - idx - 1) % p)
    idx += p
print(remainder(list(zip(amari, plist)))[0], flush=True)

G - Unique Walk

E、Fは知らないアルゴリズムが出てきてしんどかったですが、この問題Gは、比較的易しめのように感じました。Sに属する辺以外をUnion-Findを使ってまとめてしまい、一筆書きできるかどうか？判定すれば良いとわかります。注意点として、最後にグラフを作るところで、同じ辺も追加しなければならないということです。これはサンプルテストケースの1つ目で気づけるようになっていたので、親切でした。「オイラー路」という言葉にも触れる必要があるでしょう。すべての辺を通る閉路を持つグラフを「オイラーグラフ」と呼び、すべての頂点の次数が偶数であることと同値です。閉路でないオイラー路のみ持つものを「準オイラーグラフ」と呼び、次数が奇数であるものがちょうど2つであることと同値です。グラフの次数が奇数である頂点は必ず偶数個です。なぜなら、辺の両側に頂点があるので、次数の合計は必ず偶数であるためです。この問題はオイラーグラフか準オイラーグラフであることを判定する問題なので、次数が奇数の頂点が0個、もしくは2個の場合にYesとなります。次数が奇数の頂点が1個にはなりえないので、<=2をYesの条件とすればよいです。ABC285 Gは、ACに次の土曜の朝までかかりましたが、これは翌日ACできて早めに肩の荷が下りました。このあとARCがあるらしいのですが、どうしよう。 2023-01-22

class Union():
    # 省略
N, M = map(int, input().split())
es = []
for _ in range(M):
    u, v = map(int, input().split())
    es.append((u-1, v-1)) # 0-(N-1)
K = int(input())
xset = {x-1 for x in map(int, input().split())} # 0-(M-1)
union = Union(N)
for i, e in enumerate(es):
    if i not in xset:
        union.unite(e[0], e[1])
from collections import defaultdict
g = defaultdict(list)
for i, e in enumerate(es):
    if i in xset:
        u, v = e
        u = union.find_root(u)
        v = union.find_root(v)
        g[u].append(v)
        g[v].append(u)
oddcount = 0
for v in g:
    if len(g[v]) % 2 == 1:
        oddcount += 1
if oddcount > 2:
    print('No')
else:
    print('Yes')

AtCoder Regular Contest 154

疲れてますが、参加せざるを得ません。笑。2度目、そして2連続のARC参加でした。A、Bの2完でした。問題Aが難しく、1時間くらいかかりました。できたときは嬉しかったです。しかしどうも問題Aを短時間で解いてる人が多い。ARC慣れでしょうか？ぼくは1問しか解いたことがないので、問題Aも大きな壁です。明らかに前回より難しかったですし。そして問題B。ARC153は1完に終わったので、これができれば記録更新。30分くらいで解くことができました。残りの時間、問題Cを考え、考え方までは導くことができましたが実装が間に合わず、時間内の提出に至りませんでした。2度目のARCを経て、やはりARCとABCって全然違うなという印象が強まりました。ARCは、なんらかのアルゴリズムを適用すれば解けるのではなく、自分で考えることの方がメインと感じ、それをおもしろいと思います。昨日のABC286で、Eがワーシャルフロイド法、Fが中国剰余定理というような、どうしようもない感じだったのもあって、なおさらそのような印象が強まりました。あれ？もしかして、ABCって実はおもしろくないのか？

A - Swap Digit

難しいと思うんですが。ACしたときガッツポーズしました。できたコードが気持ちいいです。ARC153 Aよりだいぶ難しいでしょう。でもこれでもARCでは簡単な問題なのでしょう。Aの最上位桁をAU、それ以外をAL、Bの最上位桁をBU、それ以外をBLとすると、かけ算A*Bは100*AU*BU+10*(AU*BL+BU*AL)+AL*BLと表現できます。するとAUとBUをスワップした場合に変化するのはAU*BL+BU*ALの部分だけということがわかります。スワップしたら小さくなるかどうかは引き算をすれば条件が求まります。10の位から最上位の桁まで、順番にスワップするかどうか？決めていけばよいです。確定した値までのAとBを順次更新していき、全桁確定したら、最後に掛け算して答えを求めます。最初に、AとBを各桁の数字をリスト化しましたが、このように実装しました。文字列ってlist関数に渡すとバラバラになるんですね。

2023-01-23

import sys
M = 998244353
N = int(input())
A = list(map(int, list(input())))
B = list(map(int, list(input())))
if N == 1:
    print(A[0]*B[0])
    sys.exit()
albig = 0 # 1:a big, 0:equal, -1:b big
if A[N-1] > B[N-1]:
    albig = 1
elif A[N-1] < B[N-1]:
    albig = -1

al = A[N-1]
bl = B[N-1]
keta = 1
for i in range(N-2, -1, -1): # swap i or not
    if albig == 1 and A[i] < B[i] \
        or albig == -1 and A[i] > B[i]:
        A[i], B[i] = B[i], A[i]
    # update al
    keta = keta * 10 % M
    al = (keta * A[i] + al) % M
    bl = (keta * B[i] + bl) % M
    if A[i] > B[i]:
        albig = 1
    elif A[i] < B[i]:
        albig = -1

print(al * bl % M)

B - New Place

これも残り30分くらいのところで解けて、ヨシッと声出ました。SとTの各アルファベットの数が一致していればこの操作を繰り返して同じにできるでしょう。Sの後ろ何文字をそのまま使えるか？調べれば、残りが操作回数ですね。 2023-01-23

import sys
N = int(input())
S = input()
T = input()
counterS = [0]*26
counterT = [0]*26
for c in S:
    counterS[ord(c) - ord('a')] += 1
for c in T:
    counterT[ord(c) - ord('a')] += 1
for i in range(26):
    if counterS[i] != counterT[i]:
        print(-1)
        sys.exit()
posiT = N-1 # position of T
for i in range(N-1, -1, -1):
    c = S[i]
    for j in range(posiT, -1, -1):
        # search c in T
        if c == T[j]:
            posiT = j - 1
            if posiT < 0:
                print(i)
                sys.exit()
            break
    else:
        print(i+1)
        sys.exit()
# i == 0 possible? -> impossible

C - Roller

処理の流れがちょっと複雑になりましたが、ACできました。ぼくの判定ロジックですが、文字列の最初と最後がつながっているとみなして、ランレングス圧縮したときのグループの個数agnum, bgnumを求めます。agnum<bgnumなら操作でグループ数を増やせないのでNoです。そうでない場合は、操作によってグループを損なわずにローテーションさせる余裕があり、かつBのグループをAのグループが含んでいるかどうか？をチェックしています。ランレングス圧縮に、Python標準ライブラリのitertools.groupbyを使えることを知り、初めて利用しました。

2023-01-23

import itertools
T = int(input())
for _ in range(T):
    N = int(input())
    alist = list(map(int, input().split()))
    blist = list(map(int, input().split()))
    if alist == blist:
        print('Yes')
        continue
    akeys = [k for k, _ in itertools.groupby(alist)]
    if len(akeys) > 1 and akeys[0] == akeys[-1]:
        akeys.pop()
    bkeys = [k for k, _ in itertools.groupby(blist)]
    if len(bkeys) > 1 and bkeys[0] == bkeys[-1]:
        bkeys.pop()
    agnum = len(akeys)
    bgnum = len(bkeys)
    if agnum < bgnum:
        print('No')
        continue
    # condition of room to move
    if (agnum == bgnum and agnum < N) or agnum > bgnum:
        bb = bkeys*2
        for sta in range(bgnum):
            j = 0
            for i in range(sta, sta + bgnum):
                bk = bb[i]
                while j < agnum and akeys[j] != bk:
                    j += 1
                # akeys[j] == bk or j == agnum
                if j == agnum:
                    # NG : bk was not found
                    break
                # not NG -> check next
                j += 1
                # if j == agnum here and i != sta+bgnum-1,
                # it will go NG break
                # otherwise continue checking next
            else:
                print('Yes')
                break
        else:
            print('No')
    else:
        print('No')
        continue

D - A + B > C ?

なんとなく、問題Dも見てみました。思いつかなかったので解説を見ましたが、かなりおもしろいです。1+1>(1以外の数字)という式は、常にNoなので、N-1回調べればどれが1かわかる。さらに1がわかると、a+1>bがYesならa>b、a+1>bがNoならa<bのため、マージソートで全数字を確定できると。時間内に思いつけたらすごいですし、やはりARCおもしろいなぁという印象が強くなりました。ちなみにぼくは、マージソートが頭に入ってなかったので、思いつけないですし、マージソートの勉強になりました。いつものように、再帰関数ではなくスタックで実装しましたが、そんな必要あるんでしょうか？笑。クイックソートだと最悪計算量がO(N^2)になるので、たぶん競プロではNGなんでしょうね。 2023-01-24

N = int(input())
id1 = 1
for i in range(2, N+1):
    print(f'? {id1} {id1} {i}', flush=True)
    if 'Yes' == input():
        id1 = i
pids = list(range(1, N+1))
stack = [(~0, N), (0, N)] # stack [l,r)
while stack:
    l, r = stack.pop()
    if l >= 0:
        mid = (l + r) // 2
        if l + 1 < mid:
            stack.extend([(~l, mid), (l, mid)])
        if mid + 1 < r:
            stack.extend([(~mid, r), (mid, r)])
    else:
        l = ~l
        mid = (l + r) // 2
        left = pids[l:mid]
        right = pids[mid:r]
        j = 0
        k = 0
        for i in range(l, r):
            if k == len(right):
                pids[i] = left[j]
                j += 1
            elif j == len(left):
                pids[i] = right[k]
                k += 1
            else:
                print(f'? {left[j]} {id1} {right[k]}', flush=True)
                if 'Yes' == input():
                    pids[i] = right[k]
                    k += 1
                else:
                    pids[i] = left[j]
                    j += 1
ans = [0]*N
for i, p, in enumerate(pids):
    ans[p-1] = i + 1
print('!', *ans, flush=True)

AtCoder Beginner Contest 287

4完。問題Eに1時間ほど残っていて、トライ木でいけるだろうとやっていたにも関わらず、REとWAが解決できずに終わりました。今ARC153 Dを解こうとしてしまい、なかなか解けないまま時間が過ぎている状態の上に、ABCでなかなか5完を維持できず、Ratingも伸び悩んで、フラストレーションが半端ないです。かなり危険な状況です。問題Eが解けてないのもダメなんだけど理由がしょーもなくてイライラします。

C - Path Graph?

パスグラフの条件が、N == M+1で、すべての頂点の次数が1か2であれば良いと考えて、最初提出したのですが、パスグラフと、それと非連結の複数の巡回グラフの組み合わせでも、上記条件を満たしてしまうため、NGでした。おもしろいですね。 2023-01-28

E - Karuta

コンテスト時間中、トライ木で粘っていましたが、サンプルテストケースを通過するにも関わらず、WAx14、TLEx11というひどい状況のまま終了時刻を迎えました。トライ木でロジックは間違いないのに、時間内にACできないのはかなりつらいです。最も長いLCPは、ソートして隣を確認するだけで良いとのこと。確かにその通りで、かしこいです。これを思いつかなければなりません。まずはそれで解いてみます。 2023-01-28

N = int(input())
slist = [(input(),i) for i in range(N)]
slist.sort(key=lambda x:x[0])
def check_LCP(a, b):
    minlen = min(len(a[0]), len(b[0]))
    for i in range(minlen):
        if a[0][i] != b[0][i]:
            break
    else:
        return minlen
    return i
ans = [0]*N
for i in range(N):
    lcp = 0
    if i > 0:
        lcp = max(lcp, check_LCP(slist[i-1], slist[i]))
    if i < N-1:
        lcp = max(lcp, check_LCP(slist[i], slist[i+1]))
    ans[slist[i][1]] = lcp
for i in range(N):
    print(ans[i])

トライ木でのWAですが、どうも同じ文字列が複数含まれているようで、ムカつきますが仕方ないです。トライ木の文字列の終端ノードに同じ単語数のカウンターを追加して対処しました。TLEは、再帰呼び出し回数の上限が原因でした。しょーもないですが、まだまだダメということで、改善しながら続けていくしかありません。トライ木も地道に改善します。 2023-01-28

import sys
sys.setrecursionlimit(10**6)
class Trie():
    def __init__(self, c=''):
        self.c = c
        self.children = {}
        self.wordcount = 0
    def add(self, idx, word):
        if not self.c: # this is root
            if word[0] not in self.children:
                self.children[word[0]] = Trie(word[0])
            self.children[word[0]].add(0, word)
        elif idx == len(word) - 1: # end ow word
            self.wordcount += 1
        else: # add next char
            if word[idx+1] not in self.children:
                self.children[word[idx+1]] = Trie(word[idx+1])
            self.children[word[idx+1]].add(idx+1, word)

N = int(input())
root = Trie()
slist = []
for i in range(N):
    S = input()
    slist.append(S)
    root.add(0, S)

for s in slist:
    trie = root.children[s[0]]
    if len(s) == 1 and trie.children:
        print(1)
        continue
    # len(s) > 1
    ans = 0
    for i in range(len(s)):
        if i < len(s)-1: # 終端ではない
            if trie.wordcount:
                ans = i+1
            for c in trie.children:
                if c != s[i+1]:
                    ans = i+1
                    break
            trie = trie.children[s[i+1]]
        else: # 終端 -> break
            if trie.children or trie.wordcount > 1:
                ans = i+1
            break
    print(ans)

上のトライ木が遅くて時間制限ギリギリなのが気に入らないので、リストで実装してみました。以前から気になっていたのでやっただけで、ライブラリとして残すには直したいところがいろいろありますが、残しておきます。しかし処理時間が半分くらいになりましたが、まだ他の提出者より遅いです。他の人どうやってるんだろうか？ 2023-01-29

ちょっと書き換えて、終端フラグの代わりに、ノードが単語に使われてる回数を持たせるようにしました。こうすれば、2回以上使われていればそこまでは共通プレフィックスってことで、コードがスッキリします。が、別に速くはなってません。 2023-01-29

class Trie:
    def __init__(self, size):
        self.n = size
        self.nodes = [0]*(size*27)
        self.newnode = 1
    def print(self):
        for i in range(self.n):
            print(i, self.nodes[27*i:27*(i+1)])
    def add(self, word):
        '''word should be splitted integers'''
        node = 0
        for c in word:
            node_next = self.nodes[node*27+c]
            if not node_next:
                self.nodes[node*27+c] = self.newnode
                node_next = self.newnode
                self.newnode += 1
            node = node_next
            self.nodes[node*27+26] += 1
    def count_prefix(self, word):
        res = 0
        node = 0
        for i, c in enumerate(word):
            node = self.nodes[node*27+c]
            if self.nodes[node*27+26] > 1:
                res = i+1
        return res
N = int(input())
slist = []
trie = Trie(500001)
for _ in range(N):
    S = [ord(c)-ord('a') for c in list(input())]
    slist.append(S)
    trie.add(S)
for s in slist:
    print(trie.count_prefix(s))

F - Components

「木DP」というらしいです。少し前これまでに出てきたDPをざっと見直して、いろいろなパターンが頭に入ったかなとちょっと期待したのですが、すぐに甘かったことが判明しました。「木DP」とは。これを知らずに導けたらすごいです。さらになんとなくやり始めてしまったARC153 Dで「桁DP」というものに出会いました。新しいDPが連続で出てきますが、まだまだ出てくるのでしょうか？子の計算がすべて終わってから親の計算をする必要があるため、帰りがけでそれを行っています。子要素から先に計算するような順列を生成してそれに従って処理するというのでも良さそうです。いずれにせよ、Pythonでは解説のような再帰関数方式は使えませんので。さて、頂点vを根とする部分木で、連結成分の数がj個で、vを選択するかどうか0/1というキーで組み合わせ数をDPするようです。確かにできるなぁと思ってやり始めましたが、子の計算結果をまとめるところをどのように実装すればよいか？困ってしまいました。結局どうやっているかというと、子の結果をまとめるのではなく、親に順番にマージしていってます。「子の結果をまとめるか？親に順番にマージするか？」なんかただの言い換えなのですが、この言い換えによって、自然に計算できるのですから、不思議としか言いようがありませんが、プログラミングあるあるのような気がします。あとは、dp0[v]とdp1[v]のサイズは同じになるように進めることでシンプルに処理することに注意。それと、連結成分の数って抜けないっぽいですね。つまり、連結成分が3個の場合はあるけど、2個の場合はない、みたいなことはありえないです。消せば2個になるので。なんかこういった微妙な事実も、初めてだと気づいてなかったりするので重要です。まあ仕方ないんじゃないかなと思っています。dp0の初期値[1,0]とdp1の初期値[0,1]は、頂点1個だけ見た場合の、連結成分0個の場合と1個の場合の数です。選ぶか選ばないか？しかないので、初期値はこのようになります。 2023-02-06

N = int(input())
M = 998244353
g = [[] for _ in range(N)]
for _ in range(N-1):
    a, b = map(int, input().split())
    a -= 1
    b -= 1
    g[a].append(b)
    g[b].append(a)
dp0 = [[1, 0] for _ in range(N)] # not select i
dp1 = [[0, 1] for _ in range(N)] # select i
parent = [-2]*N
stack = [-1, 0] # 0 is root
parent[0] = -1
while stack:
    cur = stack.pop()
    if cur >= 0:
        for next in g[cur]:
            if next != parent[cur]:
                parent[next] = cur
                stack.extend([~next, next])
    else:
        cur = ~cur
        # gather results
        for next in g[cur]:
            if next == parent[cur]:
                continue
            len_cur = len(dp0[cur])
            len_next = len(dp0[next])
            length = len_cur + len_next - 1
            temp0 = [0]*length
            temp1 = [0]*length
            for i in range(len_cur):
                for j in range(len_next):
                    temp0[i+j] += dp0[cur][i] * (dp0[next][j] + dp1[next][j])
                    temp0[i+j] %= M
                    temp1[i+j] += dp1[cur][i] * dp0[next][j]
                    temp1[i+j] %= M
                    if i+j-1 > 0:
                        temp1[i+j-1] += dp1[cur][i] * dp1[next][j]
                        temp1[i+j-1] %= M
            dp0[cur] = temp0
            dp1[cur] = temp1
for item in zip(dp0[0][1:], dp1[0][1:]):
    print(sum(item) % M)

G - Balance Update Query

典型問題寄りですが、やり方に気づいても、このコード長だと、ぼくは実装が間に合わないかなぁ、と想像します。勉強にもなりました。「クエリ先読み」という言葉を、聞いたことはあるけど使ったことがなく、なんだろうなぁと思っていたのですが、この問題で初めて使うことができて理解しました。フェニック木を使うために「座圧」していますが、クエリを最後まで処理する中でありうるカードの得点を、すべて把握しなければ「座圧」できないため、「クエリ先読み」しました。自然な発想ですね。フェニック木を2つ使うパターンはABC276 Fでも出てきましたので、改めて確認しておきたいです。この問題を通じてフェニック木に関する気づきもありました。1つは、フェニック木のインデックスは1からですが、prodの引数に0を入れたら0が返ってくるので、気にせず0を渡せるなぁということ。この性質により、2分探索のところで、余計な分岐をしなくてすみました。一方、addの方のインデックスに0入れたら無限ループしますね。もう1つは、prod_range(i,j)で範囲クエリーの関数もあれば便利だなぁということで追加しました。また、2分探索をあまりちゃんと勉強してないというか、苦手意識がありますが、何度か使って慣れてきて良かったです。処理の流れをちゃんと整理する必要のある問題ですが、提出1回目でACできました。 2023-02-07

class BIT():
    def __init__(self, n):
        self.n = n
        self.sums = [0]*(n+1)
    def add(self, i, input):
        while i <= self.n:
            self.sums[i] += input
            i += i&-i
    def prod(self, i):
        '''return 0 if i == 0'''
        res = 0
        while i > 0:
            res += self.sums[i]
            i -= i&-i
        return res
    def prod_range(self, i, j):
        return self.prod(j) - self.prod(i)

N = int(input())
alist = [0]*N # points
blist = [0]*N # count
points_set = set()
for i in range(N):
    a, b = map(int, input().split())
    alist[i] = a
    blist[i] = b
    points_set.add(a)
Q = int(input())
qlist = []
for _ in range(Q):
    q = list(map(int, input().split()))
    if q[0] == 1:
        q[1] -= 1 # 0 index
        points_set.add(q[2]) # new point
    elif q[0] == 2:
        q[1] -= 1 # 0 index
    qlist.append(q)

n_bit = len(points_set) # num of point kinds
points_list = sorted(list(points_set))
points_comp = {p:i+1 for i,p in enumerate(points_list)}
points_list = [0] + points_list # 1 index
bit_num = BIT(n_bit)
bit_pnt = BIT(n_bit)
count_card = 0
for i in range(N):
    a, b = alist[i], blist[i]
    count_card += b
    idx = points_comp[a]
    bit_num.add(idx, b)
    bit_pnt.add(idx, a*b)
for q in qlist:
    if q[0] == 1:
        p = alist[q[1]]
        n = blist[q[1]]
        p_new = alist[q[1]] = q[2]
        idx = points_comp[p]
        bit_num.add(idx, -n)
        bit_pnt.add(idx, -n*p)
        idx = points_comp[p_new]
        bit_num.add(idx, n)
        bit_pnt.add(idx, n*p_new)
    elif q[0] == 2:
        p = alist[q[1]]
        n = blist[q[1]]
        n_new = blist[q[1]] = q[2]
        count_card += n_new-n
        idx = points_comp[p]
        bit_num.add(idx, n_new-n)
        bit_pnt.add(idx, (n_new-n)*p)
    else:
        n = q[1]
        if n > count_card:
            print(-1)
            continue
        elif n == count_card:
            print(bit_pnt.prod(n_bit))
            continue
        lowbound = count_card - n
        l = 0
        r = n_bit
        while l + 1 < r:
            m = (l+r)//2
            if lowbound <= bit_num.prod(m):
                r = m
            else:
                l = m
        ans = bit_pnt.prod_range(r, n_bit) +\
            points_list[r] * (n - (count_card - bit_num.prod(r)))
        print(ans)

AtCoder Regular Contest 155

疲れて眠いですが、出れるなら出るしかない！という気持ちで参加しました。ARCの参加は3回目ですが、問題Aがこれまでで一番難しく、（ARC153、ARC154と、問題Aはどんどん難しくなりました。）初めての0完に沈みかけました。途中頭が働いてなかったですし、あ～疲れてたし出なかったら良かったなぁ、とか考えてしまってましたが、なんと、残り5分でACできました。順位はぴったり賞のちょうど1000位。今回は、ほとんど0完だったらしく、ギリギリで1問解いただけで、これまででベスト2の順位です。やっぱり出て良かったです。Ratingも初めて1000を超えました。

A - ST and TS Palindrome

そういえば、最近回文の問題を別のところでも見た気がしますが、回文のアルゴリズムがあったと思うんですが、あれをまだ勉強してないのでドキッとします。しかし知らないと解けないというような状況には陥ってません。最初、KがNと比べて比較的小さいところだけ調べて、あぁいけそうだなぁと思ったのですが、2つ目のサンプルテストケースが通りません。KがNに対して大きいと、別扱いが必要になってくるのです。この状況をなかなか整理できず、終了時刻がせまってしまいました。最後、ふとACできて、声出ました。良かったぁ。1完と0完では天と地ですから。 2023-01-29

最初if K>Nとか、if K>2*Nとか条件分岐していましたが、条件分岐しなくても良いようなので、条件分岐を消しました。 2023-01-30

T = int(input())
def check(s, l, r):
    while l < r:
        if s[l] != s[r]:
            return False
        l += 1
        r -= 1
    return True
for _ in range(T):
    N, K = map(int, input().split())
    S = input()
    amari = (K-N) % (2*N)
    if amari > N:
        amari = 2*N - amari
    if check(S, 0, amari-1) and check(S, N-amari, N-1)\
        and S[amari:] == S[:N-amari]:
        print('Yes')
    else:
        print('No')

AtCoder Beginner Contest 288

残念ながら3完でした。3完はしばらくなかったので、ショックです。が、どうも今回の問題Dは難しめだったらしく、4完できた時点でほぼ過去最高の順位、パフォーマンスになっていたようです。そういうこともあるのを受け止めなければなりません。問題Cも簡単じゃないと感じましたが、みんなやたらと早く解けていて（なんで？）、そのせいでぼくの順位は低くなってしまっており、入水が遠のくようでつらいです。

C - Don’t be cycle

閉路を無くすために削除する辺の本数の最小値。ぎょっとなったのですが、一瞬で解いてる人が多く（なぜ？）、こんなの基本なんですかねぇ。連結成分からDFSで木を作り、見つかった閉路をカウントしていきました。閉路って見つかった個数1つずつしかなくせないので、問題に最小値と書いてあるけど全部カウントすればよいです。両側からカウントするので、最後2で割っています。解説では頂点数Xの連結成分において、閉路ができない（=木の）辺の数はX-1であることを利用し、連結成分の数から答えを求めていました。考え方を覚えておく価値がありますね。 2023-02-04

N, M = map(int, input().split())
g = [[] for _ in range(N)]
for _ in range(M):
    a, b = map(int, input().split())
    a -= 1
    b -= 1
    g[a].append(b)
    g[b].append(a)
graphid = 0
usedin = [0]*N # graph id, 0 is not used
parent = [-2]*N # -2 not decided -1 root's
ans = 0
for v in range(N):
    if not usedin[v]:
        graphid += 1 # next graph id
        stack = [v]
        usedin[v] = graphid
        parent[v] = -1
        while stack:
            cur = stack.pop()
            for next in g[cur]:
                if not usedin[next]:
                    stack.append(next)
                    usedin[next] = graphid
                    parent[next] = cur
                # already used in graph
                elif next != parent[cur]:
                    ans += 1
print(ans//2)

D - Range Add Query

解けませんでした。難しい！コンテスト中に考えられたのは、とりあえず1つのクエリに対してO(N)で答えることまでで、それがQ個あるのでO(NQ)、そこから改善できませんでした。解説では、階差数列を作ると書かれていました。なるほど、Range Addをすると、階差数列が変化するのは、K離れた入り口と出口だけであり、操作時に両側のプラマイは0になることがわかります。操作で和が変化しないのであれば、和が0になっている必要があり、和が0になっていれば操作によってすべて0にできることもわかります。Aの先頭に0を追加してから階差数列を作り、添字をKで割った余りごとに累積和を計算しておく…とちょっとややこしいので、階差数列の話は触れておく程度にして、わかりやすかった方法で解きます。添字をKで割った余りごとに、Aの累積和を求めます。区間[l,r]で添字をKで割った余りごとの和がすべて一致していることが、操作によって0にできる条件です。まず、なぜ添字をKで割った余りごとの和がすべて一致している必要があるのか？これは操作によってK幅の区間全部に+Cするか-Cするのですから、和の変化が同じです。なので、1つ0になれば全部0になっていなければならないです。すごいひらめきだ！というわけで、1つ0にすればよいわけですが、左から順に0でなければ0になるように操作することを繰り返せばよいです。最後の操作で[r-K+1]に対して操作することで、必ず1つのグループを0にできることがわかり、先程の説明通り、他もすべて0になります。こんなのコンテスト中に解けたらなぁ。Range Add->mod Kみたいな定石ですかね。 2023-02-05

N, K = map(int, input().split())
temp = [0]*K
sum_modk = [0]*N
for i, a in enumerate(map(int, input().split())):
    temp[i%K] += a
    sum_modk[i] = temp[i%K]
Q = int(input())
for _ in range(Q):
    l, r = map(int, input().split())
    l -= 1
    r -= 1
    ls = [0]*K
    rs = [0]*K
    for i in range(K):
        rs[(r-i) % K] = sum_modk[r-i]
        ls[(l-1-i+K) % K] = 0 if l-1-i < 0 else sum_modk[l-1-i]
    val = rs[0] - ls[0]
    for i in range(1, K):
        if rs[i] - ls[i] != val:
            print('No')
            break
    else:
        print('Yes')

E - Wish List

問題Dで行き詰まった間、こちらをしばらく考え、一筋縄でいかないと感じてDに戻っていました。実際解説を読んでもいまいちピンとこず、難しかったです。解説は、正しい説明のために用意した数式で書かれており、直感的ではなくて何を言ってるかわからない、ということが結構あるように思います。だからといって直感的に書くって何？という話で、理解する側ががんばって自分なりの説明にたどり着くというプロセスが必要、なのでしょう。解説に書いてあるcostという式や、「この下界は達成可能です。 実際、「現時点での購入費用がその下界 (1) を達成している商品」の中で番号が最大のものを買うという行動を繰り返すことで達成できます。」という説明、読んでも頭に入ってこず、自分なりに考え直して理解しました。この問題におけるDPでは、i番目について計算するときに、i-1番目までに何個買うか？をキーとして使っています。買うと決めるだけで、すでに買ったわけではないのがこのDPの難しいところです。買う順番によって値段のCの部分が変化してしまうからです。i-1まででx個買う場合、iを買う時点でそのx個のうち何個先に買ったかによってCの値が決まります。0個からx個のうち何個買ってからiを買うのか？Cの値が0からxまでの場合で変化するのですが、これが、一番安く買えるというのが結論です。自力で気づくのかなり難しいと感じているんですが、みんなどういう思考手順で、しかも短時間で、たどりつけるんですかね？そうなってないと難しいよなぁ、みたいなところから勘でたどりつくんでしょうか？うーん。自分なりの説明を書きます。買う商品の番号が小さい順に、a,b,c,d,…だったとします。aは実はいつ買ってもコストはCaです。aより小さい番号は買わないのですから、買う時点で必ずa番目なのです。つまり、aはいつ買ってもいいことがわかります。bを買うときaを購入済みであればCb-1、aを未購入であればCbです。重要なのは、aの影響しか受けないということです。bより小さい番号で買うのはaだけですから。しかしaはいつ買っても同じと先程わかりましたので、aとbの購入順は自由に決めてよく、Cb-1とCbの小さい方を選べるのです。cはどうでしょうか？aとbを買うタイミングによってCc-2、Cc-1、Ccの3通りが考えられますが、もっとも小さくなるように、aとbの順序に対して、cを買う順序を決められます。よって、i番目を買う時にCi、Ci-1、Ci-2、Ci-3、…の中で最小コストは確定できることがわかります。むずかしい。むちゃくちゃ難しいと思うんですが。気づける人すごすぎるな。改めて先に引用した解説の文章は、一体正しいことを言ってるのでしょうか？CのRange Minimumが必要なので、dpといっしょにcminも逐次更新していますが、この実装もちゃんと整理しないと混乱に陥ります。ところで、Python勢の中で最速タイの207msです。いつも時間制限に苦しめられているので、他の人より速いとうれしいです。 2023-02-05

N, M = map(int, input().split())
A = [0] + list(map(int, input().split()))
C = [0] + list(map(int, input().split()))
Xset = set(map(int, input().split()))
dp = [10**14]*(N+1)
cmin = [10**14]*(N+1) # cmin[i] i個買わない場合
dp[0] = 0
count_bought = 0
for i in range(1, N+1):
    a = A[i]
    for j in range(1, i+1):
        cmin[j] = min(cmin[j], C[i])
    buy = i in Xset
    for j in range(count_bought, i)[::-1]:
        if buy:
            dp[j+1] = dp[j] + cmin[i-j] + a
        else:
            dp[j+1] = min(dp[j+1], dp[j] + cmin[i-j] + a)
    if buy:
        count_bought += 1
    if count_bought == M:
        break
print(min(dp[M:]))

F - Integer Division

雰囲気的にDPだろうなぁ。i番目をまでの合計値は、Σ(dpk + X[k+1:i])だなぁ。と、そこまでいっても、最後まで詰められない。解けたい問題です。式変形するとこんなにシンプルなDPにたどり着けます。これをひらめけないの、本当にくやしいです。むちゃくちゃいい問題ですね。 2023-02-06

M = 998244353
N = int(input())
X = [int(c) for c in input()]
dp = X[0]
sum = 1 + X[0]
for i in range(1,N):
    dp = (sum * X[i] + 10 * dp) % M
    sum = (sum + dp) % M
print(dp)

G - 3^N Minesweeper

また解説を見ても最初ピンとこなかったですが、サウナで考えてたらわかりました。問題の条件から、近い位置にある爆弾の数がわかっているわけです。ある位置のi桁目が0だった場合、その近い位置にある爆弾の位置は、i桁目が0か1であることがわかります。（他の桁のことは後で考えましょう。）同様に、i桁目が1なら近い位置はi桁目が0か1か2、i桁目が2なら近い位置はi桁目が1か2です。それぞれa個、b個、c個だったとしましょう。b-cを計算するとi桁目が0である個数に絞り込めることがわかります。b-aでi桁目が2、a+c-bでi桁目が1に絞り込めます。すべての桁で同様に絞り込めば、全桁確定した個数が求まるというわけです。むずかしい！あたおか。えげつない気がするのですが。これをコンテスト中にひらめくってどうなってんでしょうか？ぼくもいつかできるのでしょうか？？？orange #3進数 2023-02-07

N = int(input())
alist = [a for a in map(int, input().split())]
for i in range(N):
    pow3i = 3**i
    for j in range(3**N):
        if j // pow3i % 3 == 0:
            x, y, z = j, j+pow3i, j+2*pow3i
            alist[x], alist[z] = alist[y]-alist[z], alist[y]-alist[x]
            alist[y] -= alist[x] + alist[z]
print(*alist)

AtCoder Beginner Contest 289

4完でした。問題DをPythonでやったところ、制限時間2秒に対してTLEx3、どうしても高速化方法が思いつかないので、APG4bで学びたてのC++で同じロジックで書き直したところ、69msでACできました。どんだけ速度違うんでしょう？しかし解説を見ると、もっと速いロジックがあることがわかり、それであればPythonでも84msでした。しかし下手くそな実装のC++にまだ負けてんじゃん。下手くそでもむちゃくちゃ速いC++、使うしかねぇと再認識した今日です。C++で書き直している間に1000位くらい下落して、パフォーマンスが下がりまくり、全然レーティングが伸びません。つらいです。伸び悩むとやめたくなります。

D - Step Up Robot

C++コードも載せてますが、同じ方法でPythonでやると、2秒の制限に間に合いません。C++で書けるようになってて良かったです。このPythonの実装を思いつかないのは反省点です。 2023-02-11

import sys
input = sys.stdin.readline
N = int(input())
alist = list(map(int, input().split()))
M = int(input())
bset = set(map(int, input().split()))
X = int(input())
dp = [0]*(X+1)
dp[0] = 1
for i in range(X+1):
    if i in bset:
        continue
    for a in alist:
        if i-a >= 0 and dp[i-a] == 1:
            dp[i] = 1
            break
print('Yes' if dp[X] else 'No')

// C++
int main() {
    int N, M, X;
    cin >> N;
    vector<int> A(N);
    for (int i = 0; i < N; i++) {
        cin >> A.at(i);
    }
    cin >> M;
    set<int> B;
    for (int i = 0; i < M; i++) {
        int b;
        cin >> b;
        B.insert(b);
    }
    cin >> X;
    set<int> S;
    S.insert(0);
    while (!S.empty()) {
        int cur = *begin(S);
        S.erase(cur);
        for (int a : A) {
            int next = cur + a;
            if (next == X) {
                cout << "Yes" << endl;
                return 0;
            }
            if (B.find(next) == B.end() && next < X) {
                S.insert(next);
            }
        }
    }
    cout << "No" << endl;
}

E - Swap Places

思いつきませんでした。解けてる人が多いですが、普通に難しいと感じています。高橋君と青木君の位置を合わせて状態とみなすことで、NxNの盤面を移動する問題になります。うーん、これみんな見えるのかぁ。難しいなぁ。その盤面上の最短経路を求めるので、BFSをします。DFSじゃないので、注意。 2023-02-11

from collections import deque
T = int(input())
for _ in range(T):
    N, M = map(int, input().split())
    clist = [0] + list(map(int, input().split()))
    g = [[] for _ in range(N+1)] # 1 indexed
    for _ in range(M):
        u, v = map(int, input().split())
        g[u].append(v)
        g[v].append(u)
    dist = [[-1]*(N+1) for _ in range(N+1)]
    q = deque([(1,N)])
    dist[1][N] = 0
    found = False
    while q:
        t, a = q.popleft()
        dcur = dist[t][a]
        for nt in g[t]:
            for na in g[a]:
                if dist[nt][na] == -1 and clist[nt] != clist[na]:
                    if nt == N and na == 1:
                        print(dcur + 1)
                        found = True
                        break
                    q.append((nt,na))
                    dist[nt][na] = dcur + 1
            if found:
                break
        if found:
            break
    if not found:
        print(-1)

F - Teleporter Takahashi

コンテスト時間中に考えられませんでしたが、こういうの時間内に解きたいなぁ。A<BだとAとA+1を使ってワープすることで、どちらの方向へも2ずつ移動することができます。つまり、2の倍数離れた任意の位置に移動できます。奇数回目は反対側に飛んでるので、どうすればよいでしょうか？1回目で移動した位置から2ずつ移動できると考えると、奇数回目も2の倍数離れた任意の位置に移動できることがわかります。A=BやC=Dの場合について、ちゃんと整理すれば解けます。 2023-02-11

import sys
Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
A, B, C, D = map(int, input().split())
def move_even(start, end, a):
    if end > start:
        return [a,a+1]*((end-start)//2)
    return [a+1,a]*((start-end)//2)
def move_odd(start, end, a):
    start = 2*a-start
    return [a] + move_even(start, end, a)
if (Tx-Sx) % 2 == 1 or (Ty-Sy) % 2 == 1:
    print('No')
    sys.exit()
if A == B:
    if C == D:
        if (Sx,Sy) == (Tx,Ty):
            print('Yes')
        elif (2*A-Sx,2*C-Sy) == (Tx,Ty):
            print('Yes')
            print(A, C)
        else:
            print('No')
        sys.exit()
    else: # C < D
        if Sx != Tx and 2*A-Sx != Tx:
            print('No')
        else:
            print('Yes')
            if Sx == Tx:
                ylist = move_even(Sy, Ty, C)
            else:
                ylist = move_odd(Sy, Ty, C)
            ans = [[A, y] for y in ylist]
            for a in ans:
                print(*a)
        sys.exit()
if C == D:
    if A < B:
        if Sy != Ty and 2*C-Sy != Ty:
            print('No')
        else:
            print('Yes')
            if Sy == Ty:
                xlist = move_even(Sx, Tx, A)
            else:
                xlist = move_odd(Sx, Tx, A)
            ans = [[x, C] for x in xlist]
            for a in ans:
                print(*a)
        sys.exit()
# C < D and A < B
print('Yes')
xlist = move_even(Sx, Tx, A)
ans = [[x, C] for x in xlist]
ylist = move_even(Sy, Ty, C)
ans.extend([[A, y] for y in ylist])
for a in ans:
    print(*a)