AtCoder Grand Contest 052 A,B,C,E問題メモ

AtCoder Grand Contest 052

A - Long Common Subsequence

問題

'0'と'1'からなる文字列 $s_1,s_2,s_3$ が与えられる
$s_1,s_2,s_3$ は'0','1'をそれぞれ $N$ 個ずつ含む長さ $2N$ の文字列である
以下の条件を満たす、長さ $2N+1$ の文字列 $t$ を出力せよ
条件
- $t$ は、$s_1+s_1,s_2+s_2,s_3+s_3$ のいずれの（連続するとは限らない）部分列でもある
テストケースは $T$ 個与えられる
$1 \le T \le 10^5$
$1 \le N \le 10^5$
全てのテストケースにおける $N$ の総和 $\le 10^5$

解法

あまりにも答え一発なので折りたたむ

具体的な $s_1,s_2,s_3$ を見る必要すら無い。

「$N$ 個の'0'、$N$ 個の'1'、1個の'0'」を並べたものが答えの1つとなる。これを $t$ とする。

どんな $s$ でも、$t$ が必ず $s+s$ の部分列となることを証明する。

最後の'0'の後に $k$ 個の '1' が続いていたとすると、$s+s$ の前半の1周で $t$ の中の「$N$ 個の'0' と $k$ 個の'1'」まで一致する。

続く後半の1周では、最後の'0'の前に $N-k$ 個の'1'があるはずなので、残る「$N-k$ 個の'1' と 1個の'0'」まで一致させることができる。

|------s------|------s------|
 01101...10111 01101...10111
 |--------||-| |-------||
   N個の0   ^  N-k個の1 ^
          k個の1        1個の0

Python3

t = int(input())
for _ in range(t):
    n = int(input())
    s1 = input()
    s2 = input()
    s3 = input()
    print('0' * n + '1' * n + '0')

今回は配点の傾斜的に1完勝負となり得るので未証明で出すのはちょっと怖かったけど、まぁ通った（よくない）。

B - Tree Edges XOR

問題

$N$ 頂点の木が与えられる。$N$ は奇数である
各辺には非負整数値が設定されていて、初期値は $w_i^1$、目標値は $w_i^2$
以下の操作を好きなだけ行える
操作
- 好きな辺を1本選ぶ。$(u,v)$ を結ぶ辺を選んだとする
- その辺の現在の値を $w$ とする
- 頂点 $u,v$ を端点に持つ、選んだ1本以外の全ての辺について、辺の値を「現在の値 XOR $w$」に置き換える
全ての辺の値を目標値にできるか判定せよ
$1 \le N \le 10^5$
$0 \le w_i^1,w_i^2 \lt 2^{30}$

○--○==,        ,==○      ～～: 操作する辺
    ○==ｕ～～～ｖ==○      ====: 操作によって値が変わる辺
○--○=='        `==○--○

解法

最初、$N$ で奇数である意味が全くわからないので不安になるが、最後に結びついたときは感動する。

根を決めて、葉に近い辺から確定させていくのか？とか考えるが、ある辺を目標値にできるような操作を確定したところで結局「他の辺のためにその辺自身は操作すべきかどうか」を確定できない。
また、XOR問題でよくある性質「操作の順番は関係ない」はこの問題では成り立たず、しっかり操作順が関係するので、操作した場合としない場合を親に波及させるのも上手くいかない。

ふと、「辺の値」って考えづらいので「頂点に対する値」に言い直していい感じにならないか考えてみる。

「辺の値＝辺が結ぶ2頂点の値のXOR」と定義すると、適当な頂点（たとえば頂点1）の値を $0$ と仮定して、そこからつながる頂点の値を矛盾しないように次々一意に決めていける。

頂点番号   １        ２        ３        ４
  辺の値       1100      0010      0111
頂点の値  0000------1100------1110------1001

そして、この定義の中で操作がどのように言い換えられるか考えると、

頂点番号   １        ２        ３        ４
  辺の値       1100      0010      0111          ２－３に対する操作
頂点の値  0000------1100------1110------1001

                          ↓

  辺の値       1110      0010      0101
頂点の値  0000------1110------1100------1001

