#718300 (C++17) No.1776 Love Triangle 2 (Hard)

提出ソース

結果

問題	No.1776 Love Triangle 2 (Hard)
ユーザー	hitonanode
提出日時	2021-11-20 00:58:13
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	5,431 ms / 10,000 ms
コード長	8,338 bytes
コンパイル時間	2,171 ms
コンパイル使用メモリ	147,372 KB
実行使用メモリ	6,948 KB
最終ジャッジ日時	2024-07-06 21:19:30
合計ジャッジ時間	139,919 ms
ジャッジサーバーID （参考情報）	judge3 / judge2

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	22 ms 6,812 KB
testcase_01	AC	20 ms 6,816 KB
testcase_02	AC	22 ms 6,948 KB
testcase_03	AC	25 ms 6,944 KB
testcase_04	AC	58 ms 6,944 KB
testcase_05	AC	57 ms 6,940 KB
testcase_06	AC	57 ms 6,944 KB
testcase_07	AC	60 ms 6,940 KB
testcase_08	AC	59 ms 6,944 KB
testcase_09	AC	119 ms 6,940 KB
testcase_10	AC	147 ms 6,940 KB
testcase_11	AC	76 ms 6,944 KB
testcase_12	AC	65 ms 6,940 KB
testcase_13	AC	47 ms 6,940 KB
testcase_14	AC	40 ms 6,940 KB
testcase_15	AC	35 ms 6,940 KB
testcase_16	AC	34 ms 6,940 KB
testcase_17	AC	31 ms 6,940 KB
testcase_18	AC	32 ms 6,944 KB
testcase_19	AC	104 ms 6,940 KB
testcase_20	AC	99 ms 6,944 KB
testcase_21	AC	73 ms 6,940 KB
testcase_22	AC	60 ms 6,944 KB
testcase_23	AC	48 ms 6,940 KB
testcase_24	AC	73 ms 6,944 KB
testcase_25	AC	59 ms 6,940 KB
testcase_26	AC	49 ms 6,940 KB
testcase_27	AC	60 ms 6,944 KB
testcase_28	AC	45 ms 6,940 KB
testcase_29	AC	30 ms 6,940 KB
testcase_30	AC	55 ms 6,940 KB
testcase_31	AC	146 ms 6,944 KB
testcase_32	AC	272 ms 6,944 KB
testcase_33	AC	468 ms 6,940 KB
testcase_34	AC	464 ms 6,940 KB
testcase_35	AC	627 ms 6,944 KB
testcase_36	AC	841 ms 6,940 KB
testcase_37	AC	1,061 ms 6,940 KB
testcase_38	AC	1,490 ms 6,944 KB
testcase_39	AC	41 ms 6,940 KB
testcase_40	AC	93 ms 6,940 KB
testcase_41	AC	156 ms 6,944 KB
testcase_42	AC	183 ms 6,940 KB
testcase_43	AC	183 ms 6,940 KB
testcase_44	AC	103 ms 6,940 KB
testcase_45	AC	559 ms 6,944 KB
testcase_46	AC	209 ms 6,940 KB
testcase_47	AC	59 ms 6,940 KB
testcase_48	AC	282 ms 6,940 KB
testcase_49	AC	30 ms 6,940 KB
testcase_50	AC	54 ms 6,940 KB
testcase_51	AC	141 ms 6,944 KB
testcase_52	AC	274 ms 6,940 KB
testcase_53	AC	471 ms 6,944 KB
testcase_54	AC	476 ms 6,940 KB
testcase_55	AC	629 ms 6,944 KB
testcase_56	AC	849 ms 6,940 KB
testcase_57	AC	1,082 ms 6,944 KB
testcase_58	AC	1,488 ms 6,940 KB
testcase_59	AC	45 ms 6,940 KB
testcase_60	AC	71 ms 6,940 KB
testcase_61	AC	113 ms 6,940 KB
testcase_62	AC	61 ms 6,940 KB
testcase_63	AC	81 ms 6,940 KB
testcase_64	AC	121 ms 6,944 KB
testcase_65	AC	47 ms 6,944 KB
testcase_66	AC	107 ms 6,940 KB
testcase_67	AC	186 ms 6,940 KB
testcase_68	AC	73 ms 6,944 KB
testcase_69	AC	151 ms 6,940 KB
testcase_70	AC	154 ms 6,940 KB
testcase_71	AC	149 ms 6,940 KB
testcase_72	AC	154 ms 6,944 KB
testcase_73	AC	152 ms 6,944 KB
testcase_74	AC	208 ms 6,944 KB
testcase_75	AC	145 ms 6,940 KB
testcase_76	AC	113 ms 6,940 KB
testcase_77	AC	96 ms 6,940 KB
testcase_78	AC	68 ms 6,944 KB
testcase_79	AC	56 ms 6,940 KB
testcase_80	AC	54 ms 6,944 KB
testcase_81	AC	45 ms 6,944 KB
testcase_82	AC	43 ms 6,940 KB
testcase_83	AC	41 ms 6,940 KB
testcase_84	AC	172 ms 6,944 KB
testcase_85	AC	131 ms 6,940 KB
testcase_86	AC	124 ms 6,940 KB
testcase_87	AC	80 ms 6,944 KB
testcase_88	AC	69 ms 6,944 KB
testcase_89	AC	112 ms 6,940 KB
testcase_90	AC	81 ms 6,944 KB
testcase_91	AC	68 ms 6,940 KB
testcase_92	AC	88 ms 6,940 KB
testcase_93	AC	65 ms 6,944 KB
testcase_94	AC	40 ms 6,940 KB
testcase_95	AC	120 ms 6,940 KB
testcase_96	AC	375 ms 6,940 KB
testcase_97	AC	976 ms 6,944 KB
testcase_98	AC	1,687 ms 6,940 KB
testcase_99	AC	1,708 ms 6,944 KB
testcase_100	AC	2,645 ms 6,944 KB
testcase_101	AC	3,641 ms 6,940 KB
testcase_102	AC	4,410 ms 6,940 KB
testcase_103	AC	5,336 ms 6,940 KB
testcase_104	AC	51 ms 6,940 KB
testcase_105	AC	150 ms 6,940 KB
testcase_106	AC	299 ms 6,944 KB
testcase_107	AC	106 ms 6,944 KB
testcase_108	AC	497 ms 6,940 KB
testcase_109	AC	142 ms 6,940 KB
testcase_110	AC	172 ms 6,944 KB
testcase_111	AC	206 ms 6,940 KB
testcase_112	AC	159 ms 6,944 KB
testcase_113	AC	361 ms 6,940 KB
testcase_114	AC	38 ms 6,940 KB
testcase_115	AC	119 ms 6,940 KB
testcase_116	AC	382 ms 6,940 KB
testcase_117	AC	898 ms 6,940 KB
testcase_118	AC	1,728 ms 6,940 KB
testcase_119	AC	1,719 ms 6,944 KB
testcase_120	AC	2,708 ms 6,944 KB
testcase_121	AC	3,637 ms 6,940 KB
testcase_122	AC	4,439 ms 6,940 KB
testcase_123	AC	5,372 ms 6,940 KB
testcase_124	AC	68 ms 6,940 KB
testcase_125	AC	82 ms 6,944 KB
testcase_126	AC	135 ms 6,940 KB
testcase_127	AC	92 ms 6,944 KB
testcase_128	AC	98 ms 6,944 KB
testcase_129	AC	100 ms 6,944 KB
testcase_130	AC	114 ms 6,940 KB
testcase_131	AC	161 ms 6,940 KB
testcase_132	AC	180 ms 6,940 KB
testcase_133	AC	208 ms 6,944 KB
testcase_134	AC	238 ms 6,940 KB
testcase_135	AC	828 ms 6,944 KB
testcase_136	AC	1,171 ms 6,940 KB
testcase_137	AC	1,469 ms 6,944 KB
testcase_138	AC	1,300 ms 6,940 KB
testcase_139	AC	1,513 ms 6,944 KB
testcase_140	AC	1,489 ms 6,940 KB
testcase_141	AC	1,180 ms 6,940 KB
testcase_142	AC	1,489 ms 6,944 KB
testcase_143	AC	1,476 ms 6,944 KB
testcase_144	AC	144 ms 6,940 KB
testcase_145	AC	184 ms 6,940 KB
testcase_146	AC	346 ms 6,944 KB
testcase_147	AC	293 ms 6,944 KB
testcase_148	AC	429 ms 6,944 KB
testcase_149	AC	250 ms 6,944 KB
testcase_150	AC	428 ms 6,944 KB
testcase_151	AC	183 ms 6,944 KB
testcase_152	AC	358 ms 6,944 KB
testcase_153	AC	857 ms 6,944 KB
testcase_154	AC	647 ms 6,944 KB
testcase_155	AC	3,687 ms 6,944 KB
testcase_156	AC	3,615 ms 6,940 KB
testcase_157	AC	3,758 ms 6,944 KB
testcase_158	AC	2,565 ms 6,940 KB
testcase_159	AC	4,515 ms 6,940 KB
testcase_160	AC	1,978 ms 6,944 KB
testcase_161	AC	2,487 ms 6,940 KB
testcase_162	AC	4,954 ms 6,944 KB
testcase_163	AC	5,431 ms 6,940 KB
testcase_164	AC	5,215 ms 6,944 KB
testcase_165	AC	1,537 ms 6,944 KB
testcase_166	AC	555 ms 6,940 KB
testcase_167	AC	697 ms 6,940 KB
testcase_168	AC	648 ms 6,944 KB
testcase_169	AC	1,256 ms 6,940 KB
testcase_170	AC	1,177 ms 6,940 KB
testcase_171	AC	2,355 ms 6,944 KB
testcase_172	AC	962 ms 6,940 KB
testcase_173	AC	3,270 ms 6,944 KB
testcase_174	AC	1,072 ms 6,940 KB
testcase_175	AC	3,033 ms 6,944 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <array>
#include <chrono>
#include <iostream>
#include <random>
#include <vector>
using namespace std;
// https://epubs.siam.org/doi/10.1137/1.9781611973099.139

