結果

問題 No.2985 May Count Induced C4 Subgraphs
ユーザー ecottea
提出日時 2024-12-10 01:59:09
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
CE  
(最新)
AC  
(最初)
実行時間 -
コード長 11,488 bytes
コンパイル時間 3,522 ms
コンパイル使用メモリ 247,568 KB
最終ジャッジ日時 2025-02-26 11:42:20
ジャッジサーバーID
(参考情報)
judge3 / judge3
このコードへのチャレンジ
(要ログイン)
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。(リジャッジ後のコンパイルエラーは公開されます)
ただし、clay言語の場合は開発者のデバッグのため、公開されます。

コンパイルメッセージ
In file included from /usr/include/c++/13/string:43,
                 from /usr/include/c++/13/bitset:52,
                 from /usr/include/x86_64-linux-gnu/c++/13/bits/stdc++.h:52,
                 from main.cpp:13:
/usr/include/c++/13/bits/allocator.h: In destructor ‘std::_Bvector_base<std::allocator<bool> >::_Bvector_impl::~_Bvector_impl()’:
/usr/include/c++/13/bits/allocator.h:184:7: error: inlining failed in call to ‘always_inline’ ‘std::allocator< <template-parameter-1-1> >::~allocator() noexcept [with _Tp = long unsigned int]’: target specific option mismatch
  184 |       ~allocator() _GLIBCXX_NOTHROW { }
      |       ^
In file included from /usr/include/c++/13/vector:67,
                 from /usr/include/c++/13/functional:64,
                 from /usr/include/x86_64-linux-gnu/c++/13/bits/stdc++.h:53:
/usr/include/c++/13/bits/stl_bvector.h:590:14: note: called from here
  590 |       struct _Bvector_impl
      |              ^~~~~~~~~~~~~

ソースコード

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

// QCFium
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#ifndef HIDDEN_IN_VS //
//
#define _CRT_SECURE_NO_WARNINGS
//
#include <bits/stdc++.h>
using namespace std;
//
using ll = long long; using ull = unsigned long long; // -2^63 2^63 = 9e18int -2^31 2^31 = 2e9
using pii = pair<int, int>; using pll = pair<ll, ll>; using pil = pair<int, ll>; using pli = pair<ll, int>;
using vi = vector<int>; using vvi = vector<vi>; using vvvi = vector<vvi>; using vvvvi = vector<vvvi>;
using vl = vector<ll>; using vvl = vector<vl>; using vvvl = vector<vvl>; using vvvvl = vector<vvvl>;
using vb = vector<bool>; using vvb = vector<vb>; using vvvb = vector<vvb>;
using vc = vector<char>; using vvc = vector<vc>; using vvvc = vector<vvc>;
using vd = vector<double>; using vvd = vector<vd>; using vvvd = vector<vvd>;
template <class T> using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
using Graph = vvi;
//
const double PI = acos(-1);
int DX[4] = { 1, 0, -1, 0 }; // 4
int DY[4] = { 0, 1, 0, -1 };
int INF = 1001001001; ll INFL = 4004004003094073385LL; // (int)INFL = INF, (int)(-INFL) = -INF;
//
struct fast_io { fast_io() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(18); } } fastIOtmp;
//
#define all(a) (a).begin(), (a).end()
#define sz(x) ((int)(x).size())
#define lbpos(a, x) (int)distance((a).begin(), std::lower_bound(all(a), (x)))
#define ubpos(a, x) (int)distance((a).begin(), std::upper_bound(all(a), (x)))
#define Yes(b) {cout << ((b) ? "Yes\n" : "No\n");}
#define rep(i, n) for(int i = 0, i##_len = int(n); i < i##_len; ++i) // 0 n-1
#define repi(i, s, t) for(int i = int(s), i##_end = int(t); i <= i##_end; ++i) // s t
#define repir(i, s, t) for(int i = int(s), i##_end = int(t); i >= i##_end; --i) // s t
#define repe(v, a) for(const auto& v : (a)) // a
#define repea(v, a) for(auto& v : (a)) // a
#define repb(set, d) for(int set = 0, set##_ub = 1 << int(d); set < set##_ub; ++set) // d
#define repis(i, set) for(int i = lsb(set), bset##i = set; i < 32; bset##i -= 1 << i, i = lsb(bset##i)) // set
#define repp(a) sort(all(a)); for(bool a##_perm = true; a##_perm; a##_perm = next_permutation(all(a))) // a
#define uniq(a) {sort(all(a)); (a).erase(unique(all(a)), (a).end());} //
#define EXIT(a) {cout << (a) << endl; exit(0);} //
#define inQ(x, y, u, l, d, r) ((u) <= (x) && (l) <= (y) && (x) < (d) && (y) < (r)) //
//
template <class T> inline ll powi(T n, int k) { ll v = 1; rep(i, k) v *= n; return v; }
template <class T> inline bool chmax(T& M, const T& x) { if (M < x) { M = x; return true; } return false; } // true
    
