ARC086 E問題 Smuggling Marbles

E: Smuggling Marbles - AtCoder Regular Contest 086 | AtCoder

解法

縮約解について説明する。よく考えるとマージテク解と本質的に同じ。

深さが等しい頂点をまとめて計算できるのは自明だと思いたい。普通にやると$O(depth\times n)$ だが、各深さごとに木を縮約してあげると $O(n \log n+ n\log (10^9+7))$ で解ける。

縮約するとなぜ計算量が落ちるのかというと、内部節点がかならず分岐を持つ木であれば、内部節点の個数は葉の個数より少ないためである。

内部節点の個数の評価は二分木で有名だろう。一応説明する。

証明（内部節点の個数の評価）

葉と隣接する内部節点をひとつ選び、それを改めて葉に置き直す操作を考える（図を参照）。頂点がひとつになるまでこの操作を繰り返すと、その回数は内部節点の個数と一致する。この操作によって葉は少なくとも一つ減るため、（内部節点の個数）＜（葉の個数）であることが言える。（証明終わり）

ソースコード

縮約解：https://arc086.contest.atcoder.jp/submissions/1864868
マージテク解：https://arc086.contest.atcoder.jp/submissions/1864696

感想

縮約すると計算量が落ちるのには気がついたのだけど、縮約の仕方がまずかったみたいでコンテスト中には通せなかった。縮約は post-order に並べて隣接要素の LCA を取っていくと良いのだが、変な方法でやろうとして失敗した。

CSA #60 E問題

Rust で書き直したのだが Rust で提出できなかった。そういえばクロージャの再帰ってできるんだろうか。グラフを引数に渡すのくどい。

パスを交差させる必要はなくて、互いに素なものだけ考慮すれば良い。これは適当な木DPで解ける――具体的には、状態を(dp0: 親と繋がない)(dp1:親と繋ぐ)として値を (パス数, パス長) とすれば良い。

macro_rules! input {
  ($($x:ident : $t:ty), *) => {
    $(let $x: $t;)*
    {
      let mut s = String::new();
      std::io::stdin().read_line(&mut s).unwrap();
      let mut it = s.trim().split_whitespace();
      $($x = it.next().unwrap().parse().unwrap();)*
      assert!(it.next().is_none());
    }
  };
}

fn dfs(u: usize, p: usize, g: &Vec<Vec<(usize, i32)>>) -> ((i32, i32), (i32, i32)) {
  use std::cmp;

  let mut dp0 = (0, 0);
  let mut dp1 = (1, 0);

  for &(v, c) in &g[u] {
    if v == p { continue }
    let (ep0, ep1) = dfs(v, u, g);

    let x0 = (dp0.0 + ep0.0    , dp0.1 + ep0.1);
    let y0 = (dp1.0 + ep0.0    , dp1.1 + ep0.1);
    let x1 = (dp1.0 + ep1.0 - 1, dp1.1 + ep1.1 + 1);
    let y1 = (dp0.0 + ep1.0    , dp0.1 + ep1.1 + 1);

    if c == 0 {
      dp0 = x0;
      dp1 = y0;
    } else if c == 1 {
      dp0 = x1;
      dp1 = y1;
    } else {
      dp0 = cmp::min(x0, x1);
      dp1 = cmp::min(y0, y1);
    }
  }
  (dp0, dp1)
}

fn main() {
  input!(n: usize);

  let mut g: Vec<Vec<(usize, i32)>> = vec![Vec::new(); n];

  for _ in 1..n {
    input!(a: usize, b: usize, c: i32, d: i32);
    let a = a - 1;
    let b = b - 1;
    let d = if d != 2 { c ^ d } else { d };
    g[a].push((b, d));
    g[b].push((a, d));
  }

  let ((x, y), _) = dfs(0, n, &g);
  println!("{} {}", x, y);
}

ARC 085 F

http://arc085.contest.atcoder.jp/tasks/arc085_d

愚直な DP 解を示す。DP の値には一致した文字数を格納してあり、状態は(位置、最後に使った区間番号)としている。0 番目に番兵として区間 [-1,-1] を入れている。

int dp[100][101];

void to(int &x, int y) {
  x = max(x, y);
}

int main() {
  int n;
  cin >> n;

  vector<int> b(n);
  for (int i = 0; i < n; i++) {
    cin >> b[i];
  }

  int q;
  cin >> q;

  vector<int> l(q + 1), r(q + 1);
  l[0] = -1;
  r[0] = -1;
  for (int i = 1; i <= q; i++) {
    cin >> l[i] >> r[i];
    l[i]--;
    r[i]--;
  }
  q++;

  fill_n(*dp, 100 * 101, -1e9);
  dp[0][0] = 0;

  for (int i = 0; i < n; i++) {
    for (int j = 0; j < q; j++) {
      for (int k = 0; k < q; k++) {
        if (l[k] == i && r[j] <= r[k]) {
          to(dp[i + 1][k], dp[i][j] + b[i]);
        }
      }
      if (i <= r[j]) {
        to(dp[i + 1][j], dp[i][j] + b[i]);
      } else {
        to(dp[i + 1][j], dp[i][j] + !b[i]);
      }
    }
  }

  int ans = 0;
  for (int i = 0; i < q; i++) {
    ans = max(ans, dp[n][i]);
  }
  cout << n - ans << endl;
}

区間を右端でソートすることで、DP の性質が良くなる。

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
 
using namespace std;
 
const int N = 1 << 18;
const int inf = 1.01e9;
int dat[N * 2];
int lz[N * 2];
 
void apply(int k, int v) {
  dat[k] += v;
  lz[k] += v;
}
 
void push(int k) {
  apply(k * 2 + 0, lz[k]);
  apply(k * 2 + 1, lz[k]);
  lz[k] = 0;
}
 
void setval(int y, int v, int k = 1, int ll = 0, int rr = N) {
  if (rr - ll == 1) {
    dat[k] = v;
    lz[k] = 0;
    return;
  }
  push(k);
  int mm = ll + rr >> 1;
  if (y < mm) {
    setval(y, v, k * 2 + 0, ll, mm);
  } else {
    setval(y, v, k * 2 + 1, mm, rr);
  }
  dat[k] = max(dat[k * 2], dat[k * 2 + 1]);
}
 
void update(int l, int r, int v, int k = 1, int ll = 0, int rr = N) {
  if (rr <= l || r <= ll) return;
  if (l <= ll && rr <= r) {
    apply(k, v);
    return;
  }
  push(k);
  update(l, r, v, k * 2 + 0, ll, ll + rr >> 1);
  update(l, r, v, k * 2 + 1, ll + rr >> 1, rr);
  dat[k] = max(dat[k * 2], dat[k * 2 + 1]);
}
 
int query(int l, int r, int k = 1, int ll = 0, int rr = N) {
  if (rr <= l || r <= ll) return -inf;
  if (l <= ll && rr <= r) return dat[k];
  push(k);
  return max(query(l, r, k * 2, ll, ll + rr >> 1), query(l, r, k * 2 + 1, ll + rr >> 1, rr));
}
 
int main() {
  int n;
  cin >> n;
 
  vector<int> b(n);
  for (int i = 0; i < n; i++) {
    cin >> b[i];
  }
 
  int q;
  cin >> q;
 
  vector<pair<int, int>> rl(q + 1);
  rl[0].first = 0;
  rl[0].second = 0;
  for (int i = 1; i <= q; i++) {
    cin >> rl[i].second >> rl[i].first;
  }
  sort(rl.begin(), rl.end());
  q++;
 
  vector<int> l(q), r(q);
  vector<vector<int>> foo(n);
  for (int i = 0; i < q; i++) {
    l[i] = rl[i].second - 1;
    r[i] = rl[i].first - 1;
    if (l[i] >= 0) 
      foo[l[i]].push_back(i);
  }
 
  update(1, q, -inf);
 
  int u = 0;
 
  for (int i = 0; i < n; i++) {
    vector<int> hoge;
    for (int j = 0; j < foo[i].size(); j++) {
      // r[t] > r[k]
      int t = upper_bound(r.begin(), r.end(), r[foo[i][j]]) - r.begin();
      hoge.push_back(query(0, t));
    }
 
    for (int j = 0; j < foo[i].size(); j++) {
      setval(foo[i][j], hoge[j]);
    }
    while (u < q && r[u] < i) {
      u++;
    }
    update(0, u, !b[i]);
    update(u, q, b[i]);
  }
 
  int ans = query(0, q);
  cout << n - ans << endl;
}

ARC 084 F XorShift

http://arc084.contest.atcoder.jp/tasks/arc084_d

多項式への言い換えが気持ちがいい問題だった。多項式は気持ちがいい。

#include <iostream>
#include <algorithm>
#include <vector>
 
using namespace std;

const long long mod = 998244353;

string gcd(string a, string b) {
  while (true) {
    if (a.size() < b.size()) swap(a, b);
    for (int i = 0; i < b.size(); i++) {
      a[i] ^= b[i];
    }
    int pos = a.find(1);
    if (pos == string::npos) return b;
    a.erase(0, pos);
  }
}

string input() {
  string s;
  cin >> s;
  for (char &c : s) c -= '0';
  return s;
}

long long modpow(long long x, long long y) {
  long long ret = 1;
  while (y > 0) {
    if (y & 1) ret = ret * x % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return ret;
}

int main() {
  int n;
  cin >> n;
  string x = input();
  string g = input();
  for (int i = 1; i < n; i++) {
    g = gcd(g, input());
  }

  long long ans = 0;
  string curr(x.size(), 0);
  for (int i = 0; i + g.size() <= x.size(); i++) {
    if (curr[i] == 0 && x[i] == 0) {
      // can't use
    } else if (curr[i] == 1 && x[i] == 0) {
      for (int j = 0; j < g.size(); j++) {
        curr[i + j] ^= g[j];
      }
    } else if (curr[i] == 0 && x[i] == 1) {
      for (int j = 0; j < g.size(); j++) {
        curr[i + j] ^= g[j];
      }
      ans += modpow(2, x.size() - i - g.size());
      ans %= mod;
    } else if (curr[i] == 1 && x[i] == 1) {
      ans += modpow(2, x.size() - i - g.size());
      ans %= mod;
    }
  }
  if (curr <= x) {
    ans++;
    ans %= mod;
  }
  
  cout << ans << endl;
}

yukicoder No.590 Replacement

実装が結構大変。

https://yukicoder.me/problems/no/590

解法

順列なので辺 $ i \to A_i$ のグラフを考えよう。このようなグラフはサイクルの集まりになることに注意したい。

\( (x,y) \to (i,i) \) と考えるのではなく、逆向きの操作を考えて、\( (i,i) \to (x,y) \) となる対 \( (x,y) \) の数を数えることにする。

もし \( (i,i) \to (j,j) \) となるような \(j\) が存在しなければ、\( (i,i) \to (x,y) \) となる対 \((x,y)\) の個数はサイクル長の LCM である。個数が $n$ ならコストは $n(n-1)/2$ であるから、個数を求めることが本質である。存在するときが難しい。

まず問題になるのは \( (i,i) \) と \( (j,j) \) の連結性判定である。よって次は連結性判定について考える。

辺 $A_i \to i$ で構成されたグラフを $A$、辺 $B_i \to i$ で構成されたグラフを $B$ とする。グラフ $G$ において、頂点 $i$ が属する連結成分の代表頂点を $[i]_G$ と書くことにすると、少なくとも連結であるためには $([i]_A,[i]_B) = ([j]_A,[j]_B)$ である必要がある。$(i,i)$ と $(j,j)$ が連結である条件はもう一つある。各サイクルに 0 から順に通し番号を割り振る。$(i)_G$ を頂点 $i$ に振られた番号だとすると $(i)_B-(i)_A \equiv (j)_B-(j)_A \pmod{\gcd(n, m)}$ が必要である。ここで $n$, $ m $ はそれぞれ頂点 $i$, $j$ が属する連結成分の頂点数である。理由は図を見よ。

動かしていく様子

$(A,A)\to(B,B)\to(C,C)\to(A,A)\to\cdots$ となり、ラベル差が不変になっていることが分かる。またラベル差が等しい組は、一方から一方へ必ず到達できることも確認できる（大きなグループでみると互いに素であるため）。

条件をまとめると、

• $([i]_A,[i]_B) = ([j]_A,[j]_B)$
• $(i)_B-(i)_A \equiv (j)_B-(j)_A \pmod{\gcd(n, m)}$

となる。まずこの条件を用いて $(i,i)$ を分類する。

次に $(i,i) \to (j,j)$ に何手で到達できるかを求める。いま $(x_1,x_1), (x_2,x_2), \ldots, (x_s, x_s)$ が連結だったとする。中国剰余定理により $(x_i, x_i)$ に対応する $z_i$ が存在し、$z_i$ でソートすることで、$(x_k,x_k)$ の次の頂点対が分かる。さらに $z$ の差を見ることで距離も同時に分かる。以上より解くことが出来た。

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>

using namespace std;

const long long mod = 1e9 + 7;

long long gcd(long long x, long long y) {
  if (y == 0) return x;
  return gcd(y, x % y);
}

long long lcm(long long x, long long y) {
  return x / gcd(x, y) * y;
}

vector<vector<int>> cycle(vector<int> a) {
  const int n = a.size();
  vector<vector<int>> ret(n);
  vector<bool> vis(n);
  for (int i = 0; i < n; i++) {
    if (vis[i]) continue;
    for (int k = i; !vis[k]; k = a[k]) {
      ret[i].push_back(k);
      vis[k] = true;
    }
  }
  return ret;
}

long long modinv(long long a, long long m) {
  long long b = m, x = 1, y = 0;
  while (b != 0) {
    long long q = a / b;
    a -= b * q;
    x -= y * q;
    std::swap(a, b);
    std::swap(x, y);
  }
  return x < 0 ? x + m : x;
}

long long crt(long long a1, long long m1, long long a2, long long m2) {
  long long v = (a2 - a1) * modinv(m1, m2) % m2;
  if (v < 0) v += m2;
  return a1 + v * m1;
}

map<long long, int> factors(long long n) {
  map<long long, int> ret;
  for (int i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      ret[i]++;
      n /= i;
    }
  }
  if (n != 1) ret[n] = 1;
  return ret;
}