操作対象の辺の両端の頂点（1100, 1110）に、それぞれ現在の辺の値（0010）をXORする操作に相当する。
結果的に「辺が結ぶ2頂点の値を入れ替える」操作と言い換えられることがわかる。

木で、頂点に値が設定されていて「辺でつながった2頂点の値swapを好きなだけ繰り返す」という操作では、好きな頂点に好きなように値を並べ替えられる。

従って、辺の初期値 $w_i^1$ から構成した頂点の値の多重集合を上手く並べ替えることで、目標値 $w_i^2$ が満たされる状態にしたい。

初期値 $w_i^1$ から構成した頂点の値の多重集合を $F$ とする。
また、目標値 $w_i^2$ からも同様に頂点の値の多重集合 $G$ を構成する。

$F$ や $G$ は、最初に頂点1で仮定した初期値によって様々に変化するが、逆に言うとそれにしか依存しない。

最初に頂点1に仮定する値を $i$ としたときの $G$ を $G_i$ とする。
$i=0$ から $i=X$ に置き換えると、できあがる $G_X$ は、$G_0$ の全ての値に $X$ をxorしたものになる。

$X$ の値によらず $G_X$ は全て「目標値 $w_i^2$ が満たされる状態」として条件を満たすし、それ以外は満たさない。

$F_0=G_X$（多重集合として一致する）ような $X$ を見つけたいのだが、ここでやっと $N$ が奇数であることが生きる。

多重集合 $F$ の全ての要素のXORを $f(F)$ と表現することにする。

$F_0=G_X$ なら、当然 $f(F_0)=f(G_X)$ となる。
また、$G_X$ の長さは $N$、つまり奇数なので、$f(G_X)$ は $f(G_0)$ に奇数回 $X$ がXORされた値となり、2つのXOR $f(G_0) \oplus f(G_X)$ はちょうど $X$ となるはずである。

したがって、$f(F_0)=f(G_X)$ となりうる $X$ があるとしたら、$X=f(F_0) \oplus f(G_0)$ しかないことがわかる。

あとは実際に $G_X$ を作り、$F_0$ と多重集合として一致するかどうか確認すればよい。

Python3

def dfs(n, links, current, required):
    vertex_weight1 = [0] * n
    vertex_weight2 = [0] * n
    q = [0]
    parents = [-1] * n
    while q:
        v = q.pop()
        p = parents[v]
        w1 = vertex_weight1[v]
        w2 = vertex_weight2[v]
        for u, i in links[v]:
            if u == p:
                continue
            parents[u] = v
            vertex_weight1[u] = current[i] ^ w1
            vertex_weight2[u] = required[i] ^ w2
            q.append(u)
    return vertex_weight1, vertex_weight2


n = int(input())
links = [[] for _ in range(n)]
current_weight = []
required_weight = []
bitwise_can = [0]
for i in range(n - 1):
    u, v, w1, w2 = map(int, input().split())
    u -= 1
    v -= 1
    links[u].append((v, i))
    links[v].append((u, i))
    current_weight.append(w1)
    required_weight.append(w2)

F, G0 = dfs(n, links, current_weight, required_weight)

x = 0
for w in F:
    x ^= w
for w in G0:
    x ^= w

GX = [w ^ x for w in G0]

F.sort()
GX.sort()

if F == GX:
    print('YES')
else:
    print('NO')

二乗の木DPとかの方面に迷走して大分時間を食ったが、まぁギリギリで通せたのはよかった。

C - Nondivisible Prefix Sums

問題

正整数 $N$ と素数 $P$ が与えられる
長さ $N$ で、各項が $1～(P-1)$ の数列 $A$ は $(P-1)^N$ 通りあるが、以下の条件を満たすものの個数を $\mod{998244353}$ で求めよ
条件
- 接頭辞の和 $A_1, A_1+A_2, A_1+A_2+A_3, ..., $ のいずれも $P$ で割りきれない数列を「よい数列」とよぶ
- 並べ替えることによって、よい数列にすることが可能である
$1 \le N \le 5000$
$2 \le P \le 10^8$

解法

ぱっと見で、「好きに並べ替えてさえ、よい数列にできない」方がレアそうなので、こちらを数えて、全体から引くことにする。

