#721666 (C++17) No.1773 Love Triangle

提出ソース

結果

問題	No.1773 Love Triangle
ユーザー	Sumitacchan
提出日時	2021-12-04 05:40:50
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	WA
実行時間	-
コード長	15,234 bytes
コンパイル時間	2,621 ms
コンパイル使用メモリ	223,736 KB
実行使用メモリ	23,372 KB
最終ジャッジ日時	2023-09-20 15:20:24
合計ジャッジ時間	41,484 ms
ジャッジサーバーID （参考情報）	judge14 / judge11

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 4,380 KB
testcase_01	AC	2 ms 4,376 KB
testcase_02	WA	-
testcase_03	AC	2 ms 4,376 KB
testcase_04	AC	3 ms 4,376 KB
testcase_05	WA	-
testcase_06	WA	-
testcase_07	AC	3 ms 4,376 KB
testcase_08	AC	2 ms 4,380 KB
testcase_09	WA	-
testcase_10	AC	2 ms 4,376 KB
testcase_11	WA	-
testcase_12	WA	-
testcase_13	WA	-
testcase_14	WA	-
testcase_15	AC	3 ms 4,376 KB
testcase_16	AC	2 ms 4,376 KB
testcase_17	WA	-
testcase_18	AC	508 ms 7,444 KB
testcase_19	WA	-
testcase_20	AC	23 ms 4,380 KB
testcase_21	AC	2 ms 4,380 KB
testcase_22	AC	21 ms 4,376 KB
testcase_23	AC	24 ms 4,376 KB
testcase_24	WA	-
testcase_25	WA	-
testcase_26	AC	99 ms 5,084 KB
testcase_27	WA	-
testcase_28	AC	3 ms 4,376 KB
testcase_29	WA	-
testcase_30	WA	-
testcase_31	WA	-
testcase_32	AC	1,736 ms 14,964 KB
testcase_33	AC	1,122 ms 12,256 KB
testcase_34	AC	2 ms 4,380 KB
testcase_35	WA	-
testcase_36	AC	67 ms 4,376 KB
testcase_37	AC	2 ms 4,380 KB
testcase_38	AC	675 ms 7,852 KB
testcase_39	WA	-
testcase_40	WA	-
testcase_41	WA	-
testcase_42	WA	-
testcase_43	WA	-
testcase_44	WA	-
testcase_45	WA	-
testcase_46	WA	-
testcase_47	WA	-
testcase_48	AC	707 ms 8,216 KB
testcase_49	WA	-
testcase_50	WA	-
testcase_51	AC	696 ms 8,084 KB
testcase_52	AC	674 ms 7,980 KB
testcase_53	AC	681 ms 7,972 KB
testcase_54	WA	-
testcase_55	WA	-
testcase_56	AC	673 ms 7,964 KB
testcase_57	AC	685 ms 7,924 KB
testcase_58	WA	-
testcase_59	AC	714 ms 8,068 KB
testcase_60	WA	-
testcase_61	AC	725 ms 7,956 KB
testcase_62	WA	-
testcase_63	WA	-
testcase_64	AC	710 ms 7,976 KB
testcase_65	AC	718 ms 8,036 KB
testcase_66	AC	709 ms 7,920 KB
testcase_67	WA	-
testcase_68	AC	712 ms 8,136 KB
testcase_69	AC	712 ms 7,912 KB
testcase_70	WA	-
testcase_71	AC	714 ms 8,160 KB
testcase_72	WA	-
testcase_73	AC	711 ms 8,136 KB
testcase_74	AC	727 ms 8,080 KB
testcase_75	WA	-
testcase_76	AC	714 ms 7,948 KB
testcase_77	WA	-
testcase_78	AC	1 ms 4,376 KB
testcase_79	TLE	-
testcase_80	--	-
testcase_81	--	-
testcase_82	--	-
testcase_83	--	-
testcase_84	--	-
testcase_85	--	-
testcase_86	--	-
testcase_87	--	-
testcase_88	--	-
testcase_89	--	-
testcase_90	--	-
testcase_91	--	-
testcase_92	--	-

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

