AtCoder Beginner Contest 237 E,G問題メモ

AtCoder Beginner Contest 237

E - Skiing

問題

$N$ 頂点 $M$ 辺の単純連結無向グラフ
各頂点には標高 $H_i$ が定まっている
頂点 $u$ から $v$ へ移動したとき、以下の満足度を得る
- $H_u \ge H_v$ の場合、 $H_u-H_v$
- $H_u \lt H_v$ の場合、 $2(H_u-H_v)$ （満足度が下がる）
頂点1から移動開始して好きな頂点で終了できるとき、終了までに得た満足度の総和として可能な最大値を求めよ
$2 \le N \le 2 \times 10^5$
$N-1 \le M \le 2 \times 10^5$

解法

ポテンシャルという概念の教育的問題。

満足度を正負逆転させて「コスト」とすると、最短経路問題となる。
しかし負辺を含むので、Dijkstraでは一部の意地悪なケースで計算量が増大し、 $O(2^{\frac{N}{3}})$ かかるケースが作れてしまう。

Bellman-Fordは負閉路さえ含まなければOKだが、そもそも計算量が $O(NM)$ かかる。

以下のように考える。

基本的に各頂点へのコストは、下り道しか通らなければどんな経路でも始点と終点の標高差となる。

しかし途中で登り道を通ると、2点間の標高差を $d$ として、 $d$ だけ余分にかかる。
（本来のコストは $2d$ だが、そのうち $d$ は後でまた下るときに回収されるので、追加分だけを考えると $d$ となる）

この「追加分」だけを考えれば負辺は出てこないので、Dijkstraで「各頂点に到達するのに必要な最小の追加分」を求め、それに $H_1$ からの標高差を加味することで、最小コストが求められる。

ポテンシャル

ダイクストラとポテンシャルのはなし - niuez’s diary

一般に、グラフでは以下のようにすると辺のコストを変換できる。

各頂点に、ある値 $p_i$ を決める
各辺の元のコスト $dist(u,v)$ を、 $dist'(u,v) = dist(u,v)+p_u-p_v$ に置き換える
それで求めた $s$ からの最短距離を $d'_i$ とすると、本来の答えは $d_i=d'_i+p_i-p_s$

ここで、変換後の辺が非負になるよう上手く $p_i$ を決めるには、以下の条件が満たされればよい。

全ての辺について、 $p_u+dist(u,v) \ge p_v$

結局、これを上手く求めるのが難しく、一番シンプルと思われるものが「どっかの頂点からの最短距離」となる。

最短経路探索を高速化したいのに、どっちみち最初に最短経路求めなあかんのかい！となる。
世の中そんなうまい話はなかった。

だが、以下のような場合に有効活用できる。

最短距離でなくても、 $p_u+dist(u,v) \ge p_v$ が満たされるようなグラフの性質がある
ちょっとずつ $p_u+dist(u,v) \ge p_v$ が崩れないような変更が行われるグラフ上で、何回も繰り返し最短経路を求める
- 最初の1回をBellman-Fordなどで求めてやれば、次からはそれをポテンシャルとしてDijkstraが使える

2番目は、最小費用流を求めるときなんかに使われる。

今回は1番に当てはまり、 $H_i$ を $p_i$ として使うことで、上式が全ての辺で成り立つことがわかる。

Python3

G - Range Sort Query

問題

$1～N$ の順列 $P_1,P_2,...,P_N$ が与えられる
$Q$ 個のクエリが飛んでくる
- 1 Li Ri : $P_{Li}～P_{Ri}$ を昇順にソートする
- 2 Li Ri : $P_{Li}～P_{Ri}$ を降順にソートする
最終的な順列における $X$ の位置（ $P_i=X$ である $i$ ）を求めよ
$1 \le N \le 2 \times 10^5$
$1 \le Q \le 2 \times 10^5$

解法