int power(int a, int b) {
  int ret = 1;
  for (int i = 0; i < b; i++) {
    ret *= a;
  }
  return ret;
}

long long crt_g(long long a1, long long m1, long long a2, long long m2) {
  auto f1 = factors(m1);
  auto f2 = factors(m2);
  int M1 = 1;
  int M2 = 1;
  set<int> st;
  for (auto kv : f1) st.insert(kv.first);
  for (auto kv : f2) st.insert(kv.first);
  for (int k : st) {
    if (f1[k] >= f2[k]) {
      M1 *= power(k, f1[k]);
    } else {
      M2 *= power(k, f2[k]);
    }
  }
  return crt(a1 % M1, M1, a2 % M2, M2);
}

int main() {
  int n;
  cin >> n;

  vector<int> a(n), b(n);
  for (int i = 0; i < n; i++) {
    scanf("%d", &a[i]);
    a[i]--;
  }
  for (int i = 0; i < n; i++) {
    scanf("%d", &b[i]);
    b[i]--;
  }
  vector<vector<int>> cycleA = cycle(a);
  vector<vector<int>> cycleB = cycle(b);

  vector<int> rootA(n), rootB(n);
  vector<int> xa(n), xb(n);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < cycleA[i].size(); j++) {
      xa[cycleA[i][j]] = j;
      rootA[cycleA[i][j]] = i;
    }
    for (int j = 0; j < cycleB[i].size(); j++) {
      xb[cycleB[i][j]] = j;
      rootB[cycleB[i][j]] = i;
    }
  }

  map<pair<int, int>, vector<int>> mp;
  for (int i = 0; i < n; i++) {
    mp[make_pair(rootA[i], rootB[i])].push_back(i);
  }
  long long ans = 0;
  for (auto kv : mp) {
    int A = kv.first.first;
    int B = kv.first.second;
    int lenA = cycleA[A].size();
    int lenB = cycleB[B].size();
    long long G = gcd(lenA, lenB);
    long long L = lcm(lenA, lenB);

    map<int, vector<int>> mp2;
    for (int i : kv.second) {
      int d = (xb[i] - xa[i]) % G;
      if (d < 0) d += G;
      mp2[d].push_back(i);
    }

    for (auto kv2 : mp2) {
      vector<long long> xs;
      for (int i : kv2.second) {
        int x = xa[i];
        int y = xb[i] - kv2.first;
        if (y < 0) y += lenB;
        xs.push_back(crt_g(x, lenA, y, lenB));
      }
      sort(xs.begin(), xs.end());
      xs.push_back(xs[0] + L);
      for (int i = 0; i + 1 < xs.size(); i++) {
        long long d = (xs[i + 1] - xs[i]) % mod;
        ans += d * (d + mod - 1) % mod * ((mod + 1) / 2);
        ans %= mod;
      }
    }
  }

  cout << ans << endl;
}