けんちょんの競プロ精進記録

競プロの精進記録や小ネタを書いていきます

AtCoder ABC 187 D - Choose Me (茶色, 400 点)

ペア  (A+B, A) の大きい順にソートする嘘貪欲にハマってしまった方が多そうだった

問題概要

青木君と高橋君が選挙を行う。 N 個の町があり、 i 番目の町では

  • 青木派が  A_{i} 人いる
  • 高橋派が  B_{i} 人いる

ということがわかっている。高橋君はいくつかの町で選挙活動を行う。

  • 高橋君が選挙活動を行わない町では、青木君が  A_{i} 票を獲得し、高橋君が 0 票を獲得する (高橋派は怠惰)
  • 高橋君が選挙活動を行う町では、青木君が 0 票を獲得し、高橋君が  A_{i} + B_{i} 票を獲得する (青木派は裏切り者)

高橋君が青木君よりも多く票を獲得するようにしたい。高橋君が選挙活動を行うべき町の個数の最小値を求めよ。

制約

  •  1 \le N \le 2 \times 10^{5}

考えたこと

高橋君は演説をしないと、まったく票をもらえないのねw

まず題意を把握するのに時間がかかった。こういう風に  N 個の対象物 (今回は町) それぞれに対して、二つの「属性」(今回は青木派人数と高橋派人数) が与えられるような問題は、独特の思考を要することが多い。たとえば今回でいえば

  • 高橋君の得票数を増やしたいので  A_{i} + B_{i} が大きいところを優先的に選挙したい
  • 青木君の得票数を減らしたいので  A_{i} が大きいところを優先的に選挙したい

という 2 つの価値観があるのだ。このように、二つの「属性」が登場する問題では、相異なる 2 つの価値観に基づく順序付けが登場して、そのジレンマに悩まされることが多い。

嘘解法:ペア  (A+B, A) でソート

上のようなジレンマから、次のような解法を考えた方が多かったようだ。


 A+B が大きい順に選挙活動する、ただし  A+B が等しい町同士では  A が大きい順に選挙活動する


つまり、ペア  (A+B, A) をキー (辞書順比較) として大きい順にソートするということだ。しかしこれは嘘だ。たとえば

  •  (A, B) = (10, 90), (20, 79), (81, 17)

を考えてみよう。上記の価値観に沿うと、 (10, 90), (20, 79), (81, 17) の順に演説に行きたくなる (総和が 100, 99, 98)。このとき

  •  (10, 90) の町に行っただけでは「高橋君: 100、青木君: 101」となってダメ

でも実際には

  •  (20, 79) の町に 1 個行くだけで、「高橋君: 99、青木君: 91」となるので OK

となっている。

正しくは

まず高橋君がどこにも演説に行かない場合を考えてみよう。このとき、 A_{i} の総和を  S として、

「高橋君: 0、青木君:  S

となる。このとき、 (A_{i}, B_{i}) で表される町へいくと

「高橋君:  A_{i} + B_{i}、青木君:  S - A_{i}

となる。このとき、青木君と高橋君との差がどのくらい縮まったのかに着目しよう。

  • 高橋君の票数は  A_{i} + B_{i} だけ増えた
  • 青木君の票数は  A_{i} だけ減った

ということで、差に着目すると

 (A_{i} + B_{i}) - (- A_{i}) = 2 A_{i} + B_{i}

だけ縮まることになるのだ (before の状態に依らない)。つまり、


  • 最初の「差」は  S である
  •  i で選挙すると、「差」は  2 A_{i} + B_{i} だけ減少する

ということがわかった。ここまで来ると簡単だ。 2 A_{i} + B_{i} が大きい方から順に選挙へ行けばよいのだ!!!

このように、2 つの属性値を扱う問題では、「差」に着目するとよいことがあったりする!!

コード

 2 A_{i} + B_{i} が大きい順にソートするので、計算量は  O(N \log N) となる。

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N;
    cin >> N;
    vector<long long> A(N), B(N);
    for (int i = 0; i < N; ++i) cin >> A[i] >> B[i];

    // ソート
    vector<int> ids(N);
    iota(ids.begin(), ids.end(), 0);
    sort(ids.begin(), ids.end(), [&](int i, int j) {
            return A[i]*2+B[i] > A[j]*2+B[j];
        });

    // 2A[i] + B[i] が大きい順に「差」を減らしていく
    long long diff = 0;
    for (int i = 0; i < N; ++i) diff += A[i];
    int res = 0;
    for (auto i: ids) {
        ++res;
        diff -= A[i]*2 + B[i];
        if (diff < 0) break;
    }
    cout << res << endl;
}