なるほどーと唸る上手い解法。
ソート結果全てではなくて、特定の1つの値の位置がわかればいいところがミソ。

ソートって基本的に計算量が大変だけど、シンプルにできる場合が1つある。
それは、要素が $0,1$ のみからなる場合。

$L_i～R_i$ の $1$ の数を数える＝区間の総和をとる（ $k$ とする）
昇順なら、末尾 $k$ 個を $1$ に、残りを $0$ に上書きする
- 0 1 1 0 1 0 0 1 → 0 0 0 0 1 1 1 1
降順なら、先頭 $k$ 個を $1$ に、残りを $0$ に上書きする
- 0 1 1 0 1 0 0 1 → 1 1 1 1 0 0 0 0

これも愚直にやったら間に合わないが、区間更新・区間和の取得ができればよいので、遅延評価セグメント木を使えば1回あたり $O(\log{N})$ で効率的に行える。

順列 $P$ を「 $X$ 以上なら1、未満なら0」「 $X$ より大きいなら1、以下なら0」とした2つの数列に変換すると、 2つはちょうど、 $X$ の位置だけが異なった状態となり、その性質はソートしても変わらない。

この2つで個別にクエリを処理し、結果から異なる位置を探せばよい。

Python3

        
          
          
              
              from operator import add
from typing import TypeVar, Generic, Callable, List
 
T = TypeVar('T')
U = TypeVar('U')
 
 
class LazySegmentTreeInjectable(Generic[T, U]):
    def __init__(self,
                 n: int,
                 identity_data: Callable[[], T],
                 identity_lazy: Callable[[], U],
                 operation: Callable[[T, T], T],
                 mapping: Callable[[T, U], T],
                 composition: Callable[[U, U], U],
                 ):
        self.n = n
        self.depth = n.bit_length()
        self.offset = 1 << self.depth
        self.identity_data = identity_data
        self.identity_lazy = identity_lazy
        self.operation = operation
        self.mapping = mapping
        self.composition = composition
        self.data = [identity_data() for _ in range(self.offset << 1)]
        self.lazy = [identity_lazy() for _ in range(self.offset)]
 
    @classmethod
    def from_array(cls,
                   arr: List[T],
                   identity_data: Callable[[], T],
                   identity_lazy: Callable[[], U],
                   operation: Callable[[T, T], T],
                   mapping: Callable[[T, U], T],
                   composition: Callable[[U, U], U],
                   ):
        ins = cls(len(arr), identity_data, identity_lazy, operation, mapping, composition)
        ins.data[ins.offset:ins.offset + ins.n] = arr
        for i in range(ins.offset - 1, 0, -1):
            ins.update(i)
        return ins
 
    def push(self, i: int) -> None:
        if i < self.offset:
            data = self.data
            lazy = self.lazy
            lz = lazy[i]
 
            lch = i << 1
            rch = lch + 1
            data[lch] = self.mapping(data[lch], lz)
            data[rch] = self.mapping(data[rch], lz)
            if lch < self.offset:
                lazy[lch] = self.composition(lazy[lch], lz)
                lazy[rch] = self.composition(lazy[rch], lz)
            lazy[i] = self.identity_lazy()
 
    def update(self, i: int) -> None:
        lch = i << 1
        rch = lch + 1
        self.data[i] = self.operation(self.data[lch], self.data[rch])
 
    def all_apply(self, i: int, d: U) -> None:
        self.data[i] = self.mapping(self.data[i], d)
        if i < self.offset:
            self.lazy[i] = self.composition(self.lazy[i], d)
 
    def propagate(self, l: int, r: int) -> None:
        for i in range(self.depth, 0, -1):
            if ((l >> i) << i) != l:
                self.push(l >> i)
            if ((r >> i) << i) != r:
                self.push((r - 1) >> i)
 
    def range_update(self, l: int, r: int, d: U) -> None:
        l += self.offset
        r += self.offset
        self.propagate(l, r)
 
        l2 = l
        r2 = r
        while l < r:
            if (l & 1) == 1:
                self.all_apply(l, d)
                l += 1
            if (r & 1) == 1:
                r -= 1
                self.all_apply(r, d)
            l >>= 1
            r >>= 1
        l = l2
        r = r2
 
        for i in range(1, self.depth + 1):
            if ((l >> i) << i) != l:
                self.update(l >> i)
            if ((r >> i) << i) != r:
                self.update((r - 1) >> i)
 
    def range_query(self, l: int, r: int) -> T:
        l += self.offset
        r += self.offset
 
        self.propagate(l, r)
        sml = self.identity_data()
        smr = self.identity_data()
        while l < r:
            if (l & 1) == 1:
                sml = self.operation(sml, self.data[l])
                l += 1
            if (r & 1) == 1:
                r -= 1
                smr = self.operation(self.data[r], smr)
            l >>= 1
            r >>= 1
        return self.operation(sml, smr)
 
    def point_set(self, p: int, d: T) -> None:
        p += self.offset
        for i in range(self.depth, 0, -1):
            self.push(p >> i)
        self.data[p] = d
        for i in range(1, self.depth + 1):
            self.update(p >> i)
 
    def point_get(self, p: int) -> T:
        p += self.offset
        for i in range(self.depth, 0, -1):
            self.push(p >> i)
        return self.data[p]
 
    def debug_print(self) -> None:
        i = 1
        while i <= self.offset:
            print(*map('{: 4d}'.format, self.data[i:i * 2]))
            i <<= 1
        i = 1
        while i <= self.offset:
            print(*map('{: 4d}'.format, self.lazy[i:i * 2]))
            i <<= 1
 
 