捉えどころが無いが、愚直に調べるコードを書くと（$N,P$ が1桁くらいならなんとかなる）、以下の2つが該当しそうなことがわかる。

全体の和が $P$ の倍数
同じ数がほとんどを占める
- でも他の数の組み合わせによって、最頻値の個数が同じでもセーフだったりアウトだったりする

1つめの条件

どういう順番で並べようと、全体が $P$ の倍数なら避けようがない。よってそのような数列を数える。

「最後の1個手前までを任意に並べたら残り1個は $P$ の倍数にならないような数を選べばいいから $(P-1)^{N-1} \times (P-2)$ かな？」と思ったら、実は「最後の1個手前がちょうど $P$ の倍数だった場合、最後は何を選んでもよい」ので、微妙にずれる。

DP的に考えると、以下のようになる。

P = 5                                        遷移
数列長さ           0    1    2    3    4      Pの倍数 →: x 0
-------------------------------------------   Pの倍数 ↘: x (P-1)
和がPの倍数        1    0    4   12   52      P以外   →: x (P-2)
和がPの倍数以外    0    4   12   52  204      P以外   ↗: x 1

これの $N$ 番目の項は、漸化式を解くなり OEISに聞くなりすれば、$\dfrac{(P-1)^N + (-1)^N(P-1)}{P}$ であることがわかる。

2つめの条件

重要な性質として、$P$ と互いに素な数 $x$ について、$x,2x,3x,...,(P-1)x \mod{P}$ の $P-1$ 個の数は必ず $1～P-1$ の数のいずれかとダブらずに1対1対応する。

同じ数 $x$ がたくさんある時を考える。
上記の性質より、途中まで並べた時の和の $\mod{P}$ が何であったとしても、そこから $x$ を並べ続けると $P-1$ 回以内には $P$ の倍数は必ず現れてしまう。

つまり、接頭辞の和が $P$ の倍数とならない範囲で $x$ をなるべく多く消費しつつ前から並べても、最終的に置けるものが $x$ しか残らず、残った $x$ を並べると $P$ の倍数が現れてしまう時、「よい数列」が作れないことになる。

さて、また同様の性質として、$1～(P-1)$ の中で $x$ 以外の数は、$\mod{P}$ 上で「$-(P-2)x, -(P-3)x, ..., -2x, -x$」のいずれかに1対1対応する。

$x$ を $P$ の倍数とならないギリギリの $P-1$ 個まで並べた後、例えば $-3x$ に相当する数を置けば、$x$ は $3$ 個相殺され、さらにあと $3$ 個置けるようになる。

P=5, x=2
                 和modP
2 2 2 2             3    次に2を置いたらPの倍数となる。
2 2 2 2 4           2    -3x ≡ 4 mod 5 なので、4を置いたら、和は3個前の状態に戻る
2 2 2 2 4 2 2 2     3    さらにあと2を3個置ける（次に置いたらPの倍数となる）

2 2 2 2 3           1    -x ≡ 3 mod 5 なので、3を置いたら、和は1個前の状態にしか戻らない
2 2 2 2 3 2         3    あと2を1個置くだけで、再びギリギリになる

不可能な場合というのは、このように $x$ を他の数で相殺しても、なお $x$ が $P$ 個以上余ってしまう状態といえる。
（逆に、$x$ が $P$ 個以上余らなければ、上記のようにすれば必ず $P$ の倍数を避けられる）

「相殺した結果、$x$ が $P$ 個以上余るか」によって、「並べ替えて、よい数列とできるか」が判定可能であることがわかった。

この性質は $x$ によらず同じだし、$x$ ごとに具体的な $-x,-2x,...$ が何に相当するかを知らなくても、 1個ずつあるということさえわかっていれば、まとめて計算できる。

前から順に数列の要素を決めていきつつ、以下のDPを行う。

$DP[i][j]=$ $i$ 番目の要素まで決め、そこまでで $x$ が $j$ 個余っているとき（負もある）の数列のパターン数

最終的に、$DP[N][P以上]$ が、よい数列を作れないものとなる。
$j$ は減らす時は一気に減らせても増やすのは1ずつしか出来ず、最終的に $P$ 以上となるものだけが重要なので、 $j$ の範囲は $P-N～N$ を考え、この範囲外に遷移するものは捨ててよい。

遷移は、以下のようになる。

$x$ を置く場合: $DP[i][j] += DP[i-1][j-1]$
それ以外を置く場合: $DP[i][j] += DP[i-1][j+1]+DP[i-1][j+2]+...+DP[i-1][j+P-2]$

連続した累積和なので、尺取的に枠をずらしながら計算していくと、$i$ ごとに $O(N)$、全体 $O(N^2)$ で遷移できる。

最終的に、$DP[N][P以上]$ の和が、よい数列を作れないものとなる……が、$j$ が $P$ の倍数のものは1つめの条件（総和が $P$ の倍数）と重複しているので除く。

Python3

import os
import sys

import numpy as np


def bruteforce(n, p):
    from itertools import product
    count = 0
    cache = set()
    for aaa in product(range(1, p), repeat=n):
        if aaa in cache:
            continue
        if sum(aaa) % p == 0:
            count += 1
    return count


def solve(n, p):
    def mod_pow(x, a, MOD):
        ret = 1
        cur = x
        while a:
            if a & 1:
                ret = ret * cur % MOD
            cur = cur * cur % MOD
            a >>= 1
        return ret

    MOD = 998244353
    whole = mod_pow(p - 1, n, MOD)

    cannot = (whole + (1 if n % 2 == 0 else -1) * (p - 1)) * mod_pow(p, MOD - 2, MOD) % MOD

    if n <= p:
        return (whole - cannot) % MOD

    dp_from = np.zeros(2 * n, np.int64)
    dp_to = np.zeros_like(dp_from)
    dp_from[0] = 1
    for t in range(n):
        tmp = 0
        for i in range(p - (n - t) - 1, 2 * p - (n - t) - 1):
            tmp += dp_from[i]
        for i in range(p - (n - t), t + 2):
            dp_to[i] = tmp - dp_from[i]
            tmp -= dp_from[i - 1]
            tmp += dp_from[i + p - 1]
        dp_to %= MOD
        dp_from, dp_to = dp_to, dp_from
        dp_to.fill(0)

    dp_from[p::p] = 0
    too_many = dp_from[p:].sum() % MOD * (p - 1) % MOD

    return (whole - cannot - too_many) % MOD


SIGNATURE = '(i8,i8)'
if sys.argv[-1] == 'ONLINE_JUDGE':
    from numba.pycc import CC

    cc = CC('my_module')
    cc.export('solve', SIGNATURE)(solve)
    cc.compile()
    exit()

if os.name == 'posix':
    # noinspection PyUnresolvedReferences
    from my_module import solve
else:
    from numba import njit

    solve = njit(SIGNATURE, cache=True)(solve)
    print('compiled', file=sys.stderr)

n, p = map(int, input().split())
ans = solve(n, p)
print(ans)

E - 3 Letters

問題

ある文字列 $s$ がどの連続する2文字も異なるとき、「$s$ はよい文字列」とする
'A','B','C' からなる長さ $N$ の2つの「よい」文字列 $S,T$ が与えられる
以下の操作を繰り返して、$S$ を $T$ にしたい
操作
- $S$ の好きな1文字を、'A','B','C' のうちの好きな文字に変える
- ただし操作後も、文字列 $S$ は「よい」文字列である状態を保つこと
最小の操作回数を求めよ
$1 \le N \le 5 \times 10^5$

解法

もっと効率のよい方法はありそうだが、自分が解いた方針について。

ABC文字列を使った問題でよくあるのは、ABCを0,1,2に変換したり、その上でXORや差分を取ったりして、不変量を探したり操作の言い換えを行うこと。

今回は、$S$ を以下のような数列 $S_d$ に変換すると、操作が言い換えられる。

$S$ の両端には便宜的に 'A' が置かれていて、これは変えられないとする
$S[i]$ が'A'で $S[i+1]$ が'B'など、位置的に次の文字が辞書順的に次の文字なら、$S_d[i]=0$
$S[i]$ が'A'で $S[i+1]$ が'C'など、位置的に次の文字が辞書順的に次の文字でないなら、$S_d[i]=1$
- ただし便宜的に'C'の辞書順の次は'A'で、ループしているとする
次の文字が同じとき、$S_d[i]=2$（基本的に両端のみに発生する）