AtCoder ABC 187 E - Through Path (水色, 500 点)

これの応用問題って感じだった!!

drken1215.hatenablog.com

問題概要

頂点数  N の木が与えられる。 i (= 0, 1, \dots, N-2) 番目の辺は頂点  A_{i} と頂点  B_{i} とを結んでいる。はじめ、各頂点には、値 0 が書き込まれている。以下の  Q 個のクエリを処理したあとの、各頂点に書き込まれた値を求めよ。

  • クエリタイプ 1:辺番号  i と、値  x が与えられる。頂点  A_{i} から出発して頂点  B_{i} を通過することなくたどり着けるすべての頂点の値を  x だけ増やす
  • クエリタイプ 2:辺番号  i と、値  x が与えられる。頂点  B_{i} から出発して頂点  A_{i} を通過することなくたどり着けるすべての頂点の値を  x だけ増やす

制約

  •  N, Q \le 2 \times 10^{5}

考えたこと

単純化した次の問題を考えてみよう。

  • 与えられた木は根付き木であるとする
  • 各クエリでは、頂点  v を根とする部分木に含まれるすべての頂点の値を  x だけ増やす

この問題は実は過去問にそっくりそのままある!

drken1215.hatenablog.com

今回は、ちょっと応用問題と言える。というのも、まず与えられる木に根は指定されていない。よってまずは適当な頂点 (たとえば頂点 0) を根とした根付き木にしてしまおう。そして、クエリタイプ 1, 2 はいずれも、以下の 2 つの場合のいずれかの処理を行うことになる。


二頂点  p, v があって、 p v の親であるとする。

  • パターン 1: v を根とする根付き木全体に  x を足す
  • パターン 2: v を根とする根付き木以外の頂点に  x を足す


もともとのクエリタイプ 1, 2 が、このパターン 1, 2 にそのまま対応するとは限らない。いずれにしても、上に述べた 2 パターンのいずれかになる。

パターン 2 をパターン 1 へ帰着

さて、上のパターン 1 だけならば、まさに過去問の通りに解ける。パターン 2 があるのが厄介だ。しかしよく考えてみると、下図のように、パターン 2 はパターン 1 に帰着できるのだ!!!

つまり、パターン 2 は

  • すべての頂点に  x を足す (別途保持しておいて最後にまとめて足す)
  • 頂点  v を根とする根付き木全体に  -x を足す (パターン 1 と同じ処理)

というふうにすることで、結局すべてパターン 1 に帰着できる。

パターン 1

パターン 1 は、まさに次の問題そのものなので、以下の記事参照!

drken1215.hatenablog.com

コード

計算量は  O(N + Q) になる。

#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;

int main() {
    int N;
    cin >> N;
    Graph G(N);
    vector<int> A(N-1), B(N-1);
    for (int i = 0; i < N-1; ++i) {
        cin >> A[i] >> B[i];
        --A[i], --B[i];
        G[A[i]].push_back(B[i]);
        G[B[i]].push_back(A[i]);
    }

    // DFS (根付き木にするのと、累積和をとるのを使い回す)
    int root = 0;
    vector<int> par(N, -1); // par[v]: 頂点 v の親
    vector<long long> add(N, 0);
    auto dfs = [&](auto self, int v, int p) -> void {
        par[v] = p;
        if (p != -1) add[v] += add[p];
        for (auto nv: G[v]) {
            if (nv == p) continue;
            self(self, nv, v);
        }
    };
    dfs(dfs, root, -1);

    // クエリ処理
    long long offset = 0;
    int Q;
    cin >> Q;
    while (Q--) {
        int type, id, v;
        cin >> type >> id >> v;
        --id;
        
        int a = A[id], b = B[id];
        if (type == 1) swap(a, b);
        
        if (par[b] == a) add[b] += v;
        else  add[a] -= v, offset += v;
    }
    
    // 累積和をとる
    dfs(dfs, root, -1);
    for (auto v: add) cout << v+offset << endl;    
}

AtCoder ABC 187 F - Close Group (青色, 600 点)

 O(3^{N}) な bit DP としてよく知られている問題ですね!