ソースコード

raw source code

#include <bits/stdc++.h>
//cplib-cpp
//https://hitonanode.github.io/cplib-cpp/graph/test/general_matching.test.cpp

template <typename T>
struct matrix
{
    int H, W;
    std::vector<T> elem;
    typename std::vector<T>::iterator operator[](int i) { return elem.begin() + i * W; }
    inline T &at(int i, int j) { return elem[i * W + j]; }
    inline T get(int i, int j) const { return elem[i * W + j]; }
    operator std::vector<std::vector<T>>() const {
        std::vector<std::vector<T>> ret(H);
        for (int i = 0; i < H; i++) std::copy(elem.begin() + i * W, elem.begin() + (i + 1) * W, std::back_inserter(ret[i]));
        return ret;
    }

    matrix() = default;
    matrix(int H, int W) : H(H), W(W), elem(H * W) {}
    matrix(const std::vector<std::vector<T>> &d) : H(d.size()), W(d.size() ? d[0].size() : 0) {
        for (auto &raw : d) std::copy(raw.begin(), raw.end(), std::back_inserter(elem));
    }

    static matrix Identity(int N) {
        matrix ret(N, N);
        for (int i = 0; i < N; i++) ret.at(i, i) = 1;
        return ret;
    }

    matrix operator-() const { matrix ret(H, W); for (int i = 0; i < H * W; i++) ret.elem[i] = -elem[i]; return ret; }
    matrix operator*(const T &v) const { matrix ret = *this; for (auto &x : ret.elem) x *= v; return ret; }
    matrix operator/(const T &v) const { matrix ret = *this; for (auto &x : ret.elem) x /= v; return ret; }
    matrix operator+(const matrix &r) const { matrix ret = *this; for (int i = 0; i < H * W; i++) ret.elem[i] += r.elem[i]; return ret; }
    matrix operator-(const matrix &r) const { matrix ret = *this; for (int i = 0; i < H * W; i++) ret.elem[i] -= r.elem[i]; return ret; }
    matrix operator*(const matrix &r) const {
        matrix ret(H, r.W);
        for (int i = 0; i < H; i++) {
            for (int k = 0; k < W; k++) {
                for (int j = 0; j < r.W; j++) {
                    ret.at(i, j) += this->get(i, k) * r.get(k, j);
                }
            }
        }
        return ret;
    }
    matrix &operator*=(const T &v) { return *this = *this * v; }
    matrix &operator/=(const T &v) { return *this = *this / v; }
    matrix &operator+=(const matrix &r) { return *this = *this + r; }
    matrix &operator-=(const matrix &r) { return *this = *this - r; }
    matrix &operator*=(const matrix &r) { return *this = *this * r; }
    bool operator==(const matrix &r) const { return H == r.H and W == r.W and elem == r.elem; }
    bool operator!=(const matrix &r) const { return H != r.H or W != r.W or elem != r.elem; }
    bool operator<(const matrix &r) const { return elem < r.elem; }
    matrix pow(int64_t n) const {
        matrix ret = Identity(H);
        if (n == 0) return ret;
        for (int i = 63 - __builtin_clzll(n); i >= 0; i--) {
            ret *= ret;
            if ((n >> i) & 1) ret *= (*this);
        }
        return ret;
    }
    matrix transpose() const {
        matrix ret(W, H);
        for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) ret.at(j, i) = this->get(i, j);
        return ret;
    }
    // Gauss-Jordan elimination
    // - Require inverse for every non-zero element
    // - Complexity: O(H^2 W)
    matrix gauss_jordan() const {
        int c = 0;
        matrix mtr(*this);
        for (int h = 0; h < H; h++) {
            if (c == W) break;
            int piv = -1;
            for (int j = h; j < H; j++) if (mtr.get(j, c)) {
                piv = j;
                break;
            }
            if (piv == -1) { c++; h--; continue; }
            if (h != piv) {
                for (int w = 0; w < W; w++) {
                    std::swap(mtr[piv][w], mtr[h][w]);
                    mtr.at(piv, w) *= -1; // To preserve sign of determinant
                }
            }
            for (int hh = 0; hh < H; hh++) if (hh != h) {
                T coeff = mtr.at(hh, c) * mtr.at(h, c).inv();
                for (int w = W - 1; w >= c; w--) {
                    mtr.at(hh, w) -= mtr.at(h, w) * coeff;
                }
            }
            c++;
        }
        return mtr;
    }
    int rank_of_gauss_jordan() const {
        for (int i = H * W - 1; i >= 0; i--) if (elem[i]) return i / W + 1;
        return 0;
    }
    T determinant_of_upper_triangle() const {
        T ret = 1;
        for (int i = 0; i < H; i++) ret *= get(i, i);
        return ret;
    }
    int inverse() {
        assert(H == W);
        std::vector<std::vector<T>> tmp = Identity(H), A = *this;
        std::vector<int> col(H);
        std::iota(col.begin(), col.end(), 0);
        for (int i = 0; i < H; i++) {
            int r = -1, c = -1;
            [&]() {
                for (int j = i; j < H; j++) {
                    for (int k = i; k < H; k++) {
                        if (A[j][k]) {
                            r = j, c = k;
                            return;
                        }
                    }
                }
            }();
            if (r < 0) {
                return i;
            }
            A[i].swap(A[r]), tmp[i].swap(tmp[r]);
            for (int j = 0; j < H; j++) {
                std::swap(A[j][i], A[j][c]), std::swap(tmp[j][i], tmp[j][c]);
            }
            std::swap(col[i], col[c]);
            T v = A[i][i].inv();
            for (int j = i + 1; j < H; j++) {
                T f = A[j][i] * v;
                A[j][i] = 0;
                for (int k = i + 1; k < H; k++) {
                    A[j][k] -= f * A[i][k];
                }
                for (int k = 0; k < H; k++) {
                    tmp[j][k] -= f * tmp[i][k];
                }
            }
            for (int j = i + 1; j < H; j++) {
                A[i][j] *= v;
            }
            for (int j = 0; j < H; j++) {
                tmp[i][j] *= v;
            }
            A[i][i] = 1;
        }
        for (int i = H - 1; i > 0; --i) {
            for (int j = 0; j < i; j++) {
                T v = A[j][i];
                for (int k = 0; k < H; k++) {
                    tmp[j][k] -= v * tmp[i][k];
                }
            }
        }
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < H; j++) {
                (*this)[col[i]][col[j]] = tmp[i][j];
            }
        }
        return H;
    }
    friend std::vector<T> operator*(const matrix &m, const std::vector<T> &v) {
        assert(m.W == int(v.size()));
        std::vector<T> ret(m.H);
        for (int i = 0; i < m.H; i++) {
            for (int j = 0; j < m.W; j++) {
                ret[i] += m.get(i, j) * v[j];
            }
        }
        return ret;
    }
    friend std::vector<T> operator*(const std::vector<T> &v, const matrix &m) {
        assert(int(v.size()) == m.H);
        std::vector<T> ret(m.W);
        for (int i = 0; i < m.H; i++) {
            for (int j = 0; j < m.W; j++) {
                ret[j] += v[i] * m.get(i, j);
            }
        }
        return ret;
    }
    friend std::ostream &operator<<(std::ostream &os, const matrix &x) {
        os << "[(" << x.H << " * " << x.W << " matrix)";
        os << "\n[column sums: ";
        for (int j = 0; j < x.W; j++) {
            T s = 0;
            for (int i = 0; i < x.H; i++) s += x.get(i, j);
            os << s << ",";
        }
        os << "]";
        for (int i = 0; i < x.H; i++) {
            os << "\n[";
            for (int j = 0; j < x.W; j++) os << x.get(i, j) << ",";
            os << "]";
        }
        os << "]\n";
        return os;
    }
    friend std::istream &operator>>(std::istream &is, matrix &x) {
        for (auto &v : x.elem) is >> v;
        return is;
    }
};
template <typename MODINT>
std::vector<std::pair<int, int>> generalMatching(int N, const std::vector<std::pair<int, int>>& ed)
{
    std::mt19937 mt(std::chrono::steady_clock::now().time_since_epoch().count());
    std::uniform_int_distribution<int> d(MODINT::get_mod());

    std::vector<std::vector<MODINT>> mat(N, std::vector<MODINT>(N));
    for (auto p : ed) {
        int a = p.first, b = p.second;
        if (a == b) continue;
        mat[a][b] = d(mt), mat[b][a] = -mat[a][b];
    }
    matrix<MODINT> A = mat;
    const int rank = A.inverse(), M = 2 * N - rank;
    if (M != N) {
        do {
            mat.resize(M, std::vector<MODINT>(M));
            for (int i = 0; i < N; i++) {
                mat[i].resize(M);
                for (int j = N; j < M; j++) {
                    mat[i][j] = d(mt), mat[j][i] = -mat[i][j];
                }
            }
            A = mat;
        } while (A.inverse() != M);
    }

    std::vector<int> has(M, 1);
    std::vector<std::pair<int, int>> ret;
    int fi = -1, fj = -1;
    for (int it = 0; it < M / 2; it++) {
        [&]() {
            for (int i = 0; i < M; i++) {
                if (has[i]) {
                    for (int j = i + 1; j < M; j++) {
                        if (A[i][j] and mat[i][j]) {
                            fi = i, fj = j;
                            return;
                        }
                    }
                }
            }
        }();
        if (fj < N) {
            ret.emplace_back(fi, fj);
        }
        has[fi] = has[fj] = 0;
        for (int sw = 0; sw < 2; sw++) {
            MODINT a = A[fi][fj].inv();
            for (int i = 0; i < M; i++) {
                if (has[i] and A[i][fj]) {
                    MODINT b = A[i][fj] * a;
                    for (int j = 0; j < M; j++) {
                        A[i][j] -= A[fi][j] * b;
                    }
                }
            }
            std::swap(fi, fj);
        }
    }
    return ret;
}
template <int mod>
struct ModInt
{
    using lint = long long;
    static int get_mod() { return mod; }
    static int get_primitive_root() {
        static int primitive_root = 0;
        if (!primitive_root) {
            primitive_root = [&](){
                std::set<int> fac;
                int v = mod - 1;
                for (lint i = 2; i * i <= v; i++) while (v % i == 0) fac.insert(i), v /= i;
                if (v > 1) fac.insert(v);
                for (int g = 1; g < mod; g++) {
                    bool ok = true;
                    for (auto i : fac) if (ModInt(g).power((mod - 1) / i) == 1) { ok = false; break; }
                    if (ok) return g;
                }
                return -1;
            }();
        }
        return primitive_root;
    }
    int val;
    constexpr ModInt() : val(0) {}
    constexpr ModInt &_setval(lint v) { val = (v >= mod ? v - mod : v); return *this; }
    constexpr ModInt(lint v) { _setval(v % mod + mod); }
    explicit operator bool() const { return val != 0; }
    constexpr ModInt operator+(const ModInt &x) const { return ModInt()._setval((lint)val + x.val); }
    constexpr ModInt operator-(const ModInt &x) const { return ModInt()._setval((lint)val - x.val + mod); }
    constexpr ModInt operator*(const ModInt &x) const { return ModInt()._setval((lint)val * x.val % mod); }
    constexpr ModInt operator/(const ModInt &x) const { return ModInt()._setval((lint)val * x.inv() % mod); }
    constexpr ModInt operator-() const { return ModInt()._setval(mod - val); }
    constexpr ModInt &operator+=(const ModInt &x) { return *this = *this + x; }
    constexpr ModInt &operator-=(const ModInt &x) { return *this = *this - x; }
    constexpr ModInt &operator*=(const ModInt &x) { return *this = *this * x; }
    constexpr ModInt &operator/=(const ModInt &x) { return *this = *this / x; }
    friend constexpr ModInt operator+(lint a, const ModInt &x) { return ModInt()._setval(a % mod + x.val); }
    friend constexpr ModInt operator-(lint a, const ModInt &x) { return ModInt()._setval(a % mod - x.val + mod); }
    friend constexpr ModInt operator*(lint a, const ModInt &x) { return ModInt()._setval(a % mod * x.val % mod); }
    friend constexpr ModInt operator/(lint a, const ModInt &x) { return ModInt()._setval(a % mod * x.inv() % mod); }
    constexpr bool operator==(const ModInt &x) const { return val == x.val; }
    constexpr bool operator!=(const ModInt &x) const { return val != x.val; }
    bool operator<(const ModInt &x) const { return val < x.val; }  // To use std::map<ModInt, T>
    friend std::istream &operator>>(std::istream &is, ModInt &x) { lint t; is >> t; x = ModInt(t); return is; }
    friend std::ostream &operator<<(std::ostream &os, const ModInt &x) { os << x.val;  return os; }
    constexpr lint power(lint n) const {
        lint ans = 1, tmp = this->val;
        while (n) {
            if (n & 1) ans = ans * tmp % mod;
            tmp = tmp * tmp % mod;
            n /= 2;
        }
        return ans;
    }
    constexpr lint inv() const { return this->power(mod - 2); }
    constexpr ModInt operator^(lint n) const { return ModInt(this->power(n)); }
    constexpr ModInt &operator^=(lint n) { return *this = *this ^ n; }

    inline ModInt fac() const {
        static std::vector<ModInt> facs;
        int l0 = facs.size();
        if (l0 > this->val) return facs[this->val];

        facs.resize(this->val + 1);
        for (int i = l0; i <= this->val; i++) facs[i] = (i == 0 ? ModInt(1) : facs[i - 1] * ModInt(i));
        return facs[this->val];
    }

    ModInt doublefac() const {
        lint k = (this->val + 1) / 2;
        if (this->val & 1) return ModInt(k * 2).fac() / ModInt(2).power(k) / ModInt(k).fac();
        else return ModInt(k).fac() * ModInt(2).power(k);
    }

    ModInt nCr(const ModInt &r) const {
        if (this->val < r.val) return ModInt(0);
        return this->fac() / ((*this - r).fac() * r.fac());
    }

    ModInt sqrt() const {
        if (val == 0) return 0;
        if (mod == 2) return val;
        if (power((mod - 1) / 2) != 1) return 0;
        ModInt b = 1;
        while (b.power((mod - 1) / 2) == 1) b += 1;
        int e = 0, m = mod - 1;
        while (m % 2 == 0) m >>= 1, e++;
        ModInt x = power((m - 1) / 2), y = (*this) * x * x;
        x *= (*this);
        ModInt z = b.power(m);
        while (y != 1) {
            int j = 0;
            ModInt t = y;
            while (t != 1) j++, t *= t;
            z = z.power(1LL << (e - j - 1));
            x *= z, z *= z, y *= z;
            e = j;
        }
        return ModInt(std::min(x.val, mod - x.val));
    }
};
#define PROBLEM "https://judge.yosupo.jp/problem/general_matching"

using namespace std;

int main()
{
    //それぞれの三角形につき、(u->v,u->w),(v->u,v->w),(w->u,w->v)の3択のいずれかを貼ると解釈
    //できる有向グラフが根付き木にできることが必要十分条件？
    //(u->v,u->w)の代わりに(v<->w)に貼る、みたいなことを考えると、一般マッチングになっていることが必要条件
    //ただしそれだけだと最初の有向グラフに戻したときになもりになることがある、情助

    cin.tie(NULL), ios::sync_with_stdio(false);

    int N, M;
    cin >> N >> M;
    vector<pair<int, int>> edges;
    for(int i = 0; i < M; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        u--; v--; w--;
        edges.emplace_back(u, v);
        edges.emplace_back(v, w);
        edges.emplace_back(w, u);
    }
    vector<pair<int, int>> ret = generalMatching<ModInt<1000000007>>(N, edges);
    cout << ret.size() << '\n';
}

yukicoder

結果

テストケース

ソースコード