結果
| 問題 | No.2985 May Count Induced C4 Subgraphs |
| ユーザー |
 wsrtrt
|
| 提出日時 | 2024-12-13 06:20:46 |
| 言語 | C++23 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
MLE
|
| 実行時間 | - |
| コード長 | 19,378 bytes |
| コンパイル時間 | 5,183 ms |
| コンパイル使用メモリ | 302,208 KB |
| 実行使用メモリ | 817,888 KB |
| 最終ジャッジ日時 | 2024-12-13 06:21:18 |
| 合計ジャッジ時間 | 31,105 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge4 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,248 KB |
| testcase_02 | AC | 2 ms
5,248 KB |
| testcase_03 | AC | 2 ms
5,248 KB |
| testcase_04 | AC | 2 ms
5,248 KB |
| testcase_05 | AC | 2 ms
5,248 KB |
| testcase_06 | AC | 1,512 ms
433,088 KB |
| testcase_07 | AC | 1,349 ms
433,308 KB |
| testcase_08 | AC | 1,392 ms
433,040 KB |
| testcase_09 | AC | 1,330 ms
431,928 KB |
| testcase_10 | AC | 1,296 ms
433,292 KB |
| testcase_11 | MLE | - |
| testcase_12 | AC | 433 ms
51,584 KB |
| testcase_13 | AC | 439 ms
51,500 KB |
| testcase_14 | AC | 372 ms
51,504 KB |
| testcase_15 | AC | 311 ms
51,496 KB |
| testcase_16 | AC | 308 ms
51,368 KB |
| testcase_17 | AC | 2,213 ms
234,404 KB |
| testcase_18 | AC | 2,158 ms
233,896 KB |
| testcase_19 | AC | 2,372 ms
234,656 KB |
| testcase_20 | AC | 2,357 ms
140,548 KB |
| testcase_21 | AC | 2,435 ms
234,644 KB |
ソースコード
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
IN(__VA_ARGS__)
#define ll long long
#define yes cout<<"Yes"<<"\n"
#define no cout<<"No"<<"\n"
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#define allr(x) (x).rbegin(),(x).rend()
#define SUM(v) accumulate(all(v), 0LL)
#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
#define pii pair<int, int>
#define pll pair<long long,long long>
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define vi vector<int>
#define vll vector<long long>
#define vc vector<char>
#define vvi vector<vector<int>>
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size) \
vector<type> name(size); \
IN(name)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S> void scan(pair<T, S> &p) { scan(p.first), scan(p.second); }
template <class T> void scan(vector<T> &);
template <class T> void scan(vector<T> &a) {
for(auto &i : a) scan(i);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T> void print(const T &a) { cout << a; }
void OUT() { cout << endl; }
template <class Head, class... Tail> void OUT(const Head &head, const Tail &...tail) {
print(head);
if(sizeof...(tail)) cout << ' ';
OUT(tail...);
}
#define vv(type, name, h, ...) vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, w) \
vector<vector<type>> name(h, vector<type>(w)); \
IN(name)
#define vvv(type, name, h, w, ...) vector<vector<vector<type>>> name(h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...) \
vector<vector<vector<vector<type>>>> name(a, vector<vector<vector<type>>>(b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))
template<typename T> using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> pair<T, T> operator-(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.ff - y.ff, x.ss - y.ss); }
template <class T> pair<T, T> operator+(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.ff + y.ff, x.ss + y.ss); }
template <class T> pair<T, T> operator&(const pair<T, T> &l, const pair<T, T> &r) { return pair<T, T>(max(l.ff, r.ff), min(l.ss, r.ss)); }
template <class T> vector<T> &operator--(vector<T> &v) {
fore(e, v) e--;
return v;
}
template <class T> vector<T> operator--(vector<T> &v, int) {
auto res = v;
fore(e, v) e--;
return res;
}
template <class T> vector<T> &operator++(vector<T> &v) {
fore(e, v) e++;
return v;
}
template <class T> vector<T> operator++(vector<T> &v, int) {
auto res = v;
fore(e, v) e++;
return res;
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end())
//座標圧縮
template <typename T> void zip(vector<T> &x) {
vector<T> y = x;
UNIQUE(y);
for(int i = 0; i < x.size(); ++i) { x[i] = lb(y, x[i]); }
}
template <class T> T ceil(T x, T y) {
assert(y >= 1);
return (x > 0 ? (x + y - 1) / y : x / y);
}
template <class T> T floor(T x, T y) {
assert(y >= 1);
return (x > 0 ? x / y : (x + y - 1) / y);
}
long long POW(long long x, int n) {
long long res = 1LL;
for(; n; n >>= 1, x *= x)
if(n & 1) res *= x;
return res;
}
//0^n=0
long long modpow(long long a, long long n, long long mod) {
a%=mod;
assert(a!=0||n!=0);
if(a==0)return 0;
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
//return 0<=a&&a<h&&0<=b&&b<w;
inline bool ingrid(ll a,ll b,ll h,ll w){return 0<=a&&a<h&&0<=b&&b<w;}
//return 0<=a&&a<n;
inline bool inl(int a,int n){return 0<=a&&a<n;}
// bit 演算系
ll pow2(int i) { return 1LL << i; }
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int lowbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int lowbit(ll a) { return a == 0 ? 64 : __builtin_ctzll(a); }
// int allbit(int n) { return (1 << n) - 1; }
ll allbit(ll n) { return (1LL << n) - 1; }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
int in() {
int x;
cin >> x;
return x;
}
ll lin() {
unsigned long long x;
cin >> x;
return x;
}
long long sqrtll(long long x) {
assert(x >= 0);
long long rev = sqrt(x);
while(rev * rev > x) --rev;
while((rev+1) * (rev+1)<=x) ++rev;
return rev;
}
int logN(long long n){
int ret=1;
while((1LL<<ret)<n)ret++;
return ret;
}
const double PI=3.1415926535897932384626433832795028841971;
const ll MOD998 = 998244353;
const int INFI = numeric_limits<int>::max() / 2; const long long INFL = numeric_limits<long long>::max() / 2;
#define inf INFINITY
template<class T>
void debug(vector<T> a){
rep(i,0,(int)a.size()){
cout<<a[i]<<' ';
}
cout<<endl;
return;
}
bool palindrome(const string& s){
return equal(all(s),s.rbegin());
}
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
constexpr u64 &val() noexcept { return a; }
constexpr const u64 &val() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
friend bool operator==(const modint& a,const modint& b) { return a.val()==b.val(); }
friend bool operator!=(const modint& a,const modint& b) { return a.val()!=b.val(); }
};
using mint9=modint<998244353>;
using mint1=modint<1000000007>;
//costを指定しないと重みなし辺になります
struct Edge{
int from,to;
ll cost;
int idx{0};
Edge()=default;
Edge(int from,int to,ll cost=1):from(from),to(to),cost(cost){}
operator int() const {return to;}
};
constexpr pii dx4[4] = {pii{-1, 0},pii{0, -1}, pii{0, 1}, pii{1, 0} };
constexpr pii dx8[8] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
constexpr pii dx[100]={{1,0},{0,1},{1,1},{0,0}};
#define el "\n"
#define endl "\n"
#define fastio std::cin.sync_with_stdio(false);std::cin.tie(nullptr);
//{1,1,1,1,1,1,1,1,1,1,1}
mint9 solveVec1(int n,int m){
mint9 res=1;
rep(i,0,4)res*=n-i;
rep(i,1,4+1)res/=i;
return res;
}
//{0,1,2,2,3,3,3,4,4,5,6}
mint9 solveVec2(int n,int m){
mint9 res=12*m;
rep(i,0,2)res*=n-i-2;
res/=24;
return res;
}
vector<ll> d;
//{0,0,1,0,3,2,3,4,5,8,12},
mint9 solveVec3(int n,int m,vi &u,vi &v){
mint9 res=0;
d.resize(n);
rep(i,0,m){
d[u[i]]++;d[v[i]]++;
}
rep(i,0,n){
if(d[i]!=0)res+=(d[i]-1)*d[i]/2;
}
res*=(n-3);
return res;
}
//{0,0,0,1,0,1,0,2,1,2,3}
mint9 solveVec4(int n,ll m,vi &u,vi &v){
mint9 res=0;
rep(i,0,m){
res+=(m-d[u[i]]-d[v[i]]+1);
}
res/=2;
return res;
}
//{0,0,0,0,1,0,0,0,1,2,4}
mint9 solveVec5(int n,int m,vi &u,vi &v){
mint9 res=0;
rep(i,0,n){
if(d[i]>=3){
mint9 tmp=d[i]*(d[i]-1);tmp*=(d[i]-2);
tmp/=6;
res+=tmp;
}
}
return res;
}
vll tdeg;
vll cnt;
template<class G>
vector<tuple<int,int,int>> EnumerateTriangles(G& g){
int n=g.size();
vector<vector<Edge>> h(n);
vector<int> deg(n);
for(int i=0;i<n;i++){
for(auto &j:g[i]){
deg[i]++;
deg[j]++;
}
}
for(int i=0;i<n;i++){
for(auto &j:g[i]){
if((deg[i]==deg[(int)j] && i < (int)j) || deg[i] < deg[(int)j]){
h[i].push_back({i,j});
h[i].back().idx=j.idx;
}
}
}
vector<tuple<int,int,int>> res;
vector<int> flag(n,-1);
for(int i=0;i<n;i++){
for(auto &j:h[i]){
flag[(int)j] = j.idx;
}
for(auto &j:h[i]){
for(auto &k:h[(int)j]){
if(flag[(int)k]!=-1){
res.emplace_back(i,j,k);
cnt[j.idx]++;
cnt[k.idx]++;
cnt[flag[(int)k]]++;
tdeg[i]++;
tdeg[j]++;
tdeg[k]++;
}
}
}
for(auto &j:h[i]){
flag[(int)j] = -1;
}
}
return res;
};
/*
辺の数を M として三角形の数は高々 Msqrt(2M) 個
グラフの三角形をO(Msqrt(M))で列挙できる
辺の向きを(次数の小さい頂点)->(次数の大きい頂点)とすることで出次数をいい感じに抑えつつ
DAGにできる
参考
https://ei1333.github.io/library/graph/others/enumerate-triangles.hpp.html
https://www.slideshare.net/slideshow/trianguler/38443802#58
*/
vector<tuple<int,int,int>> tr;
//{0,0,0,0,0,1,0,4,2,6,12}
mint9 solveVec6(int n,int m,vi u,vi v){
mint9 res=0;
rep(i,0,m){
res+=(d[u[i]]-1)*(d[v[i]]-1);
}
res-=3*(ll)tr.size();
return res;
}
//{0,0,0,1,0,1,0,2,1,2,3},
mint9 solveVec7(int n,int m,vi &u,vi &v){
mint9 res=tr.size();
res*=(n-3);
return res;
}
//{0,0,0,0,0,0,0,0,1,4,12}
mint9 solveVec9(int n,int m,vi &u,vi &v){
mint9 res=0;
rep(i,0,m){
res+=tdeg[u[i]]+tdeg[v[i]];
}
res-=6*(ll)tr.size();
return res;
}
//{0,0,0,0,0,0,0,0,0,1,6}
mint9 solveVec10(int n,int m,vi &u,vi &v){
mint9 res=0;
rep(i,0,m){
res+=(cnt[i]-1)*(cnt[i])/2;
}
return res;
}
class CountingC4 {
private:
int V, threshold;
vector<vector<int> > G;
vector<vector<array<int, 2> > > memo;
vector<int> flag1, flag2;
void process_high_degree(long long& ans){
for(int i = 0; i < V; ++i){
if((int)G[i].size() <= threshold) continue;
for(const int u : G[i]){
if(u > i) flag1[u] = 1;
flag2[u] = 1;
}
for(int j = 0; j < i; ++j){
if((int)G[j].size() > threshold) continue;
long long cnt1 = 0, cnt2 = 0;
for(const int u : G[j]){
if(u < j || !flag2[u]) continue;
if((int)G[u].size() > threshold) ++cnt1;
else ++cnt2;
}
ans += (cnt1 + cnt2) * (cnt1 + cnt2 - 1) / 2;
}
for(int j = i + 1; j < V; ++j){
long long cnt = 0;
for(const int u : G[j]){
if(flag1[u]) ++cnt;
}
ans += cnt * (cnt - 1) / 2;
}
for(const int u : G[i]) flag1[u] = flag2[u] = 0;
}
}
void process_low_degree(long long& ans){
for(int i = 0; i < V; ++i){
if((int)G[i].size() > threshold) continue;
for(const int u : G[i]){
for(const int v : G[i]){
if(v > u) memo[u].push_back({i, v});
}
}
}
for(int i = 0; i < V; ++i){
for(const auto& e : memo[i]){
if(e[0] < i) ++flag1[e[1]];
else ++flag2[e[1]];
}
for(const auto& e : memo[i]){
ans += (long long)(flag1[e[1]] + 2 * flag2[e[1]] - 1) * flag1[e[1]] / 2;
flag1[e[1]] = flag2[e[1]] = 0;
}
}
}
public:
CountingC4(const int node_size)
: V(node_size), threshold(0), G(V), memo(V), flag1(V, 0), flag2(V, 0){}
void add_edge(const int u, const int v){
G[u].push_back(v), G[v].push_back(u);
++threshold;
}
long long solve(){
threshold = floor(sqrt(2 * threshold)) / 2;
long long ans = 0;
process_high_degree(ans);
process_low_degree(ans);
return ans;
}
};
//{0,0,0,0,0,0,0,1,0,1,3}
mint9 solveVec14(int n,int m,vi &u,vi &v){
CountingC4 cc(n);
rep(i,0,m){
cc.add_edge(u[i],v[i]);
}
mint9 res=cc.solve();
return res;
}
long long modinv(long long a, long long mod) {
long long b = mod, u = 1, v = 0;
while (b) {
long long t = a/b;
a -= t*b; swap(a, b);
u -= t*v; swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
// matrix
template<int MOD> struct Matrix {
vector<vector<long long> > val;
Matrix(int n, int m, long long x = 0) : val(n, vector<long long>(m, x)) {}
void init(int n, int m, long long x = 0) {val.assign(n, vector<long long>(m, x));}
size_t size() const {return val.size();}
inline vector<long long>& operator [] (int i) {return val[i];}
};
template<int MOD> int GaussJordan(Matrix<MOD> &A, bool is_extended = false) {
int m = A.size(), n = A[0].size();
for (int row = 0; row < m; ++row)
for (int col = 0; col < n; ++col)
A[row][col] = (A[row][col] % MOD + MOD) % MOD;
int rank = 0;
for (int col = 0; col < n; ++col) {
if (is_extended && col == n-1) break;
int pivot = -1;
for (int row = rank; row < m; ++row) {
if (A[row][col] != 0) {
pivot = row;
break;
}
}
if (pivot == -1) continue;
swap(A[pivot], A[rank]);
auto inv = modinv(A[rank][col], MOD);
for (int col2 = 0; col2 < n; ++col2)
A[rank][col2] = A[rank][col2] * inv % MOD;
for (int row = 0; row < m; ++row) {
if (row != rank && A[row][col]) {
auto fac = A[row][col];
for (int col2 = 0; col2 < n; ++col2) {
A[row][col2] -= A[rank][col2] * fac % MOD;
if (A[row][col2] < 0) A[row][col2] += MOD;
}
}
}
++rank;
}
return rank;
}
void solve(ll n,ll m,vi &u,vi &v){
vector<vector<Edge>> g(n);
rep(i,0,m){
g[u[i]].pb({u[i],v[i]});
g[u[i]].back().idx=i;
g[v[i]].pb({v[i],u[i]});
g[v[i]].back().idx=i;
}
tr=EnumerateTriangles(g);
Matrix<998244353> mt(10,12);
mt.val={
{1,1,1,1,1,1,1,1,1,1,1,(ll)solveVec1(n,m).val()},
{0,1,2,2,3,3,3,4,4,5,6,(ll)solveVec2(n,m).val()},
{0,0,1,0,3,2,3,4,5,8,12,(ll)solveVec3(n,m,u,v).val()},
{0,0,0,1,0,1,0,2,1,2,3,(ll)solveVec4(n,m,u,v).val()},
{0,0,0,0,1,0,0,0,1,2,4,(ll)solveVec5(n,m,u,v).val()},
{0,0,0,0,0,1,0,4,2,6,12,(ll)solveVec6(n,m,u,v).val()},
{0,0,0,0,0,0,1,0,1,2,4,(ll)solveVec7(n,m,u,v).val()},
{0,0,0,0,0,0,0,1,0,1,3,(ll)solveVec14(n,m,u,v).val()},
{0,0,0,0,0,0,0,0,1,4,12,(ll)solveVec9(n,m,u,v).val()},
{0,0,0,0,0,0,0,0,0,1,6,(ll)solveVec10(n,m,u,v).val()}
};
GaussJordan(mt,1);
mint9 ans=mt[0].back();
mint9 p=1;p/=3;
mint9 q=0;q-=p;
cout<<q.val()<<' ';
ans+=q*mt[7].back();
cout<<ans.val()<<' ';
cout<<endl;
}
int main(){
fastio
INT(n,m);
tdeg.resize(n);
cnt.resize(m);
if(n<4){
OUT(0,0);
return 0;
}
vi u(m),v(m);
rep(i,0,m){
IN(u[i],v[i]);
}
u--;v--;
solve(n,m,u,v);
return 0;
}
/*
{
{1,1,1,1,1,1,1,1,1,1,1},
{0,1,2,2,3,3,3,4,4,5,6},
{0,0,1,0,3,2,3,4,5,8,12},
{0,0,0,1,0,1,0,2,1,2,3},
{0,0,0,0,1,0,0,0,1,2,4},
{0,0,0,0,0,1,0,4,2,6,12},
{0,0,0,0,0,0,1,0,1,2,4},
{0,0,0,0,0,0,0,1,0,1,3},
{0,0,0,0,0,0,0,0,1,4,12},
{0,0,0,0,0,0,0,0,0,1,6}
};
*/