// Nimber (16 bit)
// Reference:
// - https://en.wikipedia.org/wiki/Nimber
// - https://kyopro-friends.hatenablog.com/entry/2020/04/07/195850
// - https://judge.yosupo.jp/submission/4542 (implementation idea)
struct Nimber {
    using ull = unsigned;
    ull v;
    const static std::array<std::array<ull, 256>, 256> small_table;
    const static std::array<std::array<std::array<ull, 256>, 2>, 2> precalc;

    explicit operator bool() const { return v != 0; }
    Nimber(ull val = 0) : v(val) {}
    Nimber operator+(const Nimber &x) const { return Nimber(v ^ x.v); }
    Nimber operator-(const Nimber &x) const { return Nimber(v ^ x.v); }
    Nimber operator-() const { return *this; }
    Nimber &operator+=(const Nimber &x) { return *this = *this + x; }
    Nimber &operator-=(const Nimber &x) { return *this = *this + x; }
    template <class IStream> friend IStream &operator>>(IStream &is, Nimber &x) {
        ull v;
        return is >> v, x = Nimber(v), is;
    }
    template <class OStream> friend OStream &operator<<(OStream &os, const Nimber &x) {
        return os << x.v;
    }
    bool operator==(const Nimber &x) const { return v == x.v; }
    bool operator!=(const Nimber &x) const { return v != x.v; }
    bool operator<(const Nimber &x) const { return v < x.v; }

    static ull _rec(ull x, ull y) {
        if (x == 0 or y == 0) return 0;
        if (x < y) x ^= y, y ^= x, x ^= y; // Make x >= y
        if (y == 1) return x;
        for (int shift = 16 / 2;; shift >>= 1) {
            ull mask = (1ULL << shift) - 1;
            if (y >> shift) {
                ull v00 = _rec(x & mask, y & mask);
                ull v01 = _rec(x & mask, y >> shift);
                ull v10 = _rec(x >> shift, y & mask);
                ull v11 = _rec(x >> shift, y >> shift);
                return v00 ^ ((v01 ^ v10 ^ v11) << shift) ^ _rec(v11, 1ULL << (shift - 1));
            } else if (x >> shift) {
                return (_rec(x >> shift, y) << shift) ^ _rec(x & mask, y);
            }
        }
    }
    Nimber operator*(const Nimber &x) const {
        if (this->v < 256 and x.v < 256) return small_table[this->v][x.v];
        ull ret = 0;
        for (int d = 0; d < 2; ++d) {  // 16 bit
            for (int e = 0; e < 2; ++e) {  // 16 bit
                ret ^= precalc[d][e][small_table[(v >> (d * 8)) & 255][(x.v >> (e * 8)) & 255]];
            }
        }
        return Nimber(ret);
    }
    Nimber &operator*=(const Nimber &x) { return *this = *this * x; }
};

