結果

問題 No.363 門松サイクル
ユーザー kyunakyuna
提出日時 2019-11-12 13:33:58
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 577 ms / 4,000 ms
コード長 3,474 bytes
コンパイル時間 1,020 ms
コンパイル使用メモリ 84,756 KB
実行使用メモリ 33,088 KB
最終ジャッジ日時 2024-09-18 23:22:23
合計ジャッジ時間 11,565 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,812 KB
testcase_01 AC 2 ms
6,940 KB
testcase_02 AC 5 ms
6,940 KB
testcase_03 AC 5 ms
6,940 KB
testcase_04 AC 6 ms
6,940 KB
testcase_05 AC 6 ms
6,940 KB
testcase_06 AC 6 ms
6,944 KB
testcase_07 AC 7 ms
6,940 KB
testcase_08 AC 6 ms
6,944 KB
testcase_09 AC 193 ms
15,340 KB
testcase_10 AC 197 ms
16,220 KB
testcase_11 AC 354 ms
30,936 KB
testcase_12 AC 463 ms
28,476 KB
testcase_13 AC 426 ms
27,872 KB
testcase_14 AC 345 ms
25,220 KB
testcase_15 AC 342 ms
29,372 KB
testcase_16 AC 312 ms
19,912 KB
testcase_17 AC 557 ms
32,828 KB
testcase_18 AC 495 ms
30,172 KB
testcase_19 AC 410 ms
30,732 KB
testcase_20 AC 490 ms
30,228 KB
testcase_21 AC 577 ms
32,196 KB
testcase_22 AC 489 ms
29,416 KB
testcase_23 AC 496 ms
27,096 KB
testcase_24 AC 2 ms
6,940 KB
testcase_25 AC 2 ms
6,940 KB
testcase_26 AC 390 ms
32,960 KB
testcase_27 AC 394 ms
33,088 KB
testcase_28 AC 527 ms
31,552 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

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

using Graph = vector<vector<int>>;
struct LowestCommonAncestor {
    const Graph &g;
    int root, h;
    vector<vector<int>> par;    // par[k][v] := 2^k-th parent of v
    vector<int> dep;
    LowestCommonAncestor(const Graph &g, int r = 0) : \
        g(g), root(r), dep(g.size()) { }
    void build() {
        int V = g.size();
        h = 1; while ((1 << h) < V) ++h;        // 32 - __builtin_clz(V)
        par.assign(h, vector<int>(V, -1));
        dfs(root, -1, 0);
        for (int k = 0; k + 1 < h; ++k) for (int v = 0; v < V; ++v) {
            if (par[k][v] != -1) par[k + 1][v] = par[k][par[k][v]];
        }
    }
    void dfs(int u, int p, int d) {
        par[0][u] = p;
        dep[u] = d;
        for (auto v: g[u]) if (v != p) dfs(v, u, d + 1);
    }
    int get(int u, int v) {
        if (dep[u] > dep[v]) swap(u, v);
        for (int k = 0; k < h; ++k) {
            if ((dep[v] - dep[u]) >> k & 1) v = par[k][v];
        }
        if (u == v) return u;
        for (int k = h - 1; k >= 0; --k) {
            if (par[k][u] != par[k][v]) u = par[k][u], v = par[k][v];
        }
        return par[0][u];
    }
    int ancestor(int u, int k) {
        for (int i = h - 1; i >= 0; i--) if (k >> i & 1) u = par[i][u];
        return u;
    }
    int dist(int u, int v) { return dep[u] + dep[v] - dep[get(u, v)] * 2; }
};

int main() {
    int n; cin >> n;
    vector<int> a(n);
    for (auto &ai: a) cin >> ai;
    Graph g(n);
    for (int i = 0; i < n - 1; ++i) {
        int x, y; cin >> x >> y; x--, y--;
        g[x].emplace_back(y);
        g[y].emplace_back(x);
    }
    LowestCommonAncestor lca(g);
    lca.build();
    auto par = lca.par;
    auto dep = lca.dep;
    auto is_kado = [](int x, int y, int z) {
        if (x == y || y == z || z == x) return false;
        return (x < y && y > z) || (x > y && y < z);
    };
    auto check = [&](int v) {
        if (dep[v] < 2) return false;
        return is_kado(a[v], a[par[0][v]], a[par[1][v]]);
    };
    int h = par.size();
    vector<vector<int>> dp(h, vector<int>(n));
    for (int v = 0; v < n; v++) dp[0][v] = check(v);
    for (int k = 0; k + 1 < h; ++k) for (int v = 0; v < n; ++v) {
        if (~par[k][v]) dp[k + 1][v] = dp[k][v] && dp[k][par[k][v]];
    }
    auto query = [&](int v, int p) {
        int d = dep[v] - dep[p] - 1, k = 0, flg = true;
        while (d > 0) {
            if (d & 1) flg &= dp[k][v], v = par[k][v];
            k++, d >>= 1;
        }
        return flg;
    };
    int Q; cin >> Q;
    while (Q--) {
        int u, v; cin >> u >> v; u--, v--;
        int p = lca.get(u, v);
        bool ok = true;
        if (par[0][u] == v || par[0][v] == u) {
            ok = false;
        } else if (u != p && v != p) {
            int pu = lca.ancestor(u, dep[u] - dep[p] - 1);
            int pv = lca.ancestor(v, dep[v] - dep[p] - 1);
            ok &= is_kado(a[pu], a[p], a[pv]);
            ok &= is_kado(a[par[0][u]], a[u], a[v]);
            ok &= is_kado(a[par[0][v]], a[v], a[u]);
            ok &= query(u, p);
            ok &= query(v, p);
        } else {
            if (p == v) swap(u, v);     // u == p
            int q = lca.ancestor(v, dep[v] - dep[u] - 1);
            ok &= is_kado(a[q], a[u], a[v]);
            ok &= is_kado(a[par[0][v]], a[v], a[u]);
            ok &= query(v, u);
        }
        cout << (ok ? "YES" : "NO") << endl;
    }
    return 0;
}
0