EDPC U - Grouping の類題と言える!

atcoder.jp

問題概要

頂点数  N、辺数  M の単純無向グラフが与えられる。頂点集合を、いくつかの頂点部分集合に分割したい。ただし、分割してできる各部分グラフがいずれもクリークとなるようにしたい。

分割されたグループの個数の最小値を求めよ。

制約

  •  1 \le N \le 18

解法 (1): O(3^{N}) の bit DP

こんな bit DP をすれば OK!!!

  • dp[bit] ← bit に対応する頂点集合をいくつかのクリークに分割するとき、分割されたクリークの個数の最小値

そして遷移は次の通り。

// 頂点集合 add が、bit と共通要素を持たず、クリークであるとする
chmin(dp[bit | add], dp[bit] + 1);

これは一見すると、bit が  2^{N} 通りあって、そのそれぞれに対して add が  O(2^{N}) 通りあって、全体で  O(4^{N}) 通りに思えてしまうかもしれない。しかし実はちゃんと解析すると  O(3^{N}) となって十分間に合うのだ。具体的には

add は、bit の補集合の部分集合しか動かない

という点に着目する。実装上はこんな感じにできる。ここで、「部分集合の部分集合を列挙する方法」を活用している。

for (int bit = 0; bit < (1<<N); ++bit) {
    int cbit = (1<<N) - 1 - bit; // 補集合
    for (int add = cbit; ; add = (add-1) & cbit) {
        if (!add) break;

        // 頂点集合 add がクリークかどうかを表す配列 ok を予め求めておく
        if (ok[add]) chmin(dp[bit|add], dp[bit] + 1);
    }
}

この処理の計算量が  O(3^{N}) であることを示そう。実は簡単だ。(bit, add) のとりうる値は次のように考えると  3^{N} 通りしかない。各頂点  i = 0, 1, \dots, N-1 について、

  • 頂点  i は頂点集合 bit に含まれる
  • 頂点  i は頂点集合 bit に含まれないが、頂点集合 add に含まれる
  • 頂点  i は頂点集合 bit, add のいずれにも含まれない

という 3 パターンしかない。したがって、考えられる状況は  3^{N} 通りなのだ。以上から、今回の bit DP の計算量が  O(3^{N}) であることがわかった。

コード

前処理として、以下の配列を求めている。

  • ok[bit] ← 頂点集合 bit がクリークかどうか
#include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> G(N, vector<int>(N, false));
    for (int i = 0; i < M; ++i) {
        int a, b; cin >> a >> b; --a, --b;
        G[a][b] = G[b][a] = true;
    }

    vector<bool> ok(1<<N, true);
    for (int bit = 0; bit < (1<<N); ++bit) {
        vector<int> vs;
        for (int i = 0; i < N; ++i) if (bit & (1<<i)) vs.push_back(i);
        for (int i = 0; i < vs.size() && ok[bit]; ++i) {
            for (int j = i+1; j < vs.size() && ok[bit]; ++j) {
                if (!G[vs[i]][vs[j]]) ok[bit] = false;
            }
        }
    }

    const int INF = 1<<29;
    vector<int> dp(1<<N, INF);
    dp[0] = 0;
    for (int bit = 0; bit < (1<<N); ++bit) {
        if (dp[bit] >= INF) continue;
        int cbit = (1<<N) - 1 - bit;
        for (int add = cbit; ; add = (add-1) & cbit) {
            if (!add) break;
            if (ok[add]) chmin(dp[bit|add], dp[bit] + 1);
        }
    }
    cout << dp[(1<<N)-1] << endl;
}

解法 (2):補グラフの彩色数

クリークといえば、補グラフをとれば「安定集合」になる。安定集合とは、

「頂点集合の部分集合であって、どの 2 頂点間にも辺がないようなもの」

のことを指す。クリークを見たら補グラフをとるのはありかもしれない。さて、もとのグラフで同一のグループの頂点は同じ色で塗り、異なるグループの頂点は異なる色で塗るとしたとき、

  • もとのグラフで条件を満たしている場合、同じ色の頂点間にはすべて辺があるので、補グラフでは辺彩色 (同じ色の頂点間には辺がない) になっている
  • 補グラフで辺彩色になっている場合、同じ色の頂点間にはすべて辺がないので、もとのグラフでは同じ色の頂点間にはすべて辺がある

