結果

問題 No.1774 Love Triangle (Hard)
ユーザー 👑 ygussany
提出日時 2021-10-12 23:19:27
言語 C
(gcc 13.3.0)
結果
AC  
実行時間 7,228 ms / 8,000 ms
コード長 8,794 bytes
コンパイル時間 1,984 ms
コンパイル使用メモリ 91,444 KB
実行使用メモリ 14,720 KB
最終ジャッジ日時 2024-07-04 17:10:53
合計ジャッジ時間 464,866 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge1
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 90
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <stdio.h>
#define DIM 500
#define M_MAX 1000
const int Mod = 10007;
long long div_mod(long long x, long long y, long long z)
{
    if (x % y == 0) return x / y;
    else return (div_mod((1 + x / y) * y - x, (z % y), y) * z + x) / y;
}
int rank_matrix(int d, int A[][DIM])
{
    if (d <= 0) return 1;
    
    static int i, j, k, r, p[DIM], X[DIM][DIM], inv, tmp[DIM];
    for (i = 0; i < d; i++) p[i] = i;
    for (i = 0; i < d; i++) for (j = 0; j < d; j++) X[i][j] = A[i][j];
    for (i = 0, r = 0; i < d; i++) {
        for (j = r; j < d; j++) if (X[i][p[j]] != 0) break;
        if (j == d) continue;
        else if (j != r) {
            p[r] ^= p[j];
            p[j] ^= p[r];
            p[r] ^= p[j];
        }
        inv = div_mod(1, X[i][p[r]], Mod);
        for (k = i; k < d; k++) tmp[k] = X[k][p[r]] * inv % Mod;
        for (j = r + 1; j < d; j++) {
            if (X[i][p[j]] != 0) {
                for (k = i + 1; k < d; k++) {
                    X[k][p[j]] -= tmp[k] * X[i][p[j]] % Mod;
                    if (X[k][p[j]] < 0) X[k][p[j]] += Mod;
                }
                X[i][p[j]] = 0;
            }
        }
        r++;
    }
    return r;
}
int inv_matrix(int d, int A[][DIM], int A_inv[][DIM])
{
    int dd = d * 2;
    static int i, j, k, p[DIM], X[DIM][DIM*2], inv, tmp;
    for (i = 0; i < d; i++) p[i] = i;
    for (i = 0; i < d; i++) {
        for (j = 0; j < d; j++) {
            X[i][j] = A[i][j];
            X[i][j+d] = (j == i)? 1: 0;
        }
    }
    for (i = 0; i < d; i++) {
        for (k = i; k < d; k++) if (X[p[k]][i] != 0) break;
        if (k == d) return -1;
        else if (k != i) {
            p[i] ^= p[k];
            p[k] ^= p[i];
            p[i] ^= p[k];
        }
        inv = div_mod(1, X[p[i]][i], Mod);
        for (j = i; j < dd; j++) X[p[i]][j] = X[p[i]][j] * inv % Mod;
        for (k = 0; k < d; k++) {
            if (k == i) continue;
            if (X[p[k]][i] != 0) {
                tmp = X[p[k]][i];
                X[p[k]][i] = 0;
                for (j = i + 1; j < dd; j++) {
                    X[p[k]][j] -= tmp * X[p[i]][j] % Mod;
                    if (X[p[k]][j] < 0) X[p[k]][j] += Mod;
                }
            }
        }
    }
    for (i = 0; i < d; i++) for (j = 0; j < d; j++) A_inv[i][j] = X[p[i]][j+d];
    return 0;
}
// A = B
void copy_matrix(int d1, int d2, int A[][DIM], int B[][DIM])
{
    int i, j;
    for (i = 0; i < d1; i++) for (j = 0; j < d2; j++) A[i][j] = B[i][j];
}
// A += cB
void add_matrix(int d, int A[][DIM], int c, int B[][DIM])
{
    int i, j;
    for (i = 0; i < d; i++) {
        for (j = 0; j < d; j++) {
            A[i][j] += (long long)B[i][j] * c % Mod;
            if (A[i][j] >= Mod) A[i][j] -= Mod;
        }
    }
}
// A = A * B
void multiply_matrix_right(int d1, int d2, int d3, int A[][DIM], int B[][DIM])
{
    int i, j, k;
    static long long C[DIM][DIM];
    for (i = 0; i < d1; i++) {
        for (j = 0; j < d3; j++) {
            for (k = 0, C[i][j] = 0; k < d2; k++) C[i][j] += A[i][k] * B[k][j];
        }
    }
    for (i = 0; i < d1; i++) for (j = 0; j < d3; j++) A[i][j] = C[i][j] % Mod;
}
// A = B * A
void multiply_matrix_left(int d1, int d2, int d3, int B[][DIM], int A[][DIM])
{
    int i, j, k;
    static long long C[DIM][DIM];
    for (i = 0; i < d1; i++) {
        for (j = 0; j < d3; j++) {
            for (k = 0, C[i][j] = 0; k < d2; k++) C[i][j] += B[i][k] * A[k][j];
        }
    }
    for (i = 0; i < d1; i++) for (j = 0; j < d3; j++) A[i][j] = C[i][j] % Mod;
}
int SMW_rank2_update_inv(int d, int A_inv[][DIM], int U[][DIM], int VT[][DIM])
{
    static int I[DIM][DIM] = {{1, 0}, {0, 1}}, B[DIM][DIM], B_inv[DIM][DIM];
    int i, j;
    copy_matrix(d, d, B, A_inv);
    multiply_matrix_left(2, d, d, VT, B);
    multiply_matrix_right(2, d, 2, B, U);
    add_matrix(2, B, 1, I);
    if (inv_matrix(2, B, B_inv) != 0) return -1;
    multiply_matrix_left(d, d, 2, A_inv, U);
    multiply_matrix_right(2, d, d, VT, A_inv);
    multiply_matrix_left(d, 2, 2, U, B_inv);
    multiply_matrix_right(d, 2, d, B_inv, VT);
    add_matrix(d, A_inv, Mod - 1, B_inv);
    return 0;
}
void wedge_prod_vector(int d, int b[], int c[], int A[][DIM])
{
    int i, j;
    for (i = 0; i < d; i++) {
        for (j = 0; j < d; j++) {
            A[i][j] = (b[i] * c[j] - c[i] * b[j]) % Mod;
            if (A[i][j] >= Mod) A[i][j] -= Mod;
            else if (A[i][j] < 0) A[i][j] += Mod;
        }
    }
}
#define MT_N 624
#define MT_M 397
#define MT_MATRIX_A 0x9908b0dfUL
#define MT_UPPER_MASK 0x80000000UL
#define MT_LOWER_MASK 0x7fffffffUL
static unsigned int mt[MT_N];
static int mti = MT_N + 1;
void init_genrand(unsigned int s)
{
    mt[0] = s & 0xffffffffUL;
    for (mti = 1; mti < MT_N; mti++) {
        mt[mti] = (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
        mt[mti] &= 0xffffffffUL;
    }
}
unsigned int genrand()
{
    unsigned int y;
    static unsigned int mag01[2] = {0x0UL, MT_MATRIX_A};
    if (mti >= MT_N) {
        int kk;
        if (mti == MT_N + 1) init_genrand(5489UL);
        
        for (kk = 0; kk < MT_N - MT_M; kk++) {
            y = (mt[kk] & MT_UPPER_MASK) | (mt[kk+1] & MT_LOWER_MASK);
            mt[kk] = mt[kk+MT_M] ^ (y >> 1) ^ mag01[y&0x1UL];
        }
        for (; kk < MT_N - 1; kk++) {
            y = (mt[kk] & MT_UPPER_MASK) | (mt[kk+1] & MT_LOWER_MASK);
            mt[kk] = mt[kk+(MT_M-MT_N)] ^ (y >> 1) ^ mag01[y&0x1UL];
        }
        y = (mt[MT_N-1] & MT_UPPER_MASK) | (mt[0] & MT_LOWER_MASK);
        mt[MT_N-1] = mt[MT_M-1] ^ (y >> 1) ^ mag01[y&0x1UL];
        mti = 0;
    }
  
    y = mt[mti++];
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);
    return y;
}
int ans[M_MAX + 1] = {};
void chmax(int* a, int b)
{
    if (*a < b) *a = b;
}
void solve(int N, int M, int u[], int v[], int w[])
{
    int i, j, k, tmp[M_MAX + 1], x[M_MAX + 1], Y[DIM][DIM], Y_inv[DIM][DIM], Z[DIM][DIM], b[DIM], c[DIM], U[DIM][DIM], VT[DIM][DIM];
    long long r;
    if (N % 2 != 0) N++;
    for (i = 0; i < N; i++) for (j = 0; j < N; j++) Y[i][j] = 0;
    for (i = 1; i <= M; i++) {
        r = genrand() % Mod;
        x[i] = r;
        Y[u[i]][v[i]] += r;
        if (Y[u[i]][v[i]] >= Mod) Y[u[i]][v[i]] -= Mod;
        Y[u[i]][w[i]] -= r;
        if (Y[u[i]][w[i]] < 0) Y[u[i]][w[i]] += Mod;
        Y[v[i]][u[i]] -= r;
        if (Y[v[i]][u[i]] < 0) Y[v[i]][u[i]] += Mod;
        Y[v[i]][w[i]] += r;
        if (Y[v[i]][w[i]] >= Mod) Y[v[i]][w[i]] -= Mod;
        Y[w[i]][u[i]] += r;
        if (Y[w[i]][u[i]] >= Mod) Y[w[i]][u[i]] -= Mod;
        Y[w[i]][v[i]] -= r;
        if (Y[w[i]][v[i]] < 0) Y[w[i]][v[i]] += Mod;
    }
    r = rank_matrix(N, Y);
    tmp[M] = r / 2;
    
    for (k = 0; k * 2 + r < N; k++) {
        for (j = 0; j < N; j++) {
            b[j] = genrand() % Mod;
            c[j] = genrand() % Mod;
        }
        wedge_prod_vector(N, b, c, Z);
        add_matrix(N, Y, genrand() % Mod, Z);
    }
    inv_matrix(N, Y, Y_inv);
    
    for (i = M; i > 1; i--) {
        for (j = 0; j < N; j++) {
            U[j][0] = 0;
            U[j][1] = 0;
            VT[0][j] = 0;
            VT[1][j] = 0;
        }
        U[u[i]][0] = x[i];
        U[v[i]][0] = Mod - x[i];
        U[u[i]][1] = x[i];
        U[w[i]][1] = Mod - x[i];
        VT[0][u[i]] = Mod - 1;
        VT[0][w[i]] = 1;
        VT[1][u[i]] = 1;
        VT[1][v[i]] = Mod - 1;
        if (SMW_rank2_update_inv(N, Y_inv, U, VT) != 0) {
            tmp[i-1] = tmp[i] - 1;
            do {
                r = genrand() % Mod;
                for (j = 0; j < N; j++) {
                    b[j] = genrand() % Mod;
                    c[j] = genrand() % Mod;
                    U[j][0] = b[j] * r % Mod;
                    U[j][1] = c[j] * r % Mod;
                    VT[0][j] = c[j];
                    VT[1][j] = Mod - b[j];
                }
                if (SMW_rank2_update_inv(N, Y_inv, U, VT) != 0) continue;
                
                for (j = 0; j < N; j++) {
                    U[j][0] = 0;
                    U[j][1] = 0;
                    VT[0][j] = 0;
                    VT[1][j] = 0;
                }
                U[u[i]][0] = x[i];
                U[v[i]][0] = Mod - x[i];
                U[u[i]][1] = x[i];
                U[w[i]][1] = Mod - x[i];
                VT[0][u[i]] = Mod - 1;
                VT[0][w[i]] = 1;
                VT[1][u[i]] = 1;
                VT[1][v[i]] = Mod - 1;
                if (SMW_rank2_update_inv(N, Y_inv, U, VT) == 0) break;
                
                for (j = 0; j < N; j++) {
                    U[j][0] = b[j] * r % Mod;
                    U[j][1] = c[j] * r % Mod;
                    VT[0][j] = Mod - c[j];
                    VT[1][j] = b[j];
                }
                SMW_rank2_update_inv(N, Y_inv, U, VT);
            } while (1);
            wedge_prod_vector(N, b, c, Z);
            add_matrix(N, Y, r, Z);
        } else tmp[i-1] = tmp[i];
        
        r = x[i];
        Y[u[i]][v[i]] -= r;
        if (Y[u[i]][v[i]] < 0) Y[u[i]][v[i]] += Mod;
        Y[u[i]][w[i]] += r;
        if (Y[u[i]][w[i]] >= Mod) Y[u[i]][w[i]] -= Mod;
        Y[v[i]][u[i]] += r;
        if (Y[v[i]][u[i]] >= Mod) Y[v[i]][u[i]] -= Mod;
        Y[v[i]][w[i]] -= r;
        if (Y[v[i]][w[i]] < 0) Y[v[i]][w[i]] += Mod;
        Y[w[i]][u[i]] -= r;
        if (Y[w[i]][u[i]] < 0) Y[w[i]][u[i]] += Mod;
        Y[w[i]][v[i]] += r;
        if (Y[w[i]][v[i]] >= Mod) Y[w[i]][v[i]] -= Mod;
    }
    for (i = 1; i <= M; i++) chmax(&(ans[i]), tmp[i]);
}
int main()
{
    int i, j, N, M, u[M_MAX + 1], v[M_MAX + 1], w[M_MAX + 1];
    scanf("%d %d", &N, &M);
    if (3 > N || N > 500 || 1 > M || M > 1000 || M > N * (N - 1) * (N - 2) / 6) return -1;
    for (i = 1; i <= M; i++) {
        scanf("%d %d %d", &(u[i]), &(v[i]), &(w[i]));
        if (1 > u[i] || u[i] >= v[i] || v[i] >= w[i] || w[i] > N) return -1;
        u[i]--;
        v[i]--;
        w[i]--;
        for (j = 1; j < i; j++) if (u[j] == u[i] && v[j] == v[i] && w[j] == w[i]) return -1;
    }
    solve(N, M, u, v, w);
    solve(N, M, u, v, w);
    for (i = 1; i <= M; i++) printf("%d\n", ans[i]);
    fflush(stdout);
    return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0