n, q, x = map(int, input().split())
ppp = list(map(int, input().split()))
 
ge_x = [(int(p >= x), 1) for p in ppp]
gt_x = [(int(p > x), 1) for p in ppp]
 
identity_data = lambda: (0, 1)
identity_lazy = lambda: -1
operation = lambda a, b: (a[0] + b[0], a[1] + b[1])
mapping = lambda a, b: a if b == -1 else (a[1] * b, a[1])
composition = lambda a, b: a if b == -1 else b
 
lst_ge = LazySegmentTreeInjectable.from_array(ge_x, identity_data, identity_lazy, operation, mapping, composition)
lst_gt = LazySegmentTreeInjectable.from_array(gt_x, identity_data, identity_lazy, operation, mapping, composition)
 
for _ in range(q):
    c, l, r = map(int, input().split())
    l -= 1
    r -= 1
    if c == 1:
        s, _ = lst_ge.range_query(l, r + 1)
        lst_ge.range_update(l, r - s + 1, 0)
        lst_ge.range_update(r - s + 1, r + 1, 1)
        s, _ = lst_gt.range_query(l, r + 1)
        lst_gt.range_update(l, r - s + 1, 0)
        lst_gt.range_update(r - s + 1, r + 1, 1)
    else:
        s, _ = lst_ge.range_query(l, r + 1)
        lst_ge.range_update(l, l + s, 1)
        lst_ge.range_update(l + s, r + 1, 0)
        s, _ = lst_gt.range_query(l, r + 1)
        lst_gt.range_update(l, l + s, 1)
        lst_gt.range_update(l + s, r + 1, 0)
 
for i in range(n):
    if lst_ge.point_get(i) != lst_gt.point_get(i):
        print(i + 1)
        break
else:
    raise NotImplementedError

            

        
      

全ソート結果

特定の1つに絞らなくても、実装は複雑になるが、Binary Trieでsplitとmergeを繰り返すことで $O((N+Q) \log{N})$ で可能らしい。

keijakさんはTwitterを使っています「ABC-G で X が最初にひとつ与えられるのではなく最終的な順列を全部出力するように一般化した問題が O((N+Q)logN) で解けたと思うんだけど誰にも言及されてないな。嘘か？」 / Twitter