というふうになっている。つまり、補グラフの彩色数を求めれば OK。補グラフの彩色数は次の記事で書いた。計算量は  O(N2^{N}) でできる!

drken1215.hatenablog.com

コード

#include <bits/stdc++.h>
using namespace std;

// 彩色数
long long modpow(long long a, long long n, long long MOD) {
    long long res = 1;
    while (n > 0) {
        if (n & 1) res = res * a % MOD;
        a = a * a % MOD;
        n >>= 1;
    }
    return res;
}
int chromatic_number(const vector<vector<int> > &G) {
    const int MOD = 1000000007;
    int n = (int)G.size();
    vector<int> neighbor(n, 0);
    for (int i = 0; i < n; ++i) {
        int S = (1<<i);
        for (int j = 0; j < n; ++j)
            if (G[i][j])
                S |= (1<<j);
        neighbor[i] = S;
    }
    
    // I[S] := #. of inndepndet subset of S
    vector<int> I(1<<n);
    I[0] = 1;
    for (int S = 1; S < (1<<n); ++S) {
        int v = __builtin_ctz(S);
        I[S] = I[S & ~(1<<v)] + I[S & ~neighbor[v]];
    }
    int low = 0, high = n;
    while (high - low > 1) {
        int mid = (low + high) >> 1;
        
        // g[S] := #. of "k independent sets" which cover S just
        // f[S] := #. of "k independent sets" which consist of subseta of S
        // then
        //   f[S] = sum_{T in S} g(T)
        //   g[S] = sum_{T in S} (-1)^(|S|-|T|)f[T]
        long long g = 0;
        for (int S = 0; S < (1<<n); ++S) {
            if ((n - __builtin_popcount(S)) & 1) g -= modpow(I[S], mid, MOD);
            else g += modpow(I[S], mid, MOD);
            g = (g % MOD + MOD) % MOD;
        }
        if (g != 0) high = mid;
        else low = mid;
    }
    return high;
}

int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> G(N, vector<int>(N, 1));
    for (int i = 0; i < M; ++i) {
        int a, b; cin >> a >> b; --a, --b;
        G[a][b] = G[b][a] = 0;
    }
    cout << chromatic_number(G) << endl;
}

JOI 本選 2007 D - 最悪の記者 (AOJ 0519, 難易度 7)

トポロジカルソートせよ、という問題!

問題概要

頂点数  N、辺数  M の DAG (閉路のない単純有向グラフ) が与えられる。

このグラフのトポロジカルソート順を一つ求めよ。また、トポロジカルソート順が唯一かどうかを判定せよ。

制約

  •  1 \le N \le 5000
  •  1 \le M \le 10^{5}

考えたこと

まずトポロジカルソート自体は次の記事に書いた!

  • DFS でやるやつ

qiita.com

  • BFS でやるやつ

qiita.com

一意性の方をちょっと考えてみよう!

トポロジカルソートが一意となる条件とは

まずトポロジカルソートとは、下図のように、各頂点を辺の向きに沿うように一列に並べることである。

上の並び替え方は一意ではない。下図のような並び替え方もできる。

一般に、トポロジカルソート順  v_{1}, v_{2}, \dots, v_{N} において、ある連続する 2 要素  v_{i}, v_{i+1} の間に辺がないとき、その 2 要素を入れ替えることができてしまう!!!!!

逆に、すべての連続する 2 要素  v_{i}, v_{i+1} の間に辺があるとき、順序が一意に確定する!!!!!!

よって、解法としては以下のとおり。


  • トポロジカルソート順を 1 つ求める
  • その順序に沿って辺がすべてあるかどうかを判定する

計算量は  O(N+M)

コード 1 (DFS バージョン)

#include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using Graph = vector<vector<int>>;

int main() {
    int N, M;
    cin >> N >> M;
    Graph G(N);
    set<pint> edges;
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        --u, --v;
        G[u].push_back(v);
        edges.insert(pint(u, v));
    }

    // ord: 実際に並び替えられた順序
    vector<int> ord, seen(N, false);
    auto dfs = [&](auto self, int v) -> void {
        seen[v] = true;
        for (auto nv: G[v]) if (!seen[nv]) self(self, nv);
        ord.push_back(v);
    };
    for (int v = 0; v < N; ++v) if (!seen[v]) dfs(dfs, v);
    reverse(ord.begin(), ord.end());

    // 出力
    bool unique = true;
    for (int i = 0; i+1 < ord.size(); ++i) {
        if (!edges.count(pint(ord[i], ord[i+1]))) unique = false;
    }
    for (auto v: ord) cout << v+1 << endl;
    cout << (unique ? 0 : 1) << endl;
}   

