#954709 (C++17) No.2651 [Cherry 6th Tune B] $\mathbb{C}$omplex комбинат

• 問題: No.2651 [Cherry 6th Tune B] $\mathbb{C}$omplex комбинат
• ユーザー: Today03
• 提出日時: 2024-02-23 23:13:44
• 言語: C++17 (gcc 13.3.0 + boost 1.87.0)
• 結果: AC
• 実行時間: 1,028 ms / 2,500 ms
• コード長: 4,532 bytes
• コンパイル時間: 2,442 ms
• コンパイル使用メモリ: 209,064 KB
• 最終ジャッジ日時: 2025-02-19 20:35:00
• ジャッジサーバーID （参考情報）: judge4 / judge3

ファイルパターン	結果
other	AC * 39

ソースコード

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#include <bits/stdc++.h>
#ifdef LOCAL
#include "./debug.cpp"
#else
#define debug(...)
#define print_line
#endif
using namespace std;
using ll = long long;
template <long long MOD>
struct modint {
    long long value;
    modint(long long x = 0) {
        if (x >= 0) {
            value = x % MOD;
        } else {
            value = MOD - (-x) % MOD;
        }
    }
    modint operator-() const {
        return modint(-value);
    }
    modint operator+() const {
        return modint(*this);
    }
    modint &operator+=(const modint &other) {
        value += other.value;
        if (value >= MOD) value -= MOD;
        return *this;
    }
    modint &operator-=(const modint &other) {
        value += MOD - other.value;
        if (value >= MOD) value -= MOD;
        return *this;
    }
    modint &operator*=(const modint other) {
        value = value * other.value % MOD;
        return *this;
    }
    modint &operator/=(modint other) {
        (*this) *= other.inv();
        return *this;
    }
    modint operator+(const modint &other) const {
        return modint(*this) += other;
    }
    modint operator-(const modint &other) const {
        return modint(*this) -= other;
    }
    modint operator*(const modint &other) const {
        return modint(*this) *= other;
    }
    modint operator/(const modint &other) const {
        return modint(*this) /= other;
    }
    modint pow(long long x) const {
        modint ret(1), mul(value);
        while (x) {
            if (x & 1) ret *= mul;
            mul *= mul;
            x >>= 1;
        }
        return ret;
    }
    modint inv() const {
        return pow(MOD - 2);
    }
    bool operator==(const modint &other) const {
        return value == other.value;
    }
    bool operator!=(const modint &other) const {
        return value != other.value;
    }
    friend ostream &operator<<(ostream &os, const modint &x) {
        return os << x.value;
    }
    friend istream &operator>>(istream &is, modint &x) {
        long long v;
        is >> v;
        x = modint<MOD>(v);
        return is;
    }
};
using mod998 = modint<998244353>;
using mod107 = modint<1000000007>;
using mint = mod998;
int main() {
    int T;
    cin >> T;
    while (T--) {
        int N;
        cin >> N;
        vector<mint> X(N), Y(N);
        for (int i = 0; i < N; i++) cin >> X[i] >> Y[i];
        vector<mint> A(N), B(N), C(N), D(N), E(N), F(N), G(N);
        for (int i = 0; i < N; i++) {
            A[i] = X[i] * X[i] * X[i] * X[i];
            B[i] = Y[i] * Y[i] * Y[i] * Y[i];
            C[i] = X[i] * X[i];
            D[i] = Y[i] * Y[i];
            E[i] = X[i] * Y[i];
            F[i] = E[i] * E[i];
            G[i] = (X[i] * X[i] + Y[i] * Y[i]).inv();
            A[i] *= (X[i] * X[i] + Y[i] * Y[i]).inv();
            B[i] *= (X[i] * X[i] + Y[i] * Y[i]).inv();
            C[i] *= (X[i] * X[i] + Y[i] * Y[i]).inv();
            D[i] *= (X[i] * X[i] + Y[i] * Y[i]).inv();
            E[i] *= (X[i] * X[i] + Y[i] * Y[i]).inv();
            F[i] *= (X[i] * X[i] + Y[i] * Y[i]).inv();
        }
        vector<mint> A1(N + 1), B1(N + 1), C1(N + 1), D1(N + 1), E1(N + 1), F1(N + 1), G1(N + 1);
        for (int i = 0; i < N; i++) {
            A1[i + 1] = A1[i] + A[i];
            B1[i + 1] = B1[i] + B[i];
            C1[i + 1] = C1[i] + C[i];
            D1[i + 1] = D1[i] + D[i];
            E1[i + 1] = E1[i] + E[i];
            F1[i + 1] = F1[i] + F[i];
            G1[i + 1] = G1[i] + G[i];
        }
        mint ans = 0;
        for (int i = 0; i < N; i++) {
            mint res = 0;
            res += (X[i] * X[i] * X[i] * X[i] + X[i] * X[i] * Y[i] * Y[i] * 2 + Y[i] * Y[i] * Y[i] * Y[i]) * (G1[N] - G1[i + 1]) * (X[i] * X[i] + 
                Y[i] * Y[i]).inv();
            res -= (C1[N] - C1[i + 1]) * (X[i] * X[i] * (X[i] * X[i] + Y[i] * Y[i]).inv()) * 2;
            res += (D1[N] - D1[i + 1]) * (X[i] * X[i] * (X[i] * X[i] + Y[i] * Y[i]).inv()) * 2;
            res -= (E1[N] - E1[i + 1]) * (X[i] * Y[i] * (X[i] * X[i] + Y[i] * Y[i]).inv()) * 8;
            res += (C1[N] - C1[i + 1]) * (Y[i] * Y[i] * (X[i] * X[i] + Y[i] * Y[i]).inv()) * 2;
            res -= (D1[N] - D1[i + 1]) * (Y[i] * Y[i] * (X[i] * X[i] + Y[i] * Y[i]).inv()) * 2;
            res += (A1[N] - A1[i + 1]) * (X[i] * X[i] + Y[i] * Y[i]).inv();
            res += (B1[N] - B1[i + 1]) * (X[i] * X[i] + Y[i] * Y[i]).inv();
            res += (F1[N] - F1[i + 1]) * (X[i] * X[i] + Y[i] * Y[i]).inv() * 2;
            ans += res;
        }
        cout << ans << '\n';
    }
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX