#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,746 ms
コンパイル使用メモリ	226,556 KB
実行使用メモリ	26,076 KB
最終ジャッジ日時	2024-07-06 10:27:00
合計ジャッジ時間	34,040 ms
ジャッジサーバーID （参考情報）	judge1 / judge5

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 10,624 KB
testcase_01	AC	2 ms 5,376 KB
testcase_02	WA	-
testcase_03	AC	2 ms 5,376 KB
testcase_04	AC	3 ms 5,376 KB
testcase_05	WA	-
testcase_06	WA	-
testcase_07	AC	2 ms 5,376 KB
testcase_08	AC	2 ms 5,376 KB
testcase_09	WA	-
testcase_10	AC	2 ms 5,376 KB
testcase_11	WA	-
testcase_12	WA	-
testcase_13	WA	-
testcase_14	WA	-
testcase_15	AC	3 ms 5,376 KB
testcase_16	AC	2 ms 5,376 KB
testcase_17	WA	-
testcase_18	AC	420 ms 7,480 KB
testcase_19	WA	-
testcase_20	AC	19 ms 5,376 KB
testcase_21	AC	1 ms 5,376 KB
testcase_22	AC	18 ms 5,376 KB
testcase_23	AC	20 ms 5,376 KB
testcase_24	WA	-
testcase_25	WA	-
testcase_26	AC	83 ms 5,376 KB
testcase_27	WA	-
testcase_28	AC	3 ms 5,376 KB
testcase_29	WA	-
testcase_30	WA	-
testcase_31	WA	-
testcase_32	AC	1,443 ms 13,968 KB
testcase_33	AC	938 ms 12,060 KB
testcase_34	AC	2 ms 5,376 KB
testcase_35	WA	-
testcase_36	AC	55 ms 5,376 KB
testcase_37	AC	2 ms 5,376 KB
testcase_38	AC	565 ms 8,004 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	588 ms 8,244 KB
testcase_49	WA	-
testcase_50	WA	-
testcase_51	AC	579 ms 8,228 KB
testcase_52	AC	560 ms 8,112 KB
testcase_53	AC	566 ms 8,012 KB
testcase_54	WA	-
testcase_55	WA	-
testcase_56	AC	565 ms 8,108 KB
testcase_57	AC	573 ms 8,204 KB
testcase_58	WA	-
testcase_59	AC	596 ms 8,360 KB
testcase_60	WA	-
testcase_61	AC	603 ms 8,384 KB
testcase_62	WA	-
testcase_63	WA	-
testcase_64	AC	590 ms 8,128 KB
testcase_65	AC	600 ms 8,268 KB
testcase_66	AC	591 ms 8,344 KB
testcase_67	WA	-
testcase_68	AC	592 ms 8,360 KB
testcase_69	AC	590 ms 8,220 KB
testcase_70	WA	-
testcase_71	AC	594 ms 8,236 KB
testcase_72	WA	-
testcase_73	AC	595 ms 8,292 KB
testcase_74	AC	603 ms 8,380 KB
testcase_75	WA	-
testcase_76	AC	616 ms 8,276 KB
testcase_77	WA	-
testcase_78	AC	1 ms 5,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

結果

テストケース

ソースコード