const std::array<std::array<unsigned, 256>, 256> Nimber::small_table = []() {
    std::array<std::array<unsigned, 256>, 256> ret;
    for (int i = 0; i < 256; ++i) {
        for (int j = 0; j < 256; ++j) ret[i][j] = _rec(i, j);
    }
    return ret;
}();
const std::array<std::array<std::array<unsigned, 256>, 2>, 2> Nimber::precalc = []() {
    std::array<std::array<std::array<unsigned, 256>, 2>, 2> ret;
    for (int d = 0; d < 2; ++d) {
        for (int e = 0; e < 2; ++e) {
            ull p = _rec(1ULL << (8 * d), 1ULL << (8 * e));
            for (int i = 0; i < 256; ++i) ret[d][e][i] = _rec(p, i);
        }
    }
    return ret;
}();

struct rand_int_ {
    using lint = long long;
    mt19937 mt;
    rand_int_() : mt(chrono::steady_clock::now().time_since_epoch().count()) {}
    lint operator()(lint x) { return this->operator()(0, x); } // [0, x)
    lint operator()(lint l, lint r) {
        uniform_int_distribution<lint> d(l, r - 1);
        return d(mt);
    }
} rnd;

int N;
#include <cstring>
constexpr int NMAX = 200;
Nimber dp[2][2][NMAX + 1][NMAX + 1];
Nimber dpnxt[2][2][NMAX + 1][NMAX + 1];
Nimber weight[NMAX + 1][NMAX + 1];

int can_reach(int x, int y, int z, int dlim) {
    // x を始点に y, z を経由し N に到達する長さ dlim 以下のパスがあるかを判定
    // dp[visited y][visited z][current v][previous v]
    vector dp(2, vector(2, vector(N + 1, vector<Nimber>(N + 1, 0))));
    dp[0][0][N][N] = 1;
    for (int d = 1; d <= dlim; ++d) {
        vector dpnxt(2, vector(2, vector(N + 1, vector<Nimber>(N + 1, 0))));
        for (int visy = 0; visy < 2; ++visy) {
            for (int visz = 0; visz < 2; ++visz) {
                for (int now = 0; now <= N; ++now) {
                    Nimber sum = 0;
                    for (int prv = 0; prv <= N; ++prv) sum += dp[visy][visz][now][prv];
                    for (int nxt = 0; nxt <= N; ++nxt) {
                        if (visy and (nxt == y)) continue;
                        if (visz and (nxt == z)) continue;
                        Nimber wadd = sum - ((now == y or now == z) ? dp[visy][visz][now][nxt] : 0);
                        dpnxt[visy | (nxt == y)][visz | (nxt == z)][nxt][now] += wadd * weight[now][nxt];
                    }
                }
            }
        }
        dp = dpnxt;
        for (int i = 0; i < N; ++i) {
            if (dp[1][1][x][i] != 0) return d;
        }
    }
    return 0;  // not found
}

int next_step(int h, int vy, int vz, int y, int z, int D) {
    // h を始点に y, z を経由し N に到達する長さ D のパスの次の一歩
    // dp[visited y][visited z][current v][previous v]
    // vector dp(2, vector(2, vector(N + 1, vector<Fq>(N + 1, 0))));
    memset(dp, 0, sizeof(dp));
    dp[0][0][N][N] = 1;
    for (int d = 1; d < D; ++d) {
        // vector dpnxt(2, vector(2, vector(N + 1, vector<Fq>(N + 1, 0))));
        memset(dpnxt, 0, sizeof(dpnxt));
        for (int visy = 0; visy < 2; ++visy) {
            for (int visz = 0; visz < 2; ++visz) {
                for (int now = 0; now <= N; ++now) {
                    Nimber sum = 0;
                    for (int prv = 0; prv <= N; ++prv) sum += dp[visy][visz][now][prv];
                    for (int nxt = 0; nxt <= N; ++nxt) {
                        if (visy and (nxt == y)) continue;
                        if (visz and (nxt == z)) continue;
                        if (nxt == h) continue;
                        if (!weight[now][nxt]) continue;
                        // Nimber wadd = sum - ((now == y or now == z) ? dp[visy][visz][now][nxt] : 0);
                        Nimber wadd = sum - dp[visy][visz][now][nxt];
                        dpnxt[visy | (nxt == y)][visz | (nxt == z)][nxt][now] += wadd * weight[now][nxt];
                    }
                }
            }
        }
        // dp = dpnxt;
        swap(dp, dpnxt);
    }
    for (int i = 0; i < N; ++i) {
        if (!weight[i][h]) continue;
        Nimber sum = 0;
        for (int j = 0; j <= N; ++j) sum += dp[vy][vz][i][j];
        if (!sum) continue;
        return i;
    }
    throw;
}

int main() {
    int M;
    cin >> N >> M;
    int x, y, z;
    cin >> x >> y >> z;

    --x, --y, --z;
    // vector weight(N + 1, vector<Nimber>(N + 1));
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < i; ++j) {
            Nimber w = rnd(1LL << 16);
            Nimber wn = rnd(1LL << 16);
            if (j != x) {
                weight[j][i] = w;
            } else {
                weight[N][i] = wn;
            }
            if (i != x) {
                weight[i][j] = w;
            } else {
                weight[N][j] = wn;
            }
        }
    }

    while (M--) {
        int a, b;
        cin >> a >> b;
        --a, --b;
        weight[a][b] = weight[b][a] = 0;
        if (a == x) weight[N][b] = 0;
        if (b == x) weight[N][a] = 0;
    }
    int len = can_reach(x, y, z, N);
    if (!len) {
        puts("-1");
        return 0;
    }
    cout << len << '\n';

    vector<int> path{x};
    int vy = 1, vz = 1;
    for (int l = 1; l < len; ++l) {
        int cur = path.back();
        if (y == cur) vy = 0;
        if (z == cur) vz = 0;
        int ok = next_step(cur, vy, vz, y, z, len - l + 1);
        path.push_back(ok);

        for (int i = 0; i <= N; ++i) weight[cur][i] = weight[i][cur] = 0;
    }

    path.push_back(x);

    for (auto x : path) cout << x + 1 << ' ';
    cout << '\n';
}

yukicoder

結果

テストケース

ソースコード