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$ が属する連結成分の頂点数である。理由は図を見よ。

f:id:pekempey:20171104185320g:plain
動かしていく様子

$(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;
}

ブログの分岐について

Haskell 用のブログを作ったので、Haskellはそっちに書きます。http://pekeskell.hatenadiary.jp/

Haskell: codefes 2017 qualC

D 問題が解けなかったのはまずい。何故か AtCoder だと DP じゃない気がしてくるんだよね…。

A 問題

point-free style、関数の本質を捉えてる感があって良い。

import Data.List
 
main :: IO ()
main = getLine >>= putStrLn . yesno . isInfixOf "AC"
 
yesno :: Bool -> String
yesno True = "Yes"
yesno False = "No"

B 問題

数式を書いただけ。

main :: IO ()
main = getLine >> getLine >>= print . solve . map read . words
 
solve :: [Int] -> Int
solve a = let n = length a; e = length . filter even $ a
          in 3 ^ n - 2 ^ e

C 問題

標準で Data.Sequence.Seq という deque の機能を持ったデータ構造が用意されているのでこれを使うと良い。失敗したら-∞を返そうかと思ったけど、Maybe モナドでやるのがお洒落な気がしたのでそうした。

solve を 2 つに分離させたんだけど、分離する必要はないらしい。そもそも何で分離させたのかというと、長さ 1 以下の Seq が来た時 viewl/viewr が評価されてエラーになると思ったからなんだけど、遅延評価されるから(多分?)気にしなくてよかったらしい。strict に慣れすぎてて lazy で起こる事柄は難しく感じる。

import Control.Applicative
import Data.Maybe
import qualified Data.Sequence as S
import Data.Sequence (Seq, fromList, (<|), (|>), viewl, viewr, ViewL(..), ViewR(..))
 
main = getLine >>= print . fromMaybe (-1) . solve . fromList
 
solve :: Seq Char -> Maybe Int
solve q | S.length q <= 1 = Just 0
solve q
  | l == r    = solve ms
  | l == 'x'  = succ <$> solve (q |> 'x')
  | r == 'x'  = succ <$> solve ('x' <| q)
  | otherwise = Nothing
  where
    (l :< rs) = viewl q
    (ms :> r) = viewr rs

まとめ

最近 Haskellアルゴリズムを構築するのにハマっている。アルゴリズム系は
Haskell で書くと結構きついんだけど(速度とかの最適化の面で)、使い捨てプログラムとかは python とかで書くより Haskell で書いた方が楽な気がする。