S     B C B C B A C A
           ↓
    A B C B C B A C A A
Sd   0 0 1 0 1 1 1 0 2

この時、操作により $S_d$ がどのようになるかというと、

    A B C B C B A C A A
     0 0 1 0 1 1 1 0 2
            v
    A B C B A B A C A A
     0 0 1 1 0 1 1 0 2

端っこ以外では、値が $1$ だけ隣り合う箇所に移動する操作となる。

端っこでも、大体は同様のことが発生する。

    A C A B C B A C A A
     1 0 0 0 1 1 1 0 2
      v             v
    A B A B C B A C B A
     0 1 1 0 1 1 1 1 1   swapではなく、あくまで
                   ~~~   値が1ずつ隣り合う箇所に移動する操作

特定の状況のみ例外的なことが発生するが、、、

    A B C B C B A B A A
     0 0 1 0 1 1 0 1 2
      v             v
    A A C B C B A B C A
     2 1 1 0 1 1 1 0 0

端が '0 0' なら '2 1' に、'2 1'なら '0 0' に変化する。（左端の場合。右端は'2'と'1'が逆になる）

ただ、これも「端だけは負の数や3以上の数も許される」とすれば、他と同様「値が1だけ隣り合う箇所に移動する操作」として一貫した法則と見なせる。
この時、初期値と $\mod{3}$ が同じでなければならない。

    A B C B C B A B A A
     3 0 1 0 1 1 0 1 -1
      v             v
    A A C B C B A B C A
     2 1 1 0 1 1 1 0 0

まとめると、

よい文字列 $S$ は、両端のみ $-1$ 以下や $2$ 以上も許されるが、両端以外では'0','1'からなる数列 $S_d$ に変換される
- 両端以外が同じで、両端も $\mod{3}$ が同じ $S_d$ 同士は、同じ文字列を表す
$S$ に対する操作は、$S_d$ に対しては値を $1$ ずつ隣り合う箇所に移動させる操作となる
両端以外の数は、操作の途中で $-1$ 以下や $2$ 以上にしてはならない
- 隣り合う2文字が同じになってしまうことを意味する
- ただ、端から順に処理していけば問題ないので、特に考えなくてよい

この上で、文字列 $S$ を $T$ にすることを考える。

まず、$S_d,T_d$ に変換する。

$S_d$ の値を1ずつ移動させて、$T_d$ に一致させればよい。

この時、$S_d$ と $T_d$ の総和が異なる場合がある。
$S_d$ の両端の数を±3で調整して総和を $T_d$ に揃えたい。

調整の方法は、左右にどれだけ割り振るかで複数考えられる（総和が同じであっても、左を $-3$ して右を $+3$ するのがよい場合などもある）。
割り振り方を決めると、あとは単に端から対応させるのが最適なので、操作回数は $O(N)$ で求められる。$S_d[i]$ の1と $T_d[j]$ の1を対応させる場合、操作回数は $|i-j|$。

S   A B C B C B A B A A
T   A A B C A B C A B A

Sd   0 0 1 0 1 1 0 1 2    総和がSdの方が3多い
Td   2 0 0 0 0 0 0 0 1

Sd   0 0 1 0 1 1 0 1 -1   調整する
                     ~~
Sd   0 0 1 0 1 1 0 1 -1   調整方法を1つ決めると、
Td   2 0 0 0 0 0 0 0 1    Sdを1ずつ動かしてTdに一致させる最小手数が確定する
      ←←         →
      ←←←← →→→     この調整の仕方では10手

Sd   3 0 1 0 1 1 0 1 -4   調整方法は複数考えられる。
Td   2 0 0 0 0 0 0 0 1    この調整の仕方では22手

調整のために左端に加算した値を $x$ とすると、あまり極端に小さかったり大きかったりしても移動距離が伸びるだけなので、「$f(x)=$ その調整方法の最小操作回数」のグラフは下に凸なグラフとなっているはずである。
（小さいケースで試した結果だが、本当はこれもちゃんと証明すべき）

