結果

問題 No.399 動的な領主
ユーザー はまやんはまやんはまやんはまやん
提出日時 2017-04-06 11:22:44
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 446 ms / 2,000 ms
コード長 3,883 bytes
コンパイル時間 1,766 ms
コンパイル使用メモリ 185,476 KB
実行使用メモリ 47,992 KB
最終ジャッジ日時 2024-07-08 13:43:44
合計ジャッジ時間 8,141 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 11 ms
36,284 KB
testcase_01 AC 11 ms
36,168 KB
testcase_02 AC 12 ms
36,224 KB
testcase_03 AC 11 ms
36,100 KB
testcase_04 AC 13 ms
36,224 KB
testcase_05 AC 40 ms
36,992 KB
testcase_06 AC 429 ms
43,776 KB
testcase_07 AC 415 ms
43,740 KB
testcase_08 AC 436 ms
43,852 KB
testcase_09 AC 430 ms
43,820 KB
testcase_10 AC 15 ms
36,140 KB
testcase_11 AC 33 ms
37,068 KB
testcase_12 AC 323 ms
44,248 KB
testcase_13 AC 296 ms
44,416 KB
testcase_14 AC 78 ms
47,992 KB
testcase_15 AC 122 ms
47,928 KB
testcase_16 AC 198 ms
45,892 KB
testcase_17 AC 446 ms
43,844 KB
testcase_18 AC 427 ms
43,792 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)



class HeavyLightDecomposition {
private:
    const vector<vector<int>> &g;

public:
    struct Node {
        int vid;
        int head;
        int parent;
        int heavy;
        int length;
    };

    vector<Node> nodes;

    HeavyLightDecomposition(const vector<vector<int>> &g) : g(g), nodes(g.size()) {
        dfs(0, -1);
        bfs(0);
    }

    void forEach(int u, int v, function<void(int, int, int, int)> f) {
        while (true) {
            if (nodes[u].vid > nodes[v].vid) {
                swap(u, v);
            }
            int h = nodes[v].head;
            int l = nodes[h].length;
            if (nodes[u].head == nodes[v].head) {
                f(nodes[h].vid, l, nodes[u].vid, nodes[v].vid);
                break;
            }
            else {
                f(nodes[h].vid, l, nodes[h].vid, nodes[v].vid);
                v = nodes[h].parent;
            }
        }
    }

    int operator[](int k) {
        return nodes[k].vid;
    }

private:
    int dfs(int curr, int prev) {
        nodes[curr].heavy = -1;
        nodes[curr].parent = prev;
        int maxSub = 0;
        int sub = 1;
        for (int next : g[curr]) {
            if (next == prev) {
                continue;
            }
            int subNext = dfs(next, curr);
            sub += subNext;
            if (maxSub < subNext) {
                maxSub = subNext;
                nodes[curr].heavy = next;
            }
        }
        return sub;
    }

    void bfs(int s) {
        queue<int> q;
        q.push(s);
        int k = 0;
        while (!q.empty()) {
            int h = q.front();
            q.pop();
            for (int i = h; i != -1; i = nodes[i].heavy) {
                nodes[i].vid = k++;
                nodes[i].head = h;
                nodes[h].length++;
                for (int j : g[i]) {
                    if (j != nodes[i].parent && j != nodes[i].heavy) {
                        q.push(j);
                    }
                }
            }
        }
    }
};




typedef long long ll;
template<int NV> struct LazySegTreeAddSum {
    vector<ll> a, b;
    explicit LazySegTreeAddSum() { a.resize(2 * NV - 1); b.resize(2 * NV - 1); }
    
    void add(int i, int il, int ir, int l, int r, int z) {
        if (l <= il and ir <= r) { a[i] += z; b[i] += z * (ir - il); }
        else if (ir <= l or r <= il) { }
        else {
            add(2 * i + 1, il, (il + ir) / 2, l, r, z);
            add(2 * i + 2, (il + ir) / 2, ir, l, r, z);
            b[i] = a[i] * (ir - il) + b[2 * i + 1] + b[2 * i + 2];
        }
    }
    
    ll get(int i, int il, int ir, int l, int r) {
        if (l <= il and ir <= r) return b[i];
        else if (ir <= l or r <= il) return 0;
        else return a[i] * (min(ir, r) - max(il, l)) + get(2 * i + 1, il, (il + ir) / 2, l, r) + get(2 * i + 2, (il + ir) / 2, ir, l, r);
    }
    void add(int l, int r, int z) { add(0, 0, NV, l, r, z); } // [l,r)に+z
    ll get(int l, int r) { return get(0, 0, NV, l, r); } // [l,r)の総和
};

int N, Q;
vector<vector<int>> G;
LazySegTreeAddSum<1<<20> sst;
//-----------------------------------------------------------------------------------
int main() {
    cin >> N;
    G.resize(N);
    rep(i, 0, N - 1) {
        int a, b;
        scanf("%d%d", &a, &b);
        a--; b--;
        G[a].push_back(b);
        G[b].push_back(a);
    }

    HeavyLightDecomposition hld(G);
    sst.add(0, N, 1);

    ll ans = 0;
    cin >> Q;
    rep(q, 0, Q) {
        int a, b;
        scanf("%d%d", &a, &b);
        a--; b--;

        hld.forEach(a, b, [&](int head, int len, int l, int r) {
            //printf("<%d : %lld>\n", hld[l] + 1, sst.get(l, l + 1));
            ans += sst.get(l, r + 1);
            sst.add(l, r + 1, 1);
        });
    }
    printf("%lld\n", ans);
}
0