コード 2 (BFS バージョン)

#include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using Graph = vector<vector<int>>;

int main() {
    int N, M;
    cin >> N >> M;
    Graph G(N);
    vector<int> deg(N, 0); // 出次数
    set<pint> edges;
    for (int i = 0; i < M; ++i) {
        int u, v;
        cin >> u >> v;
        --u, --v;
        G[v].push_back(u); // 逆向きに辺を張っておく
        deg[u]++;
        edges.insert(pint(u, v));
    }

    // 出次数が 0 の頂点から後退解析していく
    vector<int> ord, finished(N, false);
    queue<int> que;
    for (int v = 0; v < N; ++v) if (deg[v] == 0) que.push(v);
    while (!que.empty()) {
        int v = que.front();
        que.pop();
        finished[v] = true;
        ord.push_back(v);
        for (auto nv: G[v]) {
            if (finished[nv]) continue;
            deg[nv]--;
            if (deg[nv] == 0) que.push(nv);
        }
    }
    reverse(ord.begin(), ord.end());

    // 出力
    bool unique = true;
    for (int i = 0; i+1 < ord.size(); ++i) {
        if (!edges.count(pint(ord[i], ord[i+1]))) unique = false;
    }
    for (auto v: ord) cout << v+1 << endl;
    cout << (unique ? 0 : 1) << endl;
}   

AtCoder ABC 170 D - Not Divisible (緑色, 400 点)

数列をヒストグラム化することで解決できるタイプの問題!特に今回みたいに、数値の値も  10^{6} 以下と小さい場合はすごくそれっぽい!

問題概要

長さが  N の正の整数からなる数列  A_{1}, \dots, A_{N} が与えられる。以下の条件を満たす  i の個数を求めよ。

  •  j \neq i なる任意の  j に対して、 A_{i} A_{j} の倍数ではない

制約

  •  1 \le N \le 2 \times 10^{5}
  •  1 \le A_{i} \le 10^{6}

考えたこと

数列  A を次のような配列に変換して考えるのは、割とよくやっても良さそうな気がする。

  • num[v] ← 数列  A の中に  v が何個あるか

このように変換したとき、サイズ  N に関する問題から、サイズ  V に関する問題へと変わる ( V を登場する最大値とする)。このように変換してあげた方が解きやすいことも多い。

さて、今回の問題を解くにあたっては、エラトステネスの篩と同じような方法でやると良さそう。こんな感じ。

int V = 1000000;
vector<bool> ok(V, true);
for (int d = 1; d < MAX; ++d) {
     if (v[d] == 0) continue;
     if (v[d] > 1) v[d] = 0;
  
     // d の倍数を除去していく
     for (int e = d * 2; e < MAX; e += d) v[e] = 0;
}    

これは一見すると  O(V^{2}) かかるように見えるかもしれない。しかしちゃんと解析すると  O(V \log V) になっているのだ。計算時間をよりちゃんと書くと

 \frac{V}{1} + \frac{V}{2} + \dots + \frac{V}{V}

という風になる。二番目の for 文は  d の倍数のみを走るので、大体  \frac{V}{i} くらいの範囲を動くことになるのだ。一方

 1 + \frac{1}{2} + \frac{1}{3} + \dots = O(\log N)

となることが知られている ( \frac{1}{x} の積分が  \log x であることから来る)。よって、上述の処理の計算量は  O(V \log V) となる。

コード

#include <bits/stdc++.h>
using namespace std;

const int MAX = 2100000;

int main() {
    int N;
    cin >> N;
    vector<long long> v(MAX, 0);
    for (int i = 0; i < N; ++i) {
        long long a;
        cin >> a;
        v[a]++;
    }
    for (int d = 1; d < MAX; ++d) {
        if (v[d] == 0) continue;
        if (v[d] > 1) v[d] = 0;
        for (int e = d * 2; e < MAX; e += d) v[e] = 0;
    }
    long long res = 0;
    for (int d = 1; d < MAX; ++d) res += v[d];
    cout << res << endl;
}