$x$ を三分探索すれば、$O(N \log{N})$ で答えが求められる。

Python3

from itertools import accumulate

n = int(input())
s = [0] + ['ABC'.index(c) for c in input()] + [0]
t = [0] + ['ABC'.index(c) for c in input()] + [0]

sd = [(c2 - c1 - 1) % 3 for c1, c2 in zip(s, s[1:])]
td = [(t2 - t1 - 1) % 3 for t1, t2 in zip(t, t[1:])]
ssd = sum(sd)
std = sum(td)
if ssd > std:
    s, t = t, s
    sd, td = td, sd
    ssd, std = std, ssd

d = (std - ssd) // 3


def make_indices(sd):
    result = [0] * sd[0]
    result.extend(i for i, c in enumerate(sd[1:-1], start=1) if c == 1)
    result.extend([n] * sd[n])
    result_acc = list(accumulate([0] + result))
    return result, result_acc


s_idx = [i for i, c in enumerate(sd[1:-1], start=1) if c == 1]
s_idx_acc = list(accumulate([0] + s_idx))

t_idx = [0] * td[0]
t_idx.extend(i for i, c in enumerate(td[1:-1], start=1) if c == 1)
t_idx.extend([n] * td[n])
t_idx_acc = list(accumulate([0] + t_idx))

s_idx_total = s_idx_acc[-1]
t_idx_total = t_idx_acc[-1]


def check(m):
    p = sd[0] + m * 3
    q = sd[n] + (d - m) * 3
    result = 0
    if p >= 0:
        if p > std:
            return 1 << 60
        result += t_idx_acc[p]
        if q >= 0:
            if q > std:
                return 1 << 60
            result += 0 if q == 0 else abs(n * q - (t_idx_total - t_idx_acc[-q - 1]))
            remaining = std - p - q
        else:
            q = -q
            if q > len(s_idx):
                return 1 << 60
            result += abs(n * q - (s_idx_total - s_idx_acc[-q - 1]))
            remaining = std - p
        for i in range(remaining):
            result += abs(s_idx[i] - t_idx[i + p])
    else:
        p = -p
        if p > len(s_idx):
            return 1 << 60
        result += s_idx_acc[p]
        result += 0 if q == 0 else abs(n * q - (t_idx_total - t_idx_acc[-q - 1]))
        for i in range(std - q):
            result += abs(s_idx[i + p] - t_idx[i])
    return result


l, r = -(std // 3), (std // 3) + 1
while l + 1 < r:
    m1 = (l + r) // 2
    m2 = m1 + 1
    r1 = check(m1)
    r2 = check(m2)
    if r1 < r2:
        if r == m2:
            r -= 1
        else:
            r = m2
    else:
        l = m2

r1 = check(l)
r2 = check(r)
print(min(r1, r2))

解法2

公式解説の方法。

差分では無く、$S$ の各文字をそれぞれ1つの数に対応させた数列 $S_c$ に変換する。
隣り合う数は異なることを利用して「ウォーク」として考える。
つまり、次の文字が辞書順で進む関係なら+1、戻る関係なら-1する（'A'と'C'はループでつながっているとする）。

S   C A B C A B A C B C B A
Sc  2 3 4 5 6 7 6 5 4 5 4 3
            ／＼
          ／    ＼
        ／        ＼／＼
      ／                ＼
    ／

ただし $A=0,B=1,C=2$ と対応づけるとして、各 $Sc$ の $\mod{3}$ が $S$ と等しくなるようにする。
これは、最初の数を揃えれば、後は自動的に揃う。
こうすると、$S_c$ から $S$ を一意に復元できる。全体を±3ずつ平行移動させたものは同じ $S$ を表す。

両端以外の箇所に対する操作は、「山をへこませる」「谷を盛り上げる」操作となる。
つまり、左右に隣り合う数字が同じ箇所を選び、+2または-2する操作となる。

           v
 C A B C A C A C B C B A
 2 3 4 5 6 5 6 5 4 5 4 3
          
        ／＼／＼
      ／        ＼／＼
    ／                ＼
  ／

両端も同様だが、これは左または右の制約がないので、いつでも好きなときに+2または-2できる。

 v                     v
 B A B C A C A C B C B C
 4 3 4 5 6 5 6 5 4 5 4 5
          
        ／＼／＼
      ／        ＼／＼／
  ＼／

さて、$S_c$ と $T_c$ を決めたとき、$S_c$ に操作して $T_c$ に一致させるための最小手数を考えたい。

操作は常に±2でしか行えないので、$S_c[i]$ と $T_c[i]$ の偶奇は一致するように最初の値を決める必要がある。
ウォークなので、$S_c[0]$ と $T_c[0]$ の偶奇を一致させれば、後は自動的に揃う。

その上で、要素ごとの差分 $\displaystyle \sum_{i=1}^{N}\frac{|S_c[i]-T_c[i]|}{2}$ 回の操作は、必ず必要になる。

これ以上かかることがあるとすれば、「本来は操作しなくてよかったり値を減らしたい箇所だが、他の要素を矛盾無く処理するため、一旦は値を増やす必要がある」みたいなことが発生する場合となる。

Sc  2 3 4 5 6 7 6 5 4 5 4 3
Tc  0 1 0 1 2 3 4 5 6 7 6 5
                  ^ 例えばここは±2する必要はないが、
                    他の箇所をそろえるために、一旦操作して戻すような必要性が生じるか？

しかし、そのようなことは発生しない。
「値を減らしたい箇所のうち、最大値の $S_c[i]$ を減らす」「増やしたい箇所のうち、最小値の $S_c[i]$ を増やす」ことを繰り返すと、回り道となる操作は必要なく、$S_c$ を $T_c$ に一致させられる。

よって、下限となる $\displaystyle \sum_{i=1}^{N}\frac{|S_c[i]-T_c[i]|}{2}$ が実現可能で、これが最小手数となる。

最後に、どのように $S_c$ の値を決めれば $\displaystyle \sum_{i=1}^{N}\frac{|S_c[i]-T_c[i]|}{2}$ を最小化できるか？だが、 $S_c[i]-T_c[i]$ が正になるものと負になるものをなるべく均等にした時が最小となる。

$S_c$ は全体の平行移動でしか調整できないので、たとえば全体を+6すると、$S_c[i]-T_c[i]$ は一律6増える。
この時、その絶対値 $|S_c[i]-T_c[i]|$ は、元が正なら1個あたり6増え、負なら6減る。（正負の境界をまたぐときが微妙に異なるが、まぁ大まかに）
正の個数が負の個数より多ければ $S_c$ は減らした方が得だし、負が多ければ増やした方が得で、それが均衡するところが最小となる。

一度 $S_c[i]-T_c[i]$ を計算し、その中の中央値が0になるようにオフセットを決め、その上で改めて $|S_c[i]+offset-T_c[i]|$ を求めればよい。
ただし、オフセットは6の倍数でしか決められないので、小さめに決めたものと大きめに決めたものを2通り試す。

計算量は、中央値を求めるときのソートのみ $O(N \log{N})$ かかるが、他は $O(N)$ となり、解法1より少ない定数倍で求められる。

Python3

def convert(s):
    tmp = list(map('A C B'.index, s))
    result = [tmp[0]]
    for c1, c2 in zip(tmp, tmp[1:]):
        if (c2 - c1) % 3 == 1:
            result.append(result[-1] + 1)
        else:
            result.append(result[-1] - 1)
    return result


n = int(input())
s = convert(input())
t = convert(input())
d = sorted(tc - sc for sc, tc in zip(s, t))
offset1 = d[n // 2] // 6 * 6
offset2 = offset1 + 6

ans1 = 0
ans2 = 0
for sc, tc in zip(s, t):
    ans1 += abs(sc + offset1 - tc)
    ans2 += abs(sc + offset2 - tc)

print(min(ans1, ans2) // 2)

目次

AtCoder Grand Contest 052 A,B,C,E問題メモ

A - Long Common Subsequence

問題

解法

B - Tree Edges XOR

問題

解法

C - Nondivisible Prefix Sums

問題

解法

1つめの条件

2つめの条件

E - 3 Letters

問題

解法

解法2