template <class T> inline bool chmin(T& m, const T& x) { if (m > x) { m = x; return true; } return false; } // true
    
template <class T> inline T getb(T set, int i) { return (set >> i) & T(1); }
template <class T> inline T smod(T n, T m) { n %= m; if (n < 0) n += m; return n; } // mod
//
template <class T, class U> inline istream& operator>>(istream& is, pair<T, U>& p) { is >> p.first >> p.second; return is; }
template <class T> inline istream& operator>>(istream& is, vector<T>& v) { repea(x, v) is >> x; return is; }
template <class T> inline vector<T>& operator--(vector<T>& v) { repea(x, v) --x; return v; }
template <class T> inline vector<T>& operator++(vector<T>& v) { repea(x, v) ++x; return v; }
#endif //
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
#ifdef _MSC_VER
#include "localACL.hpp"
#endif
using mint = modint998244353;
//using mint = static_modint<1000000009>;
//using mint = modint; // mint::set_mod(m);
namespace atcoder {
inline istream& operator>>(istream& is, mint& x) { ll x_; is >> x_; x = x_; return is; }
inline ostream& operator<<(ostream& os, const mint& x) { os << x.val(); return os; }
}
using vm = vector<mint>; using vvm = vector<vm>; using vvvm = vector<vvm>; using vvvvm = vector<vvvm>; using pim = pair<int, mint>;
#endif
#ifdef _MSC_VER // Visual Studio
#include "local.hpp"
#else // gcc
inline int popcount(int n) { return __builtin_popcount(n); }
inline int popcount(ll n) { return __builtin_popcountll(n); }
inline int lsb(int n) { return n != 0 ? __builtin_ctz(n) : 32; }
inline int lsb(ll n) { return n != 0 ? __builtin_ctzll(n) : 64; }
inline int msb(int n) { return n != 0 ? (31 - __builtin_clz(n)) : -1; }
inline int msb(ll n) { return n != 0 ? (63 - __builtin_clzll(n)) : -1; }
#define dump(...)
#define dumpel(...)
#define dump_list(v)
#define dump_mat(v)
#define input_from_file(f)
#define output_to_file(f)
#define Assert(b) { if (!(b)) { vc MLE(1<<30); EXIT(MLE.back()); } } // RE MLE
#endif
//O(n + m)
/*
* (, ) n m
*
* n :
* m : n-1
* directed : false
* zero_indexed : 0-indexed false
*/
Graph read_Graph(int n, int m = -1, bool directed = false, bool zero_indexed = false) {
// verify : https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_bi
Graph g(n);
if (m == -1) m = n - 1;
rep(j, m) {
int a, b;
cin >> a >> b;
if (!zero_indexed) { --a; --b; }
g[a].push_back(b);
if (!directed && a != b) g[b].push_back(a);
}
return g;
}
//r n-r O(min(r, n-r))
/*
* nCr
*/
mint bin_mint(ll n, ll r) {
// verify : https://atcoder.jp/contests/tessoku-book/tasks/tessoku_book_ad
mint num = 1, dnm = 1;
chmin(r, n - r);
if (r < 0) return 0;
Assert(n >= 0);
rep(i, r) {
num *= n - i;
dnm *= i + 1;
}
return num / dnm;
}
//O(m √m log n) ?
/*
* g {v1, v2, v3} v1 < v2 < v3
*/
mint enumerate_triangles(const Graph& g) {
// verify : https://judge.yosupo.jp/problem/enumerate_triangles
int n = sz(g);
// gD : g s → t (s < t) DAG
vector<vector<pii>> gD(n); int m = 0;
rep(s, n) repe(t, g[s]) if (s < t) gD[s].push_back({ t, m++ });
// d[s] : gD s
vi d(n);
rep(s, n) {
d[s] = sz(gD[s]);
sort(all(gD[s])); //
}
vi cnt_v(n);
vi cnt_e(m);
rep(s, n) for (auto [t, id1] : gD[s]) {
if (d[s] < d[t]) {
// s→u u t→u 調
repir(j, sz(gD[s]) - 1, 0) {
auto [u, id2] = gD[s][j];
if (u <= t) break;
auto it = lower_bound(all(gD[t]), make_pair(u, -1));
if (it != gD[t].end() && it->first == u) {
cnt_v[s]++;
cnt_v[t]++;
cnt_v[u]++;
cnt_e[id1]++;
cnt_e[id2]++;
cnt_e[it->second]++;
}
}
}
else {
// t→u u s→u 調
for (auto [u, id2] : gD[t]) {
auto it = lower_bound(all(gD[s]), make_pair(u, -1));
if (it != gD[s].end() && it->first == u) {
cnt_v[s]++;
cnt_v[t]++;
cnt_v[u]++;
cnt_e[id1]++;
cnt_e[id2]++;
cnt_e[it->second]++;
}
}
}
}
mint x6, x7, x9, x10;
rep(s, n) repe(t, g[s]) if (s < t) {
x6 += mint(sz(g[s]) - 1) * (sz(g[t]) - 1);
}
rep(s, n) {
x6 -= cnt_v[s];
x7 += cnt_v[s];
x9 += cnt_v[s] * mint(sz(g[s]) - 2);
}
rep(s, n) for (auto [t, id] : gD[s]) {
x10 += bin_mint(cnt_e[id], 2);
}
x7 *= (n - 3);
x7 /= 3;
mint res;
res -= x6;
res -= x7;
res += x9;
res -= x10 * 2 / 3;
dump("x6:", x6);
dump("x7:", x7);
dump("x9:", x9);
dump("x10:", x10);
return res;
}
// from
// https://github.com/yosupo06/library-checker-problems/blob/master/graph/counting_c4/sol/correct.cpp
// simple graph
// for each edge
// O( n + m sqrt(m) ) time
std::vector<long long> CountC4Simple(
int n,
std::vector<int> U,
std::vector<int> V,
std::vector<long long> W
) {
int m = int(W.size());
// less incident edges, smaller index
std::vector<int> deg(n);
for (int e = 0; e < m; e++) { deg[U[e]]++; deg[V[e]]++; }
std::vector<int> I(n); for (int i = 0; i < n; i++) I[i] = i;
std::stable_sort(I.begin(), I.end(), [&](int l, int r) { return deg[l] < deg[r]; });
{
std::vector<int> O(n);
for (int i = 0; i < n; i++) O[I[i]] = i;
for (int& u : U) u = O[u];
for (int& u : V) u = O[u];
}
for (int e = 0; e < m; e++) if (U[e] < V[e]) std::swap(U[e], V[e]);
// adjacency list
std::vector<int> estart(n);
for (int i = 0; i < n - 1; i++) estart[i + 1] = estart[i] + deg[I[i]];
std::vector<int> eend = estart;
std::vector<int> eid(m * 2);
std::vector<int> eto(m * 2);
for (int e = 0; e < m; e++) {
int v = U[e];
int w = V[e];
eid[eend[v]] = e;
eto[eend[v]] = w;
eend[v]++;
}
std::vector<int> eendx = eend;
for (int v = 0; v < n; v++) {
for (int i = estart[v]; i < eendx[v]; i++) {
int e = eid[i];
int w = eto[i];
eid[eend[w]] = e;
eto[eend[w]] = v;
eend[w]++;
}
}
std::vector<long long> c(n); // c[x] : number of paths(v --> w --> x)
std::vector<long long> ans(m);
for (int v = n - 1; v >= 0; v--) {
for (int i = estart[v]; i < eend[v]; i++) {
int evw = eid[i];
int w = eto[i];
eend[w] -= 1; // remove w -> v
for (int j = estart[w]; j < eend[w]; j++) {
int ewx = eid[j];
int x = eto[j];
c[x] += W[evw] * W[ewx];
}
}
for (int i = estart[v]; i < eend[v]; i++) {
int evw = eid[i];
int w = eto[i];
for (int j = estart[w]; j < eend[w]; j++) {
int ewx = eid[j];
int x = eto[j];
long long val = c[x] - W[evw] * W[ewx];
ans[evw] += val * W[ewx];
ans[ewx] += val * W[evw];
}
}
for (int i = estart[v]; i < eend[v]; i++) {
int w = eto[i];
for (int j = estart[w]; j < eend[w]; j++) c[eto[j]] = 0;
}
}
return ans;
}
int main() {
// input_from_file("input.txt");
// output_to_file("output.txt");
int n, m;
cin >> n >> m;
auto g = read_Graph(n, m);
mint x1 = bin_mint(n, 4);
dump("x1:", x1);
mint x2 = m * bin_mint(n - 2, 2);
dump("x2:", x2);
mint x3;
rep(s, n) x3 += bin_mint(sz(g[s]), 2);
x3 *= n - 3;
dump("x3:", x3);
mint x4 = bin_mint(m, 2);
rep(s, n) x4 -= bin_mint(sz(g[s]), 2);
dump("x4:", x4);
mint x5;
rep(s, n) x5 += bin_mint(sz(g[s]), 3);
dump("x5:", x5);
vi U, V; int M = 0;
rep(s, n) repe(t, g[s]) if (s < t) {
U.push_back(s);
V.push_back(t);
M++;
}
auto ans = CountC4Simple(n, U, V, std::vector<long long>(M, 1));
mint x8;
repe(c, ans) x8 += c;
x8 /= 4;
dump("x8:", x8);
mint res;
res += x1;
res -= x2;
res += x3;
res += x4;
res -= x5;
res += enumerate_triangles(g);
res += x8 * 2 / 3;
mint T = mint(-1) / 3;
cout << T << " " << res << endl;
dump(2 + T * 1);
dump(13 + T * 2);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0