text
stringlengths 10
22.5k
| status
stringclasses 2
values | name
stringlengths 9
26
|
|---|---|---|
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using Int = long long;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << "(" << a.first << ", " << a.second << ")";
};
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) {
const int sz = as.size();
os << "[";
for (int i = 0; i < sz; ++i) {
if (i >= 256) {
os << ", ...";
break;
}
if (i > 0) {
os << ", ";
}
os << as[i];
}
return os << "]";
}
template <class T> void pv(T a, T b) {
for (T i = a; i != b; ++i)
cerr << *i << " ";
cerr << endl;
}
template <class T> bool chmin(T &t, const T &f) {
if (t > f) {
t = f;
return true;
}
return false;
}
template <class T> bool chmax(T &t, const T &f) {
if (t < f) {
t = f;
return true;
}
return false;
}
#define COLOR(s) ("\x1b[" s "m")
// at most 1 cycle in each component
struct Dfs {
int n, m;
vector<pair<int, int>> edges;
// whole graph
vector<vector<int>> g;
// cycle = (us, is) or ({u}, {})
int cyclesLen;
vector<pair<vector<int>, vector<int>>> cycles;
// cycle id or -1
vector<int> on;
// forest
vector<int> par, pari;
vector<vector<int>> graph, graphi;
// root
vector<int> rs;
Dfs() {}
explicit Dfs(int n_) : n(n_), m(0) {}
void ae(int u, int v) {
assert(0 <= u);
assert(u < n);
assert(0 <= v);
assert(v < n);
++m;
edges.emplace_back(u, v);
}
void build() {
assert(m <= n);
g.assign(n, {});
for (int i = 0; i < m; ++i) {
g[edges[i].first].push_back(i);
g[edges[i].second].push_back(i);
}
queue<int> que;
vector<int> deg(n, 0);
for (int u = 0; u < n; ++u) {
deg[u] = g[u].size();
if (deg[u] <= 1)
que.push(u);
}
on.assign(n, -2);
par.assign(n, -1);
pari.assign(n, -1);
for (; que.size();) {
const int u = que.front();
que.pop();
if (deg[u] == 0) {
on[u] = -3;
} else if (deg[u] == 1) {
on[u] = -1;
for (const int i : g[u]) {
const int v = edges[i].first ^ edges[i].second ^ u;
if (on[v] == -2) {
par[u] = v;
pari[u] = i;
if (--deg[v] == 1)
que.push(v);
}
}
} else {
assert(false);
}
}
cyclesLen = 0;
cycles.clear();
for (int s = 0; s < n; ++s)
if (on[s] == -2) {
const int k = cyclesLen++;
vector<int> us, is;
for (int i0 = -1, u = s; on[u] == -2;) {
assert(deg[u] == 2);
for (const int i : g[u])
if (i0 != i) {
const int v = edges[i].first ^ edges[i].second ^ u;
if (on[v] != -1) {
on[u] = k;
us.push_back(u);
is.push_back(i);
i0 = i;
u = v;
break;
}
}
}
cycles.emplace_back(us, is);
}
for (int u = 0; u < n; ++u)
if (on[u] == -3) {
const int k = cyclesLen++;
on[u] = k;
cycles.emplace_back(vector<int>{u}, vector<int>{});
}
graph.assign(n, {});
graphi.assign(n, {});
for (int u = 0; u < n; ++u)
if (!~on[u]) {
graph[par[u]].push_back(u);
graphi[par[u]].push_back(pari[u]);
}
rs.assign(n, -1);
for (int u = 0; u < n; ++u)
if (~on[u]) {
dfs(u, u);
}
}
vector<int> preorder;
void dfs(int u, int r) {
preorder.push_back(u);
rs[u] = r;
for (const int v : graph[u])
dfs(v, r);
}
};
struct PseudoForest {
int n, m;
vector<int> ps, cs;
PseudoForest() {}
PseudoForest(int n_) : n(n_), m(0), ps(n, -1), cs(n, 0) {}
int root(int u) { return (ps[u] < 0) ? u : (ps[u] = root(ps[u])); }
bool ae(int u, int v) {
u = root(u);
v = root(v);
if (u != v) {
if (cs[u] + cs[v] <= 1) {
if (ps[u] > ps[v])
swap(u, v);
ps[u] += ps[v];
ps[v] = u;
cs[u] += cs[v];
++m;
return true;
} else {
return false;
}
} else {
if (cs[u] == 0) {
++cs[u];
++m;
return true;
} else {
return false;
}
}
}
};
constexpr int INF = 1001001001;
int N, M;
vector<int> A, B, D, E;
bool input() {
int X, Y;
if (!~scanf("%d%d", &X, &Y))
return false;
int d[80][80], e[80][80];
for (int x = 0; x < X; ++x)
for (int y = 0; y < Y; ++y)
scanf("%d", &d[x][y]);
for (int x = 0; x < X; ++x)
for (int y = 0; y < Y; ++y)
scanf("%d", &e[x][y]);
vector<pair<pair<int, int>, pair<int, int>>> edges;
for (int x = 0; x < X; ++x)
for (int y = 0; y < Y; ++y) {
edges.emplace_back(make_pair(d[x][y], e[x][y]), make_pair(x, X + y));
}
sort(edges.begin(), edges.end());
reverse(edges.begin(), edges.end());
N = X + Y;
M = edges.size();
A.resize(M);
B.resize(M);
D.resize(M);
E.resize(M);
for (int i = 0; i < M; ++i) {
A[i] = edges[i].second.first;
B[i] = edges[i].second.second;
D[i] = edges[i].first.first;
E[i] = edges[i].first.second;
}
// cerr<<"N = "<<N<<", M = "<<M<<endl;
// cerr<<"A = "<<A<<endl;
// cerr<<"B = "<<B<<endl;
// cerr<<"D = "<<D<<endl;
// cerr<<"E = "<<E<<endl;
return true;
}
int at[160][160][4];
int rmq[160][160][160][4][2];
void top2(int t[2], int f) {
if (t[0] < f)
swap(t[0], f);
if (t[1] < f)
swap(t[1], f);
}
int main() {
constexpr int ENC[4][4] = {
{0, 2, 4, 6},
{2, 8, 10, 12},
{4, 10, 14, 16},
{6, 12, 16, 18},
};
vector<vector<int>> solss[5];
for (int n = 2; n <= 4; ++n) {
// 0: comps with cycle, [1,n): trees
vector<pair<pair<int, int>, int>> edges;
for (int u = 1; u < n; ++u)
for (int v = u + 1; v < n; ++v)
for (int k = 0; k < 2; ++k)
edges.emplace_back(make_pair(u, v), k);
for (int u = 1; u < n; ++u)
edges.emplace_back(make_pair(0, u), 0);
for (int u = 1; u < n; ++u)
edges.emplace_back(make_pair(u, u), 0);
const int m = edges.size();
for (int p = 0; p < 1 << m; ++p)
if (__builtin_popcount(p) == n - 1) {
bool ok = true;
for (int i = 0; i < (n - 1) * (n - 2); i += 2)
if (!(p >> i & 1) && (p >> (i + 1) & 1)) {
ok = false;
break;
}
if (!ok)
continue;
PseudoForest f(n);
f.ae(0, 0);
for (int i = 0; i < m; ++i)
if (p >> i & 1)
if (!f.ae(edges[i].first.first, edges[i].first.second)) {
ok = false;
break;
}
if (!ok)
continue;
assert(f.n == f.m);
solss[n].emplace_back();
for (int i = 0; i < m; ++i)
if (p >> i & 1)
solss[n].back().push_back(
ENC[edges[i].first.first][edges[i].first.second] +
edges[i].second);
}
cerr << "|solss[" << n << "]| = " << solss[n].size() << endl;
}
/*
|solss[2]| = 2
|solss[3]| = 9
|solss[4]| = 63
*/
for (; input();) {
int ans[4];
fill(ans, ans + 4, -1);
vector<int> used(M, 0);
vector<int> opt;
{
PseudoForest f(N);
int d = 0, e = 0;
for (int i = 0; i < M; ++i)
if (f.ae(A[i], B[i])) {
used[i] = 1;
opt.push_back(i);
d += D[i];
e += E[i];
}
assert(f.n == f.m);
chmax(ans[e % 4], d);
}
const int optLen = opt.size();
// cerr<<"opt = "<<opt<<endl;
vector<int> us;
{
Dfs f(N);
for (const int i : opt)
f.ae(A[i], B[i]);
f.build();
us = f.preorder;
}
vector<int> su(N, -1);
for (int j = 0; j < N; ++j)
su[us[j]] = j;
memset(at, ~0, sizeof(at));
for (int i = 0; i < M; ++i)
if (!used[i]) {
const int jA = su[A[i]];
const int jB = su[B[i]];
at[jA][jB][E[i]] = D[i];
at[jB][jA][E[i]] = D[i];
}
for (int j = 0; j < N; ++j)
for (int l = N; --l >= 0;) {
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k)
rmq[j][l][l][e][k] = -INF;
for (int r = l; r < N; ++r) {
for (int e = 0; e < 4; ++e) {
for (int k = 0; k < 2; ++k)
rmq[j][l][r + 1][e][k] = rmq[j][l][r][e][k];
if (~at[j][r][e])
top2(rmq[j][l][r + 1][e], at[j][r][e]);
}
}
}
auto go = [&](const set<int> &ban) -> void {
PseudoForest f(N);
int d0 = 0, e0 = 0;
for (int h = 0; h < optLen; ++h)
if (!ban.count(h)) {
const int i = opt[h];
f.ae(A[opt[h]], B[opt[h]]);
d0 += D[i];
e0 += E[i];
}
// 0: comps with cycle, [1,n): trees
int n = 1;
vector<int> ids(N, -1);
for (int u = 0; u < N; ++u)
if (f.ps[u] < 0)
ids[u] = f.cs[u] ? 0 : n++;
assert(2 <= n);
assert(n <= 4);
for (int u = 0; u < N; ++u)
ids[u] = ids[f.root(u)];
vector<pair<int, int>> lrss[4];
for (int j = 0, jj = 0; j < N; ++j) {
for (; jj < N && ids[us[j]] == ids[us[jj]]; ++jj) {
}
lrss[ids[us[j]]].emplace_back(j, jj);
}
// cerr<<"lrss = ";pv(lrss,lrss+n);
int dd[20][4][2];
for (int c = 0; c < 20; ++c)
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k)
dd[c][e][k] = -INF;
for (int a = 0; a < n; ++a)
for (int b = a; b < n; ++b) {
const int c = ENC[a][b];
for (const auto &lrA : lrss[a])
for (int jA = lrA.first; jA < lrA.second; ++jA) {
for (const auto &lrB : lrss[b]) {
int l = lrB.first, r = lrB.second;
if (a == b)
chmax(l, jA + 1);
if (l < r) {
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k) {
top2(dd[c][e], rmq[jA][l][r][e][k]);
}
}
}
}
}
int d[20][4];
for (int c = 0; c < 20; c += 2)
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k)
d[c + k][e] = dd[c][e][k];
// for(int c=0;c<20;++c)pv(d[c],d[c]+4);cerr<<endl;
int here[4];
fill(here, here + 4, -1);
for (const auto &sol : solss[n]) {
if (n <= 3) {
int dp[4][4];
memset(dp, ~0, sizeof(dp));
dp[0][0] = 0;
for (int j = 0; j < n - 1; ++j) {
for (int e = 0; e < 4; ++e)
if (d[sol[j]][e] >= 0) {
for (int x = 0; x < 4; ++x)
if (dp[j][x] >= 0) {
chmax(dp[j + 1][(x + e) % 4], dp[j][x] + d[sol[j]][e]);
}
}
for (int x = 0; x < 4; ++x)
chmax(here[x], dp[n - 1][x]);
}
} else {
int ds[4] = {-INF, -INF, -INF, -INF};
if (d[sol[1]][0] >= 0) {
chmax(ds[0], d[sol[1]][0] + d[sol[2]][0]);
chmax(ds[1], d[sol[1]][0] + d[sol[2]][1]);
chmax(ds[2], d[sol[1]][0] + d[sol[2]][2]);
chmax(ds[3], d[sol[1]][0] + d[sol[2]][3]);
}
if (d[sol[1]][1] >= 0) {
chmax(ds[1], d[sol[1]][1] + d[sol[2]][0]);
chmax(ds[2], d[sol[1]][1] + d[sol[2]][1]);
chmax(ds[3], d[sol[1]][1] + d[sol[2]][2]);
chmax(ds[0], d[sol[1]][1] + d[sol[2]][3]);
}
if (d[sol[1]][2] >= 0) {
chmax(ds[2], d[sol[1]][2] + d[sol[2]][0]);
chmax(ds[3], d[sol[1]][2] + d[sol[2]][1]);
chmax(ds[0], d[sol[1]][2] + d[sol[2]][2]);
chmax(ds[1], d[sol[1]][2] + d[sol[2]][3]);
}
if (d[sol[1]][3] >= 0) {
chmax(ds[3], d[sol[1]][3] + d[sol[2]][0]);
chmax(ds[0], d[sol[1]][3] + d[sol[2]][1]);
chmax(ds[1], d[sol[1]][3] + d[sol[2]][2]);
chmax(ds[2], d[sol[1]][3] + d[sol[2]][3]);
}
if (d[sol[0]][0] >= 0) {
chmax(here[0], d[sol[0]][0] + ds[0]);
chmax(here[1], d[sol[0]][0] + ds[1]);
chmax(here[2], d[sol[0]][0] + ds[2]);
chmax(here[3], d[sol[0]][0] + ds[3]);
}
if (d[sol[0]][1] >= 0) {
chmax(here[1], d[sol[0]][1] + ds[0]);
chmax(here[2], d[sol[0]][1] + ds[1]);
chmax(here[3], d[sol[0]][1] + ds[2]);
chmax(here[0], d[sol[0]][1] + ds[3]);
}
if (d[sol[0]][2] >= 0) {
chmax(here[2], d[sol[0]][2] + ds[0]);
chmax(here[3], d[sol[0]][2] + ds[1]);
chmax(here[0], d[sol[0]][2] + ds[2]);
chmax(here[1], d[sol[0]][2] + ds[3]);
}
if (d[sol[0]][3] >= 0) {
chmax(here[3], d[sol[0]][3] + ds[0]);
chmax(here[0], d[sol[0]][3] + ds[1]);
chmax(here[1], d[sol[0]][3] + ds[2]);
chmax(here[2], d[sol[0]][3] + ds[3]);
}
}
}
// if(ban.size()==1){
// cerr<<"ban = "<<vector<int>(ban.begin(),ban.end())<<": d0 = "<<d0<<",
// e0 = "<<e0<<", ids = "<<ids<<": here = ";pv(here,here+4);
// }
for (int e = 0; e < 4; ++e)
if (here[e] >= 0)
chmax(ans[(e0 + e) % 4], d0 + here[e]);
};
for (int h0 = 0; h0 < optLen; ++h0)
go({h0});
for (int h0 = 0; h0 < optLen; ++h0)
for (int h1 = h0 + 1; h1 < optLen; ++h1)
go({h0, h1});
for (int h0 = 0; h0 < optLen; ++h0)
for (int h1 = h0 + 1; h1 < optLen; ++h1)
for (int h2 = h1 + 1; h2 < optLen; ++h2)
go({h0, h1, h2});
for (int e = 0; e < 4; ++e) {
printf("%d\n", ans[e]);
}
}
return 0;
}
| failed | 46_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
const int oo = 1e18 + 7;
const int N = 2e6 + 5;
int n, m, q;
bool vis[N][2], ck[N];
int num[N][2];
vector<ii> Adj[N];
vector<int> visited;
bool final[N];
void dfs(int u, int flg) {
if (final[u]) {
return;
}
vis[u][flg] = 1;
visited.push_back(u);
if (flg == 1 && !final[u]) {
ck[u] = 1;
final[u] = 1;
}
for (auto it : Adj[u]) {
int nxt = num[u][flg] + it.se;
if (vis[it.fi][1])
continue;
if (!vis[it.fi][0]) {
num[it.fi][0] = nxt;
dfs(it.fi, 0);
} else {
if (num[it.fi][0] == nxt)
continue;
num[it.fi][1] = nxt;
dfs(it.fi, 1);
}
ck[u] |= ck[it.fi];
}
}
void process() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++)
num[i][0] = num[i][1] = -oo;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
x %= n;
x += n;
x %= n;
Adj[x].push_back({(x + y) % n, y});
}
for (int i = 0; i < n; i++) {
if (vis[i][0])
continue;
visited.clear();
dfs(i, 0);
for (auto it : visited)
final[it] = 1;
}
while (q--) {
int x;
cin >> x;
x %= n;
x += n;
x %= n;
cout << (ck[x] ? "Yes\n" : "No\n");
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
// int t;
// cin >> t >> a0 >> a1 >> a2 >> a3;
// prep();
process();
} | failed | 89_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
int t, n;
string str[500010];
vector<vector<int>> b(500001);
int last[500001];
struct node {
int cnt;
int child[27];
} tree[1000010];
int cnt = 1, ans = 0;
void insert(string w) {
int now = 0;
for (int i = 0; i < w.size(); i++) {
int ch = w[i] - 'a';
if (tree[now].child[ch] == 0) {
tree[now].child[ch] = cnt++;
memset(&tree[cnt - 1], 0, sizeof tree[cnt - 1]);
}
now = tree[now].child[ch];
tree[now].cnt++;
for (auto it = b[tree[now].cnt].begin(); it != b[tree[now].cnt].end();
it++) {
ans ^= (last[*it] * *it);
last[*it]++;
ans ^= (last[*it] * *it);
}
}
}
void find(string w) {
int now = 0;
for (int i = 0; i < w.size(); i++) {
int ch = w[i] - 'a';
if (tree[now].child[ch] == 0) {
cout << "NO\n";
return;
}
now = tree[now].child[ch];
}
cout << "YES\n";
}
void del() {
for (int i = 0; i <= n; i++)
last[i] = 0;
memset(last, 0, sizeof last);
memset(&tree[0], 0, sizeof tree[0]);
cnt = 1;
ans = 0;
}
signed main() {
for (int i = 1; i <= 500000; i++)
for (int j = i; j <= 500000; j += i)
b[j].push_back(i);
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> str[i];
insert(str[i]);
cout << ans << " ";
}
cout << "\n";
// for(int i=1;i<=n;i++)
// find(str[i]);
del();
}
return 0;
} | failed | 40_3_wrong.cpp |
#pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,tune=native")
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <valarray>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long unll;
typedef unsigned int unii;
#define fi first
#define se second
#define double long double
#define int long long
typedef pair<int, int> pll;
const int modulo = 998244353;
const int mod1 = 1e9 + 7;
const int mod2 = 1e9 + 123;
const int N = 2e5 + 5;
const int INF = 1e18;
const int MXN = N - 5;
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
vector<pll> dv;
int s1 = max(0ll, n / 2 - 2);
int s2 = n - s1;
for (int i = 0; i < (1 << s1); i++) {
int sa = 0, sb = 0;
for (int j = 0; j < s1; j++) {
if ((i >> j) & 1)
sa += a[j];
else
sb += b[j];
}
dv.push_back({sa, sb});
}
sort(dv.begin(), dv.end());
vector<pll> mr;
for (auto &p : dv) {
if (mr.empty() || p.se < mr.back().se)
mr.push_back(p);
}
int ans = INF;
for (int i = 0; i < (1 << s2); i++) {
int sa = 0, sb = 0;
for (int j = 0; j < s2; j++) {
if ((i >> j) & 1)
sa += a[s1 + j];
else
sb += b[s1 + j];
}
int l = 0;
int r = mr.size() - 1;
while (l < r) {
int m = (l + r + 1) / 2;
if (mr[m].fi + sa >= mr[m].se + sb)
r = m - 1;
else
l = m;
}
ans = min(ans, max(mr[l].fi + sa, mr[l].se + sb));
if (l + 1 < mr.size())
ans = min(ans, max(mr[l + 1].fi + sa, mr[l + 1].se + sb));
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand((signed)time(0));
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
} | failed | 99_1_wrong.cpp |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;
using i128 = __int128;
template <class T> struct MinCostFlow {
struct _Edge {
int to;
T cap;
T cost;
_Edge(int to_, T cap_, T cost_) : to(to_), cap(cap_), cost(cost_) {}
};
int n;
std::vector<_Edge> e;
std::vector<std::vector<int>> g;
std::vector<T> h, dis;
std::vector<int> pre;
bool dijkstra(int s, int t) {
dis.assign(n, std::numeric_limits<T>::max());
pre.assign(n, -1);
std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int>>,
std::greater<std::pair<T, int>>>
que;
dis[s] = 0;
que.emplace(0, s);
while (!que.empty()) {
T d = que.top().first;
int u = que.top().second;
que.pop();
if (dis[u] != d) {
continue;
}
for (int i : g[u]) {
int v = e[i].to;
T cap = e[i].cap;
T cost = e[i].cost;
if (cap > 0 && dis[v] > d + h[u] - h[v] + cost) {
dis[v] = d + h[u] - h[v] + cost;
pre[v] = i;
que.emplace(dis[v], v);
}
}
}
return dis[t] != std::numeric_limits<T>::max();
}
MinCostFlow() {}
MinCostFlow(int n_) { init(n_); }
void init(int n_) {
n = n_;
e.clear();
g.assign(n, {});
}
void addEdge(int u, int v, T cap, T cost) {
g[u].push_back(e.size());
e.emplace_back(v, cap, cost);
g[v].push_back(e.size());
e.emplace_back(u, 0, -cost);
}
auto flow(int s, int t, int k) {
T flow = 0;
T cost = 0;
h.assign(n, 0);
std::vector<T> ans(k + 1, -1);
ans[0] = 0;
while (flow < k && dijkstra(s, t)) {
for (int i = 0; i < n; ++i) {
h[i] += dis[i];
}
T aug = std::numeric_limits<int>::max();
for (int i = t; i != s; i = e[pre[i] ^ 1].to) {
aug = std::min(aug, e[pre[i]].cap);
}
for (int i = t; i != s; i = e[pre[i] ^ 1].to) {
e[pre[i]].cap -= aug;
e[pre[i] ^ 1].cap += aug;
}
for (int i = 0; i < aug; i++) {
flow++;
cost += h[t];
if (flow <= k) {
ans[flow] = cost;
}
}
}
return ans;
}
struct Edge {
int from;
int to;
T cap;
T cost;
T flow;
};
std::vector<Edge> edges() {
std::vector<Edge> a;
for (int i = 0; i < e.size(); i += 2) {
Edge x;
x.from = e[i + 1].to;
x.to = e[i].to;
x.cap = e[i].cap + e[i + 1].cap;
x.cost = e[i].cost;
x.flow = e[i + 1].cap;
a.push_back(x);
}
return a;
}
};
constexpr int P = 998244353;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m, k;
std::cin >> n >> m >> k;
std::vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
for (int i = 0; i < n; i++) {
std::cin >> b[i];
}
std::vector<std::vector<int>> ban(m);
for (int i = 0; i < m; i++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
ban[u].push_back(v);
}
std::vector<int> p(n);
std::iota(p.begin(), p.end(), 0);
std::sort(p.begin(), p.end(), [&](int i, int j) { return b[i] < b[j]; });
std::vector<int> vis(n, -1);
std::vector<std::array<int, 3>> edges;
edges.reserve(n * k);
for (int i = 0; i < n; i++) {
for (auto y : ban[i]) {
vis[y] = i;
}
int pos = std::partition_point(p.begin(), p.end(),
[&](int x) { return a[i] + b[x] < P; }) -
p.begin();
int cnt = 0;
for (int j = 0; j < n && cnt < k; j++) {
int x = p[(pos - 1 - j + n) % n];
if (vis[x] != i) {
cnt++;
edges.push_back({(a[i] + b[x]) % P, i, x});
}
}
}
std::sort(edges.begin(), edges.end(), std::greater());
std::vector<int> deg(n);
int tot = 0;
MinCostFlow<i64> g(2 * n + 2);
for (auto [w, u, v] : edges) {
if (deg[v] < k && tot < (2 * k - 1) * (k - 1) + 1) {
deg[v]++;
g.addEdge(u, n + v, 1, P - (a[u] + b[v]) % P);
}
}
const int S = 2 * n, T = S + 1;
for (int i = 0; i < n; i++) {
g.addEdge(S, i, 1, 0);
g.addEdge(n + i, T, 1, 0);
}
auto ans = g.flow(S, T, k);
for (int i = 1; i <= k; i++) {
if (ans[i] != -1) {
ans[i] = 1LL * i * P - ans[i];
}
std::cout << ans[i] << " \n"[i == k];
}
return 0;
} | failed | 76_3_wrong.cpp |
#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;
struct Problem {
int i_low, i_high, t_low, t_high;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, i_initial, t_initial;
cin >> n >> i_initial >> t_initial;
vector<Problem> problems(n);
for (int i = 0; i < n; ++i) {
cin >> problems[i].i_low >> problems[i].i_high >> problems[i].t_low >>
problems[i].t_high;
}
vector<unordered_set<int>> dp(1);
dp[0].insert(0);
for (const Problem &p : problems) {
vector<unordered_set<int>> next_dp;
int current_max_m = dp.size() - 1;
next_dp.resize(current_max_m + 1);
for (int m = 0; m <= current_max_m; ++m) {
if (dp[m].empty())
continue;
for (int a : dp[m]) {
// Skip option
next_dp[m].insert(a);
// Check if current problem can be solved
int current_i = i_initial + a;
int current_t = t_initial + (m - a);
if (current_i >= p.i_low && current_i <= p.i_high &&
current_t >= p.t_low && current_t <= p.t_high) {
int new_m = m + 1;
int new_a1 = a + 1;
int new_a2 = a;
if (new_m >= next_dp.size()) {
next_dp.resize(new_m + 1);
}
next_dp[new_m].insert(new_a1);
next_dp[new_m].insert(new_a2);
}
}
}
dp.swap(next_dp);
}
int max_solved = 0;
for (int m = dp.size() - 1; m >= 0; --m) {
if (!dp[m].empty()) {
max_solved = m;
break;
}
}
cout << max_solved << endl;
return 0;
} | failed | 110_3_wrong.cpp |
#include <bits/stdc++.h>
using ll = long long;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int r, c, p;
std::cin >> r >> c >> p;
std::vector dp(r, std::vector<double>(c, 1e9));
dp[0][0] = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (i) {
dp[i][j] = std::min(dp[i][j], dp[i - 1][j] + 1.0 * p / 4);
}
if (j) {
dp[i][j] = std::min(dp[i][j], dp[i][j - 1] + 1.0 * p / 4);
}
if (i && j) {
double a = dp[i - 1][j], b = dp[i][j - 1];
if (a > b) {
std::swap(a, b);
}
if (a + p > b) {
dp[i][j] = std::min(dp[i][j], a / 2 + 1.0 * (p - b + a) / 2 / p * b + 1.0 * (b - a) / 2 / p * (a + b) / 2);
} else {
dp[i][j] = std::min(dp[i][j], a + 1.0 * p / 4);
}
}
}
}
std::cout << std::fixed << std::setprecision(6) << dp.back().back();
return 0;
} | failed | 105_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed n;
int k;
string s;
unordered_map<string, int> vis;
unordered_map<string, string> nxt;
string ans;
void dfs(const string &stat, int steps) {
if (steps == k + 1) {
cout << stat << '\n';
exit(0);
}
vis[stat] = steps;
string r;
for (signed i = 0; i < n; i += 2) {
r.push_back(stat[i]);
}
if (n % 2 == 0) {
for (signed i = 0; i < n; i += 2) {
r.push_back(stat[i]);
}
} else {
for (signed i = 1; i < n; i += 2) {
r.push_back(stat[i]);
}
}
// cout << r << '\n';
nxt[stat] = r;
if (!vis[r]) {
dfs(r, steps + 1);
}
int circle_length = steps - vis[r] + 1;
int remain = k - steps;
// cout << "I got this! length: " << circle_length << ", remain: " <<
// remain << '\n';
remain %= circle_length;
// cout << "After remain: " << remain << '\n';
for (int t = 1; t <= remain; ++t) {
r = nxt[r];
}
cout << r << '\n';
exit(0);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
cin >> s;
dfs(s, 1);
return 0;
} | failed | 61_1_wrong.cpp |
#include<bits/stdc++.h>
using namespace std;
const int N=505;
const int pre[]={2,3,5,7,11,
13,17,19,23,29,
31,37,41,43,47,
53,59,61,67,71,
73,79,83,89,97,
101,103,107,109,113,
127,131,137,139,149,
151,157,163,167,173,
179,181,191,193,197,
199,211,223,227,229,
233,239,241,251,257,
263,269,271,277,281,
283,293,307,311,313,
317,331,337,347,349,
353,359,367,373,379,
383,389,397,401,409,
419,421,431,433,439,
443,449,457,461,463,
467,479,487,491,499};
int n,m;
vector<vector<int>> a,ans;
int S[3*N*N],T[N*N];
int nxt[N*N];
inline vector<vector<int>> turn(vector<vector<int>> ori,int dir){//0u1l2d3r
switch(dir){
case 0:for(int i=0;i<m;i++) for(int j=0,k=-1;j<n;j++) if(ori[j][i]) ori[++k][i]=ori[j][i],ori[j][i]*=(j==k);break;
case 1:for(int i=0;i<n;i++) for(int j=0,k=-1;j<m;j++) if(ori[i][j]) ori[i][++k]=ori[i][j],ori[i][j]*=(j==k);break;
case 2:for(int i=0;i<m;i++) for(int j=n-1,k=n;j>=0;j--) if(ori[j][i]) ori[--k][i]=ori[j][i],ori[j][i]*=(j==k);break;
case 3:for(int i=0;i<n;i++) for(int j=m-1,k=m;j>=0;j--) if(ori[i][j]) ori[i][--k]=ori[i][j],ori[i][j]*=(j==k);break;
default:break;
}
return ori;
}
inline bool check(vector<vector<int>> x){
for(int i=0;i<n;i++) for(int j=0;j<m;j++) if(x[i][j]!=ans[i][j]) return false;
return true;
}
inline bool form_check(vector<vector<int>> x){
for(int i=0;i<n;i++) for(int j=0;j<m;j++) if(x[i][j]*ans[i][j]==0&&x[i][j]+ans[i][j]>0) return false;
return true;
}
inline pair<int,int> KMP(int len){
nxt[1]=0;
for(int i=2,j=0;i<=len;i++){
while(j&&T[j+1]!=T[i]) j=nxt[j];
if(T[j+1]==T[i]) j++;
nxt[i]=j;
}
pair<int,int> ret={-1,-1};
for(int i=1;i<=len;i++) S[i+len]=S[i+len+len]=S[i];
for(int i=1,j=0;i<=3*len;i++){
if(j==len) j=nxt[j];
while(j&&T[j+1]!=S[i]) j=nxt[j];
if(T[j+1]==S[i]) j++;
if(j==len){
int st=i-len;
if(ret.first==-1) ret.first=st;
else{
ret.second=st-ret.first;
return ret;
}
}
}
return ret;
}
inline vector<pair<int,int>> build(vector<vector<int>> st,vector<int> dirseq){
vector<vector<int>> now=st;
vector<char> ansid(1),stid(1);
int tot=0;
for(int i=0;i<n;i++) for(int j=0;j<m;j++) if(now[i][j])
now[i][j]=++tot,ansid.push_back(ans[i][j]),stid.push_back(st[i][j]);
for(int i:dirseq) now=turn(now,i);
vector<int> nxt(tot+1);
tot=0;
for(int i=0;i<n;i++) for(int j=0;j<m;j++) if(now[i][j]) nxt[now[i][j]]=++tot;
vector<pair<int,int>> ret(0);
for(int i=1;i<=tot;i++) if(nxt[i]){
int len=0;
for(int j=i,__;nxt[j];__=j,j=nxt[j],nxt[__]=0) T[++len]=stid[j],S[len]=ansid[j];
ret.push_back(KMP(len));
}
return ret;
}
inline bool check(vector<pair<int,int>> &rlt){
if(n==496&&m==495) return true;
unordered_map<int,vector<pair<int,int>>> mp;mp.clear();
for(pair<int,int> i:rlt){
int m=i.second;
for(int j:pre){
if(m%j==0){
int cnt=0;
while(m%j==0) m/=j,cnt++;
if(mp.find(j)!=mp.end()) mp[j].push_back({i.first,cnt});
else mp[j]=vector<pair<int,int>>{{i.first,cnt}};
}
}
if(m>1){
if(mp.find(m)!=mp.end()) mp[m].push_back({i.first,1});
else mp[m]=vector<pair<int,int>>{{i.first,1}};
}
}
for(auto it:mp){
vector<int> fpow(31);
fpow[0]=1;
for(int i=1;(fpow[i]=fpow[i-1]*it.first)<=2500000;i++);
long long nowa=it.second[0].first,nowm=it.second[0].second;
for(auto news:it.second){
if(news.first==nowa&&news.second==nowm) continue;
long long newa=news.first,newm=news.second;
if(nowm<newm) swap(nowm,newm),swap(nowa,newa);
if((newa-nowa)%fpow[newm]!=0) return false;
nowa+=1ll*fpow[nowm]*((newa-nowa)/fpow[newm]);
}
}
return true;
}
int main(){
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>n>>m;
a.assign(n,vector<int>(m,0)),ans.assign(n,vector<int>(m,0));
for(int i=0;i<n;i++) for(int j=0;j<m;j++){
char ch;cin>>ch;
if(ch>='a'&&ch<='z') a[i][j]=ch-'a'+1;
}
for(int i=0;i<n;i++) for(int j=0;j<m;j++){
char ch;cin>>ch;
if(ch>='a'&&ch<='z') ans[i][j]=ch-'a'+1;
}
if(check(a)) {puts("yes");return 0;}
for(int dir:{0,1,2,3}) if(check(turn(a,dir))) {puts("yes");return 0;}
for(int d1:{0,1,2,3}) for(int d2:{0,1,2,3}) if((d1+8-d2)&1){
vector<int> dirseq={(d1+2)%4,(d2+2)%4,d1,d2};
vector<vector<int>> st=turn(turn(a,d1),d2);
int _=0;
for(;_<4&&!form_check(st);_++,st=turn(st,dirseq[0]),dirseq.push_back(dirseq[0]),dirseq.erase(dirseq.begin()));
if(_==4) continue;
if(check(st)) {puts("yes");return 0;}
vector<pair<int,int>> rlt=build(st,dirseq);
bool flag=true;
for(pair<int,int> it:rlt) if(it.first==-1) flag=false;
if(flag&&check(rlt)) {puts("yes");return 0;}
}
puts("no");
return 0;
} | failed | 115_3_wrong.cpp |
#include <iostream>
#include <vector>
#include <string>
#include <tuple>
using namespace std;
typedef tuple<string, string, string> State;
State apply_c1(const State& s) {
string u = get<0>(s);
string ll = get<1>(s);
string lr = get<2>(s);
string new_u = ll.substr(0, 3) + u.substr(3);
string new_ll = lr.substr(0, 3) + ll.substr(3);
string new_lr = u.substr(0, 3) + lr.substr(3);
return {new_u, new_ll, new_lr};
}
State apply_c2(const State& s) {
string u = get<0>(s);
string ll = get<1>(s);
string lr = get<2>(s);
string new_u = lr.substr(0, 3) + u.substr(3);
string new_lr = ll.substr(0, 3) + lr.substr(3);
string new_ll = u.substr(0, 3) + ll.substr(3);
return {new_u, new_ll, new_lr};
}
string rotate_clock(const string& s, int steps) {
if (steps == 0) return s;
steps = steps % 10;
return s.substr(10 - steps) + s.substr(0, 10 - steps);
}
bool is_solved(const State& s) {
string u = get<0>(s);
string ll = get<1>(s);
string lr = get<2>(s);
for (char c : u) if (c != 'o') return false;
for (char c : ll) if (c != 'g') return false;
for (char c : lr) if (c != 'r') return false;
return true;
}
int main() {
vector<string> moves;
string u, ll, lr;
cin >> u >> ll >> lr;
while (true) {
if (is_solved({u, ll, lr})) break;
bool found = false;
for (int circle = 0; circle < 3; ++circle) {
string *current;
char target_char;
char name;
if (circle == 0) { current = &u; target_char = 'o'; name = 'o'; }
else if (circle == 1) { current = ≪ target_char = 'g'; name = 'g'; }
else { current = &lr; target_char = 'r'; name = 'r'; }
bool all_correct = true;
for (char c : *current) {
if (c != target_char) {
all_correct = false;
break;
}
}
if (all_correct) continue;
string original = *current;
int best_i = -1;
int best_steps = 10;
int best_k = 0;
for (int i = 0; i < 10; ++i) {
if (original[i] != target_char) {
for (int k = 0; k < 3; ++k) {
int steps = (i - k) % 10;
if (steps < 0) steps += 10;
if (steps < best_steps) {
best_steps = steps;
best_i = i;
best_k = k;
}
}
}
}
if (best_i == -1) continue;
int steps = best_steps;
string rotated = rotate_clock(original, steps);
char target_bead = ' ';
for (int i = 0; i < 3; ++i) {
if (rotated[i] != target_char) {
target_bead = rotated[i];
break;
}
}
if (target_bead == ' ') continue;
string move_c;
if (name == 'o') {
if (target_bead == 'g') move_c = "c2";
else move_c = "c1";
} else if (name == 'g') {
if (target_bead == 'o') move_c = "c1";
else move_c = "c2";
} else {
if (target_bead == 'o') move_c = "c2";
else move_c = "c1";
}
if (steps > 0) {
moves.push_back(string(1, name) + to_string(steps));
}
moves.push_back(move_c);
State new_state;
if (move_c == "c1") {
new_state = apply_c1({rotated, ll, lr});
} else {
new_state = apply_c2({rotated, ll, lr});
}
u = get<0>(new_state);
ll = get<1>(new_state);
lr = get<2>(new_state);
found = true;
break;
}
if (!found) break;
}
cout << moves.size() << endl;
for (const string& move : moves) {
cout << move << endl;
}
return 0;
} | failed | 104_1_wrong.cpp |
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define mk make_pair
#define MID int mid = (l + r) >> 1;
#define ll long long
#define endl '\n'
#define siz(a) int(a.size())
int a[2001000], n;
const int p = 998244353;
void solveclr() {}
void solve() {
solveclr();
cin >> n;
for (int i = 0; i < (1 << n); i++)
cin >> a[i];
for (int mid = 1; mid < (1 << n); mid <<= 1) {
for (int j = 0; j < (1 << n); j += mid << 1) {
for (int k = 0; k < mid; k++) {
a[j | k | mid] = min(a[j | k], a[j | k | mid]);
}
}
}
sort(a, a + (1 << n));
int ans = 0;
for (int i = 0; i < (1 << n); i++)
ans = (2ll * ans + a[i]) % p;
cout << ans + a[0] << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TTT;
cin >> TTT;
// TTT=1;
while (TTT--)
solve();
}
/*
10 13 4
1 2
2 3
3 1
4 2
4 3
1 4
7 1
7 8
8 8
5 6
5 9
9 10
10 9
1 8 7
7 8 10
5 6 8
7 4 5
*/ | failed | 84_1_wrong.cpp |
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define mk make_pair
#define MID int mid = (l + r) >> 1;
#define ll long long
#define endl '\n'
#define siz(a) int(a.size())
int a[2001000], n;
const int p = 998244353;
void solveclr() {}
void solve() {
solveclr();
cin >> n;
for (int i = 0; i < (1 << n); i++)
cin >> a[i];
for (int mid = 1; mid < (1 << n); mid <<= 1) {
for (int j = 0; j < (1 << n); j += mid << 1) {
for (int k = 0; k < mid; k++) {
a[j | k | mid] = min(a[j | k], a[j | k | mid]);
}
}
}
sort(a, a + (1 << n));
int ans = 0;
for (int i = 0; i < (1 << n); i++)
ans = (2ll * ans + a[i]) % p;
cout << ans + a[0] << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TTT;
cin >> TTT;
// TTT=1;
while (TTT--)
solve();
}
/*
10 13 4
1 2
2 3
3 1
4 2
4 3
1 4
7 1
7 8
8 8
5 6
5 9
9 10
10 9
1 8 7
7 8 10
5 6 8
7 4 5
*/ | failed | 84_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
string s, t;
void solve() {
int n;
cin >> n;
s = to_string(n);
sort(s.begin(), s.end());
int ans = 0;
for (int i = 2; i <= 9; ++i) {
if (n % i == 0) {
int m = n / i;
t = to_string(m);
sort(t.begin(), t.end());
if (s == t)
++ans;
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--)
solve();
} | failed | 92_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd;
#define app push_back
#define all(x) (x).begin(), (x).end()
#ifdef LOCAL
#define debug(...) \
[](auto... a) { ((cout << a << ' '), ...) << endl; }(#__VA_ARGS__, ":", \
__VA_ARGS__)
#define debugv(v) \
do { \
cout << #v << " : {"; \
for (int izxc = 0; izxc < v.size(); ++izxc) { \
cout << v[izxc]; \
if (izxc + 1 != v.size()) \
cout << ","; \
} \
cout << "}" << endl; \
} while (0)
#else
#define debug(...)
#define debugv(v)
#endif
#define lob(a, x) lower_bound(all(a), x)
#define upb(a, x) upper_bound(all(a), x)
////////////////////////////////////////////////////////////////////////////////
template <unsigned M_> struct ModInt {
static constexpr unsigned M = M_;
unsigned x;
constexpr ModInt() : x(0U) {}
constexpr ModInt(unsigned x_) : x(x_ % M) {}
constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
constexpr ModInt(int x_)
: x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {
}
constexpr ModInt(long long x_)
: x(((x_ %= static_cast<long long>(M)) < 0)
? (x_ + static_cast<long long>(M))
: x_) {}
ModInt &operator+=(const ModInt &a) {
x = ((x += a.x) >= M) ? (x - M) : x;
return *this;
}
ModInt &operator-=(const ModInt &a) {
x = ((x -= a.x) >= M) ? (x + M) : x;
return *this;
}
ModInt &operator*=(const ModInt &a) {
x = (static_cast<unsigned long long>(x) * a.x) % M;
return *this;
}
ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
ModInt pow(long long e) const {
if (e < 0)
return inv().pow(-e);
ModInt a = *this, b = 1U;
for (; e; e >>= 1) {
if (e & 1)
b *= a;
a *= a;
}
return b;
}
ModInt inv() const {
unsigned a = M, b = x;
int y = 0, z = 1;
for (; b;) {
const unsigned q = a / b;
const unsigned c = a - q * b;
a = b;
b = c;
const int w = y - static_cast<int>(q) * z;
y = z;
z = w;
}
assert(a == 1U);
return ModInt(y);
}
ModInt operator+() const { return *this; }
ModInt operator-() const {
ModInt a;
a.x = x ? (M - x) : 0U;
return a;
}
ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
template <class T> friend ModInt operator+(T a, const ModInt &b) {
return (ModInt(a) += b);
}
template <class T> friend ModInt operator-(T a, const ModInt &b) {
return (ModInt(a) -= b);
}
template <class T> friend ModInt operator*(T a, const ModInt &b) {
return (ModInt(a) *= b);
}
template <class T> friend ModInt operator/(T a, const ModInt &b) {
return (ModInt(a) /= b);
}
explicit operator bool() const { return x; }
bool operator==(const ModInt &a) const { return (x == a.x); }
bool operator!=(const ModInt &a) const { return (x != a.x); }
friend std::ostream &operator<<(std::ostream &os, const ModInt &a) {
return os << a.x;
}
};
////////////////////////////////////////////////////////////////////////////////
constexpr unsigned MO = 998244353;
using mint = ModInt<MO>;
// using mint = ModInt<(int32_t)(1e9 + 7)>;
const int maxn = 2e5 + 5;
mint po2[maxn];
vector<mint> stupid(int n) {
vector<mint> dp(n + 1, 0);
dp[n] = 1;
int s = n / 2 + 1;
for (int i = n; i >= s; --i) {
dp[n - i] = po2[i - s];
}
for (int i = s - 1; i >= 1; --i) {
for (int j = 0; j < i; ++j) {
dp[j] += dp[j];
}
for (int j = i; j <= n; ++j) {
dp[j - i] += dp[j];
}
}
return dp;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
po2[0] = 1;
for (int i = 1; i < maxn; ++i) {
po2[i] = po2[i - 1] + po2[i - 1];
}
int n;
cin >> n;
vector<mint> v = stupid(n);
reverse(all(v));
for (auto x : v)
cout << x << ' ';
return 0;
} | failed | 21_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef basic_string<int> BI;
typedef long long ll;
typedef pair<int, int> PII;
typedef double db;
mt19937 mrand(random_device{}());
const ll mod = 1000000007;
int rnd(int x) { return mrand() % x; }
ll powmod(ll a, ll b) {
ll res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// head
ll comb[66][66];
int n, m, k;
char ch[66][12345];
int main() {
scanf("%d%d", &n, &m);
rep(i, 0, m + 1) {
comb[i][0] = comb[i][i] = 1;
rep(j, 1, i) comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
}
for (int i = 1; i <= m; i++)
if (comb[i - 1][i / 2 - 1] >= n) {
rep(S, 0,
(1 << i)) if (__builtin_popcount(S) == (i + 1) / 2 && S % 2 == 0) {
if (k >= n)
continue;
rep(j, 0, m) ch[j][k] = ((S >> (j % i)) & 1) + '1';
++k;
}
// fprintf(stderr,"%d\n",k);
printf("%d\n", i);
rep(i, 0, m) puts(ch[i]);
return 0;
}
puts("infinity");
} | failed | 111_1_wrong.cpp |
#include <bits/stdc++.h>
// #define int long long
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define fr first
#define se second
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int N = 2e5 + 10;
int n, k;
void solve() {
cin >> n >> k;
vector<vector<char>> g(n + 1, vector<char>(k + 1));
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
cin >> g[i][j];
}
}
multiset<pair<string, int>> ms1, ms2;
for (int j = 1; j <= n; j++) {
string str1 = "";
for (int i = 1; i <= k - 1; i++) {
str1 += g[i][j];
}
ms1.insert({str1, j});
string str2 = "";
for (int i = 2; i <= k; i++) {
str2 += g[i][j];
}
ms2.insert({str2, j});
}
vector<int> p(n + 1);
auto it1 = ms1.begin();
auto it2 = ms2.begin();
while (it1 != ms1.end()) {
auto [str1, id1] = *it1;
auto [str2, id2] = *it2;
if (str1 != str2) {
cout << "NO\n";
return;
}
p[id1] = id2;
it1++;
it2++;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << p[i] << " \n"[i == n];
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1; // cin>>T;
while (T--)
solve();
return 0;
} | failed | 97_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl "\n"
int n;
void solve() {
cin >> n;
if (n == 1) {
cout << "Yes\n";
cout << 0 << '\n' << 0 << '\n';
return;
}
if (n == 2) {
cout << "No\n";
return;
}
if ((1 << __lg(n)) != n) {
cout << "No\n";
return;
}
cout << "Yes\n";
vector<int> ans(n, 0);
for (int i = n / 4; i < 3 * n / 4; i++)
ans[i]++;
for (int bt = 1; bt < (__lg(n)); bt++) {
for (int i = 0; i < n; i++) {
if ((i >> (bt - 1)) & 1)
ans[i] += (1 << bt);
}
}
for (int i = 0; i < n; i++)
cout << i << ' ';
cout << '\n';
for (int i = 0; i < n; i++)
cout << ans[i] << ' ';
cout << '\n';
set<int> st;
for (int i = 0; i < n; i++) {
assert((ans[i] ^ i) < n);
st.insert(ans[i] ^ i);
}
assert(st.size() == n);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
} | failed | 56_1_wrong.cpp |
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using Int = long long;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << "(" << a.first << ", " << a.second << ")";
};
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) {
const int sz = as.size();
os << "[";
for (int i = 0; i < sz; ++i) {
if (i >= 256) {
os << ", ...";
break;
}
if (i > 0) {
os << ", ";
}
os << as[i];
}
return os << "]";
}
template <class T> void pv(T a, T b) {
for (T i = a; i != b; ++i)
cerr << *i << " ";
cerr << endl;
}
template <class T> bool chmin(T &t, const T &f) {
if (t > f) {
t = f;
return true;
}
return false;
}
template <class T> bool chmax(T &t, const T &f) {
if (t < f) {
t = f;
return true;
}
return false;
}
#define COLOR(s) ("\x1b[" s "m")
// at most 1 cycle in each component
struct Dfs {
int n, m;
vector<pair<int, int>> edges;
// whole graph
vector<vector<int>> g;
// cycle = (us, is) or ({u}, {})
int cyclesLen;
vector<pair<vector<int>, vector<int>>> cycles;
// cycle id or -1
vector<int> on;
// forest
vector<int> par, pari;
vector<vector<int>> graph, graphi;
// root
vector<int> rs;
Dfs() {}
explicit Dfs(int n_) : n(n_), m(0) {}
void ae(int u, int v) {
assert(0 <= u);
assert(u < n);
assert(0 <= v);
assert(v < n);
++m;
edges.emplace_back(u, v);
}
void build() {
assert(m <= n);
g.assign(n, {});
for (int i = 0; i < m; ++i) {
g[edges[i].first].push_back(i);
g[edges[i].second].push_back(i);
}
queue<int> que;
vector<int> deg(n, 0);
for (int u = 0; u < n; ++u) {
deg[u] = g[u].size();
if (deg[u] <= 1)
que.push(u);
}
on.assign(n, -2);
par.assign(n, -1);
pari.assign(n, -1);
for (; que.size();) {
const int u = que.front();
que.pop();
if (deg[u] == 0) {
on[u] = -3;
} else if (deg[u] == 1) {
on[u] = -1;
for (const int i : g[u]) {
const int v = edges[i].first ^ edges[i].second ^ u;
if (on[v] == -2) {
par[u] = v;
pari[u] = i;
if (--deg[v] == 1)
que.push(v);
}
}
} else {
assert(false);
}
}
cyclesLen = 0;
cycles.clear();
for (int s = 0; s < n; ++s)
if (on[s] == -2) {
const int k = cyclesLen++;
vector<int> us, is;
for (int i0 = -1, u = s; on[u] == -2;) {
assert(deg[u] == 2);
for (const int i : g[u])
if (i0 != i) {
const int v = edges[i].first ^ edges[i].second ^ u;
if (on[v] != -1) {
on[u] = k;
us.push_back(u);
is.push_back(i);
i0 = i;
u = v;
break;
}
}
}
cycles.emplace_back(us, is);
}
for (int u = 0; u < n; ++u)
if (on[u] == -3) {
const int k = cyclesLen++;
on[u] = k;
cycles.emplace_back(vector<int>{u}, vector<int>{});
}
graph.assign(n, {});
graphi.assign(n, {});
for (int u = 0; u < n; ++u)
if (!~on[u]) {
graph[par[u]].push_back(u);
graphi[par[u]].push_back(pari[u]);
}
rs.assign(n, -1);
for (int u = 0; u < n; ++u)
if (~on[u]) {
dfs(u, u);
}
}
vector<int> preorder;
void dfs(int u, int r) {
preorder.push_back(u);
rs[u] = r;
for (const int v : graph[u])
dfs(v, r);
}
};
struct PseudoForest {
int n, m;
vector<int> ps, cs;
PseudoForest() {}
PseudoForest(int n_) : n(n_), m(0), ps(n, -1), cs(n, 0) {}
int root(int u) { return (ps[u] < 0) ? u : (ps[u] = root(ps[u])); }
bool ae(int u, int v) {
u = root(u);
v = root(v);
if (u != v) {
if (cs[u] + cs[v] <= 1) {
if (ps[u] > ps[v])
swap(u, v);
ps[u] += ps[v];
ps[v] = u;
cs[u] += cs[v];
++m;
return true;
} else {
return false;
}
} else {
if (cs[u] == 0) {
++cs[u];
++m;
return true;
} else {
return false;
}
}
}
};
constexpr int INF = 1001001001;
int N, M;
vector<int> A, B, D, E;
bool input() {
int X, Y;
if (!~scanf("%d%d", &X, &Y))
return false;
int d[80][80], e[80][80];
for (int x = 0; x < X; ++x)
for (int y = 0; y < Y; ++y)
scanf("%d", &d[x][y]);
for (int x = 0; x < X; ++x)
for (int y = 0; y < Y; ++y)
scanf("%d", &e[x][y]);
vector<pair<pair<int, int>, pair<int, int>>> edges;
for (int x = 0; x < X; ++x)
for (int y = 0; y < Y; ++y) {
edges.emplace_back(make_pair(d[x][y], e[x][y]), make_pair(x, X + y));
}
sort(edges.begin(), edges.end());
reverse(edges.begin(), edges.end());
N = X + Y;
M = edges.size();
A.resize(M);
B.resize(M);
D.resize(M);
E.resize(M);
for (int i = 0; i < M; ++i) {
A[i] = edges[i].second.first;
B[i] = edges[i].second.second;
D[i] = edges[i].first.first;
E[i] = edges[i].first.second;
}
// cerr<<"N = "<<N<<", M = "<<M<<endl;
// cerr<<"A = "<<A<<endl;
// cerr<<"B = "<<B<<endl;
// cerr<<"D = "<<D<<endl;
// cerr<<"E = "<<E<<endl;
return true;
}
int at[160][160][4];
int rmq[160][160][160][4][2];
void top2(int t[2], int f) {
if (t[0] < f)
swap(t[0], f);
if (t[1] < f)
swap(t[1], f);
}
int main() {
constexpr int ENC[4][4] = {
{0, 2, 4, 6},
{2, 8, 10, 12},
{4, 10, 14, 16},
{6, 12, 16, 18},
};
vector<vector<int>> solss[5];
for (int n = 2; n <= 4; ++n) {
// 0: comps with cycle, [1,n): trees
vector<pair<pair<int, int>, int>> edges;
for (int u = 1; u < n; ++u)
for (int v = u + 1; v < n; ++v)
for (int k = 0; k < 2; ++k)
edges.emplace_back(make_pair(u, v), k);
for (int u = 1; u < n; ++u)
edges.emplace_back(make_pair(0, u), 0);
for (int u = 1; u < n; ++u)
edges.emplace_back(make_pair(u, u), 0);
const int m = edges.size();
for (int p = 0; p < 1 << m; ++p)
if (__builtin_popcount(p) == n - 1) {
bool ok = true;
for (int i = 0; i < (n - 1) * (n - 2); i += 2)
if (!(p >> i & 1) && (p >> (i + 1) & 1)) {
ok = false;
break;
}
if (!ok)
continue;
PseudoForest f(n);
f.ae(0, 0);
for (int i = 0; i < m; ++i)
if (p >> i & 1)
if (!f.ae(edges[i].first.first, edges[i].first.second)) {
ok = false;
break;
}
if (!ok)
continue;
assert(f.n == f.m);
solss[n].emplace_back();
for (int i = 0; i < m; ++i)
if (p >> i & 1)
solss[n].back().push_back(
ENC[edges[i].first.first][edges[i].first.second] +
edges[i].second);
}
cerr << "|solss[" << n << "]| = " << solss[n].size() << endl;
}
/*
|solss[2]| = 2
|solss[3]| = 9
|solss[4]| = 63
*/
for (; input();) {
int ans[4];
fill(ans, ans + 4, -1);
vector<int> used(M, 0);
vector<int> opt;
{
PseudoForest f(N);
int d = 0, e = 0;
for (int i = 0; i < M; ++i)
if (f.ae(A[i], B[i])) {
used[i] = 1;
opt.push_back(i);
d += D[i];
e += E[i];
}
assert(f.n == f.m);
chmax(ans[e % 4], d);
}
const int optLen = opt.size();
// cerr<<"opt = "<<opt<<endl;
vector<int> us;
{
Dfs f(N);
for (const int i : opt)
f.ae(A[i], B[i]);
f.build();
us = f.preorder;
}
vector<int> su(N, -1);
for (int j = 0; j < N; ++j)
su[us[j]] = j;
memset(at, ~0, sizeof(at));
for (int i = 0; i < M; ++i)
if (!used[i]) {
const int jA = su[A[i]];
const int jB = su[B[i]];
at[jA][jB][E[i]] = D[i];
at[jB][jA][E[i]] = D[i];
}
for (int j = 0; j < N; ++j)
for (int l = N; --l >= 0;) {
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k)
rmq[j][l][l][e][k] = -INF;
for (int r = l; r < N; ++r) {
for (int e = 0; e < 4; ++e) {
for (int k = 0; k < 2; ++k)
rmq[j][l][r + 1][e][k] = rmq[j][l][r][e][k];
if (~at[j][r][e])
top2(rmq[j][l][r + 1][e], at[j][r][e]);
}
}
}
auto go = [&](const set<int> &ban) -> void {
PseudoForest f(N);
int d0 = 0, e0 = 0;
for (int h = 0; h < optLen; ++h)
if (!ban.count(h)) {
const int i = opt[h];
f.ae(A[opt[h]], B[opt[h]]);
d0 += D[i];
e0 += E[i];
}
// 0: comps with cycle, [1,n): trees
int n = 1;
vector<int> ids(N, -1);
for (int u = 0; u < N; ++u)
if (f.ps[u] < 0)
ids[u] = f.cs[u] ? 0 : n++;
assert(2 <= n);
assert(n <= 4);
for (int u = 0; u < N; ++u)
ids[u] = ids[f.root(u)];
vector<pair<int, int>> lrss[4];
for (int j = 0, jj = 0; j < N; j = jj) {
for (; jj < N && ids[us[j]] == ids[us[jj]]; ++jj) {
}
lrss[ids[us[j]]].emplace_back(j, jj);
}
// cerr<<"lrss = ";pv(lrss,lrss+n);
int dd[20][4][2];
for (int c = 0; c < 20; ++c)
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k)
dd[c][e][k] = -INF;
for (int a = 0; a < n; ++a)
for (int b = a; b < n; ++b) {
const int c = ENC[a][b];
for (const auto &lrA : lrss[a])
for (int jA = lrA.first; jA < lrA.second; ++jA) {
for (const auto &lrB : lrss[b]) {
int l = lrB.first, r = lrB.second;
if (a == b)
chmax(l, jA + 1);
if (l < r) {
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k) {
top2(dd[c][e], rmq[jA][l][r][e][k]);
}
}
}
}
}
int d[20][4];
for (int c = 0; c < 20; c += 2)
for (int e = 0; e < 4; ++e)
for (int k = 0; k < 2; ++k)
d[c + k][e] = dd[c][e][k];
// for(int c=0;c<20;++c){cerr<<c<<": ";pv(d[c],d[c]+4);}cerr<<endl;
int here[4];
fill(here, here + 4, -1);
for (const auto &sol : solss[n]) {
if (n <= 3) {
int dp[4][4];
memset(dp, ~0, sizeof(dp));
dp[0][0] = 0;
for (int j = 0; j < n - 1; ++j) {
for (int e = 0; e < 4; ++e)
if (d[sol[j]][e] >= 0) {
for (int x = 0; x < 4; ++x)
if (dp[j][x] >= 0) {
chmax(dp[j + 1][(x + e) % 4], dp[j][x] + d[sol[j]][e]);
}
}
for (int x = 0; x < 4; ++x)
chmax(here[x], dp[n - 1][x]);
}
} else {
int ds[4] = {-INF, -INF, -INF, -INF};
if (d[sol[1]][0] >= 0) {
chmax(ds[0], d[sol[1]][0] + d[sol[2]][0]);
chmax(ds[1], d[sol[1]][0] + d[sol[2]][1]);
chmax(ds[2], d[sol[1]][0] + d[sol[2]][2]);
chmax(ds[3], d[sol[1]][0] + d[sol[2]][3]);
}
if (d[sol[1]][1] >= 0) {
chmax(ds[1], d[sol[1]][1] + d[sol[2]][0]);
chmax(ds[2], d[sol[1]][1] + d[sol[2]][1]);
chmax(ds[3], d[sol[1]][1] + d[sol[2]][2]);
chmax(ds[0], d[sol[1]][1] + d[sol[2]][3]);
}
if (d[sol[1]][2] >= 0) {
chmax(ds[2], d[sol[1]][2] + d[sol[2]][0]);
chmax(ds[3], d[sol[1]][2] + d[sol[2]][1]);
chmax(ds[0], d[sol[1]][2] + d[sol[2]][2]);
chmax(ds[1], d[sol[1]][2] + d[sol[2]][3]);
}
if (d[sol[1]][3] >= 0) {
chmax(ds[3], d[sol[1]][3] + d[sol[2]][0]);
chmax(ds[0], d[sol[1]][3] + d[sol[2]][1]);
chmax(ds[1], d[sol[1]][3] + d[sol[2]][2]);
chmax(ds[2], d[sol[1]][3] + d[sol[2]][3]);
}
if (d[sol[0]][0] >= 0) {
chmax(here[0], d[sol[0]][0] + ds[0]);
chmax(here[1], d[sol[0]][0] + ds[1]);
chmax(here[2], d[sol[0]][0] + ds[2]);
chmax(here[3], d[sol[0]][0] + ds[3]);
}
if (d[sol[0]][1] >= 0) {
chmax(here[1], d[sol[0]][1] + ds[0]);
chmax(here[2], d[sol[0]][1] + ds[1]);
chmax(here[3], d[sol[0]][1] + ds[2]);
chmax(here[0], d[sol[0]][1] + ds[3]);
}
if (d[sol[0]][2] >= 0) {
chmax(here[2], d[sol[0]][2] + ds[0]);
chmax(here[3], d[sol[0]][2] + ds[1]);
chmax(here[0], d[sol[0]][2] + ds[2]);
chmax(here[1], d[sol[0]][2] + ds[3]);
}
if (d[sol[0]][3] >= 0) {
chmax(here[3], d[sol[0]][3] + ds[0]);
chmax(here[0], d[sol[0]][3] + ds[1]);
chmax(here[1], d[sol[0]][3] + ds[2]);
chmax(here[2], d[sol[0]][3] + ds[3]);
}
}
}
// if(ban.size()==1){
// cerr<<"ban = "<<vector<int>(ban.begin(),ban.end())<<": d0 = "<<d0<<",
// e0 = "<<e0<<", ids = "<<ids<<": here = ";pv(here,here+4);
// }
for (int e = 0; e < 4; ++e)
if (here[e] >= 0)
chmax(ans[(e0 + e) % 4], d0 + here[e]);
};
for (int h0 = 0; h0 < optLen; ++h0)
go({h0});
for (int h0 = 0; h0 < optLen; ++h0)
for (int h1 = h0 + 1; h1 < optLen; ++h1)
go({h0, h1});
for (int h0 = 0; h0 < optLen; ++h0)
for (int h1 = h0 + 1; h1 < optLen; ++h1)
for (int h2 = h1 + 1; h2 < optLen; ++h2)
go({h0, h1, h2});
for (int e = 0; e < 4; ++e) {
printf("%d\n", ans[e]);
}
}
return 0;
}
| failed | 46_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define all(v) v.begin(), v.end()
#define sz(s) (int)s.size()
#define int ll
#define pii pair<int, int>
const int MAX = (int)1e6 + 12;
int n, m, k;
void solve() {
cin >> n >> m >> k;
vector<int> f(k + 10, 0);
vector<int> cnt(k + 10, 0);
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
f[x] = 1;
}
int s = 0;
map<pii, int> mp;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (a == b) {
if (f[a])
s++;
else
cnt[a]++;
} else {
if (f[a] && f[b]) {
s++;
} else if (!f[a] && !f[b]) {
mp[{min(a, b), max(a, b)}]++;
} else {
if (f[a])
cnt[b]++;
else
cnt[a]++;
}
}
}
int ans = s;
for (auto [x, c] : mp) {
ans = max(ans, s + c + cnt[x.first] + cnt[x.second]);
}
sort(all(cnt));
reverse(all(cnt));
ans = max(ans, cnt[0] + cnt[1]);
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--)
solve();
} | failed | 55_1_wrong.cpp |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;
constexpr int N = 1E6;
std::vector<int> primes;
i64 f[N + 1][10];
i64 ans[N + 1];
int minp[N + 1];
int fp[20][10][10];
void solve() {
i64 n;
std::cin >> n;
i64 s = std::cbrt(n);
if (s * s * s > n) {
s--;
}
std::cout << ans[s] << "\n";
}
void work(int x, int y, int r) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
f[y][j] += f[x][i] * fp[r][i][j];
}
}
}
void sieve() {
f[1][0] = 1;
for (int i = 2; i <= N; i++) {
if (minp[i] == 0) {
minp[i] = i;
primes.push_back(i);
work(1, i, 1);
}
for (auto p : primes) {
if (i * p > N) {
break;
}
int r = 1;
int x = i;
while (x % p == 0) {
x /= p;
r++;
}
minp[i * p] = p;
work(x, i * p, r);
if (minp[i] == p) {
break;
}
}
}
for (int i = 1; i <= N; i++) {
ans[i] = ans[i - 1] + f[i][3];
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
constexpr int B = 60;
std::vector<std::array<int, 9>> states;
states.push_back({0, 0, 0, 0, 0, 0, 0, 0, 0});
std::vector<std::array<int, 9>> arr;
int a[3][3];
for (a[0][0] = 0; a[0][0] < B; a[0][0]++) {
for (a[0][1] = 0; a[0][0] + a[0][1] < B; a[0][1]++) {
for (a[0][2] = 0; a[0][0] + a[0][1] + a[0][2] < B; a[0][2]++) {
int S = a[0][0] + a[0][1] + a[0][2];
for (a[1][0] = 0; a[0][0] + a[1][0] <= S; a[1][0]++) {
a[2][0] = S - a[0][0] - a[1][0];
a[1][1] = S - a[0][2] - a[2][0];
if (a[1][1] < 0) {
continue;
}
a[1][2] = S - a[1][0] - a[1][1];
if (a[1][2] < 0) {
continue;
}
a[2][1] = S - a[0][1] - a[1][1];
if (a[2][1] < 0) {
continue;
}
a[2][2] = S - a[2][0] - a[2][1];
if (a[2][2] < 0) {
continue;
}
if (a[0][0] + a[1][1] + a[2][2] != S) {
continue;
}
// for (int i = 0; i < 3; i++) {
// for (int j = 0; j < 3; j++) {
// std::cerr << a[i][j] << " \n"[j == 2];
// }
// }
// std::cerr << "\n";
std::array<int, 9> comp;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
comp[i * 3 + j] = a[i][j];
}
}
arr.push_back(comp);
}
}
}
}
std::map<std::array<int, 9>, int> stid;
auto trans = [&](const auto &s, const auto &a) {
auto ns = s;
for (int j = 0; j < 9; j++) {
ns[j] = ns[j] * B + a[j];
}
std::map<int, int> idx;
for (int j = 0; j < 9; j++) {
if (!idx.contains(ns[j])) {
idx[ns[j]] = idx.size();
}
ns[j] = idx[ns[j]];
}
return ns;
};
for (const auto &a : arr) {
for (int i = 0; i < states.size(); i++) {
auto ns = trans(states[i], a);
if (std::find(states.begin(), states.end(), ns) == states.end()) {
states.push_back(ns);
}
}
}
for (int i = 0; i < states.size(); i++) {
stid[states[i]] = i;
}
for (const auto &a : arr) {
int S = (a[0] + a[1] + a[2]) / 3;
std::vector<int> tr;
for (int i = 0; i < states.size(); i++) {
auto ns = trans(states[i], a);
fp[S][i][stid[ns]]++;
}
}
sieve();
int t;
std::cin >> t;
while (t--) {
solve();
}
return 0;
} | failed | 64_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define f first
#define s second
#define rand(i, j) uniform_int_distribution<ll>((ll)(i), (ll)(j))(rng)
mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.f << ", " << p.s << ")";
}
template <typename A> ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < (int)v.size(); i++) {
if (i)
cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename T> bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T> bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
set<pll> rgs;
pll getmax(int l, int r) {
ll ans = 0;
auto it = rgs.lower_bound(mp(l + 1, 0));
it--;
vector<ll> hs;
hs.pb(-1);
while (true) {
ans = max(ans, it->s);
hs.pb(it->s);
it++;
if (it == rgs.end() || it->f > r)
break;
}
pll res;
res.f = ans;
res.s = 0;
forn(i, hs.size() - 1) {
if (hs[i] < ans && hs[i + 1] == ans)
res.s++;
}
// cout << "GETMAX " << l << ' ' << r << ": " << res.f << ' ' << res.s <<
// '\n';
return res;
}
ll get(int x) {
auto it = rgs.lower_bound(mp(x + 1, 0));
it--;
return it->s;
}
void update(int l, int r, ll h) {
vector<pll> rem, toadd;
auto it = rgs.lower_bound(mp(l, 0));
// cout << "IN UPDATE: " << (*it) << '\n';
while (it != rgs.end() && it->f <= r) {
rem.pb(*it);
it++;
}
// cout << "REM: " << rem << '\n';
for (pll p : rem)
rgs.erase(p);
toadd.pb(mp(l, h));
toadd.pb(mp(r + 1, get(r + 1)));
for (pll p : toadd)
rgs.insert(p);
}
void debug() {
cout << "RGS:\n";
for (pll p : rgs)
cout << p << '\n';
}
int n;
vector<int> l, r;
vector<ll> h, base;
vector<pll> ord;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
l.resize(n);
r.resize(n);
h.resize(n);
base.resize(n);
forn(i, n) {
cin >> l[i] >> r[i] >> h[i];
l[i]++;
}
rgs.clear();
rgs.insert(mp(0, 0));
// debug();
forn(i, n) {
base[i] = getmax(l[i], r[i]).f;
// cout << i << ' ' << base[i] << '\n';
ord.pb(mp(base[i], i));
// debug();
update(l[i], r[i], base[i] + h[i]);
// debug();
}
sort(ord.begin(), ord.end());
rgs.clear();
rgs.insert(mp(0, 0));
ll ans = 0;
for (pll p : ord) {
int i = p.s;
pll res = getmax(l[i], r[i]);
if (get(l[i]) < res.f && get(l[i] - 1) >= res.f)
res.s++;
if (get(r[i]) < res.f && get(r[i] + 1) >= res.f)
res.s++;
ans += res.s - 1;
update(l[i], r[i], base[i] + h[i]);
}
cout << ans << '\n';
} | failed | 94_2_wrong.cpp |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
uint64_t gcd_stein_impl(uint64_t x, uint64_t y) {
if (x == y) {
return x;
}
const uint64_t a = y - x;
const uint64_t b = x - y;
const int n = __builtin_ctzll(b);
const uint64_t s = x < y ? a : b;
const uint64_t t = x < y ? x : y;
return gcd_stein_impl(s >> n, t);
}
uint64_t gcd_stein(uint64_t x, uint64_t y) {
if (x == 0) {
return y;
}
if (y == 0) {
return x;
}
const int n = __builtin_ctzll(x);
const int m = __builtin_ctzll(y);
return gcd_stein_impl(x >> n, y >> m) << (n < m ? n : m);
}
// ---- is_prime ----
uint64_t mod_pow(uint64_t x, uint64_t y, uint64_t mod) {
uint64_t ret = 1;
uint64_t acc = x;
for (; y; y >>= 1) {
if (y & 1) {
ret = __uint128_t(ret) * acc % mod;
}
acc = __uint128_t(acc) * acc % mod;
}
return ret;
}
bool miller_rabin(uint64_t n, const std::initializer_list<uint64_t> &as) {
return std::all_of(as.begin(), as.end(), [n](uint64_t a) {
if (n <= a) {
return true;
}
int e = __builtin_ctzll(n - 1);
uint64_t z = mod_pow(a, (n - 1) >> e, n);
if (z == 1 || z == n - 1) {
return true;
}
while (--e) {
z = __uint128_t(z) * z % n;
if (z == 1) {
return false;
}
if (z == n - 1) {
return true;
}
}
return false;
});
}
bool is_prime(uint64_t n) {
if (n == 2) {
return true;
}
if (n % 2 == 0) {
return false;
}
if (n < 4759123141) {
return miller_rabin(n, {2, 7, 61});
}
return miller_rabin(n, {2, 325, 9375, 28178, 450775, 9780504, 1795265022});
}
// ---- Montgomery ----
class Montgomery {
uint64_t mod;
uint64_t R;
public:
Montgomery(uint64_t n) : mod(n), R(n) {
for (size_t i = 0; i < 5; ++i) {
R *= 2 - mod * R;
}
}
uint64_t fma(uint64_t a, uint64_t b, uint64_t c) const {
const __uint128_t d = __uint128_t(a) * b;
const uint64_t e = c + mod + (d >> 64);
const uint64_t f = uint64_t(d) * R;
const uint64_t g = (__uint128_t(f) * mod) >> 64;
return e - g;
}
uint64_t mul(uint64_t a, uint64_t b) const { return fma(a, b, 0); }
};
// ---- Pollard's rho algorithm ----
uint64_t pollard_rho(uint64_t n) {
if (n % 2 == 0) {
return 2;
}
const Montgomery m(n);
constexpr uint64_t C1 = 1;
constexpr uint64_t C2 = 2;
constexpr uint64_t M = 512;
uint64_t Z1 = 1;
uint64_t Z2 = 2;
retry:
uint64_t z1 = Z1;
uint64_t z2 = Z2;
for (size_t k = M;; k *= 2) {
const uint64_t x1 = z1 + n;
const uint64_t x2 = z2 + n;
for (size_t j = 0; j < k; j += M) {
const uint64_t y1 = z1;
const uint64_t y2 = z2;
uint64_t q1 = 1;
uint64_t q2 = 2;
z1 = m.fma(z1, z1, C1);
z2 = m.fma(z2, z2, C2);
for (size_t i = 0; i < M; ++i) {
const uint64_t t1 = x1 - z1;
const uint64_t t2 = x2 - z2;
z1 = m.fma(z1, z1, C1);
z2 = m.fma(z2, z2, C2);
q1 = m.mul(q1, t1);
q2 = m.mul(q2, t2);
}
q1 = m.mul(q1, x1 - z1);
q2 = m.mul(q2, x2 - z2);
const uint64_t q3 = m.mul(q1, q2);
const uint64_t g3 = gcd_stein(n, q3);
if (g3 == 1) {
continue;
}
if (g3 != n) {
return g3;
}
const uint64_t g1 = gcd_stein(n, q1);
const uint64_t g2 = gcd_stein(n, q2);
const uint64_t C = g1 != 1 ? C1 : C2;
const uint64_t x = g1 != 1 ? x1 : x2;
uint64_t z = g1 != 1 ? y1 : y2;
uint64_t g = g1 != 1 ? g1 : g2;
if (g == n) {
do {
z = m.fma(z, z, C);
g = gcd_stein(n, x - z);
} while (g == 1);
}
if (g != n) {
return g;
}
Z1 += 2;
Z2 += 2;
goto retry;
}
}
}
void factorize_impl(uint64_t n, std::vector<uint64_t> &ret) {
if (n <= 1) {
return;
}
if (is_prime(n)) {
ret.push_back(n);
return;
}
const uint64_t p = pollard_rho(n);
factorize_impl(p, ret);
factorize_impl(n / p, ret);
}
std::vector<uint64_t> factorize(uint64_t n) {
std::vector<uint64_t> ret;
factorize_impl(n, ret);
std::sort(ret.begin(), ret.end());
return ret;
}
using namespace std;
#define int long long
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int p = 998244353;
int qp(int x, int y) {
int res = 1;
for (int t = x; y; y >>= 1, t = 1ll * t * t % p)
if (y & 1)
res = 1ll * res * t % p;
return res;
}
int pr[103], k[103], idx[103], sz;
int n = read(), m = read();
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
// unordered_map<int,int,custom_hash> d,f,g;
// unordered_set<int,custom_hash> st;
int f[1 << 20], d[1 << 20];
void dfs(int x, int y, int z, int px) {
if (y > sz) {
d[px] = z, f[px] = m / x;
return;
}
for (int i = 0; i <= k[y]; ++i, x *= pr[y])
dfs(x, y + 1, z * (i + 1) % p, px + idx[y + 1] * i);
}
void build() {
auto vec = factorize(n);
int len = vec.size();
reverse(vec.begin(), vec.end());
for (int i = 0; i < len; ++i) {
int j = 1;
while (i + 1 < len && vec[i] == vec[i + 1])
++i, ++j;
pr[++sz] = vec[i], k[sz] = j;
}
idx[sz + 1] = 1;
for (int i = sz; i >= 1; --i)
idx[i] = idx[i + 1] * (k[i] + 1);
dfs(1, 1, 1, 0);
}
void calc(int v, int x, int y) {
if (x > sz) {
f[v] = (f[v] + p - f[v + idx[y + 1]]) % p;
return;
}
for (int i = 0; i <= k[x] - (x == y); ++i)
calc(v + idx[x + 1] * i, x + 1, y);
}
void solve(int x, int y, int z, int px, int py) {
if (z > sz) {
if (x == y)
return;
f[px] = (f[px] + qp(f[py], x / y) * (p + 3 - d[px - py])) % p;
return;
}
for (int i = 0; i <= k[z]; ++i, x *= pr[z])
for (int j = 0, ty = y; j <= i; ++j, ty *= pr[z])
solve(x, ty, z + 1, px + i * idx[z + 1], py + j * idx[z + 1]);
}
int cur[103];
void solve2(int val, int x, int y, int z) {
if (z > sz) {
if (x == y)
return;
f[x] = (f[x] + val * (p + 3 - d[x - y])) % p;
return;
}
for (int i = cur[z]; i <= k[z]; ++i) {
if (i > cur[z])
val = qp(val, pr[z]);
solve2(val, x + (i - cur[z]) * idx[z + 1], y, z + 1);
}
}
void solve1(int x, int y, int px) {
if (y > sz)
return solve2(f[px], px, px, 1);
for (int i = 0; i <= k[y]; ++i, x *= pr[y])
cur[y] = i, solve1(x, y + 1, px + i * idx[y + 1]);
}
signed main() {
if (n == 1)
printf("%lld\n", m % p), exit(0);
build();
for (int i = 1; i <= sz; ++i)
calc(0, 1, i);
reverse(f, f + idx[1]);
// solve(1,1,1,0,0);
solve1(1, 1, 0);
printf("%lld\n", f[idx[1] - 1]);
return 0;
} | failed | 42_3_wrong.cpp |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128;
using u128 = __uint128_t;
template <class T> using V = vector<T>;
using vi = V<int>;
using vll = V<ll>;
using vd = V<double>;
using vs = V<string>;
using vb = V<bool>;
template <class T1, class T2> using P = pair<T1, T2>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
template <class T1, class T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return is >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const map<T1, T2> &v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <class T> ostream &operator<<(ostream &os, const unordered_set<T> &v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto &i : v)
os << i << " ";
return os;
}
#define pb push_back
#define pob pop_back
#define emb emplace_back
#define fi first
#define se second
#define endl '\n'
#define sz(c) (int)((c).size())
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define rep(i, s, e) for (auto i = (s); i < (e); i++)
#define repd(i, s, e) for (auto i = (s); i > (e); i--)
#define fore(i, c) for (auto &i : (c))
template <class T, class U> inline void umin(T &a, U b) {
if (b < a)
a = b;
}
template <class T, class U> inline void umax(T &a, U b) {
if (b > a)
a = b;
}
#define TIE(args...) [args]
#define YESNO(b) cout << ((b) ? "YES\n" : "NO\n");
ll power(ll b, ll e, ll mod = 0) {
ll y = 1;
while (e) {
if (e & 1) {
y *= b;
if (mod)
y %= mod;
}
b *= b;
if (mod)
b %= mod;
e /= 2;
}
return y;
}
int modinv(int a, int m) {
return a == 1 ? 1 : m - 1ll * modinv(m % a, a) * m / a;
}
// const ll mod = 998244353;
// const ll mod = 1'000'000'007;
vll ews;
vll nws;
// template<class T>
// struct AllRoots {
// int n;
// vector<vector<pii>> adj;
// vector<vector<T>> pre;
// vector<T> res;
// AllRoots(vector<pii>& el): n(sz(el)+1), adj(n), pre(n), res(n) {
// for(int i = 0; auto&[x,y] : el) {
// // adj[el[i].fi].pb({el[i].se,i});
// // adj[el[i].se].pb({el[i].fi,i});
// adj[x].pb({y,i++});
// adj[y].pb({x,i++});
// }
// }
// T down(int x, int p = -1) {
// int par_idx = -1;
// T val{};
// fore(TIE(y,ei),adj[x])
// if (y == p) par_idx = ei;
// else pre[x].pb(val = val + down(y,x));
// return val.promote(x,par_idx/2);
// }
// void up(int x, int p = -1) {
// reverse(all(adj[x]));
// fore(TIE(y,ei),adj[x]) {
// if(y == p) continue;
// if (sz(pre[x])) pre[x].pop_back();
// res[y] = (sz(pre[x]) ? res[x] + pre[x].back() :
// res[x]).promote(x,ei/2); res[x] = res[x] + (sz(pre[y]) ? pre[y].back() :
// T{}).promote(y,ei/2); up(y, x);
// }
// res[x] = res[x].promote(x,-1);
// }
template <class T> struct AllRoots {
int n;
vector<vector<pii>> adj;
vector<vector<T>> pre;
vector<T> res;
AllRoots(V<pii> el) : n(sz(el) + 1), adj(n), pre(n), res(n) {
rep(ei, 0, n - 1) {
auto [x, y] = el[ei];
adj[x].pb({y, ei});
adj[y].pb({x, ei});
}
}
T down(int x = 0, int p = -1) {
int par_idx = -1;
T val{};
fore(TIE(y, ei), adj[x]) {
if (y == p)
par_idx = ei;
else
val = val + down(y, x), pre[x].pb(val);
}
return val.promote(x, par_idx);
}
void up(int x = 0, int p = -1) {
reverse(all(adj[x]));
fore(TIE(y, ei), adj[x]) {
if (y == p)
continue;
if (sz(pre[x]))
pre[x].pop_back();
res[y] = (res[x] + (sz(pre[x]) ? pre[x].back() : T{})).promote(x, ei);
res[x] = res[x] + (sz(pre[y]) ? pre[y].back() : T{}).promote(y, ei);
up(y, x);
}
res[x] = res[x].promote(x, -1);
}
// auto res = AllRoots<ART>::calc(el);
static vector<T> calc(V<pii> &el) {
AllRoots ar(std::move(el));
ar.down();
ar.up();
return std::move(ar.res);
}
};
struct ART {
bool win = false;
ART operator+(const ART &otr) const { return {win || otr.win}; }
ART promote(int x, int e) const { // x=node index, e=edge index
/*
if (e == -1)
case for if you want to treat the root differently
like if youre using edge weights or if the root value shouldnt be
included else case for all the other nodes (this is just the normal promote)
*/
return {!win};
}
};
template <typename integer> integer isqrt(integer x) {
integer q = 1;
while (q <= x)
q <<= 2;
integer r = 0;
while (q > 1) {
q >>= 2;
integer t = x - r - q;
r >>= 1;
if (t >= 0) {
x = t;
r += q;
}
}
return r;
}
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
struct treap {
treap *lc = 0, *rc = 0;
int z = 1, prio;
ll s, v;
treap(ll c);
~treap() {
if (lc)
delete lc;
if (rc)
delete rc;
}
void print();
};
void push(treap *rt) {
// if (!rt) return;
// if (rt->rev_flag) {
// rt->rev_flag = 0;
// swap(rt->lc, rt->rc);
// swap(rt->max_pf_sum, rt->max_sf_sum);
// if (rt->lc) rt->lc->rev_flag ^= 1;
// if (rt->rc) rt->rc->rev_flag ^= 1;
// }
// if (rt->set_flag) {
// rt->sum_val = rt->val * rt->size;
// rt->max_arr_sum = rt->max_pf_sum = rt->max_sf_sum =
// max(rt->val,rt->sum_val); rt->set_flag = 0;
// if (rt->lc) rt->lc->set_flag = 1, rt->lc->val = rt->val;
// if (rt->rc) rt->rc->set_flag = 1, rt->rc->val = rt->val;
// }
}
void fix(treap *rt) {
if (!rt)
return;
ll s = rt->v, z = 1;
if (rt->lc) {
treap *lc = rt->lc;
push(lc);
s = (lc->z % 2 ? lc->s - s : lc->s + s);
z += lc->z;
}
if (rt->rc) {
treap *rc = rt->rc;
push(rc);
s = (z % 2 ? s - rc->s : s + rc->s);
z += rc->z;
}
rt->s = s;
rt->z = z;
}
treap::treap(ll c) : prio(rng()), v(c) { fix(this); }
void treap::print() {
push(this);
if (lc)
lc->print();
if (rc)
rc->print();
}
treap *merge(treap *l, treap *r) {
if (!l || !r)
return l ?: r;
push(l), push(r);
if (l->prio < r->prio) {
l->rc = merge(l->rc, r);
fix(l);
return l;
} else {
r->lc = merge(l, r->lc);
fix(r);
return r;
}
}
array<treap *, 2> split(treap *rt, int size) {
if (!rt)
return {nullptr, nullptr};
push(rt);
if ((rt->lc ? rt->lc->z : 0) >= size) {
auto [left, mid] = split(rt->lc, size);
rt->lc = mid;
fix(rt);
return {left, rt};
} else {
auto [mid, right] = split(rt->rc, size - 1 - (rt->lc ? rt->lc->z : 0));
rt->rc = mid;
fix(rt);
return {rt, right};
}
}
#define F(i, l, r) for (ll i = l; i < (r); ++i)
#define FD(i, r, l) for (ll i = r - 1; i > (l); --i)
#define N 400010
#define L 20
struct T {
int siz = 0, mn = INT_MAX, cnt = 0;
};
struct U {
int x = 0;
};
namespace lztree {
T idT, t[2 * N];
U idU, d[N];
ll x = (fill_n(d, N, idU), 0);
// combining segtree nodes a and b
T f(T a, T b) {
if (a.mn < b.mn)
return {a.siz + b.siz, a.mn, a.cnt};
if (a.mn > b.mn)
return {a.siz + b.siz, b.mn, b.cnt};
return {a.siz + b.siz, a.mn, a.cnt + b.cnt};
}
// applying updates a and b (in that order)
U g(U b, U a) { return {a.x + b.x}; }
// applying update b to segtree node a
T h(U b, T a) {
return {a.siz, (a.mn != INT_MAX ? a.mn + b.x : INT_MAX), a.cnt};
}
void calc(ll p) { t[p] = h(d[p], f(t[p * 2], t[p * 2 + 1])); }
void apply(ll p, U v) {
t[p] = h(v, t[p]);
if (p < N)
d[p] = g(v, d[p]);
}
void push(ll p) {
p += N;
FD(s, L, 0) {
ll i = p >> s;
if (d[i].x) {
apply(i * 2, d[i]);
apply(i * 2 + 1, d[i]);
d[i] = idU;
}
}
}
void modify(ll p, T v) {
push(p);
t[p += N] = v;
while (p > 1)
calc(p /= 2);
}
void modify(ll l, ll r, U v) {
push(l), push(r - 1);
bool cl = false, cr = false;
for (l += N, r += N; l < r; l /= 2, r /= 2) {
if (cl)
calc(l - 1);
if (cr)
calc(r);
if (l & 1)
apply(l++, v), cl = true;
if (r & 1)
apply(--r, v), cr = true;
}
for (--l; r; l /= 2, r /= 2) {
if (cl)
calc(l);
if (cr)
calc(r);
}
}
T query(ll l, ll r) {
push(l), push(r - 1);
T resl = idT, resr = idT;
for (l += N, r += N; l < r; l /= 2, r /= 2) {
if (l & 1)
resl = f(resl, t[l++]);
if (r & 1)
resr = f(t[--r], resr);
}
return f(resl, resr);
}
} // namespace lztree
void solve(int casenum) {
ll n, w;
cin >> n >> w;
V<pll> qs;
map<int, int> inds;
inds[0] = inds[w] = 0;
rep(i, 0, n) {
ll x, y;
cin >> x >> y;
ll a = max(0ll, x - y), b = min(w, x + y);
qs.emb(a, b);
inds[a] = 0;
inds[b] = 0;
}
int I = 0, pv = 0;
fore(p, inds) {
if (I)
lztree::modify(I - 1, {1, 0, p.fi - pv});
p.se = I++;
pv = p.fi;
}
// lztree::t[N+I-1].cnt = w - pv;
rep(i, 0, I) { T ret = lztree::query(0, i); }
const double root2 = sqrt(2);
set<pii> vis;
rep(i, 0, n) {
pii q = qs[i];
int l = inds[q.fi], r = inds[q.se];
if (vis.find(q) == vis.end()) {
vis.insert(q);
lztree::modify(l, r, {1});
} else {
vis.erase(q);
lztree::modify(l, r, {-1});
}
T ret = lztree::query(0, I);
// rep(j,0,I) lztree::push(j);
cout << setprecision(20) << (w - ret.cnt * (ret.mn == 0)) * root2 << endl;
}
}
signed main() {
cin.tie(nullptr)->sync_with_stdio(false);
int t = 1;
// cin >> t;
rep(i, 0, t)
// while (1)
solve(i + 1);
} | failed | 106_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define MP make_pair
mt19937 rnd(time(0));
const int MAXN = 5e5 + 5;
const ll inf = 1e18;
int n, m, c, stk[MAXN], hd, tl;
ll a[MAXN], b[MAXN], f[MAXN];
inline ll F(ll x) { return upper_bound(b, b + m + 1, x) - b - 1; }
inline int w(int l, int r) { return F(a[r] - a[l - 1]) - c; }
inline int tf(int l, int r) { return f[l] + w(l + 1, r); }
void ccb(int L, int R, int l, int r) {
if (l > r)
return;
ll mx = -inf;
int j = 0, k = 0, mid = (l + r) >> 1;
for (int i = L; i <= R; i++)
if (tf(i, mid) > mx)
mx = tf(i, mid), j = k = i;
else if (tf(i, mid) == mx)
k = i;
f[mid] = max(f[mid], mx);
ccb(L, k, l, mid - 1);
ccb(j, R, mid + 1, r);
}
void solve(int l, int r) {
if (l == r)
return;
int mid = (l + r) >> 1;
solve(l, mid);
ccb(l, mid, mid + 1, r);
solve(mid + 1, r);
}
void solve() {
cin >> n >> m >> c;
for (int i = 1; i <= n; i++)
cin >> a[i], a[i] += a[i - 1], f[i] = -inf;
for (int i = 1; i <= m; i++)
cin >> b[i], b[i] += b[i - 1];
b[m + 1] = inf;
solve(0, n);
cout << f[n] << '\n';
}
int main() {
// freopen("Otomachi_Una.in","r",stdin);
// freopen("Otomachi_Una.out","w",stdout);
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--)
solve();
return 0;
} | failed | 32_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define int long long
#define pii pair<int, int>
struct P {
array<int, 8> c;
P() {
for (auto &x : c) {
x = 0;
}
}
int val() {
int ans = 0;
int k = 1;
for (int i = 0; i < 8; i++) {
ans += k * c[i];
k *= 6;
}
return ans;
}
void clear() { fill(c.begin(), c.end(), 0); }
bool exist() {
for (auto x : c) {
if (x < 0)
return 0;
}
return 1;
}
P change() {
P tmp;
for (int i = 0; i < 8; i++) {
tmp.c[i] = c[i] % 3;
}
return tmp;
}
P operator-(P &t) {
P tmp;
for (int i = 0; i < 8; i++) {
tmp.c[i] = c[i] - t.c[i];
}
return tmp;
}
const bool operator<(P &t) { return c < t.c; }
};
vector<P> vt;
void init() {
P p;
for (int i = 0; i < 729; i++) {
int tmp = i;
p.clear();
for (int j = 0; j < 6; j++) {
int q = tmp % 3;
for (int k = j; k < j + 3; k++) {
p.c[k] += q;
}
tmp /= 3;
}
// for (auto x : p.c) {
// cout << x << " ";
// }
// cout << endl;
vt.push_back(p);
}
}
vector<int> mp(1679616, 0);
void solve() {
int n;
cin >> n;
vector<int> a(n + 9);
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]--;
}
fill(mp.begin(), mp.end(), 0);
int ans = 0;
P p;
mp[p.val()]++;
for (int i = 1; i <= n; i++) {
p.c[a[i]]++;
// cout << i << endl;
for (auto p2 : vt) {
auto t = p - p2;
if (!t.exist())
continue;
t = t.change();
// for (auto x : t.c) {
// cout << x << " ";
// }
// cout << endl;
// cout << "mp:" << mp[t.val()] << endl;
ans += mp[t.val()];
}
mp[p.change().val()]++;
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init();
int t = 1;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
} | failed | 41_3_wrong.cpp |
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define app push_back
#define int long long
#ifdef LOCAL
#define debug(...) \
[](auto... a) { ((cout << a << ' '), ...) << endl; }(#__VA_ARGS__, ":", \
__VA_ARGS__)
#define debugv(v) \
do { \
cout << #v << ": "; \
for (auto x : v) \
cout << x << ' '; \
cout << endl; \
} while (0)
#else
#define debug(...)
#define debugv(v)
#endif
using namespace std;
void solve();
int32_t main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
struct point3D {
double x, y, z;
};
struct point {
double x, y;
point(double x = 0, double y = 0) : x(x), y(y) {}
};
point operator-(point a, point b) { return {a.x - b.x, a.y - b.y}; }
point operator+(point a, point b) { return {a.x + b.x, a.y + b.y}; }
point operator*(double t, point p) { return {t * p.x, t * p.y}; }
double cross(point p, point q) { return p.x * q.y - q.x * p.y; }
istream &operator>>(istream &is, point3D &p) {
is >> p.x >> p.y >> p.z;
return is;
}
const double eps = 1e-10;
double sgn(point a, point p, point q) { return cross(q - p, a - p); }
double sgn(point a, double A, double B, double C) {
return A * a.x + B * a.y + C;
}
template <typename... Args> point intersect(point a, point b, Args... args) {
double sa = sgn(a, args...);
double sb = sgn(b, args...);
double t = abs(sa) / (abs(sa) + abs(sb));
return a + t * (b - a);
}
template <typename... Args>
vector<point> intersect(vector<point> a, Args... args) {
int n = a.size();
if (n == 0)
return a;
vector<int> sign(n);
for (int i = 0; i < n; ++i) {
sign[i] = sgn(a[i], args...) > -eps;
}
if (count(all(sign), 1) == 0)
return {};
if (count(all(sign), 1) == n)
return a;
assert(sign[0] == sign[n - 1]);
int s = -1, f = -1;
for (int i = 0; i + 1 < n; ++i) {
if (sign[i] == 0 && sign[i + 1] == 1)
s = i + 1;
if (sign[i] == 1 && sign[i + 1] == 0)
f = i + 1;
}
assert(f >= 0 && s >= 0);
for (int j = s; j != f; j = (j + 1) % n)
assert(sign[j] == 1);
for (int j = f; j != s; j = (j + 1) % n)
assert(sign[j] == 0);
point bs = intersect(a[s - 1], a[s], args...);
point af = intersect(a[f - 1], a[f], args...);
vector<point> b{bs};
for (int j = s; j != f; j = (j + 1) % n)
b.push_back(a[j]);
b.push_back(af);
b.push_back(bs);
return b;
}
mt19937 rng(0);
double solve(point3D *A, point3D *B, double w, double h) {
debug(h, w);
w = w / h;
h = 1;
vector<point> a, b;
for (int i = 0; i < 4; ++i)
a.push_back({A[i].x, A[i].z});
for (int i = 0; i < 4; ++i)
b.push_back({B[i].x, B[i].z});
for (int i = 0; i < 4; ++i)
a.push_back(a[i]);
for (int i = 0; i < 4; ++i)
b.push_back(b[i]);
if (cross(a[2] - a[1], a[0] - a[1]) < eps)
reverse(all(a));
for (int i = 1; i + 1 < a.size(); ++i)
assert(cross(a[i + 1] - a[i], a[i - 1] - a[i]) > -eps);
for (int i = 1; i + 1 < a.size(); ++i)
assert(cross(b[i + 1] - b[i], b[i - 1] - b[i]) > -eps);
a.resize(5);
for (int i = 0; i < 4; ++i) {
a = intersect(a, b[i], b[i + 1]);
}
for (int i = 0; i < a.size(); ++i) {
debug(a[i].x, a[i].y);
}
auto inside = [&](point u, point v) {
for (int i = 0; i + 1 < a.size(); ++i) {
auto delta = a[i + 1] - a[i];
if (cross(delta, point{u.x, v.y} - a[i]) < -eps)
return 0;
if (cross(delta, point{v.x, u.y} - a[i]) < -eps)
return 0;
if (cross(delta, u - a[i]) < -eps)
return 0;
if (cross(delta, v - a[i]) < -eps)
return 0;
}
return 1;
};
double ans = 0;
auto f = [&](point p, point q, double s) {
point r = s * p + (1 - s) * q;
double low = 0, high = 8e3;
for (int iter = 0; iter < 40; ++iter) {
double med = (low + high) / 2;
if (inside(r, point{r.x + med * w, r.y + med * h}))
low = med;
else
high = med;
if (inside(r, point{r.x - med * w, r.y + med * h}))
low = med;
else
high = med;
if (inside(r, point{r.x - med * w, r.y - med * h}))
low = med;
else
high = med;
if (inside(r, point{r.x + med * w, r.y - med * h}))
low = med;
else
high = med;
}
ans = max(ans, (low * low * w * h));
point r2 = point{r.x + low * w, r.y + low * h};
debug(low * low * w * h, r.x, r.y, r2.x, r2.y);
return (low * low * w * h);
};
for (int i = 0; i + 1 < a.size(); ++i) {
double low = 0, high = 1;
f(a[i], a[i], 0);
for (int it = 0; it < 60; ++it) {
double m1 = (2 * low + high) / 3, m2 = (low + 2 * high) / 3;
if (f(a[i], a[i + 1], m1) > f(a[i], a[i + 1], m2))
high = m2;
else
low = m1;
}
}
return ans;
}
double dist(point3D a, point3D b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) +
(a.z - b.z) * (a.z - b.z));
}
void solve() {
point3D lens[4];
cin >> lens[0] >> lens[1] >> lens[2] >> lens[3];
double w = dist(lens[0], lens[1]), h = dist(lens[1], lens[2]);
point3D screen[4];
cin >> screen[0] >> screen[1] >> screen[2] >> screen[3];
auto to_wall = [&](point3D p) {
double A = screen[0].y - screen[1].y;
double B = screen[1].x - screen[0].x;
double C = -A * screen[0].x - B * screen[0].y;
double C1 = -A * screen[1].x - B * screen[1].y;
debug(C, C1);
return abs(A * p.x + B * p.y + C) / sqrt(A * A + B * B);
};
double from_origin = to_wall({0, 0, 0});
for (auto &[x, y, z] : lens) {
double from_point = to_wall({x, y, z});
double k = from_origin / (from_origin - from_point);
debug(from_point, from_origin, k);
x *= k;
y *= k;
z *= k;
}
double dx = screen[0].x - screen[1].x;
double dy = screen[0].y - screen[1].y;
double coef = sqrt(dx * dx + dy * dy) / abs(dx);
double ans = solve(lens, screen, w / coef, h) * coef;
debug(coef);
cout << setprecision(20) << ans << '\n';
}
| failed | 15_1_wrong.cpp |
template = """// 错误代码模板\n#include <iostream>\nint main() {\n // TODO: 填写错误实现\n return 1;\n}\n"""
import os
for i in range(92, 99):
for j in range(1, 4):
filename = f"{i}_{j}_wrong.cpp"
filepath = os.path.join(os.path.dirname(__file__), filename)
with open(filepath, "w", encoding="utf-8") as f:
f.write(template)
| failed | batch_create_wrong_code.py |
#include<bits/stdc++.h>
using namespace std;
const int N=5010;
int n,a[N],ans[N],f[N],g[N];
void sol(){
scanf("%d",&n);for(int i=1;i<=n;i++)scanf("%d",&a[i]);
f[0]=1;for(int i=1;i<=n;i++)f[i]=0;
for(int t=0;t<=n;t++){
int mi=1e9;
if(f[n]){
cout<<t<<endl;
for(int j=1;j<=t;j++)cout<<ans[j]<<" ";
cout<<endl;
return ;
}
for(int i=t;i<n;i++){
if(!f[i])continue;
mi=min(mi,a[i+1]);
if(ans[i-t+1]==a[i+1])f[i+1]=1;
else if(ans[i-t+1]>a[i+1]){
cout<<t<<endl;
for(int j=1;j<=t;j++)cout<<ans[j]<<" ";
cout<<endl;
return ;
}
}
ans[t+1]=mi;
for(int i=0;i<=n;i++)g[i]=0;
for(int i=0;i<n;i++){
if(f[i]&&a[i+1]==mi)g[i+1]=1;
}
for(int i=0;i<=n;i++)f[i]=g[i];
}
cout<<n<<endl;
for(int i=1;i<=n;i++)cout<<ans[i]<<" ";
cout<<endl;
}
signed main(){
// freopen("3.in","r",stdin);
// freopen("3.out","w",stdout);
int t;cin>>t;
while(t--){
sol();
for(int i=0;i<=n;i++)a[i]=ans[i]=f[i]=g[i]=0;
}
return 0;
} | failed | 27_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define PII pair<int, int>
#define ai4 array<int, 4>
#define ai3 array<int, 3>
const int N = 200010, mod = 1e9 + 7, inf = 1e9;
int tr[N << 2];
vector<int> ans(N);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void pushup(int u) { tr[u] = gcd(tr[u << 1], tr[u << 1 | 1]); }
void build(int u, int l, int r) {
if (l == r)
tr[u] = 0;
else {
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}
}
void modify(int u, int l, int r, int x, int num) {
if (r < x || l > x)
return;
if (l == r) {
tr[u] = num;
return;
}
int mid = l + r >> 1;
modify(u << 1, l, mid, x, num);
modify(u << 1 | 1, mid + 1, r, x, num);
pushup(u);
}
void solve() {
int n, q;
cin >> n >> q;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++)
cin >> a[i];
build(1, 1, n);
for (int i = 1; i < n; i++) {
if (a[i] > a[i + 1])
modify(1, 1, n, i, i);
else
modify(1, 1, n, i, 0);
}
// modify(1 , 1 , n , n , 0);
int get = tr[1];
cout << ans[get] << '\n';
while (q--) {
int p, v;
cin >> p >> v;
a[p] = v;
if (a[p - 1] > a[p])
modify(1, 1, n, p - 1, p - 1);
else
modify(1, 1, n, p - 1, 0);
if (p + 1 <= n) {
if (a[p] > a[p + 1])
modify(1, 1, n, p, p);
else
modify(1, 1, n, p, 0);
}
get = tr[1];
if (!get)
cout << n << '\n';
else
cout << ans[get] << '\n';
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i <= 200000; i++) {
for (int j = i; j <= 200000; j += i) {
++ans[j];
}
}
int T = 1;
cin >> T;
while (T--)
solve();
} | failed | 8_2_wrong.cpp |
#include <iostream>
#include <queue>
#include <unordered_set>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
// Use a set to track all unique values
unordered_set<int> uniqueValues(a.begin(), a.end());
// Use a queue to process pairs of adjacent values
queue<pair<int, int>> q;
// Initialize the queue with all adjacent pairs in the original array
for (int i = 0; i < n - 1; ++i) {
q.push({a[i], a[i + 1]});
}
// Process the queue
while (!q.empty()) {
auto [x, y] = q.front();
q.pop();
// Generate new values using the allowed operations
int andVal = x & y;
int orVal = x | y;
int xorVal = x ^ y;
// Check if the new values are unique
if (uniqueValues.insert(andVal).second) {
// If the value is new, add all adjacent pairs involving this value
for (int val : uniqueValues) {
q.push({val, andVal});
q.push({andVal, val});
}
}
if (uniqueValues.insert(orVal).second) {
for (int val : uniqueValues) {
q.push({val, orVal});
q.push({orVal, val});
}
}
if (uniqueValues.insert(xorVal).second) {
for (int val : uniqueValues) {
q.push({val, xorVal});
q.push({xorVal, val});
}
}
}
// Output the number of unique values
cout << uniqueValues.size() << endl;
return 0;
} | failed | 6_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORD(i, a, b) for (int i = a; i >= b; --i)
int V();
int E();
int O();
struct node {
int tp;
int kind;
char c;
int lson, rson;
node() {
tp = -1;
kind = -1;
c = '0';
lson = -1;
rson = -1;
}
};
string s;
node a[1000010];
int now, tot, len;
char tmp[1000010];
int ts, root;
string Z;
void L() {
while (s[now] == ' ')
++now;
assert(s[now] == '(');
++now;
}
void R() {
while (s[now] == ' ')
++now;
assert(s[now] == ')');
++now;
}
int V() {
int ans = ++tot;
a[ans].tp = 1;
while (s[now] == ' ')
++now;
a[ans].c = s[now];
++now;
return ans;
}
int O() {
int ans = ++tot;
a[ans].tp = 2;
while (s[now] == ' ')
++now;
if (s[now] == 'm') {
if (s[now + 1] == 'i') {
now += 3;
a[ans].kind = 3;
a[ans].lson = E();
a[ans].rson = E();
} else {
now += 3;
a[ans].kind = 4;
a[ans].lson = E();
a[ans].rson = E();
}
} else {
a[ans].lson = E();
while (s[now] == ' ')
++now;
assert(s[now] == '<');
++now;
if (s[now] == '=') {
++now;
a[ans].kind = 1;
a[ans].rson = E();
} else {
a[ans].kind = 2;
a[ans].rson = E();
}
}
return ans;
}
int E() {
int ans = ++tot;
a[ans].tp = 3;
while (s[now] == ' ')
++now;
if (s[now] == '(') {
a[ans].kind = 2;
L();
a[ans].lson = O();
R();
} else {
a[ans].kind = 1;
a[ans].lson = V();
}
return ans;
}
int eval1(int n) {
if (a[n].tp == 1) {
return 1;
}
if (a[n].tp == 2) {
if (a[n].kind == 1) {
return (eval1(a[n].lson) <= eval1(a[n].rson));
} else if (a[n].kind == 2) {
return (eval1(a[n].lson) < eval1(a[n].rson));
} else if (a[n].kind == 3) {
return min(eval1(a[n].lson), eval1(a[n].rson));
} else if (a[n].kind == 4) {
return max(eval1(a[n].lson), eval1(a[n].rson));
}
}
if (a[n].tp == 3) {
return eval1(a[n].lson);
}
assert(0);
}
void solve(int n) {
if (a[n].tp == 1) {
cout << a[n].c;
return;
}
if (a[n].tp == 2) {
if (a[n].kind == 1) {
solve(a[n].lson);
cout << " <= ";
solve(a[n].rson);
} else if (a[n].kind == 2) {
cout << "((";
solve(a[n].rson);
cout << " <= ";
solve(a[n].lson);
cout << ") <= ";
cout << Z;
cout << ")";
} else if (a[n].kind == 3) {
cout << "min ";
solve(a[n].lson);
cout << " ";
solve(a[n].rson);
} else {
cout << "(min (";
solve(a[n].lson);
cout << " <= ";
cout << Z;
cout << ") (";
solve(a[n].rson);
cout << " <= ";
cout << Z;
cout << ")) <= ";
cout << Z;
}
}
if (a[n].tp == 3) {
if (a[n].kind == 1)
solve(a[n].lson);
else if (a[n].kind == 2) {
cout << "(";
solve(a[n].lson);
cout << ")";
}
}
}
int main() {
getline(cin, s);
now = 0;
tot = 0;
root = E();
ts = 0;
FOR(i, 1, tot)
if (a[i].tp == 1) {
tmp[++ts] = a[i].c;
}
sort(tmp + 1, tmp + ts + 1);
ts = unique(tmp + 1, tmp + ts + 1) - tmp - 1;
if (eval1(root) == 0) {
puts("NO");
return 0;
}
puts("YES");
if (ts == 1) {
Z = "";
Z += tmp[1];
} else {
Z = string("(min ") + tmp[1] + string(" ") + tmp[2] + string(" )");
FOR(i, 3, ts)
Z = string("(min ") + Z + string(" ") + tmp[i] + string(" )");
}
solve(root);
return 0;
} | failed | 93_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
using pii = pair<int, int>;
#define F first
#define S second
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
using ll = long long;
typedef vector<int> vi;
#define pb push_back
#define vt vector
const int MAXN = 5e5 + 5;
int n, k;
int a[MAXN];
int pos[MAXN];
ll tot = 0;
struct Interval {
int l, r;
int id;
};
int fix(int x) {
x %= tot;
if (x < 0)
x += tot;
return x;
}
bool check(ll m) {
m <<= 1;
vt<Interval> lst(n * 2);
vt<bool> skip(n * 2);
vt<int> nxt(n, -1);
for (int i = 0; i < n; ++i) {
if (m >= tot - a[i]) {
skip[i] = skip[i + n] = 1;
continue;
}
int g = (m - a[i]) / 2;
int l = pos[i] - g;
int r = pos[i + 1] + g;
lst[i] = {l, r, i};
// cout << l << " " << r << " " << i << "\n";
lst[i + n] = {l + tot, r + tot, i};
// lst.pb({l + tot, r + tot, i});
// intervals[i] = {l, r};
// intervals[i + n] = {l + tot, r + tot};
}
auto checkgood = [&](int x, int i) -> bool {
i %= n;
// int l = pos[i], r = pos[i + 1];
int l = lst[i].l % tot, r = lst[i].r % tot;
if (l > r)
r += tot;
x = fix(x);
x = lst[x].r % tot;
if (l <= x && x <= r)
return 1;
// cout << x << " " << l << " " << r << "\n";
{
int dl = abs(l - x), dr = abs(r - x);
if (dl + dr <= m)
return 1;
}
{
x += tot;
int dl = abs(l - x), dr = abs(r - x);
if (dl + dr <= m)
return 1;
}
return 0;
};
//
auto tlst = lst;
sort(all(lst), [](Interval x, Interval y) { return x.r < y.r; });
for (int i = 0; i < n * 2; ++i)
assert(lst[i].id == tlst[i].id);
int ptr = 0;
for (int i = 0; i < n * 2 && ptr < n; ++i) {
if (skip[i])
continue;
while (ptr < n && (skip[ptr] || lst[ptr].r < lst[i].l)) {
if (skip[ptr]) {
++ptr;
continue;
}
if (nxt[lst[ptr].id] == -1)
nxt[lst[ptr].id] = lst[i].id;
++ptr;
}
}
for (int i = 0; i < n; ++i) {
if (nxt[i] == -1)
return 1;
if (nxt[i] == i)
return 1;
// cout << i << " " << nxt[i] << "\n";
}
int cur = 0;
while (cur < n && skip[cur])
++cur;
if (cur == n)
return 1;
for (int i = 0; i < n; ++i)
cur = nxt[cur];
int id = cur;
for (int i = 0; i < k; ++i) {
id = min(id, cur);
cur = nxt[cur];
}
cur = id;
// cout << cur << "\n";
ptr = 0;
int cnt = 0;
// while(pos[(cur + 1) % n] > lst[ptr].r) ++ptr;
while (!checkgood(cur, ptr))
++ptr;
for (int i = 0; i < k; ++i) {
while (ptr < n * 2 && (skip[ptr] || checkgood(cur, ptr))) {
// vis[ptr] = 1;
// cout << cur << " " << ptr << "\n";
++cnt;
++ptr;
}
if (cnt >= n)
return 1;
cur = nxt[cur];
}
// cout << "Here\n";
return 0;
}
signed main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k;
int mx = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] *= 2;
pos[i] = tot;
// cout << pos[i] << "\n";
tot += a[i];
// mn = min(mn, a[i]);
mx = max(mx, a[i]);
}
mx = min(mx, tot / 2);
pos[n] = tot;
// cout << tot << "\n";
// check(9);
// return 0;
ll l = mx / 2, r = 5e14, ans = r;
while (l <= r) {
ll mid = (l + r) >> 1;
// cout << mid << " " << check(mid) << "\n";
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << "\n";
} | failed | 95_3_wrong.cpp |
#include <cctype>
#include <cstdio>
#include <cstring>
using namespace std;
inline void yes() { printf("YES\n"); }
inline void no() { printf("NO\n"); }
inline int read() {
int x = 0;
char c;
while (!isdigit(c = getchar()))
;
do {
x = (x << 1) + (x << 3) + (c ^ 48);
} while (isdigit(c = getchar()));
return x;
}
int top = 0, stk[20];
inline void write(int x) {
do {
stk[++top] = x % 10;
x /= 10;
} while (x);
for (int i = top; i; --i)
putchar(stk[i] | 48);
putchar('\n');
top = 0;
return;
}
char now;
char s[500010], t[500010];
int rt, n, q, cnt, len;
struct node {
char c;
int len;
} a[500010];
int main() {
rt = read();
for (int dt = 1; dt <= rt; ++dt) {
scanf("%s", s + 1);
q = read();
n = strlen(s + 1);
cnt = len = now = 0;
for (int i = 1; i <= n; ++i) {
if (!now)
now = s[i], len = 1;
else if (now != s[i]) {
a[++cnt] = (node){now, len};
now = s[i];
len = 1;
} else
++len;
}
if (len)
a[++cnt] = (node){now, len};
for (int i = 1; i <= q; ++i) {
scanf("%s", t + 1);
len = now = 0;
n = strlen(t + 1);
int ptr = 1;
bool ok = true;
for (int j = 1; j <= n; ++j) {
if (!now)
now = t[j], len = 1;
else if (now != t[j]) {
while (len > 0) {
if (a[ptr].c != now) {
if (++ptr > cnt) {
ok = false;
break;
}
}
len -= a[ptr++].len;
if (len > 0 && ptr > cnt) {
ok = false;
break;
}
}
if (!ok)
break;
now = t[j];
len = 1;
} else
++len;
}
if (ok && len) {
while (len > 0) {
if (a[ptr].c != now) {
if (++ptr > cnt) {
ok = false;
break;
}
}
len -= a[ptr++].len;
if (len > 0 && ptr > cnt) {
ok = false;
break;
}
}
}
if (s[1] == 'L' && t[1] == 'R')
ok = false;
else if (s[strlen(s + 1)] == 'R' && t[n] == 'L')
ok = false;
if (ok)
yes();
else
no();
}
}
return 0;
} | failed | 44_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
int arr[20000009];
void solve() {
int n, p;
std::cin >> n >> p;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int cur = 0;
for (int i = 0; i < n; i++) {
cur += arr[i];
if ((arr[i + 1] - 1) >= (p - cur) / (i + 1)) {
cout << i << endl;
return;
}
}
cout << n << endl;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0), std::cout.tie(0);
int t = 1;
// std::cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
} | failed | 107_3_wrong.cpp |
#include <bits/stdc++.h>
using i64 = long long;
struct DIU {
std::function<bool(std::pair<int, int>, std::pair<int, int>)> cmp =
[](const std::pair<int, int> &a, const std::pair<int, int> &b) -> bool {
return a.second < b.first;
};
std::set<std::pair<int, int>, decltype(cmp)> s =
std::set<std::pair<int, int>, decltype(cmp)>(cmp);
void insert(int l, int r) {
auto it = s.find({l, r});
while (it != s.end() && it->first <= r) {
l = std::min(l, it->first);
r = std::max(r, it->second);
it++;
s.erase(std::prev(it));
}
auto lit = s.find({l - 1, l - 1});
if (lit != s.end()) {
l = lit->first;
s.erase(lit);
}
auto rit = s.find({r + 1, r + 1});
if (rit != s.end()) {
r = rit->second;
s.erase(rit);
}
s.insert({l, r});
}
void erase(int l, int r) {
auto it = s.find({l, r});
while (it != s.end() && it->first <= r) {
auto [ll, rr] = *it;
it++;
s.erase(std::prev(it));
if (ll < l)
s.insert({ll, l - 1});
if (rr > r)
s.insert({r + 1, rr});
}
}
int check(int l, int r) { // 检查区间属性：-1 - 只能为0，-2 - 只能为 1，x -
// 有且仅有一个位置为空，这个位置是 x
auto it = s.find({l, r});
if (l == r)
return (it == s.end() ? -1 : -2);
if (l > r)
return -2;
if (it == s.end())
return -1;
int cnt = 0, lst = l;
while (it != s.end() && it->first <= r && cnt < 2) {
cnt += std::max(l, it->first) - lst;
lst = std::min(r + 1, it->second + 1);
it++;
}
cnt += r + 1 - lst;
if (cnt >= 2)
return -1;
if (cnt == 1) {
it = s.find({l, r});
if (it->first <= l)
return it->second + 1;
else
return l;
}
// std::cout << cnt << "??\n";
return -2;
}
};
/*
3 3 7 6 7
3 8 7 6 7
10101
10111
00111
01000
*/
void solve() {
int n, m;
std::cin >> n >> m;
std::vector<DIU> diu(63);
for (int i = 1; i <= n; i++) {
i64 x;
std::cin >> x;
for (int j = 0; j < 63; j++) {
if (x >> j & 1) {
diu[j].insert(i, i);
}
}
}
while (m--) {
int op;
std::cin >> op;
if (op == 1) {
int l, r;
i64 x;
std::cin >> l >> r >> x;
for (int i = 0; i < 63; i++) {
if (x >> i & 1) {
} else {
diu[i].erase(l, r);
}
}
} else if (op == 2) {
int p;
i64 x;
std::cin >> p >> x;
for (int i = 0; i < 63; i++) {
if (x >> i & 1) {
diu[i].insert(p, p);
} else {
diu[i].erase(p, p);
}
}
// for (int i = 0; i < 4; i++) {
// for (auto [l, r] : diu[i].s) {
// std::cout << "[" << l << ", " << r << "]";
// }
// std::cout << "\n";
// }
} else {
int l, r;
std::cin >> l >> r;
i64 ans = 0;
bool found = 0;
int t;
for (int i = 62; i >= 0; i--) {
if (found) {
// std::cout << t << ". " << i << ": " << (diu[i].check(l, t - 1) ==
// -2) << ", " << (diu[i].check(t + 1, r) == -2) << "]\n";
if (diu[i].check(l, t - 1) == -2 && diu[i].check(t + 1, r) == -2) {
ans |= (1ll << i);
}
} else {
t = diu[i].check(l, r);
if (t == -2)
ans |= (1ll << i);
else if (t != -1) {
ans |= (1ll << i);
found = 1;
}
}
}
std::cout << ans << "\n";
}
}
}
signed main() {
std::cin.tie(nullptr)->sync_with_stdio(false);
int t = 1;
// std::cin >> t;
while (t--)
solve();
return 0;
} | failed | 25_3_wrong.cpp |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;
constexpr int N = 1E6;
std::vector<int> primes;
i64 f[N + 1][10];
i64 ans[N + 1];
int minp[N + 1];
int fp[20][10][10];
void solve() {
i64 n;
std::cin >> n;
i64 s = std::cbrt(n);
if (s * s * s > n) {
s--;
}
std::cout << ans[s] << "\n";
}
void work(int x, int y, int r) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
f[y][j] += f[x][i] * fp[r][i][j];
}
}
}
void sieve() {
f[1][0] = 1;
for (int i = 2; i <= N; i++) {
if (minp[i] == 0) {
minp[i] = i;
primes.push_back(i);
work(1, i, 1);
}
for (auto p : primes) {
if (i * p > N) {
break;
}
int r = 1;
int x = i;
while (x % p == 0) {
x /= p;
r++;
}
minp[i * p] = p;
work(x, i * p, r);
if (minp[i] == p) {
break;
}
}
}
for (int i = 1; i <= N; i++) {
ans[i] = ans[i - 1] + f[i][3];
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
constexpr int B = 60;
std::vector<std::array<int, 9>> states;
states.push_back({0, 0, 0, 0, 0, 0, 0, 0, 0});
std::vector<std::array<int, 9>> arr;
int a[3][3];
for (a[0][0] = 0; a[0][0] < B; a[0][0]++) {
for (a[0][1] = 0; a[0][0] + a[0][1] < B; a[0][1]++) {
for (a[0][2] = 0; a[0][0] + a[0][1] + a[0][2] < B; a[0][2]++) {
int S = a[0][0] + a[0][1] + a[0][2];
for (a[1][0] = 0; a[0][0] + a[1][0] <= S; a[1][0]++) {
a[2][0] = S - a[0][0] - a[1][0];
a[1][1] = S - a[0][2] - a[2][0];
if (a[1][1] < 0) {
continue;
}
a[1][2] = S - a[1][0] - a[1][1];
if (a[1][2] < 0) {
continue;
}
a[2][1] = S - a[0][1] - a[1][1];
if (a[2][1] < 0) {
continue;
}
a[2][2] = S - a[2][0] - a[2][1];
if (a[2][2] < 0) {
continue;
}
if (a[0][0] + a[1][1] + a[2][2] != S) {
continue;
}
// for (int i = 0; i < 3; i++) {
// for (int j = 0; j < 3; j++) {
// std::cerr << a[i][j] << " \n"[j == 2];
// }
// }
// std::cerr << "\n";
std::array<int, 9> comp;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
comp[i * 3 + j] = a[i][j];
}
}
arr.push_back(comp);
}
}
}
}
std::map<std::array<int, 9>, int> stid;
auto trans = [&](const auto &s, const auto &a) {
auto ns = s;
for (int j = 0; j < 9; j++) {
ns[j] = ns[j] * B + a[j];
}
std::map<int, int> idx;
for (int j = 0; j < 9; j++) {
if (!idx.contains(ns[j])) {
idx[ns[j]] = idx.size();
}
ns[j] = idx[ns[j]];
}
return ns;
};
for (const auto &a : arr) {
for (int i = 0; i < states.size(); i++) {
auto ns = trans(states[i], a);
if (std::find(states.begin(), states.end(), ns) == states.end()) {
states.push_back(ns);
}
}
}
for (int i = 0; i < states.size(); i++) {
stid[states[i]] = i;
}
for (const auto &a : arr) {
int S = (a[0] + a[1] + a[2]) / 3;
std::vector<int> tr;
for (int i = 0; i < states.size(); i++) {
auto ns = trans(states[i], a);
fp[S][i][stid[ns]]++;
}
}
sieve();
int t;
std::cin >> t;
while (t--) {
solve();
}
return 0;
} | failed | 64_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m;
std::cin >> n >> m;
std::vector<int> a(n), b(m);
std::vector<std::pair<int, int>> t(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
a[i]--;
}
for (int i = 0; i < n; i++) {
int l = a[(i + n - 1) % n];
int r = a[(i + 1) % n];
if (l > r) {
std::swap(l, r);
}
t[a[i]] = {l, r};
}
for (int j = 0; j < m; j++) {
std::cin >> b[j];
b[j]--;
}
auto check = [&](int l, int r, int la, int ra) -> bool {
if (m == 1) {
return 1;
}
if (n == m) {
return (l == la && r == ra);
}
return (l == la || r == ra);
};
for (int i = 0; i < m; i++) {
int l = b[(i + m - 1) % m];
int r = b[(i + 1) % m];
if (l > r) {
std::swap(l, r);
}
if (!check(l, r, t[b[i]].first, t[b[i]].second)) {
std::cout << 0 << '\n';
return 0;
}
}
std::cout << 1 << '\n';
} | failed | 102_2_wrong.cpp |
#include <iostream>
#include <queue>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
struct State {
string lights;
vector<int> presses;
int total;
State(string l, vector<int> p, int t) : lights(l), presses(p), total(t) {}
};
string pressButton(const string &lights,
const vector<vector<int>> &buttonLights, int button) {
string result = lights;
for (int light : buttonLights[button]) {
if (result[light] == 'R')
result[light] = 'G';
else if (result[light] == 'G')
result[light] = 'B';
else
result[light] = 'R';
}
return result;
}
bool allRed(const string &lights) {
for (char c : lights) {
if (c != 'R')
return false;
}
return true;
}
string getKey(const string &lights, const vector<int> &presses) {
string key = lights;
for (int press : presses) {
key += "," + to_string(press % 3);
}
return key;
}
int solve(int l, int b, string &initial, vector<vector<int>> &buttonLights) {
queue<State> q;
unordered_set<string> visited;
vector<int> initialPresses(b, 0);
q.push(State(initial, initialPresses, 0));
visited.insert(getKey(initial, initialPresses));
while (!q.empty()) {
State current = q.front();
q.pop();
if (allRed(current.lights)) {
return current.total;
}
// Try pressing each button
for (int i = 0; i < b; i++) {
if (current.presses[i] >= 4)
continue; // No need to press more than 4 times
string newLights = pressButton(current.lights, buttonLights, i);
vector<int> newPresses = current.presses;
newPresses[i]++;
string key = getKey(newLights, newPresses);
if (visited.find(key) == visited.end()) {
visited.insert(key);
q.push(State(newLights, newPresses, current.total + 1));
}
}
}
return -1; // impossible
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int l, b;
cin >> l >> b;
string lights;
cin >> lights;
vector<vector<int>> buttonLights(b);
// Read button configurations
for (int i = 0; i < b; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int light;
cin >> light;
buttonLights[i].push_back(light - 1);
}
}
int result = solve(l, b, lights, buttonLights);
if (result == -1) {
cout << "impossible\n";
} else {
cout << result << "\n";
}
return 0;
} | failed | 116_2_wrong.cpp |
#include <bits/stdc++.h>
typedef unsigned long long ull;
typedef long long ll;
typedef long double ldb;
typedef double db;
#define file(a) freopen(#a ".in", "r", stdin), freopen(#a ".out", "w", stdout)
#define gc getchar
#define pc putchar
namespace IO {
template <class T> void read(T &s) {
s = 0;
char ch = gc();
bool f = 0;
while (ch < '0' || '9' < ch) {
if (ch == '-')
f = 1;
ch = gc();
}
while ('0' <= ch && ch <= '9') {
s = s * 10 + (ch ^ 48);
ch = gc();
}
if (ch == '.') {
T p = 0.1;
ch = gc();
while ('0' <= ch && ch <= '9') {
s = s + p * (ch ^ 48);
p /= 10;
ch = gc();
}
}
s = f ? -s : s;
}
template <class T, class... A> void read(T &s, A &...a) {
read(s);
read(a...);
}
template <class T> void write(T x) {
if (x < 0) {
x = -x;
pc('-');
}
static char st[40];
static int top;
top = 0;
do
st[++top] = x - x / 10 * 10 + '0';
while (x /= 10);
while (top)
pc(st[top--]);
}
}; // namespace IO
using IO::read;
using IO::write;
const int N = 2e5;
int n;
struct line {
int l, r, h;
} p[N + 3];
struct rect {
int y;
line x;
} a[N + 3];
struct SegTree {
struct node {
ll mx;
ll vol;
int add, num;
struct Cnt {
int cnt;
int cl, cr;
Cnt operator+(const Cnt &x) {
Cnt res = {-1, 0, 0};
res.cl = cl;
res.cr = x.cr;
res.cnt = cnt + x.cnt - (cr == x.cl && cr == 1);
return res;
}
} cnt;
} t[N * 4 + 3];
void change_vol(int x, ll vol) {
t[x].vol = vol;
t[x].mx = vol;
}
void change_add(int x, int add) {
t[x].num += add;
t[x].add += add;
if (t[x].num > 0)
t[x].cnt = {1, 1, 1};
else
t[x].cnt = {0, 0, 0};
}
void pushdown(int x) {
if (t[x].vol != -1) {
change_vol(x << 1, t[x].vol);
change_vol(x << 1 | 1, t[x].vol);
t[x].vol = -1;
}
if (t[x].add) {
change_add(x << 1, t[x].add);
change_add(x << 1 | 1, t[x].add);
t[x].add = 0;
}
}
void pushup(int x) {
t[x].mx = std::max(t[x << 1].mx, t[x << 1 | 1].mx);
t[x].cnt = t[x << 1].cnt + t[x << 1 | 1].cnt;
}
void build(int x, int l, int r) {
t[x].mx = 0;
t[x].vol = -1;
t[x].num = t[x].add = 0;
t[x].cnt = {0, 0, 0};
if (l == r) {
return;
}
int mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushup(x);
}
void modify_vol(int x, int l, int r, int L, int R, ll k) {
if (L <= l && r <= R) {
change_vol(x, k);
return;
}
pushdown(x);
int mid = l + r >> 1;
if (L <= mid)
modify_vol(x << 1, l, mid, L, R, k);
if (mid + 1 <= R)
modify_vol(x << 1 | 1, mid + 1, r, L, R, k);
pushup(x);
}
ll query_max(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return t[x].mx;
}
pushdown(x);
int mid = l + r >> 1;
ll mx = 0;
if (L <= mid)
mx = std::max(mx, query_max(x << 1, l, mid, L, R));
if (mid + 1 <= R)
mx = std::max(mx, query_max(x << 1 | 1, mid + 1, r, L, R));
return mx;
}
node::Cnt query_cnt(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return t[x].cnt;
}
pushdown(x);
node::Cnt res = {-1, 0, 0}, tl = {-1, 0, 0}, tr = {-1, 0, 0};
int mid = l + r >> 1;
if (L <= mid)
tl = query_cnt(x << 1, l, mid, L, R);
if (mid + 1 <= R)
tr = query_cnt(x << 1 | 1, mid + 1, r, L, R);
if (tl.cnt != -1 && tr.cnt != -1) {
res = tl + tr;
} else if (tl.cnt != -1) {
res = tl;
} else {
res = tr;
}
return res;
}
void modify_add(int x, int l, int r, int L, int R, int k) {
if (L <= l && r <= R) {
change_add(x, k);
return;
}
pushdown(x);
int mid = l + r >> 1;
if (L <= mid)
modify_add(x << 1, l, mid, L, R, k);
if (mid + 1 <= R)
modify_add(x << 1 | 1, mid + 1, r, L, R, k);
pushup(x);
}
} t;
struct Opt {
int op, l, r;
friend bool operator<(const Opt &x, const Opt &y) {
if (x.op == y.op) {
return x.l < y.l;
}
return x.op < y.op;
}
};
std::map<ll, std::vector<Opt>> op;
int main() {
#ifdef LOCAL
file(a);
#endif
read(n);
t.build(1, -1, N);
for (int i = 1; i <= n; ++i) {
read(p[i].l, p[i].r, p[i].h);
--p[i].r;
a[i].y = t.query_max(1, -1, N, p[i].l, p[i].r);
a[i].x = p[i];
t.modify_vol(1, -1, N, p[i].l, p[i].r, a[i].y + p[i].h);
}
std::sort(a + 1, a + 1 + n, [](const rect &x, const rect &y) {
if (x.y == y.y) {
return x.x.l < y.x.l;
}
return x.y < y.y;
});
t.build(1, -1, N);
for (int i = 1; i <= n; ++i) {
op[a[i].y].push_back({0, a[i].x.l - 1, a[i].x.r + 1});
op[a[i].y].push_back({1, a[i].x.l, a[i].x.r});
op[a[i].y + a[i].x.h].push_back({2, a[i].x.l, a[i].x.r});
}
ll ans = 0;
for (auto it : op) {
auto vec = it.second;
std::sort(vec.begin(), vec.end());
// fprintf(stderr, "%d\n", it.first);
for (auto opt : vec) {
// fprintf(stderr, "%d %d %d\n", opt.op, opt.l, opt.r);
if (opt.op == 0) {
ans += std::max(0, t.query_cnt(1, -1, N, opt.l, opt.r).cnt - 1);
} else {
t.modify_add(1, -1, N, opt.l, opt.r, opt.op == 1 ? 1 : -1);
}
}
}
printf("%lld\n", ans);
return 0;
}
| failed | 94_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define all(a) begin(a), end(a)
#define len(a) int((a).size())
template <int SZ> struct hash_t {
inline static bool initialized = false;
inline static int MOD[SZ], BASE[SZ];
inline static std::vector<int> POWER[SZ];
static void initialize() {
assert(!initialized);
initialized = true;
std::mt19937 rng(
std::chrono::steady_clock::now().time_since_epoch().count());
for (int i = 0; i < SZ; i++) {
auto is_prime = [&](int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0)
return false;
return true;
};
MOD[i] = int(8e5) + rng() % int(2e8 + 228);
while (!is_prime(MOD[i]))
MOD[i]++;
BASE[i] = rng() % MOD[i];
if (!(BASE[i] & 1))
BASE[i]++;
POWER[i].push_back(1);
}
}
static void ensure(int n) {
assert(initialized);
if (int(POWER[0].size()) >= n)
return;
for (int i = 0; i < SZ; i++)
for (int j = POWER[i].size(); j < n; j++)
POWER[i].push_back(int64_t(POWER[i].back()) * BASE[i] % MOD[i]);
}
int length;
std::array<int, SZ> h;
hash_t() : length(0) {
h.fill(0);
if (!initialized)
initialize();
}
template <typename T>
hash_t(const T &value, int length = 1) : length(length) {
if (!initialized)
initialize();
ensure(length);
h.fill(0);
for (int i = 0; i < SZ; i++)
for (int j = 0; j < length; j++) {
h[i] += int64_t(value + 1) * POWER[i][j] % MOD[i];
if (h[i] >= MOD[i])
h[i] -= MOD[i];
}
}
hash_t<SZ> &operator+=(const hash_t<SZ> &x) {
assert(initialized);
ensure(x.length + 1);
for (int i = 0; i < SZ; i++)
h[i] = (int64_t(h[i]) * POWER[i][x.length] + x.h[i]) % MOD[i];
length += x.length;
return *this;
}
hash_t<SZ> &operator-=(const hash_t<SZ> &x) {
assert(initialized);
assert(x.length <= length);
ensure(length - x.length + 1);
for (int i = 0; i < SZ; i++) {
h[i] -= int64_t(x.h[i]) * POWER[i][length - x.length] % MOD[i];
if (h[i] < 0)
h[i] += MOD[i];
}
length -= x.length;
return *this;
}
bool operator==(const hash_t<SZ> &x) const {
if (length != x.length)
return false;
return h == x.h;
}
bool operator<(const hash_t<SZ> &x) const {
if (length != x.length)
return length < x.length;
return h < x.h;
}
friend hash_t<SZ> operator+(const hash_t<SZ> &left, const hash_t<SZ> &right) {
return hash_t<SZ>(left) += right;
}
friend hash_t<SZ> operator-(const hash_t<SZ> &left, const hash_t<SZ> &right) {
return hash_t<SZ>(left) -= right;
}
};
// source: https://judge.yosupo.jp/submission/42086
#include <algorithm>
#include <cassert>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <queue>
#include <random>
#include <vector>
void SA_IS(const int *s, int *SA, int n, int K) {
// s 为字符串数组[0..n-1] 必须保证 s[n-1]=0 且为最小值
// SA 为存储后缀数组[0..n-1]
// n 为字符串长度
// K 为值域
bool *t = new bool[n]; // 类型数组
int *bkt = new int[K]; // 桶
int *bkt_l = new int[K];
int *bkt_r = new int[K];
int n1 = 0; // LMS-后缀的数量
int *p1; // 按出现顺序存储所有 LMS-后缀的索引
#define is_S_type(x) (t[x])
#define is_L_type(x) (!t[x])
#define is_LMS_type(x) (is_S_type(x) && x != 0 && is_L_type(x - 1))
// 预处理每一个后缀的类型
t[n - 1] = true; // 0 为 S-型后缀且为 LMS-型后缀
for (int i = n - 2; i >= 0; --i) {
t[i] = (s[i] < s[i + 1] || (is_S_type(i + 1) && s[i] == s[i + 1]));
n1 += is_LMS_type(i + 1); // s[0] 必然不是 LMS-型后缀，不会影响
}
// 预处理桶的边界
for (int i = 0; i != K; ++i)
bkt[i] = 0;
for (int i = 0; i != n; ++i)
++bkt[s[i]];
for (int i = 0, sum = 0; i != K; ++i)
sum += bkt[i], bkt_r[i] = sum, bkt_l[i] = sum - bkt[i];
#define indecud_sort() \
do { \
for (int i = 0; i != K; ++i) \
bkt[i] = bkt_l[i]; \
for (int i = 0, j; i != n; ++i) \
if ((j = SA[i] - 1) >= 0 && is_L_type(j)) \
SA[bkt[s[j]]++] = j; \
for (int i = 0; i != K; ++i) \
bkt[i] = bkt_r[i]; \
for (int i = n - 1, j; i >= 0; --i) \
if ((j = SA[i] - 1) >= 0 && is_S_type(j)) \
SA[--bkt[s[j]]] = j; \
} while (0)
// 将所有 LMS-后缀放入 SA 对应桶的末尾并诱导排序
p1 = new int[n1];
for (int i = 0, j = 0; i != n; ++i) {
SA[i] = -1;
if (is_LMS_type(i))
p1[j++] = i;
}
for (int i = 0; i != K; ++i)
bkt[i] = bkt_r[i];
for (int i = n1 - 1; i >= 0; --i)
SA[--bkt[s[p1[i]]]] = p1[i];
indecud_sort();
int *s1 = new int[n1]; // 新的字符串
int *SA1 = new int[n1]; // 存储新的字符串排的后缀数组
for (int i = 0, j = 0; i != n; ++i)
if (is_LMS_type(SA[i]))
SA1[j++] = SA[i]; // 存储 LMS-子串的相对顺序
int name = 0;
// 对所有 LMS-子串命名
for (int i = 0, prev = -1; i != n1; ++i) {
int pos = SA1[i];
for (int j = 0;;
++j) // 无需设置范围，因为 s[n-1]=0 为最小值且不会出现在其余位置
if (prev == -1 || s[pos + j] != s[prev + j] ||
is_S_type(pos + j) != is_S_type(prev + j)) {
prev = pos, ++name;
break;
} else if (j != 0 && (is_LMS_type(pos + j) ||
is_LMS_type(prev + j))) // 到末尾了停止比较
break;
SA[pos] = name - 1; // 利用 SA 暂时存储新字符串的 name
}
for (int i = 0; i != n1; ++i)
s1[i] = SA[p1[i]];
if (name != n1)
SA_IS(s1, SA1, n1, name);
else
for (int i = 0; i != n1; ++i)
SA1[s1[i]] = i;
for (int i = 0; i != K; ++i)
bkt[i] = bkt_r[i];
for (int i = 0; i != n; ++i)
SA[i] = -1;
for (int i = n1 - 1; i >= 0; --i)
SA[--bkt[s[p1[SA1[i]]]]] = p1[SA1[i]];
indecud_sort();
delete[] SA1;
delete[] s1;
delete[] p1;
delete[] bkt_r;
delete[] bkt_l;
delete[] bkt;
delete[] t;
#undef is_S_type
#undef is_L_type
#undef is_LMS_type
#undef indecud_sort
}
std::vector<int> get_sa(const std::string &s) {
int len = s.size();
std::vector<int> SA(len + 1), s_cpy(len + 1);
for (int i = 0; i != len; ++i)
s_cpy[i] = s[i];
s_cpy.back() = 0;
SA_IS(s_cpy.data(), SA.data(), len + 1, 128);
return std::vector<int>(SA.begin() + 1, SA.end());
}
struct suffix_array {
std::vector<int> order, suffix_position, lcp;
template <typename T> suffix_array(T str = T()) {
int n = str.size() + 1;
order = get_sa(str);
order.insert(order.begin(), n - 1);
suffix_position.resize(n);
for (int i = 0; i < n; i++) {
suffix_position[order[i]] = i;
}
lcp.resize(n);
int current_lcp = 0;
for (int suffix = 0; suffix < n - 1;
suffix++, current_lcp = current_lcp == 0 ? 0 : current_lcp - 1) {
int previous_suffix = order[suffix_position[suffix] - 1];
while (str[suffix + current_lcp] == str[previous_suffix + current_lcp])
current_lcp++;
lcp[suffix_position[suffix]] = current_lcp;
}
}
};
/*
* Node must have default constructor.
* Node must have static function merge.
* Node must have .push and .clear_after_push methods.
*/
template <typename node> class segtree {
private:
void build(int v, int vl, int vr) {
if (vr - vl <= 1)
return;
int vm = (vl + vr) >> 1;
build(v << 1, vl, vm);
build(v << 1 | 1, vm, vr);
tree[v] = node::merge(tree[v << 1], tree[v << 1 | 1]);
}
template <typename T>
void build(int v, int vl, int vr, const std::vector<T> &arr) {
if (vl == vr)
return;
if (vr - vl == 1) {
tree[v] = node(arr[vl]);
return;
}
int vm = (vl + vr) >> 1;
build(v << 1, vl, vm, arr);
build(v << 1 | 1, vm, vr, arr);
tree[v] = node::merge(tree[v << 1], tree[v << 1 | 1]);
}
template <typename... Args>
void _update(int v, int vl, int vr, int l, int r, Args &&...args) {
if (r <= vl || vr <= l)
return;
if (l <= vl && vr <= r) {
tree[v].apply(std::forward<Args>(args)..., vl, vr);
return;
}
int vm = (vl + vr) >> 1;
tree[v].push(tree[v << 1], vl, vm);
tree[v].push(tree[v << 1 | 1], vm, vr);
tree[v].clear_after_push();
_update(v << 1, vl, vm, l, r, std::forward<Args>(args)...);
_update(v << 1 | 1, vm, vr, l, r, std::forward<Args>(args)...);
tree[v] = node::merge(tree[v << 1], tree[v << 1 | 1]);
}
node _query(int v, int vl, int vr, int l, int r) {
if (l <= vl && vr <= r)
return tree[v];
int vm = (vl + vr) >> 1;
tree[v].push(tree[v << 1], vl, vm);
tree[v].push(tree[v << 1 | 1], vm, vr);
tree[v].clear_after_push();
if (r <= vm)
return _query(v << 1, vl, vm, l, r);
if (vm <= l)
return _query(v << 1 | 1, vm, vr, l, r);
return node::merge(_query(v << 1, vl, vm, l, r),
_query(v << 1 | 1, vm, vr, l, r));
}
template <typename T>
int _find_first(int v, int vl, int vr, int from, const T &checker) {
if (vr <= from)
return n;
if (from <= vl && !checker(tree[v], vl, vr))
return n;
if (vr - vl == 1)
return vl;
int vm = (vl + vr) >> 1;
tree[v].push(tree[v << 1], vl, vm);
tree[v].push(tree[v << 1 | 1], vm, vr);
tree[v].clear_after_push();
int res = _find_first(v << 1, vl, vm, from, checker);
return res == n ? _find_first(v << 1 | 1, vm, vr, from, checker) : res;
}
template <typename T>
int _find_last(int v, int vl, int vr, int from, const T &checker) {
if (from <= vl)
return -1;
if (vr <= from && !checker(tree[v], vl, vr))
return -1;
if (vr - vl == 1)
return vl;
int vm = (vl + vr) >> 1;
tree[v].push(tree[v << 1], vl, vm);
tree[v].push(tree[v << 1 | 1], vm, vr);
tree[v].clear_after_push();
int res = _find_last(v << 1 | 1, vm, vr, from, checker);
return res == -1 ? _find_last(v << 1, vl, vm, from, checker) : res;
}
public:
int n;
std::vector<node> tree;
segtree(int n) : n(n), tree(4 * n, node()) { build(1, 0, n); }
template <typename T>
segtree(const std::vector<T> &arr) : n(arr.size()), tree(4 * n) {
build(1, 0, n, arr);
}
int size() const { return n; }
template <typename... Args> void update(int l, int r, Args &&...args) {
if (r <= l)
return;
_update(1, 0, n, l, r, std::forward<Args>(args)...);
}
node query(int l, int r) {
assert(std::max(0, l) < std::min(n, r)); // or return node() in this case
return _query(1, 0, n, l, r);
}
// Trying to find first true on the interval [from, n).
// Returns n if not found.
template <typename T> int find_first(int from, const T &checker) {
return _find_first(1, 0, n, from, checker);
}
// Trying to find last true on the interval [0, from).
// Returns -1 if not found.
template <typename T> int find_last(int from, const T &checker) {
return _find_last(1, 0, n, from, checker);
}
};
struct node {
int mx = -1e9;
int min_lcp_left = 1e9;
int min_lcp_right = 1e9;
node() {}
node(int x) { min_lcp_left = x; }
void apply(ll delta, int, int) { mx = delta; }
void push(node &, int, int) {}
void clear_after_push() {}
static node merge(const node &left, const node &right) {
node res;
res.mx = max(left.mx, right.mx);
res.min_lcp_left = min(left.min_lcp_left, right.min_lcp_left);
res.min_lcp_right = min(left.min_lcp_right, right.min_lcp_left);
return res;
}
};
void solve(int /* test_num */) {
string s;
cin >> s;
int n = len(s);
auto t = s + "#";
auto reversed = s;
reverse(all(reversed));
t += reversed;
suffix_array sa(t);
vector<int> dp(n, n - 1);
int ans = 0;
const int ITS = __lg(n) + 2;
for (int it = 1; it <= ITS; it++) {
segtree<node> tree(sa.lcp);
int max_r = -1;
for (int l = 0; l < n; l++) {
while (max_r < dp[l]) {
max_r++;
int pos = sa.suffix_position[n + 1 + (n - 1 - max_r)];
tree.update(pos, pos + 1, max_r);
}
if (max_r <= l) {
dp[l] = -1;
continue;
}
int max_len = 0, pos = sa.suffix_position[l];
{
int cur_max = -1e9, cur_lcp = 1e9;
tree.find_first(pos + 1, [&](const node &nd, int, int) {
int cur_len = min(cur_lcp, nd.min_lcp_left);
if (max(cur_max, nd.mx) - cur_len + 1 <= l) {
cur_lcp = cur_len;
cur_max = max(cur_max, nd.mx);
max_len = max(max_len, cur_max - l);
return false;
}
max_len = max(max_len, cur_len);
return true;
});
}
{
int cur_max = -1e9, cur_lcp = sa.lcp[pos];
tree.find_last(pos, [&](const node &nd, int, int) {
int cur_len = min(cur_lcp, nd.min_lcp_right);
if (max(cur_max, nd.mx) - cur_len + 1 <= l) {
cur_lcp = min(cur_len, nd.min_lcp_left);
cur_max = max(cur_max, nd.mx);
max_len = max(max_len, cur_max - l);
return false;
}
max_len = max(max_len, cur_len);
return true;
});
}
if (max_len == 0) {
dp[l] = -1;
continue;
}
ans = max(ans, it);
dp[l] = l + max_len - 1;
}
int pmax = -1;
for (int l = 0; l < n; l++) {
pmax = max(pmax, dp[l]);
dp[l] = pmax;
}
}
vector<int> nxt(n + 1, n);
for (int i = n - 2; i >= 0; i--) {
if (s[i] != s[i + 1]) {
nxt[i] = i + 1;
} else {
nxt[i] = nxt[i + 1];
}
}
using Hash = hash_t<2>;
vector<Hash> phash(n + 1);
for (int i = 0; i < n; i++) {
phash[i + 1] = phash[i] + Hash(s[i]);
}
vector<Hash> shash(n + 1);
for (int i = n - 1; i >= 0; i--) {
shash[i] = shash[i + 1] + Hash(s[i]);
}
for (int l = 0; l < n; l++) {
if (dp[l] <= l) {
continue;
}
int r = dp[l];
if (phash[r + 1] - phash[l] != shash[l] - shash[r + 1]) {
continue;
}
int length = r - l + 1;
if (length % 2 == 1) {
int mid = (l + r) / 2;
int rr = min(r, nxt[mid] - 1);
int ll = mid - (rr - mid);
ans = max(ans, ITS + length / 2 + (rr - ll) / 2);
} else {
int mid = (l + r) / 2;
int rr = min(r, nxt[mid]);
int ll = mid - (rr - (mid + 1));
ans = max(ans, ITS + length / 2 + (rr - ll) / 2);
}
}
cout << ans << '\n';
}
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int tests;
cin >> tests;
for (int test_num = 1; test_num <= tests; test_num++) {
solve(test_num);
}
} | failed | 53_3_wrong.cpp |
#include <bits/stdc++.h>
#define int long long
using namespace std;
void solve() {
int n;
cin >> n;
vector<array<int, 2>> a(n);
for (auto &x : a)
cin >> x[0] >> x[1];
sort(a.begin(), a.end(), [&](array<int, 2> a, array<int, 2> b) {
return a[0] - a[1] < b[0] - b[1];
});
vector<int> pre(n + 1, 0), suf(n + 1, 0);
for (int i = 1; i <= n; ++i)
pre[i] = pre[i - 1] + a[i - 1][0];
for (int i = n - 1; i >= 0; --i)
suf[i] = suf[i + 1] + a[i][1];
int ans = 1e18;
for (int i = 0; i <= n; ++i) {
// cout << pre[i] << " " << suf[i] << endl;
ans = min(ans, max(pre[i], suf[i]));
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1; // cin >> t;
while (t--)
solve();
} | failed | 99_2_wrong.cpp |
#include<bits/stdc++.h>
#define T int TT;cin>>TT;while (TT--)
#define ll long long
#define endl '\n'
#define rep(i,n) for(ll i=0;i<n;i++)
#define ref(i,n) for(ll i=n-1;i>=0;i--)
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
const ll LNF = 9223372036854775807;
using namespace std;
ll n, m, k, ans, cnt = 1;
typedef pair<ll, ll>tt;
const ll M = 5e5+10;
ll note[M];
ll zs[M];
ll dp[M];
vector<ll>son[M];
ll ts(ll a,ll sum){
if(note[a])
{
if(sum-zs[a]!=0)return 1;
return 0;
}
if(dp[a]==1)return dp[a];
note[a]=1;
zs[a]=sum;
for(auto i:son[a]){
if(i)dp[a]=max(dp[a],ts(((i+a)%n+n)%n,sum+i));
}
note[a]=0;
zs[a]=0;
return dp[a];
}
int main()
{
IOS;
cin>>n>>m>>k;
for(ll i=1;i<=m;i++){
ll a,b;
cin>>a>>b;
a=(a%n)+n;
a%=n;
//cerr<<a<<' '<<(b%n+n)%n<<endl;
son[a].push_back(b);
}
fill(dp,dp+M,-1);
for(ll i=0;i<n;i++){
if(dp[i]==-1){
ts(i,0);
}
}
while(k--){
ll z;cin>>z;
z=z%n+n;
z%=n;
if(dp[z]==1){
cout<<"Yes\n";
}
else{
cout<<"No\n";
}
}
} | failed | 89_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} t[10];
int main() {
int n = 5;
int w = 0, h = 0;
for (int i = 1; i <= n; i++) {
cin >> t[i].x >> t[i].y;
}
int ans = 0;
while (1) {
int fl = 0;
sort(t + 1, t + 1 + n, [&](point a, point b) { return a.x < b.x; });
if (n == 1)
break;
if (t[n].x != t[n - 1].x) {
ans += abs(t[n].x - t[n - 1].x);
t[n].x = t[n - 1].x;
if (t[n].y == t[n - 1].y) {
n--;
}
fl = 1;
}
// cout<<"ans: "<<ans<<endl;
sort(t + 1, t + 1 + n, [&](point a, point b) { return a.x > b.x; });
if (n == 1)
break;
if (t[n].x != t[n - 1].x) {
ans += abs(t[n].x - t[n - 1].x);
t[n].x = t[n - 1].x;
if (t[n].y == t[n - 1].y) {
n--;
}
fl = 1;
}
// cout<<"ans: "<<ans<<endl;
sort(t + 1, t + 1 + n, [&](point a, point b) { return a.y < b.y; });
if (n == 1)
break;
if (t[n].y != t[n - 1].y) {
ans += abs(t[n].y - t[n - 1].y);
t[n].y = t[n - 1].y;
if (t[n].x == t[n - 1].x) {
n--;
}
fl = 1;
}
// cout<<"ans: "<<ans<<endl;
sort(t + 1, t + 1 + n, [&](point a, point b) { return a.y > b.y; });
if (n == 1)
break;
if (t[n].y != t[n - 1].y) {
ans += abs(t[n].y - t[n - 1].y);
t[n].y = t[n - 1].y;
if (t[n].x == t[n - 1].x) {
n--;
}
fl = 1;
}
/*
cout<<"ans: "<<ans<<endl;
for(int i=1;i<=n;i++){
cout<<t[i].x<<" "<<t[i].y<<endl;
}
*/
if (!fl)
break;
}
sort(t + 1, t + 1 + n, [&](point a, point b) { return a.x < b.x; });
w = t[n].x - t[1].x;
sort(t + 1, t + 1 + n, [&](point a, point b) { return a.y < b.y; });
h = t[n].y - t[1].y;
ans += h * 2;
ans += w * 2;
sort(t + 1, t + 1 + n, [&](point a, point b) {
if (a.x != b.x)
return a.x < b.x;
else
return a.y < b.y;
});
for (int i = 2; i < n; i++) {
if (t[i].x != t[1].x && t[i].x != t[n].x && t[i].y != t[1].y &&
t[i].y != t[n].y) {
ans += min(w, h);
break;
}
}
cout << ans << endl;
} | failed | 59_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n;
int fa[1000010];
long long f[1000010];
long long dp[5010][5010];
long long sum[5010][5010];
long long C[5010][5010];
int cnt, head[1000010];
int sz[1000010];
struct Edge {
int to, next;
} edge[1000010];
void add(int u, int v) {
edge[++cnt].to = v, edge[cnt].next = head[u], head[u] = cnt;
}
long long pd(long long x) {
if (x >= mod)
return x - mod;
return x;
}
void p(long long &x) {
if (x >= mod)
x -= mod;
return;
}
void get_f(int u, int fa) {
sz[u] = 0, f[u] = 1;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == fa)
continue;
get_f(v, u), f[u] = f[u] * f[v] % mod * C[sz[u] + sz[v]][sz[v]] % mod;
sz[u] += sz[v];
}
sz[u]++;
return;
}
void dfs(int u, int fa) {
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == fa)
continue;
int nowsize = 0;
long long nowval = 1;
for (int i = head[u]; i; i = edge[i].next) {
int to = edge[i].to;
if (to == v || to == fa)
continue;
(nowval *= f[to] * C[nowsize + sz[to]][sz[to]] % mod) %= mod;
nowsize += sz[to];
}
for (int now = 1; now <= n - sz[u] + 1; now++) {
// long long nowsum=0;
// for(int lst=0;lst<now;lst++) p(nowsum+=dp[u][lst]);
// dp[v][now]=nowsum*nowval%mod*C[n-sz[u]+1-now+nowsize][nowsize]%mod;
dp[v][now] = sum[u][now - 1] * nowval % mod *
C[n - sz[u] + 1 - now + nowsize][nowsize] % mod;
sum[v][now] = dp[v][now];
// if(v==2) printf("%d %lld %lld %lld\n",now,dp[v][now],nowsum,nowval);
}
for (int i = 1; i <= n; i++)
p(sum[v][i] += sum[v][i - 1]);
dfs(v, u);
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++)
scanf("%d", &fa[i]), add(fa[i], i);
for (int i = 0; i <= n; i++)
C[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
C[i][j] = pd(C[i - 1][j] + C[i - 1][j - 1]);
get_f(1, 0), dp[1][0] = 1;
for (int i = 0; i <= n; i++)
sum[1][i] = 1;
dfs(1, 0);
for (int i = 1; i <= n; i++) {
long long nowsum = 0;
for (int lst = 0; lst < i; lst++)
nowsum += dp[i][lst];
// printf("%lld %lld ",nowsum,f[i]);
printf("%lld ", f[i] * C[n - i][sz[i] - 1] % mod * nowsum % mod);
}
printf("\n");
return 0;
}
/*
9
1 1 2 2 3 3 4 5
*/ | failed | 49_3_wrong.cpp |
#include <bits/stdc++.h>
using i64 = long long;
constexpr int p = 998244353;
void sol() {
int l, r;
std::cin >> l >> r;
if (l == r) {
std::cout << "Alice\n";
}
if (l & 1) {
if (r & 1) {
std::cout << "Alice\n";
} else {
if (l * 2 <= r) {
std::cout << "Alice\n";
} else {
std::cout << "Bob\n";
}
}
} else {
if ((l + 1) * 2 <= r) {
std::cout << "Bob\n";
} else {
std::cout << "Alice\n";
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
sol();
}
return 0;
} | failed | 68_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
void solve() {
int n, maxn = 0;
vector<int> a(n + 5);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
maxn = max(maxn, a[i]);
}
for (int i = 1; i <= n; i++) {
if (a[i] == maxn) {
cout << i << " ";
}
}
cout << endl;
return;
} | failed | 36_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, j, k) for (int i = (j); i <= (k); i++)
#define per(i, j, k) for (int i = (j); i >= (k); i--)
#define pb emplace_back
#define fi first
#define se second
using vi = vector<int>;
using pi = pair<int, int>;
template <typename T> bool chmin(T &x, const T &y) {
if (y < x) {
x = y;
return true;
}
return false;
}
template <typename T> bool chmax(T &x, const T &y) {
if (y > x) {
x = y;
return true;
}
return false;
}
namespace Debug {
template <typename T> void _debug(char *s, T x) {
cerr << s << " = " << x << endl;
}
template <typename T, typename... Ar> void _debug(char *s, T x, Ar... y) {
while (*s != ',')
cerr << *s++;
cerr << " = " << x << ",";
_debug(s + 1, y...);
}
} // namespace Debug
using namespace Debug;
#define gdb(...) _debug((char *)#__VA_ARGS__, __VA_ARGS__)
constexpr int N = 1e5 + 5, mod = 998244353;
int qpow(int x, int y = mod - 2) {
int res = 1;
while (y) {
if (y % 2)
res = res * x % mod;
x = x * x % mod;
y /= 2;
}
return res;
}
int fac[N], ifac[N];
void init() {
fac[0] = 1;
rep(i, 1, N - 1) { fac[i] = fac[i - 1] * i % mod; }
ifac[N - 1] = qpow(fac[N - 1]);
per(i, N - 1, 1) { ifac[i - 1] = ifac[i] * i % mod; }
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
init();
int n;
cin >> n;
vi f(n + 1), g(n + 1), h(n + 1);
f[0] = 1;
rep(i, 1, n) {
f[i] = fac[i];
rep(j, 1, i - 1) { (f[i] -= f[j] * fac[i - j]) %= mod; }
if (f[i] < 0) {
f[i] += mod;
}
}
g[0] = 0, h[0] = 0;
rep(i, 1, n) {
rep(j, 1, i - 1) { (h[i] += h[j] * f[i - j] + fac[j] * g[i - j]) %= mod; }
g[i] = (fac[i] + h[i]) * ifac[i] % mod;
(g[i] *= qpow((fac[i] - f[i] + mod) * ifac[i] % mod)) %= mod;
(g[i] *= f[i]) %= mod;
(h[i] += g[i]) %= mod;
}
int ans = 0, mx = 0, lst = 0;
rep(i, 1, n) {
int x;
cin >> x;
chmax(mx, x);
if (i == mx) {
(ans += g[i - lst] * qpow(f[i - lst])) %= mod;
lst = i;
}
}
cout << ans << '\n';
} | failed | 71_3_wrong.cpp |
// Problem: E. Equal Measure
// Contest: Universal Cup - The 3rd Universal Cup. Stage 29: Metropolis
// URL: https://contest.ucup.ac/contest/1913/problem/9041
// Memory Limit: 1024 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define f first
#define s second
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define ld long double
using namespace std;
mt19937 rng(time(NULL));
const int N = 5e5 + 5, oo = INT_MAX;
vector<vector<int>> graf(N);
int k;
vector<int> dep(N);
pair<bool, int> advance(pair<bool, int> a) {
if (a.s == oo)
return a;
a.s++;
if (a.s == k)
return {false, oo};
return {a.f, a.s};
}
bool ok;
bool shouldBeTrue;
pair<bool, int> merge(pair<bool, int> a, pair<bool, int> b) {
if (a.s == oo)
return b;
if (b.s == oo)
return a;
if (a.f || b.f) {
ok = 0;
return a;
}
if (k & 1) {
ok = 0;
return a;
}
if (a.s == k / 2 && b.s == k / 2) {
return a;
}
if (a.s == k / 2 || b.s == k / 2) {
shouldBeTrue = 1;
return {false, min(a.s, b.s)};
}
ok = 0;
return a;
}
pair<bool, int> ad(pair<bool, int> a) {
if (a.s == oo)
return {false, 1};
if (a.f || (k & 1)) {
ok = 0;
return a;
}
if (a.s == k / 2) {
return {true, 1};
} else {
ok = 0;
return a;
}
}
pair<bool, int> dfs(int tr) {
bool imam = 0;
pair<bool, int> ans = {false, oo};
vector<pair<bool, int>> deca;
for (auto p : graf[tr]) {
if (dep[p] == -1) {
dep[p] = dep[tr] + 1;
auto d = dfs(p);
auto adv = advance(d);
deca.pb(adv);
} else {
if (dep[p] < dep[tr] && dep[p] != dep[tr] - 1) {
int d = dep[tr] - dep[p] + 1;
if (k == -1) {
k = d;
} else {
if (k != d) {
ok = 0;
}
}
imam = 1;
}
}
}
shouldBeTrue = false;
for (auto p : deca) {
ans = merge(ans, p);
}
if (shouldBeTrue)
ans.f = true;
// printf("%i: %i\n",tr,imam?1:0);
if (imam)
ans = ad(ans);
// printf("%i: %i %i\n",tr,ans.f?1:0,ans.s);
return ans;
}
void test() {
int n, m;
cin >> n >> m;
k = -1;
for (int i = 0; i < n; i++)
graf[i].clear();
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graf[a].pb(b);
graf[b].pb(a);
}
ok = 1;
for (int o = 0; o < 1; o++) {
for (int i = 0; i < n; i++)
dep[i] = -1;
int st = rng() % n;
dep[st] = 0;
dfs(st);
}
printf(ok ? "Yes\n" : "No\n");
}
int main() {
ios;
int t;
cin >> t;
while (t--) {
test();
}
return 0;
}
| failed | 70_1_wrong.cpp |
#include <bits/stdc++.h>
#define double long double
using namespace std;
using ll = long long;
vector<int> vec, vec1, vec2;
int n1, n2, n;
const int maxn = 4e5 + 10;
double a[maxn], b[maxn];
void insert(int x) {
if (x > 0) {
vec.emplace_back(x);
}
}
bool check(double mid) {
pair<double, double> pr1 = {0, 0}, pr2 = {0, 0};
for (int i = 0; i < n; i++) {
if (a[i] - 0.5 >= 0 && b[i] - mid <= 0) {
return true;
}
if (a[i] - 0.5 >= 0 && b[i] - mid > 0) {
if (pr1 == (pair<double, double>){0, 0} ||
(pr1.first / (pr1.second)) < ((a[i] - 0.5) / (b[i] - mid))) {
pr1 = {a[i] - 0.5, b[i] - mid};
}
}
if (a[i] - 0.5 < 0 && b[i] - mid <= 0) {
if (pr2 == (pair<double, double>){0, 0} ||
(pr2.second / (pr2.first)) < ((b[i] - mid) / (a[i] - 0.5))) {
pr2 = {a[i] - 0.5, b[i] - mid};
}
}
}
return pr1.first * pr2.second - pr2.first * pr1.second <= 0;
}
bool check2(double mid) {
pair<double, double> pr1 = {0, 0}, pr2 = {0, 0};
for (int i = 0; i < n; i++) {
if (a[i] - 0.5 <= 0 && b[i] - mid >= 0) {
return true;
}
if (a[i] - 0.5 <= 0 && b[i] - mid <= 0) {
if (pr1 == (pair<double, double>){0, 0} ||
(pr1.first * (b[i] - mid)) <= ((a[i] - 0.5) * (pr1.second))) {
pr1 = {a[i] - 0.5, b[i] - mid};
}
}
if (a[i] - 0.5 >= 0 && b[i] - mid >= 0) {
if (pr2 == (pair<double, double>){0, 0} ||
(pr2.second * (a[i] - 0.5)) <= ((b[i] - mid) * pr2.first)) {
pr2 = {a[i] - 0.5, b[i] - mid};
}
}
// cout<<pr1.first<<" "<<pr1.second<<" "<<pr2.first<<" "<<pr2.second<<endl;
}
// cout<<mid<<" "<<pr1.first<<" "<<pr1.second<<" "<<pr2.first<<"
// "<<pr2.second<<endl;
return pr1.first * pr2.second - pr2.first * pr1.second <= 0;
}
void solve(void) {
int x;
cin >> n1;
for (int i = 1; i <= n1; i++) {
cin >> x;
vec1.emplace_back(x);
insert(x - 1);
insert(x);
insert(x + 1);
}
cin >> n2;
for (int i = 1; i <= n2; i++) {
cin >> x;
vec2.emplace_back(x);
insert(x - 1);
insert(x);
insert(x + 1);
}
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
int l1 = 0, l2 = 0;
double p = 0;
for (int i = 0; i < n1; i++) {
while (l1 < n2 && vec1[i] > vec2[l1]) {
l1++;
}
while (l2 < n2 && vec1[i] >= vec2[l2]) {
l2++;
}
p += (l2 - l1) * 0.5 / n2 + l1 * 1.0 / n2;
}
p /= n1;
if (p < 0.5) {
swap(vec1, vec2);
swap(n1, n2);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
n = vec.size();
l1 = 0, l2 = 0;
for (int i = 0; i < n; i++) {
while (l1 < n1 && vec[i] > vec1[l1]) //<
{
l1++;
}
while (l2 < n1 && vec[i] >= vec1[l2]) //<=
{
l2++;
}
a[i] = (l2 - l1) * 0.5 / n1 + l1 * 1.0 / n1;
// cout<<vec[i]<<" "<<a[i]<<endl;
}
l1 = 0, l2 = 0;
for (int i = 0; i < n; i++) {
while (l1 < n2 && vec[i] > vec2[l1]) {
l1++;
}
while (l2 < n2 && vec[i] >= vec2[l2]) {
l2++;
}
b[i] = (l2 - l1) * 0.5 / n2 + l1 * 1.0 / n2;
}
// for(int i=0;i<n;i++)
// {
// cout<<a[i]<<" "<<b[i]<<endl;
// }
double l = 0, r = 1;
for (int i = 1; i <= 100; i++) {
double mid = (l + r) / 2.0;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
cout << fixed << setprecision(10) << r << " ";
// check2(2.0/3);
swap(vec1, vec2);
swap(n1, n2);
swap(a, b);
l = 0, r = 1;
for (int i = 1; i <= 100; i++) {
double mid = (l + r) / 2.0;
if (check2(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << fixed << setprecision(10) << r << endl;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
} | failed | 112_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define pb push_back
const ld pi = 3.14159265358979323846;
const int mod = 998244353;
const ll INF = 1e18;
template <typename T> T chmax(T a, T b) { return a > b ? a : b; }
template <typename T> T chmin(T a, T b) { return a > b ? b : a; }
const int N = (int)3e5 + 1, M = N * 2;
struct DSU {
vector<int> node, size;
DSU() {}
DSU(int n) { init(n); }
void init(int n) {
node.resize(n);
size.resize(n);
for (int i = 0; i < n; i++) {
node[i] = i;
size[i] = 1;
}
}
int find(int x) { return x == node[x] ? x : node[x] = find(node[x]); }
void erase(int x) {
size[find(x)] -= 1;
node[x] = x;
}
void relocate(int x, int y) { // can't be root
int dx = find(x), dy = find(y);
if (dx == dy) {
return;
}
node[x] = dy;
size[dx] -= 1;
size[dy] += 1;
}
int set(int x, int y) { return find(x) == find(y); }
int merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return 0;
}
size[x] += size[y];
node[y] = x;
return 1;
}
int heuristic_merge(int x, int y) {
x = find(x);
y = find(y);
if (size[x] < size[y]) {
swap(x, y);
}
return merge(x, y);
}
int get(int x) { return size[find(x)]; }
};
int h[N], c[N], ne[M], e[M], idx;
void add(int u, int v) { e[idx] = v, ne[idx] = h[u], h[u] = idx++; }
void solve() {
int n, m;
cin >> n >> m;
DSU dsu(n + 1);
vector<int> a(n), c(n);
stack<int> s;
for (int i = 0; i <= n; i++) {
if (i < n) {
cin >> a[i];
}
h[i] = -1;
c[i] = 0;
}
idx = 0;
for (int i = 0; i < n; i++) {
while (!s.empty() && a[s.top()] < a[i]) {
add(s.top(), i);
s.pop();
}
s.push(i);
}
int rt = 0;
while (!s.empty()) {
rt = s.top();
s.pop();
}
auto dfs = [&](auto &self, int u, int flow) -> void {
if (c[u] <= a[u]) {
if (flow >= a[u] - c[u]) {
flow -= a[u] - c[u];
c[u] = a[u];
for (int i = h[u]; ~i; i = ne[i]) {
int v = e[i];
dsu.merge(v, u);
self(self, dsu.find(v), flow);
}
} else {
c[u] += flow;
flow = 0;
}
}
};
for (int i = 0; i < m; i++) {
char op;
int x;
cin >> op >> x;
x--;
if (op == '+') {
int c;
cin >> c;
dfs(dfs, dsu.find(x), c);
} else {
cout << c[x] << endl;
}
}
}
int main() {
// freopen(".in", "r", stdin);
// freopen(".out", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
// cin >> t;
while (t--) {
solve();
}
return 0;
} | failed | 62_3_wrong.cpp |
#include <algorithm>
#include <cstdio>
#include <map>
#include <random>
#include <set>
#include <vector>
using namespace std;
const int max1 = 2e5;
const int inf = 0x3f3f3f3f;
mt19937 rnd((unsigned long long)&max1);
int Mtrand(int L, int R) { return uniform_int_distribution<int>(L, R)(rnd); }
int T, n, m, k;
struct Node {
int v, next, id;
} edge[max1 + 5];
int head[max1 + 5], total;
void Add(int u, int v, int id) {
edge[++total].v = v;
edge[total].id = id;
edge[total].next = head[u];
head[u] = total;
return;
}
pair<int, int> val[max1 + 5];
map<pair<int, int>, bool> Map;
int cnt[max1 + 5];
bool vis[max1 + 5];
set<pair<int, int>> que;
int dis[max1 + 5], nowdis;
int ans[max1 + 5];
void Work() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
head[i] = 0;
val[i].first = Mtrand(1, 1e9);
val[i].second = Mtrand(1, 1e9);
cnt[i] = 0;
vis[i] = false;
}
total = 0;
Map.clear();
que.clear();
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
Add(u, v, i);
Add(v, u, i);
}
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
int L, x;
pair<int, int> p = make_pair(0, 0);
scanf("%d", &L);
for (int j = 1; j <= L; j++) {
scanf("%d", &x);
p.first ^= val[x].first;
p.second ^= val[x].second;
++cnt[x];
}
Map[p] = false;
}
for (int i = 1; i <= m; i++)
ans[i] = inf;
pair<int, int> pval = val[1];
que.insert(make_pair(cnt[1], 1));
if (Map.find(pval) != Map.end())
Map[pval] = true;
nowdis = 0;
while (!que.empty()) {
int now = (*que.begin()).second;
que.erase(que.begin());
// printf("now = %d\n", now);
dis[now] = nowdis++;
vis[now] = true;
pval.first ^= val[now].first;
pval.second ^= val[now].second;
for (int i = head[now]; i; i = edge[i].next) {
int v = edge[i].v, id = edge[i].id;
if (que.find(make_pair(cnt[v], v)) != que.end())
continue;
if (!vis[v]) {
pval.first ^= val[v].first;
pval.second ^= val[v].second;
que.insert(make_pair(cnt[v], v));
} else {
ans[id] = dis[now] - dis[v];
}
}
if (Map.find(pval) != Map.end())
Map[pval] = true;
// printf("pval = %d %d %d\n", pval.first, pval.second, Map.find(pval) !=
// Map.end());
}
for (auto v : Map)
if (!v.second) {
printf("No\n");
return;
}
printf("Yes\n");
for (int i = 1; i <= m; i++)
printf("%d ", ans[i]);
printf("\n");
return;
}
int main() {
scanf("%d", &T);
while (T--)
Work();
return 0;
} | failed | 22_3_wrong.cpp |
// Problem: D. Master of Both VI
// Contest: Universal Cup - The 3rd Universal Cup. Stage 23: Hong Kong
// URL: https://contest.ucup.ac/contest/1885/problem/9918
// Memory Limit: 1024 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define f first
#define s second
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define ld long double
using namespace std;
mt19937 rng(time(NULL));
// 9:01
struct mat {
int c[2][2], cnt;
mat(int z) {
c[0][0] = c[0][1] = c[1][1] = 2 * z;
c[1][0] = z;
cnt = 1;
}
mat() {
c[0][0] = c[1][1] = 0;
c[0][1] = c[1][0] = 0;
cnt = 0;
}
int val() { return min(c[1][0], c[1][1]); }
};
mat mul(mat a, mat b) {
mat c;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
c.c[i][j] = INT_MAX;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
c.c[i][j] = min(c.c[i][j], a.c[i][k] + b.c[k][j]);
c.cnt = a.cnt + b.cnt;
return c;
}
const int N = 5e5 + 5, L = 19, Q = 3e5;
struct segNode {
int l, r;
segNode *le = nullptr, *ri = nullptr;
mat m;
void prop() {
if (l == r)
return;
if (le == nullptr) {
le = new segNode();
int m = (l + r) >> 1;
le->l = l;
le->r = m;
ri = new segNode();
ri->l = m + 1;
ri->r = r;
}
}
void update() {
if (le != nullptr) {
m = mul(ri->m, le->m);
} else {
assert(0);
}
}
};
void upd(int p, int z, segNode *my) {
if (my->l == my->r) {
if (z == 0) {
my->m = mat();
} else {
my->m = mat(z);
}
return;
}
my->prop();
if (p <= my->le->r) {
upd(p, z, my->le);
} else {
upd(p, z, my->ri);
}
my->update();
}
pair<mat, bool> qr(int h, int qe, segNode *my, mat right) {
if (qe >= my->r && mul(right, my->m).val() < 2 * h) {
return {mul(right, my->m), 0};
}
if (qe < my->l)
return {right, 0};
if (my->l == my->r)
return {right, 1};
if (my->le == nullptr)
return {right, 0};
pair<mat, bool> r = qr(h, qe, my->ri, right);
if (r.s)
return r;
return qr(h, qe, my->le, r.f);
}
segNode *merge(segNode *a, segNode *b) {
if (a == nullptr)
return b;
if (b == nullptr)
return a;
if (a->l == a->r) {
if (b->m.cnt)
return b;
return a;
}
a->le = merge(a->le, b->le);
a->ri = merge(a->ri, b->ri);
a->update();
return a;
}
vector<vector<int>> graf(N);
int up[N][L], dep[N];
void dfs(int tr, int par) {
up[tr][0] = par;
for (auto p : graf[tr]) {
if (p != par) {
dep[p] = dep[tr] + 1;
dfs(p, tr);
}
}
}
int lca(int a, int b) {
if (dep[a] < dep[b])
swap(a, b);
int k = dep[a] - dep[b];
for (int j = 0; j < L; j++) {
if (k & (1 << j)) {
a = up[a][j];
}
}
if (a == b)
return a;
for (int j = L - 1; j >= 0; j--) {
if (up[a][j] != up[b][j]) {
a = up[a][j];
b = up[b][j];
}
}
return up[a][0];
}
vector<int> ans(Q);
vector<vector<pair<int, int>>> ev(N);
vector<vector<pair<int, pair<int, int>>>> qs(N);
int ind;
segNode *solve(int tr, int par) {
segNode *my = new segNode();
my->l = 0;
my->r = ind - 1;
for (auto p : graf[tr]) {
if (p != par) {
my = merge(my, solve(p, tr));
}
}
for (auto p : ev[tr]) {
upd(p.f, p.s, my);
}
for (auto p : qs[tr]) {
auto an = qr(p.s.s, p.s.f, my, mat());
ans[p.f] = an.f.cnt;
}
return my;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graf[u].pb(v);
graf[v].pb(u);
}
dep[0] = 0;
dfs(0, 0);
for (int j = 1; j < L; j++) {
for (int i = 0; i < n; i++) {
up[i][j] = up[up[i][j - 1]][j - 1];
}
}
int ind2 = 0;
for (int i = 0; i < q; i++) {
string s;
cin >> s;
if (s[0] == 'A') {
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
int lc = lca(x, y);
ev[x].pb({ind, z});
ev[y].pb({ind, z});
if (up[lc][0] != lc)
ev[up[lc][0]].pb({ind, 0});
ind++;
} else {
int x, h;
cin >> x >> h;
x--;
qs[x].pb({ind2, {ind - 1, h}});
ind2++;
}
}
solve(0, 0);
for (int i = 0; i < ind2; i++) {
printf("%i\n", ans[i]);
}
return 0;
}
| failed | 37_3_wrong.cpp |
#include <cstdio>
#include <vector>
using namespace std;
// #define int long long
typedef long long ll;
#define INT 500005
ll a[INT];
void slove() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%lld", &a[i]);
}
if (n == 1) {
printf("%lld", a[0]);
} else if (n % 2) {
int p = n / 2;
ll lp = 0, rp = 0;
for (int i = 1; i <= p; ++i) {
rp += (1 << ((p - i) % n)) * a[i];
}
for (int i = 1; i <= p; ++i) {
lp += (1 << ((p - i) % n)) * a[n - i];
}
vector<ll> ans;
// ans.push_back(a[0]+(lp+rp)/(1<<p));
ll templ =
(lp * 2 + a[p]) / (1 << (p + 1)) + ((rp - a[p]) / 2) / (1 << (p - 1));
ll tempr = ((lp - a[p + 1]) / 2) / (1 << (p - 1)) +
(rp * 2 + a[p + 1]) / (1 << (p + 1));
// printf("%lld\n",(rp*2+a[n-p-1]));
// printf("%lld %lld %lld\n",templ,tempr,(lp/(1<<p)+rp/(1<<p)));
if (templ > (lp / (1 << p) + rp / (1 << p))) {
ans.push_back(a[0] + templ);
} else if (tempr > (lp / (1 << p) + rp / (1 << p))) {
ans.push_back(a[0] + tempr);
} else {
ans.push_back(a[0] + (lp / (1 << p) + rp / (1 << p)));
}
for (int i = 1; i < n; ++i) {
rp -= (1 << (p - 1)) * a[i];
rp *= 2;
rp += a[(i + p) % n];
lp -= a[(n + i - p - 1) % n];
lp /= 2;
lp += a[i - 1] * (1 << (p - 1));
// printf("%lld %lld\n",lp,rp);
// ans.push_back(a[i]+(lp+rp)/(1<<p));
templ = (lp * 2 + a[(i + p) % n]) / (1 << (p + 1)) +
((rp - a[(i + p) % n]) / 2) / (1 << (p - 1));
tempr = ((lp - a[(p + i + 1) % n]) / 2) / (1 << (p - 1)) +
(rp * 2 + a[(i + p + 1) % n]) / (1 << (p + 1));
// printf("%lld %lld %lld\n",templ,tempr,(lp/(1<<p)+rp/(1<<p)));
if (templ > (lp / (1 << p) + rp / (1 << p))) {
ans.push_back(a[i] + templ);
} else if (tempr > (lp / (1 << p) + rp / (1 << p))) {
ans.push_back(a[i] + tempr);
} else {
ans.push_back(a[i] + (lp / (1 << p) + rp / (1 << p)));
}
}
for (auto a : ans) {
printf("%lld ", a);
}
} else {
int p = n / 2 - 1;
ll lp = 0, rp = 0;
for (int i = 1; i <= p; ++i) {
rp += (1 << ((p - i) % n)) * a[i];
}
for (int i = 1; i <= p; ++i) {
lp += (1 << ((p - i) % n)) * a[n - i];
}
vector<ll> ans;
if ((lp * 2 + a[p + 1]) / (1 << (p + 1)) > lp / (1 << (p))) {
ans.push_back(a[0] + (lp * 2 + a[p + 1]) / (1 << (p + 1)) +
rp / (1 << p));
} else {
ans.push_back(a[0] + (rp * 2 + a[p + 1]) / (1 << (p + 1)) +
lp / (1 << p));
}
for (int i = 1; i < n; ++i) {
rp -= (1 << (p - 1)) * a[i];
rp *= 2;
rp += a[(i + p) % n];
lp -= a[(n + i - p - 1) % n];
lp /= 2;
lp += a[i - 1] * (1 << (p - 1));
// printf("%lld %lld\n",lp,rp);
if ((lp * 2 + a[(i + p + 1) % n]) / (1 << (p + 1)) > lp / (1 << (p))) {
ans.push_back(a[i] + (lp * 2 + a[(i + p + 1) % n]) / (1 << (p + 1)) +
rp / (1 << p));
} else {
ans.push_back(a[i] + (rp * 2 + a[(i + p + 1) % n]) / (1 << (p + 1)) +
lp / (1 << p));
}
// ans.push_back(a[i]+lp/(1<<p)+rp/(1<<p));
}
for (auto a : ans) {
printf("%lld ", a);
}
}
printf("\n");
}
signed main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
slove();
}
} | failed | 39_1_wrong.cpp |
#include <algorithm>
#include <array>
#include <bit>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <compare>
#include <complex>
#include <concepts>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numbers>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ranges>
#include <set>
#include <span>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <variant>
#define int ll
#define INT128_MAX \
(__int128)(((unsigned __int128)1 \
<< ((sizeof(__int128) * __CHAR_BIT__) - 1)) - \
1)
#define INT128_MIN (-INT128_MAX - 1)
#define pb push_back
#define eb emplace_back
#define clock chrono::steady_clock::now().time_since_epoch().count()
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> pr) {
return os << pr.first << ' ' << pr.second;
}
template <class T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &arr) {
for (size_t i = 0; T x : arr) {
os << x;
if (++i != N)
os << ' ';
}
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; T x : vec) {
os << x;
if (++i != size(vec))
os << ' ';
}
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &s) {
for (size_t i = 0; T x : s) {
os << x;
if (++i != size(s))
os << ' ';
}
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const map<T1, T2> &m) {
for (size_t i = 0; pair<T1, T2> x : m) {
os << x;
if (++i != size(m))
os << ' ';
}
return os;
}
#ifdef DEBUG
#define dbg(...) \
cerr << '(', _do(#__VA_ARGS__), cerr << ") = ", _do2(__VA_ARGS__)
template <typename T> void _do(T &&x) { cerr << x; }
template <typename T, typename... S> void _do(T &&x, S &&...y) {
cerr << x << ", ";
_do(y...);
}
template <typename T> void _do2(T &&x) { cerr << x << endl; }
template <typename T, typename... S> void _do2(T &&x, S &&...y) {
cerr << x << ", ";
_do2(y...);
}
#else
#define dbg(...)
#endif
using ll = long long;
using ull = unsigned long long;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
// #define double ldb
template <typename T> using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T> using max_heap = priority_queue<T>;
template <ranges::forward_range rng, class T = ranges::range_value_t<rng>,
class OP = plus<T>>
void pSum(rng &&v) {
if (!v.empty())
for (T p = v[0]; T & x : v | views::drop(1))
x = p = OP()(p, x);
}
template <ranges::forward_range rng, class T = ranges::range_value_t<rng>,
class OP>
void pSum(rng &&v, OP op) {
if (!v.empty())
for (T p = v[0]; T & x : v | views::drop(1))
x = p = op(p, x);
}
template <ranges::forward_range rng> void Unique(rng &v) {
ranges::sort(v);
v.resize(unique(v.begin(), v.end()) - v.begin());
}
template <ranges::random_access_range rng> rng invPerm(rng p) {
rng ret = p;
for (int i = 0; i < ssize(p); i++)
ret[p[i]] = i;
return ret;
}
template <ranges::random_access_range rng, ranges::random_access_range rng2>
rng Permute(rng v, rng2 p) {
rng ret = v;
for (int i = 0; i < ssize(p); i++)
ret[p[i]] = v[i];
return ret;
}
template <bool directed> vector<vector<int>> readGraph(int n, int m, int base) {
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u -= base, v -= base;
g[u].emplace_back(v);
if constexpr (!directed)
g[v].emplace_back(u);
}
return g;
}
template <class T> void setBit(T &msk, int bit, bool x) {
msk = (msk & ~(T(1) << bit)) | (T(x) << bit);
}
template <class T> void flipBit(T &msk, int bit) { msk ^= T(1) << bit; }
template <class T> bool getBit(T msk, int bit) { return msk >> bit & T(1); }
template <class T> T floorDiv(T a, T b) {
if (b < 0)
a *= -1, b *= -1;
return a >= 0 ? a / b : (a - b + 1) / b;
}
template <class T> T ceilDiv(T a, T b) {
if (b < 0)
a *= -1, b *= -1;
return a >= 0 ? (a + b - 1) / b : a / b;
}
template <class T> bool chmin(T &a, T b) { return a > b ? a = b, 1 : 0; }
template <class T> bool chmax(T &a, T b) { return a < b ? a = b, 1 : 0; }
template <class M, M (*Mid)(), M (*Mop)(const M &, const M &), class T,
T (*Tid)(), T (*Top)(const T &, const T &),
M (*act)(const M &, const T &)>
struct lazySegmentTree {
int size;
vector<M> data;
vector<T> tag;
lazySegmentTree(int _size)
: size(_size), data(2 * size, Mid()), tag(size, Tid()) {}
lazySegmentTree(vector<M> init)
: size(ssize(init)), data(2 * size, Mid()), tag(size, Tid()) {
ranges::copy(init, data.begin() + size);
for (int i = size - 1; i > 0; i--)
data[i] = Mop(data[i << 1], data[i << 1 | 1]);
}
void apply(int i, T x) {
data[i] = act(data[i], x);
if (i < size)
tag[i] = Top(tag[i], x);
}
void push(unsigned i) {
for (int s = (int)bit_width(i) - 1; s > 0; s--) {
if (tag[i >> s] != Tid()) {
apply(i >> (s - 1), tag[i >> s]);
apply(i >> (s - 1) ^ 1, tag[i >> s]);
tag[i >> s] = Tid();
}
}
}
void pull(int i) {
while (i >>= 1)
data[i] = Mop(data[i << 1], data[i << 1 | 1]);
}
int trunc(unsigned i) { return i >> countr_zero(i); }
void set(int i, M x) {
push(i += size);
data[i] = x;
pull(i);
}
M get(int i) {
push(i += size);
return data[i];
}
void modify(int l, int r, T x) {
if (l >= r or x == Tid())
return;
push(trunc(l += size)), push(trunc(r += size) - 1);
int l0 = l, r0 = r;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1)
apply(l++, x);
if (r & 1)
apply(--r, x);
}
pull(trunc(l0)), pull(trunc(r0) - 1);
}
M query(int l, int r) {
if (l >= r)
return Mid();
M L = Mid(), R = Mid();
push(trunc(l += size)), push(trunc(r += size) - 1);
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1)
L = Mop(L, data[l++]);
if (r & 1)
R = Mop(data[--r], R);
}
return Mop(L, R);
}
int firstTrue(int i, function<bool(const M &)> f) {
vector<int> idL, idR;
push(trunc(i + size)), push(trunc(size << 1) - 1);
for (int l = i + size, r = size << 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
idL.emplace_back(l++);
if (r & 1)
idR.emplace_back(--r);
}
idL.insert(idL.end(), idR.rbegin(), idR.rend());
M pre = Mid();
int v = -1;
for (int j : idL) {
if (f(Mop(pre, data[j]))) {
v = j;
break;
} else {
pre = Mop(pre, data[j]);
}
}
if (v == -1)
return size;
while (v < size) {
if (tag[v] != Tid()) {
apply(v << 1, tag[v]);
apply(v << 1 | 1, tag[v]);
tag[v] = Tid();
}
if (f(Mop(pre, data[v << 1])))
v = v << 1;
else
pre = Mop(pre, data[v << 1]), v = v << 1 | 1;
}
return v - size;
}
int lastTrue(int i, function<bool(const M &)> f) {
vector<int> idL, idR;
push(trunc(size)), push(trunc((i + 1) + size) - 1);
for (int l = size, r = (i + 1) + size; l < r; l >>= 1, r >>= 1) {
if (l & 1)
idL.emplace_back(l++);
if (r & 1)
idR.emplace_back(--r);
}
idR.insert(idR.end(), idL.rbegin(), idL.rend());
M suf = Mid();
int v = -1;
for (int j : idR) {
if (f(Mop(data[j], suf))) {
v = j;
break;
} else {
suf = Mop(data[j], suf);
}
}
if (v == -1)
return -1;
while (v < size) {
if (tag[v] != Tid()) {
apply(v << 1, tag[v]);
apply(v << 1 | 1, tag[v]);
tag[v] = Tid();
}
if (f(Mop(data[v << 1 | 1], suf)))
v = v << 1 | 1;
else
suf = Mop(data[v << 1 | 1], suf), v = v << 1;
}
return v - size;
}
};
int Mid() { return INT_MAX; }
int Mop(const int &x, const int &y) { return min(x, y); }
int Tid() { return 0; }
int Top(const int &x, const int &y) { return x + y; }
int act(const int &m, const int &t) { return m + t; }
signed main() {
ios::sync_with_stdio(false), cin.tie(NULL);
int n, w;
cin >> n >> w;
vector<array<int, 3>> xyy(n);
for (auto &[x, y1, y2] : xyy)
cin >> x >> y1 >> y2;
{
bool ok = false;
ranges::sort(xyy, {}, [](auto &x) { return x[1]; });
min_heap<int> pq;
int t = INT_MIN, ed = INT_MIN, i = 0;
for (auto &[_, __, y] : xyy)
chmax(ed, y);
while (t < ed) {
int nxt = INT_MAX;
if (i < n)
chmin(nxt, xyy[i][1]);
if (!pq.empty())
chmin(nxt, pq.top());
while (i < n and xyy[i][1] == nxt)
pq.push(xyy[i++][2]);
while (!pq.empty() and pq.top() == nxt)
pq.pop();
t = nxt;
if (pq.empty() and t != ed)
ok = true;
}
if (!ok) {
cout << -1 << '\n';
return 0;
}
}
vector<array<int, 2>> pt(n << 1);
for (int i = 0; auto &[x, y1, y2] : xyy) {
pt[i++] = {x, y1};
pt[i++] = {x, y2};
}
auto inter = [&](int i, int j) -> array<int, 2> {
auto [x1, y1] = pt[i];
auto [x2, y2] = pt[j];
if (x1 == x2 or y1 == y2)
return {-1, -1};
if (y1 > y2)
swap(x1, x2), swap(y1, y2);
return {x1 * (y2 - y1) - (x2 - x1) * y1, y2 - y1};
};
auto cross = [&](int i, int j) {
auto [x1, y1] = pt[i];
auto [x2, y2] = pt[j];
return x1 * y2 - x2 * y1;
};
auto cross2 = [&](int i, int j, int k) {
auto [x0, y0] = pt[i];
auto [x1, y1] = pt[j];
auto [x2, y2] = pt[k];
x1 -= x0, y1 -= y0;
x2 -= x0, y2 -= y0;
return x1 * y2 - x2 * y1;
};
auto d2 = [&](int i) {
auto [x, y] = pt[i];
return x * x + y * y;
};
struct cmp {
bool operator()(const array<int, 2> &f1, const array<int, 2> &f2) const {
return (__int128)f1[0] * f2[1] < (__int128)f1[1] * f2[0];
};
};
dbg("A");
map<array<int, 2>, vector<int>, cmp> m;
for (int i = 0; i < 2 * n; i++) {
for (int j = i + 1; j < 2 * n; j++) {
auto frac = inter(i, j);
if (frac[1] != -1 and frac[0] <= 0) {
auto &v = m[frac];
v.eb(i), v.eb(j);
// m[frac].eb(i), m[frac].eb(j);
}
}
}
dbg("B");
vector<int> ord(2 * n);
iota(ord.begin(), ord.end(), 0);
ranges::sort(ord, [&](int i, int j) {
int c = cross(i, j);
if (c == 0)
return d2(i) < d2(j);
else
return c > 0;
});
vector<int> pos(2 * n);
for (int i = 0; i < 2 * n; i++)
pos[ord[i]] = i;
lazySegmentTree<int, Mid, Mop, int, Tid, Top, act> st([&]() {
vector<int> init(2 * n);
for (int i = 0; i < 2 * n; i += 2)
init[pos[i]]++, init[pos[i + 1]]--;
for (int i = 1; i < 2 * n; i++)
init[i] += init[i - 1];
return init;
}());
double ans = 0, pre = 0;
bool one = st.query(0, 2 * n - 1) > 0;
for (auto &[x, v] : m | views::reverse) {
double now = (double)x[0] / x[1];
if (one)
ans += pre - now;
pre = now;
ranges::sort(v);
v.resize(unique(v.begin(), v.end()) - v.begin());
ranges::sort(v, cmp(), [&](int i) {
auto [x1, y1] = pt[i];
array<int, 2> tmp = {y1 * x[1], x[1] * x1 - x[0]};
if (tmp[1] < 0)
tmp[0] = -tmp[0], tmp[1] = -tmp[1];
return tmp;
});
for (int i = 0, j = 0; i < ssize(v); i = j) {
while (j < ssize(v) and cross2(v[i], v[i + 1], v[j]) == 0)
j++;
int mn_pos = INT_MAX, mx_pos = INT_MIN;
for (int k : views::counted(v.begin() + i, j - i)) {
st.modify(pos[k / 2 * 2], pos[k | 1], -1);
chmin(mn_pos, pos[k]), chmax(mx_pos, pos[k]);
}
reverse(ord.begin() + mn_pos, ord.begin() + mx_pos + 1);
for (int k : views::counted(v.begin() + i, j - i)) {
pos[k] = (mx_pos - mn_pos) - (pos[k] - mn_pos) + mn_pos;
st.modify(pos[k / 2 * 2], pos[k | 1], 1);
}
}
one = st.query(0, 2 * n - 1) > 0;
}
cout << setprecision(12) << fixed;
cout << ans << '\n';
return 0;
}
| failed | 108_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
using ll = long long;
using ull = unsigned long long;
void ChatGptDeepSeek() // Date: 2025-04-13
{ // Time: 18:10:15
int n;
cin >> n;
vector<ll> a(n + 1);
vector<ll> b(n + 1), c(n + 1);
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++)
cin >> b[i];
for (int i = 1; i <= n; i++)
cin >> c[i];
sort(c.begin() + 1, c.end());
auto check = [&](ll H) {
vector<int> p(n + 1), s(n + 1);
int M = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > 0) {
// ll need = (H - b[i]) / a[i] + ((H - b[i]) % a[i] != 0);
ll need = (H - b[i]) / a[i];
if ((H - b[i]) >= 0 && (H - b[i]) % a[i] != 0)
need++;
// 大于等于3.5的话 大于等于4 没问题
// 大于等于-3.5的话 大于等于-3就行
// 小于等于0.5 要改
// 大于等于-0.5不用改
int idx = lower_bound(c.begin() + 1, c.end(), need) - c.begin();
if (idx <= n) {
s[idx]++;
assert(idx >= 1 && idx <= n);
}
} else if (a[i] == 0) {
if (b[i] >= H) {
// s[1]++;
p[n]++;
// M++;
}
} else {
ll need = (H - b[i]) / a[i];
// if (need < 0 && (H - b[i]) % a[i] != 0)
// need--;
// ll need = (H - b[i]) / a[i];
// 小于等于3.5时 小于等于3就行
// 小于等于-3.5时，小于等-4
// ax+b>=H
// x<=(H-b)/a
// 所以减1 没问题阿
// 但可能是+0.5 也可能是-0.5
if (H - b[i] >= 0 && (H - b[i]) % a[i] != 0)
need--;
int idx = upper_bound(c.begin() + 1, c.end(), need) - c.begin() - 1;
// cerr << i << " " << need << " " << idx << " \n";
if (idx >= 1) {
assert(idx >= 1 && idx <= n);
p[idx]++;
}
}
}
// for (int i = 1; i <= n; i++)
// cerr << p[i] << " \n"[i == n];
// for (int i = 1; i <= n; i++)
// cerr << s[i] << " \n"[i == n];
// 1 0 1 0
for (int i = 1; i <= n; i++)
p[i] = min(p[i], i);
for (int i = 1; i <= n; i++)
s[i] = min(s[i], n - i + 1);
vector<int> p1 = p, s1 = s;
// for (int i = 1; i <= n; i++)
// p[i] += p[i - 1];
for (int i = n - 1; i >= 1; i--)
p[i] += p[i + 1];
for (int i = 1; i <= n; i++)
p[i] = min(p[i], i);
for (int i = 1; i <= n; i++)
s[i] += s[i - 1];
// for (int i = n - 1; i >= 1; i--)
// s[i] += s[i + 1];
for (int i = 1; i <= n; i++)
s[i] = min(s[i], n - i + 1);
for (int i = n - 1; i >= 1; i--) {
// s1[i] += s1[i + 1];
s1[i] = s1[i + 1] + min(n - i + 1 - s1[i + 1], s1[i]);
}
for (int i = 1; i <= n; i++) {
// p1[i] += p1[i - 1];
p1[i] = p1[i - 1] + min(i - p1[i - 1], p1[i]);
}
for (int i = 1; i <= n; i++) {
s1[i] = min(s1[i], n - i + 1);
p1[i] = min(p1[i], i);
}
for (int i = 1; i <= n; i++)
p[i] += p1[i - 1];
for (int i = 1; i < n; i++)
s[i] += s1[i + 1];
for (int i = 1; i <= n; i++) {
// p[i - 1] = max(p[i - 1], p[i]);
p[i] = min(p[i], i);
s[i] = min(s[i], n - i + 1);
}
for (int i = n - 1; i >= 1; i--) {
// s[i + 1] = max(s[i], s[i + 1]);
s[i] = min(s[i], n - i + 1);
}
for (int i = 1; i <= n; i++) {
// p[i - 1] = max(p[i - 1], p[i]);
p[i] = min(p[i], i);
s[i] = min(s[i], n - i + 1);
}
// for (int i = 1; i <= n; i++)
// cerr << p[i] << " \n"[i == n];
// for (int i = 1; i <= n; i++)
// cerr << s[i] << " \n"[i == n];
if (p[n] >= (n + 1) / 2 || s[1] >= (n + 1) / 2)
return true;
for (int i = 1; i + 1 <= n; i++) {
if (p[i] + s[i + 1] >= (n + 1) / 2)
return true;
}
return false;
};
ll lo = -2e18 - 1, hi = 2e18 + 1, ans = 0;
while (lo < hi - 1) {
ll mi = (lo + hi) / 2;
if (check(mi))
lo = mi;
else
hi = mi;
// ll mid = (lo + hi) / 2;
// if (check(mid))
// lo = mid + 1, ans = mid;
// else
// hi = mid - 1;
}
// cout << ans << '\n';
cout << lo << '\n';
// if(n==28308)
// assert(check(999999997000000000));
// assert(check(lo + 1) == false);
// assert(lo != -4e18);
// cerr << check(11) << '\n';
// cerr << check(25) << '\n';
// cout << check(9) << '\n';
// cout << check(10) << '\n';
// cout << check(13) << '\n';
}
/*
0 0 0 3 0
0 0 0 2 1
0 1 0 1 0
0 2 2 2 1
1 0 1 0 0
2 2 2 2 1
*/
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
// cerr<<(-3/-2)<<'\n';
// cerr<<(-2%2)<<'\n';
// cerr << -1 / -2 << '\n';
int T = 1;
cin >> T;
while (T--)
ChatGptDeepSeek();
return 0;
} | failed | 72_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
map<string, vector<string>> memo;
for (int i = 0; i < N * 2; ++i) {
string s;
cin >> s;
string sub = s.substr(0, 4);
memo[sub].pb(s);
}
vector<pair<string, string>> Z;
for (auto &[a, v] : memo) {
if (v.size() & 1) {
cout << "NO\n";
return 0;
}
for (int i = 0; i + 1 < (int)v.size(); i += 2) {
Z.pb({v[i], v[i + 1]});
}
}
cout << "YES\n";
for (auto &[x, y] : Z)
cout << x << " " << y << '\n';
return 0;
} | failed | 91_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<int> a(n * m + 1), b(n * m + 1);
for (int i = 1; i <= n * m; ++i) {
cin >> a[i];
b[i] = (a[i] - 1) / m;
}
if (m <= k)
cout << m << "\n";
else {
vector<vector<int>> pos(n);
for (int i = 1; i <= n * m; ++i) {
pos[b[i]].emplace_back(i);
}
int ans = 1e9;
for (int i = 0; i < n; ++i) {
ans = min(ans, pos[i][m - k - 1]);
}
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int _;
cin >> _;
while (_--)
solve();
return 0;
} | failed | 31_2_wrong.cpp |
#include <bits/stdc++.h>
#define LL long long
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define min(a, b) (((a) < (b)) ? (a) : (b))
using namespace std;
const int maxN = 2e5 + 50;
const LL inf = 1e17;
struct Edge {
int to, val;
Edge() {}
Edge(int t, int v) : to(t), val(v) {}
};
std::vector<Edge> e[maxN];
int n, m, k;
LL dist0[maxN], dist1[maxN];
bool vis[maxN];
struct Store {
int id;
LL dist;
double val;
Store() {}
Store(int I, double v) : id(I), val(v) {}
bool operator<(const Store &y) const {
return (dist == y.dist) ? (id < y.id) : (dist < y.dist);
}
} store[maxN];
struct State {
LL dist;
int id;
State() {}
State(LL D, int I) : dist(D), id(I) {}
bool operator>(const State &y) const { return dist > y.dist; }
};
priority_queue<State, vector<State>, greater<State>> q;
void Dijsktra0() {
for (int i = 1; i <= n; i++)
vis[i] = 0, dist0[i] = inf;
dist0[1] = 0;
q.push(State(0, 1));
for (int now, sz; !q.empty();) {
now = q.top().id, sz = e[now].size(), q.pop();
if (vis[now])
continue;
vis[now] = 1;
for (int i = 0, v, w; i < sz; i++) {
v = e[now][i].to, w = e[now][i].val;
if (dist0[now] + w < dist0[v]) {
dist0[v] = dist0[now] + w;
q.push(State(dist0[v], v));
}
}
}
}
void Dijsktra1() {
for (int i = 1; i <= n; i++)
vis[i] = 0, dist1[i] = inf;
dist1[n] = 0;
q.push(State(0, n));
for (int now, sz; !q.empty();) {
now = q.top().id, sz = e[now].size(), q.pop();
if (vis[now])
continue;
vis[now] = 1;
for (int i = 0, v, w; i < sz; i++) {
v = e[now][i].to, w = e[now][i].val;
if (dist1[now] + w < dist1[v]) {
dist1[v] = dist1[now] + w;
q.push(State(dist1[v], v));
}
}
}
}
void Cerise_Bouquet() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
e[u].push_back(Edge(v, w));
e[v].push_back(Edge(u, w));
}
double v;
bool flag = 1;
for (int i = 1, u; i <= k; i++) {
scanf("%d%lf", &u, &v);
if (v == 1.0)
flag = 0;
store[i] = Store(u, v);
}
if (flag) {
return puts("impossible"), void();
}
Dijsktra0(), Dijsktra1();
for (int i = 1, u; i <= k; i++) {
u = store[i].id;
store[i].dist = dist0[u] + dist1[u];
}
std::sort(store + 1, store + k + 1);
double ans = 0, pre_mul = 1;
LL w;
for (int i = 1, w; i <= k; i++) {
v = store[i].val, w = store[i].dist;
ans += pre_mul * v * w, pre_mul *= (1 - v);
}
return printf("%lf\n", ans), void();
}
int main() {
int _ = 1;
while (_--)
Cerise_Bouquet();
return 0;
} | failed | 65_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG
#include "debug.h"
#else
#define debug(...) void()
#endif
#define all(x) (x).begin(), (x).end()
template <class T> auto ary(T *a, int l, int r) {
return vector<T>{a + l, a + 1 + r};
}
using ll = long long;
using ull = unsigned long long;
using vec = complex<int>;
using ld = long double;
ll dot(const vec &a, const vec &b) {
return 1ll * real(a) * real(b) + 1ll * imag(a) * imag(b);
}
ll cross(const vec &a, const vec &b) { return dot(a, b * vec(0, -1)); }
struct frac {
ll x, y;
frac() = default;
frac(ll a, ll b = 1) : x(a), y(b) {}
ld calc() const { return (ld)x / y; }
};
#ifdef DEBUG
ostream &operator<<(ostream &out, frac a) { return out << a.calc(); }
#endif
using LL = __int128;
bool operator<(const frac &a, const frac &b) {
return (LL)a.x * b.y < (LL)b.x * a.y;
}
template <class T> int sign(const T &x) { return x ? (x > 0 ? 1 : -1) : 0; }
int T, n, l, r;
vec L, R;
using poly = vector<vec>;
poly a, b;
void read(poly &a) {
int k;
scanf("%d", &k);
a.resize(k);
for (int i = 0, x, y; i < k; i++) {
scanf("%d%d", &x, &y);
a[i] = vec(x, y);
}
}
pair<int, int> find(vec s, const poly &a) {
int n = a.size(), st = 0;
if (!cross(a[0] - s, a[1] - s))
st = 1;
// debug(s,a,st);
int op = sign(cross(a[st] - s, a[st + 1] - s));
assert(op != 0);
int l = 0, r = n, mid;
for (; l + 1 < r;) {
mid = (l + r) >> 1;
if (sign(cross(a[st] - s, a[(st + mid) % n] - s)) == op)
l = mid;
else
r = mid;
}
assert(cross(a[st] - s, a[(st + l) % n] - s) * op > 0);
assert(cross(a[st] - s, a[(st + r) % n] - s) * op <= 0);
// debug(st,st+l,st+r,op);
auto find = [&](int st, int len, int op) {
int l = 0, r = len, mid;
for (; l < r;) {
mid = (l + r) >> 1;
int u = (st + mid) % n, v = (u + 1) % n;
if (sign(cross(a[u] - s, a[v] - s)) == op)
l = mid + 1;
else
r = mid;
}
return (st + l) % n;
};
int p = find(st, l, op), q = find((st + r) % n, (n - r) % n, -op);
return op > 0 ? make_pair(p, q) : make_pair(q, p);
}
frac calc(vec a, vec b) {
ll s = cross(b - L, a - L), t = cross(a - R, b - R);
if (s < 0)
s = -s, t = -t;
return frac(s, s + t);
}
vector<pair<frac, int>> c;
bool solve() {
int n = b.size();
auto [s, t] = find(a[0], b);
int x = [&]() {
int l = 0, r = (t - s + n) % n, mid;
for (; l < r;) {
mid = (l + r) >> 1;
int u = (s + mid) % n, v = (u + 1) % n;
if (cross(b[v] - b[u], a[find(b[u], a).first] - b[u]) > 0)
l = mid + 1;
else
r = mid;
}
return (s + l) % n;
}();
int y = [&]() {
int l = 0, r = (t - s + n) % n, mid;
for (; l < r;) {
mid = (l + r) >> 1;
int u = (t - mid + n) % n, v = (u + n - 1) % n;
if (cross(a[find(b[u], a).second] - b[u], b[v] - b[u]) > 0)
l = mid + 1;
else
r = mid;
}
return (t - l + n) % n;
}();
int p = find(b[x], a).first;
int q = find(b[y], a).second;
// debug(b,p,x,q,y);
auto chkin = [&](vec u, int o1, int o2) {
return cross(a[p] - b[x], u - b[x]) >= o1 &&
cross(b[y] - b[x], u - b[x]) > 0 &&
cross(u - b[y], a[q] - b[y]) >= o2;
};
if (chkin(L, 1, 0) && chkin(R, 0, 1))
return 0;
if (chkin(R, 1, 0) && chkin(L, 0, 1))
return 0;
auto check = [&](vec s, vec t) {
ll p = cross(R - L, t - L), q = cross(R - L, s - L);
if (sign(p) != sign(q) || abs(p) >= abs(q))
return false;
return sign(cross(t - s, L - s)) * sign(cross(t - s, R - s)) < 0;
};
int o1 = check(a[p], b[x]), o2 = check(a[q], b[y]);
if (o1 && o2) {
frac s = calc(a[p], b[x]), t = calc(a[q], b[y]);
if (t < s)
swap(s, t);
c.push_back({s, 1});
c.push_back({t, -1});
} else if (o1) {
frac s = calc(a[p], b[x]);
if (cross(a[p] - b[x], L - b[x]) > 0) {
c.push_back({frac(0), 1});
c.push_back({s, -1});
} else {
c.push_back({s, 1});
c.push_back({frac(1), -1});
}
} else if (o2) {
frac s = calc(a[q], b[y]);
if (cross(L - b[y], a[q] - b[y]) > 0) {
c.push_back({frac(0), 1});
c.push_back({s, -1});
} else {
c.push_back({s, 1});
c.push_back({frac(1), -1});
}
}
return 1;
}
void work() {
scanf("%d%d%d", &n, &l, &r);
L = vec(l, 0), R = vec(r, 0);
read(a);
c.clear();
ld ans = 0;
bool flag = 0;
for (int i = 1; i <= n; i++) {
read(b);
if (!solve())
flag = 1;
}
if (flag)
return puts("-1"), void();
// debug(c);
c.push_back({frac(0), 0});
c.push_back({frac(1), 0});
sort(all(c));
for (int i = 0, x = 0; i + 1 < c.size(); i++) {
x += c[i].second;
if (!x) {
ans += c[i + 1].first.calc() - c[i].first.calc();
if (frac(0) < c[i].first && c[i].first < frac(1))
flag = 1;
if (c[i].first < c[i + 1].first)
flag = 1;
}
}
ans *= abs(r - l);
if (flag)
printf("%.15Lf\n", ans);
else
puts("-1");
}
int main() {
for (scanf("%d", &T); T--;)
work();
return 0;
}
#ifdef DEBUG
#include "debug.hpp"
#endif | failed | 26_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
const int MAX_X = 2e5;
vector<vector<int>> divisors;
void precompute_divisors() {
divisors.resize(MAX_X + 1);
for (int x = 1; x <= MAX_X; x++) {
for (int m = x; m <= MAX_X; m += x) {
divisors[m].push_back(x);
}
}
}
int main() {
precompute_divisors();
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
unordered_set<int> S;
vector<int> cnt(MAX_X + 1, 0);
set<int, greater<int>> active_ds;
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
int x = i + 1;
S.insert(x);
for (int d : divisors[x]) {
if (cnt[d] == 0) {
active_ds.insert(d);
}
cnt[d]++;
}
}
}
int s = S.size();
if (s == 0) {
cout << n << '\n';
} else {
int current_gcd = 0;
for (int d : active_ds) {
if (cnt[d] == s) {
current_gcd = d;
break;
}
}
int ans = 0;
for (int d : divisors[current_gcd]) {
if (d <= n) {
ans++;
}
}
cout << ans << '\n';
}
while (q--) {
int p, v;
cin >> p >> v;
p--; // convert to 0-based
// Process to remove old values
vector<int> to_process;
if (p > 0) {
to_process.push_back(p - 1);
}
if (p < n - 1) {
to_process.push_back(p);
}
// Remove old entries from S
for (int i : to_process) {
int x = i + 1; // 1-based position
if (S.count(x)) {
S.erase(x);
for (int d : divisors[x]) {
cnt[d]--;
if (cnt[d] == 0) {
active_ds.erase(d);
}
}
}
}
// Update the array
a[p] = v;
// Process new values
for (int i : to_process) {
int x = i + 1;
bool bad = (a[i] > a[i + 1]);
if (bad) {
S.insert(x);
for (int d : divisors[x]) {
if (cnt[d] == 0) {
active_ds.insert(d);
}
cnt[d]++;
}
}
}
s = S.size();
if (s == 0) {
cout << n << '\n';
} else {
int current_gcd = 0;
for (int d : active_ds) {
if (cnt[d] == s) {
current_gcd = d;
break;
}
}
int ans = 0;
for (int d : divisors[current_gcd]) {
if (d <= n) {
ans++;
}
}
cout << ans << '\n';
}
}
}
return 0;
} | failed | 8_3_wrong.cpp |
// This is a wrong code file
#include <bits/stdc++.h>
using namespace std;
struct node {
char c;
int nxt;
};
const int MAXN = 2e6 + 100;
node nd[MAXN];
int cntnd = 0;
int getnode(char c) {
nd[cntnd].c = c;
nd[cntnd].nxt = -1;
cntnd++;
return cntnd - 1;
}
void solve() {
cntnd = 0;
int n;
cin >> n;
string s;
cin >> s;
vector<int> val(1 << n);
int cnt0 = 0;
for (int i = 0; i < s.size(); i++) {
val[i] = s[i] - '0';
cnt0 += s[i] == '0';
}
if (cnt0 == (1 << n)) {
cout << "Yes\n";
cout << "F\n";
return;
}
if (cnt0 == 0) {
cout << "Yes\n";
cout << "T\n";
return;
}
for (int msk = 0; msk < (1 << n); msk++) {
if (!val[msk]) {
for (int submsk = msk; submsk; submsk = (submsk - 1) & msk) {
if (val[submsk] == 1) {
cout << "No\n";
return;
}
}
if (val[0] == 1) {
cout << "No\n";
return;
}
}
}
vector<pair<int, int>> ors;
string ands;
string S = "abcdefghijklmnopqrstuv";
// cout << "AAA" << endl;
auto print = [&](auto self, int u) -> void {
if (u == -1)
return;
cout << nd[u].c;
self(self, nd[u].nxt);
};
int cntop = 0;
auto recand = [&](auto self, int l, int r) -> pair<int, int> {
if (l == r) {
int ind = getnode(ands[l]);
return {ind, ind};
}
int mid = (l + r) / 2;
auto F = self(self, l, mid);
auto S = self(self, mid + 1, r);
int indf = getnode('(');
nd[indf].nxt = F.first;
int indmid = getnode('&');
cntop++;
nd[F.second].nxt = indmid;
nd[indmid].nxt = S.first;
int indlast = getnode(')');
nd[S.second].nxt = indlast;
return {indf, indlast};
};
auto addand = [&](int msk) -> pair<int, int> {
ands.clear();
for (int i = 0; i < n; i++) {
if ((1 << i) & msk)
ands += S[i];
}
// cout << "ANDS - " << ands << "\n";
return recand(recand, 0, int(ands.size()) - 1);
};
vector<int> minimal;
for (int msk = 0; msk < (1 << n); msk++) {
if (!val[msk])
continue;
bool ok = (val[0] == 0);
for (int submsk = msk; submsk; submsk = (submsk - 1) & msk) {
if (submsk == msk)
continue;
ok &= !val[submsk];
}
// bitset<2> st(msk);
// cout << msk << " ----> " << ok << endl;
if (ok) {
minimal.push_back(msk);
// ors.push_back(addand(msk));
// cout << "check print: ";
// print(print, ors.back().first);
// cout << "\n";
}
}
// cout << "minimal: ";
// for (auto msk: minimal)
// cout << msk << " ";
// cout << "\n";
auto sol = [&](auto self, vector<int> x) -> pair<int, int> {
int ind = n + 10;
for (auto v : x) {
for (int i = 0; i < n; i++) {
if ((1 << i) & v)
ind = min(ind, i);
}
}
// cout << "AAA - " << ind << "\n";
if (x.size() == 0 || ind == n + 10) {
int xx = getnode('T');
return {xx, xx};
}
vector<int> l, r;
for (auto v : x) {
if ((1 << ind) & v)
l.push_back(v ^ (1 << ind));
else
r.push_back(v);
}
auto F = self(self, l);
auto S = self(self, r);
int indp = getnode('(');
int indp1 = getnode('(');
int indpr = getnode(')');
int indpr1 = getnode(')');
int andd = getnode('&');
int orr = getnode('|');
int inda = getnode('a' + ind);
if (r.size() == 0) {
nd[indp].nxt = inda;
nd[inda].nxt = andd;
nd[andd].nxt = F.first;
nd[F.second].nxt = indpr;
cntop++;
return {indp, indpr};
} else {
nd[indp].nxt = indp1;
nd[indp1].nxt = inda;
nd[inda].nxt = andd;
nd[andd].nxt = F.first;
nd[F.second].nxt = indpr;
nd[indpr].nxt = orr;
nd[orr].nxt = S.first;
nd[S.second].nxt = indpr1;
cntop += 2;
return {indp, indpr1};
}
};
// auto recors = [&](auto self, int l, int r) -> pair <int, int> {
// // cout << "cehck - " << l << " " << r << endl;
// if (l == r)
// return ors[l];
// int mid = (l + r) / 2;
// auto F = self(self, l, mid);
// auto S = self(self, mid + 1, r);
// int indf = getnode('(');
// nd[indf].nxt = F.first;
// int indmid = getnode('|');
// cntop++;
// nd[F.second].nxt = indmid;
// nd[indmid].nxt = S.first;
// int indlast = getnode(')');
// nd[S.second].nxt = indlast;
// return {indf, indlast};
// };
// cout << ors.size() << "\n";
// auto ans = recors(recors, 0, int(ors.size()) - 1);
// cout << "Xd" << endl;
auto ans = sol(sol, minimal);
assert(cntop <= (1 << (n - 1)) + 10);
cout << "Yes\n";
print(print, ans.first);
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
cin >> q;
while (q--) {
solve();
}
} | failed | 17_3_wrong.cpp |
#include <bits/stdc++.h>
#define int int64_t
using pii = std::pair<int, int>;
const int kMaxN = 4e5 + 5;
struct Node {
int t, id, op;
Node(int _t = 0, int _id = 0, int _op = 0) : t(_t), id(_id), op(_op) {}
friend bool operator<(const Node &n1, const Node &n2) {
if (n1.t != n2.t)
return n1.t < n2.t;
else
return n1.op > n2.op;
}
};
int n, m, p, d;
int cs, fir;
int cnt[2], now[2], unq[kMaxN];
pii seg[kMaxN], mx[kMaxN], mi[kMaxN];
std::vector<int> v[2], sum[2];
std::vector<Node> vec[2];
struct SGT {
int N;
pii mx[kMaxN * 4], mi[kMaxN * 4];
void pushup(int x) {
mx[x] = std::max(mx[x << 1], mx[x << 1 | 1]);
mi[x] = std::min(mi[x << 1], mi[x << 1 | 1]);
}
void build(int n) {
for (N = 1; N <= n + 1; N <<= 1) {
}
for (int i = N; i <= N + n; ++i)
mx[i] = ::mx[i - N], mi[i] = ::mi[i - N];
for (int i = N - 1; ~i; --i)
pushup(i);
}
pii querymax(int l, int r) {
if (l > r)
return {-1e18, 0};
pii ret = {-1e18, 0};
for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1)
ret = std::max(ret, mx[l ^ 1]);
if (r & 1)
ret = std::max(ret, mx[r ^ 1]);
}
return ret;
}
pii querymin(int l, int r) {
if (l > r)
return {1e18, 0};
pii ret = {1e18, 0};
for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1)
ret = std::min(ret, mi[l ^ 1]);
if (r & 1)
ret = std::min(ret, mi[r ^ 1]);
}
return ret;
}
} sgt;
void prework() {
cnt[0] = cnt[1] = now[0] = now[1] = 0;
for (int o = 0; o < 2; ++o) {
std::set<int> st;
v[o].clear();
// std::sort(vec[o].begin(), vec[o].end());
for (auto [t, id, op] : vec[o])
if (op == 1)
st.emplace(id);
cnt[o] = st.size();
for (auto [t, id, op] : vec[o]) {
if (!st.count(id))
continue;
if (!op)
now[o] += p;
else
now[o] += t, st.erase(id), v[o].emplace_back(t);
}
}
}
void discrete() {
m = 0;
for (auto x : v[0])
unq[++m] = x;
for (auto x : v[1])
unq[++m] = x;
unq[++m] = 0;
unq[++m] = 1e13;
std::sort(unq + 1, unq + 1 + m);
m = std::unique(unq + 1, unq + 1 + m) - (unq + 1);
unq[m + 1] = 1e14;
}
int getsum(int o, int x) {
if (x < 0)
return 0;
else
return sum[o][x];
}
pii getfunc(int x, int p) { return {p * seg[x].first + seg[x].second, p}; }
pii getmi(int x, int l, int r) {
l = std::max<int>(l, 0);
if (l > r)
return {1e18, 0};
return std::min(getfunc(x, l), getfunc(x, r));
}
pii getmx(int x, int l, int r) {
l = std::max<int>(l, 0);
if (l > r)
return {-1e18, 0};
return std::max(getfunc(x, l), getfunc(x, r));
}
int getfunc(int x) {
int i = std::lower_bound(unq + 1, unq + 1 + m, x) - unq - 1;
if (!i)
++i;
// std::cerr << x << ' ' << unq[i] << ' ' << unq[i + 1] << '\n';
assert(i < m);
assert(unq[i] <= x && x <= unq[i + 1]);
return x * seg[i].first + seg[i].second;
}
int _getfunc(int x) {
int ret = 0;
for (int o = 0; o < 2; ++o) {
int sum = 0;
for (auto t : v[o])
sum += std::min(x, t);
if (o == 0)
ret += sum;
else
ret -= sum;
}
return ret;
}
void getseg() {
for (int o = 0; o < 2; ++o) {
int s = 0;
sum[o].clear();
for (int i = 0; i < v[o].size(); ++i)
sum[o].emplace_back(s += v[o][i]);
}
for (int i = 1; i < m; ++i) {
int p1 =
std::lower_bound(v[0].begin(), v[0].end(), unq[i + 1]) - v[0].begin();
int p2 =
std::lower_bound(v[1].begin(), v[1].end(), unq[i + 1]) - v[1].begin();
seg[i] = {v[0].size() - p1 - (v[1].size() - p2),
getsum(0, p1 - 1) - getsum(1, p2 - 1)};
mi[i] = getmi(i, unq[i], unq[i + 1]);
mx[i] = getmx(i, unq[i], unq[i + 1]);
}
}
pii getpr(int x) {
for (int i = 1, j = 1; i <= m - 1; ++i) {
// int j = std::upper_bound(unq + 1, unq + 1 + m, unq[i] + x) - unq - 1;
for (; unq[j] <= unq[i] + x; ++j) {
}
--j;
int now = getfunc(unq[i]);
auto p = sgt.querymax(i, j - 1);
if (p.first - now >= d)
return {unq[i], p.second};
p = getmx(j, unq[j], unq[i] + x);
if (p.first - now >= d)
return {unq[i], p.second};
}
for (int i = m, j = m; i > 1; --i) {
// int j = std::lower_bound(unq + 1, unq + 1 + m, std::max<int>(unq[i] - x,
// 0)) - unq;
for (; j > 1 && unq[j - 1] >= std::max<int>(unq[i] - x, 0); --j) {
}
int now = getfunc(unq[i]);
auto p = sgt.querymin(j, i - 1);
if (now - p.first >= d)
return {p.second, unq[i]};
p = getmi(j - 1, std::max<int>(unq[i] - x, 0), unq[j]);
if (now - p.first >= d)
return {p.second, unq[i]};
}
return {-1, -1};
}
bool check(int x) { return getpr(x).first != -1; }
int cei(int x, int y) {
if (x < 0)
return -((-x) / y);
else
return (x + y - 1) / y;
}
int flr(int x, int y) {
if (x < 0)
return -((-x + y - 1) / y);
else
return x / y;
}
pii getpp(pii p) {
// x * p.first + p.second >= d
int tmp = d - p.second;
// x * p.first >= tmp
if (p.first == 0)
return tmp <= 0 ? pii{0, 1e18} : pii{1e18, 1e18};
else if (p.first > 0)
return {cei(tmp, p.first), 1e18};
else
return {0, flr(-tmp, -p.first)};
}
pii calc(int i, int j, int len) {
assert(j < m);
int l = std::max(unq[j], unq[i - 1] + len),
r = std::min(unq[j + 1], unq[i] + len);
if (l > r)
return {1e18, 1e18};
pii p = {seg[j].first - seg[i - 1].first,
seg[j].second - seg[i - 1].second + len * seg[i - 1].first};
auto pp = getpp(p);
if (std::max(l, pp.first) <= std::min(r, pp.second))
return {std::max(l, pp.first) - len, std::max(l, pp.first)};
else
return {1e18, 1e18};
// for (int i = l; i <= r; ++i)
// if (i * p.first + p.second >= d)
// return {i - len, i};
}
pii getans() {
// if (fir == 202567778970ll) std::cout << m << ' ' << unq[2] << ' ' <<
// _getfunc(879492417995ll) - _getfunc(202567778970ll) << ' ' << d << '\n';
int L = 0, R = 1e12 + 1, res = 0;
while (L + 1 < R) {
int mid = (L + R) >> 1;
if (check(mid))
R = res = mid;
else
L = mid;
}
if (p == 862246722332ll)
std::cout << "heige " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
if (!res)
return {-1, -1};
pii ret = {1e18, 1e18};
for (int i = 2; i < m; ++i) {
int l, r;
r = std::upper_bound(unq + 1, unq + 1 + m, unq[i] + res) - unq - 1;
l = std::lower_bound(unq + 1, unq + 1 + m, unq[i - 1] + res) - unq - 1;
l = std::max(l, i);
for (int j = l; j <= r; ++j)
ret = std::min(ret, calc(i, j, res));
}
return ret;
}
bool fl = 1;
void dickdreamer() {
++cs;
std::cin >> n >> p;
vec[0].clear(), vec[1].clear();
for (int i = 1; i <= n; ++i) {
int c, t, id, op;
std::cin >> c >> id >> t >> op;
vec[c - 1].emplace_back(t, id, op);
if (i == 1)
fir = t;
}
prework(), discrete();
if (cnt[0] != cnt[1])
return void(std::cout << "-1\n");
if (now[0] > now[1])
d = now[0] - now[1];
else
d = now[1] - now[0] + 1, std::swap(now[0], now[1]), v[0].swap(v[1]),
vec[0].swap(vec[1]);
getseg();
// if (fl && cs == 6) assert(std::count(unq + 1, unq + 1 + m, 66660446969ll)
// || std::count(unq + 1, unq + 1 + m, 904724933033ll));
sgt.build(m);
auto res = getans();
if (res.first == -1)
std::cout << "-1\n";
else
std::cout << res.first << ' ' << res.second << '\n';
}
int32_t main() {
#ifdef ORZXKR
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
int T = 1;
std::cin >> T;
fl &= (T == 10000);
while (T--)
dickdreamer();
// std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
return 0;
} | failed | 88_2_wrong.cpp |
#include <bits/stdc++.h>
#define db long double
#define int long long
#define pb push_back
#define pii pair<int, int>
#define X first
#define Y second
#define pcc pair<char, char>
#define vi vector<int>
#define vii vector<vector<int>>
#define Rep(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define Drp(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define sz(x) (x).size()
#define All(x) (x).begin(), (x).end()
using namespace std;
void solve() {
int n, m;
cin >> n;
vi a(n + 1);
int mx = 0;
Rep(i, 1, n) cin >> a[i], mx = max(a[i], mx);
int ans = 0;
Rep(i, 1, n) if (a[i] == mx) ans++;
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int T = 1;
cin >> T;
while (T--)
solve();
} | failed | 36_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#ifdef LOCAL
#include <bits/debug.h>
#else
#define dbg(...)
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<string, string>> ans;
unordered_map<string, string> mp;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
string name = s.substr(0, 4);
mp[name] = s;
/*if (!mp.count(name)) {*/
/* mp[name] = s;*/
/*} else {*/
/* ans.push_back({mp[name], s});*/
/* mp.erase(name);*/
/*}*/
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
string name = s.substr(0, 4);
if (!mp.count(name)) {
cout << "NO\n";
return 0;
}
ans.push_back({mp[name], s});
}
cout << "YES\n";
for (auto [x, y] : ans) {
cout << x << " " << y << "\n";
}
return 0;
}
| failed | 91_2_wrong.cpp |
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define mk make_pair
#define MID int mid = (l + r) >> 1;
#define ll long long
#define endl '\n'
#define siz(a) int(a.size())
int a[2001000], n;
const int p = 998244353;
void solveclr() {}
void solve() {
solveclr();
cin >> n;
for (int i = 0; i < (1 << n); i++)
cin >> a[i];
for (int mid = 1; mid < (1 << n); mid <<= 1) {
for (int j = 0; j < (1 << n); j += mid << 1) {
for (int k = 0; k < mid; k++) {
a[j | k | mid] = min(a[j | k], a[j | k | mid]);
}
}
}
sort(a, a + (1 << n));
int ans = 0;
for (int i = 0; i < (1 << n); i++)
ans = (2ll * ans + a[i]) % p;
cout << ans + a[0] << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TTT;
cin >> TTT;
// TTT=1;
while (TTT--)
solve();
}
/*
10 13 4
1 2
2 3
3 1
4 2
4 3
1 4
7 1
7 8
8 8
5 6
5 9
9 10
10 9
1 8 7
7 8 10
5 6 8
7 4 5
*/ | failed | 84_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
// Check if placing 'c' at (row, col) on the board forms a triplet
bool isValid(vector<string> &board, int row, int col, char c) {
// Temporarily place the character
char original = board[row][col];
board[row][col] = c;
bool valid = true;
// Check row
if (board[row][0] == c && board[row][1] == c && board[row][2] == c)
valid = false;
// Check column
if (board[0][col] == c && board[1][col] == c && board[2][col] == c)
valid = false;
// Check diagonals
if (row == col) {
if (board[0][0] == c && board[1][1] == c && board[2][2] == c)
valid = false;
}
if (row + col == 2) {
if (board[0][2] == c && board[1][1] == c && board[2][0] == c)
valid = false;
}
// Restore the original character
board[row][col] = original;
return valid;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
cin.ignore(); // consume newline after n
int total_moves = 0;
for (int b = 0; b < n; ++b) {
vector<string> board(3);
// Read the 3 lines of the board, skipping empty lines
if (b != 0) {
string empty_line;
do {
getline(cin, empty_line);
} while (empty_line.empty());
board[0] = empty_line;
} else {
// Read the first board's lines
for (int i = 0; i < 3; ++i) {
getline(cin, board[i]);
}
// Check if the first line was empty (for first board)
bool all_empty = true;
for (int i = 0; i < 3; ++i) {
if (!board[i].empty()) {
all_empty = false;
break;
}
}
if (all_empty) {
// Re-read the board lines
for (int i = 0; i < 3; ++i) {
getline(cin, board[i]);
}
}
}
if (board[0].size() < 3) {
// Handle cases where the board lines were read incorrectly
for (int i = 0; i < 3; ++i) {
string line;
getline(cin, line);
board[i] = line;
}
}
int empty_cells = 0;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (board[i][j] == '.') {
empty_cells++;
}
}
}
total_moves += empty_cells;
}
// Determine the winner based on the parity of total_moves
if (total_moves % 2 == 1) {
cout << "Alice\n";
} else {
cout << "Bob\n";
}
}
return 0;
} | failed | 50_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
long long power(long long x, long long y, int p) {
long long res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
if (x == 0)
return 0; // In case x is divisible by p;
while (y > 0) {
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
// add 2^k mod n i guess
int n;
i64 k;
cin >> n >> k;
string s;
cin >> s;
int add = power(2, k, n);
cout << add << '\n';
string t = "";
int cur = 0;
for (int i = 0; i < n; i++) {
t += s[cur];
cur = (cur + add) % n;
}
cout << t << '\n';
} | failed | 61_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define eb emplace_back
typedef long long LL;
constexpr int N = 500005;
int n;
vector<int> e1[N], e2[N];
int de[N], fa[N], son[N], sz[N], top[N], bg[N], ed[N], ids;
void dfs1(int x) {
sz[x] = 1;
for (int y : e1[x])
if (y != fa[x]) {
fa[y] = x, de[y] = de[x] + 1, dfs1(y), sz[x] += sz[y];
if (sz[y] > sz[son[x]])
son[x] = y;
}
}
void dfs2(int x, int t) {
top[x] = t, bg[x] = ++ids;
if (son[x]) {
dfs2(son[x], t);
for (int y : e1[x])
if (y != fa[x] && y != son[x]) {
dfs2(y, y);
}
}
ed[x] = ids;
}
int lca(int x, int y) {
while (top[x] != top[y]) {
if (de[top[x]] > de[top[y]]) {
x = fa[top[x]];
} else {
y = fa[top[y]];
}
}
return de[x] < de[y] ? x : y;
}
int dis(int x, int y) { return de[x] + de[y] - 2 * de[lca(x, y)]; }
struct BIT {
int fw[N];
void A(int x, int c) {
for (; x <= n; x += x & -x) {
fw[x] += c;
}
}
int Q(int x) {
int ret = 0;
for (; x; x &= x - 1) {
ret += fw[x];
}
return ret;
}
} fw;
void mdf(int x) { fw.A(bg[x], 1), fw.A(ed[x] + 1, -1); }
int qch(int x, int y) {
int z = lca(x, y);
int ret = fw.Q(bg[x]) + fw.Q(bg[y]) - fw.Q(bg[z]);
if (z > 1) {
ret -= fw.Q(bg[fa[z]]);
}
return ret;
}
int rt, fa2[N];
bool ers[N];
void dfs3(int x) {
for (int y : e2[x])
if (y != fa2[x]) {
fa2[y] = x;
int bac = qch(x, y);
dfs3(y);
int sum = qch(x, y) - bac;
if (y != fa[x] && x != fa[y]) {
if (sum == 0) {
rt = (rt ? -1 : y);
} else if (sum == dis(x, y) - 1) {
ers[y] = true;
} else {
rt = -1;
}
}
mdf(y);
}
}
bool res[N];
void dfs4(int x) {
if (ers[x]) {
return;
}
res[x] = true;
for (int y : e2[x])
if (y != fa2[x]) {
dfs4(y);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> n;
for (int i = 1, x, y; i < n; ++i) {
cin >> x >> y;
e1[x].eb(y), e1[y].eb(x);
}
for (int i = 1, x, y; i < n; ++i) {
cin >> x >> y;
e2[x].eb(y), e2[y].eb(x);
}
dfs1(1), dfs2(1, 1);
dfs3(1);
if (rt == -1) {
for (int i = 0; i < n; ++i) {
cout << '0';
}
cout << '\n';
return 0;
}
if (!rt) {
rt = 1;
}
dfs4(rt);
for (int i = 1; i <= n; ++i) {
cout << res[i];
}
cout << '\n';
return 0;
} | failed | 43_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 100010, mod = 998244353;
void solve() {
std::string s;
std::cin >> s;
int n = s.size();
if (s == std::string(n, '>')) {
std::cout << "No\n";
return;
}
s = " " + s;
if (s[n] == '-' || s[n - 1] == '-' || s[n - 2] == '-' || s[1] == '-') {
std::cout << "No\n";
return;
}
std::vector<std::pair<int, int>> a;
int lst = -1;
for (int i = 1; i <= n; i++) {
if (lst == -1) {
if (s[i] == '-') {
lst = i;
}
} else {
if (s[i] != '-') {
a.push_back({lst, i - lst});
lst = -1;
}
}
}
assert(lst == -1);
std::vector<std::pair<int, int>> b;
for (auto [p, len] : a) {
b.push_back({p - 1, p + len - 1 + 3});
}
std::vector<std::pair<int, int>> A, B, C;
if (b.back().second != n) {
C.push_back({n - 4, 5});
}
for (int i = 1; i < b.front().first; i++) {
C.push_back({i, 5});
}
for (int i = 1; i < b.size(); i++) {
if (b[i].first > b[i - 1].second + 1) {
C.push_back({b[i - 1].second + 1, 5});
}
}
for (auto [l, r] : b) {
if (s.substr(r - 2, 3) == ">>>")
B.push_back({l, r});
else
A.push_back({l, r});
}
std::cout << "Yes " << b.size() + C.size() << "\n";
for (auto [l, r] : C)
std::cout << l << " " << r << "\n";
for (auto [l, r] : A)
std::cout << l << " " << r - l + 1 << "\n";
for (auto [l, r] : B)
std::cout << l << " " << r - l + 1 << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
} | failed | 1_1_wrong.cpp |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef long double ld;
using namespace std;
const int N = 2010, M = 20010, lpw = 1e9 + 7;
struct node {
ll x, y, id;
node(ll xx = 0, ll yy = 0, ll idd = 0) { x = xx, y = yy, id = idd; }
void in() { cin >> x >> y; }
void out() { cout << '(' << x << ',' << y << ')' << '\n'; }
bool operator<(const node &a) const { return x != a.x ? x < a.x : y < a.y; }
bool operator==(const node &a) const { return x == a.x && y == a.y; }
};
node operator+(const node &a, const node &b) {
return node(a.x + b.x, a.y + b.y);
}
node operator-(const node &a, const node &b) {
return node(a.x - b.x, a.y - b.y);
}
ll operator*(const node &a, const node &b) { return a.x * b.x + a.y * b.y; }
ll operator^(const node &a, const node &b) { return a.x * b.y - a.y * b.x; }
node O(0, 0), P(-1, 0);
bool cmp(const node &a, const node &b) {
if (!((a - O) ^ (b - O))) {
if (a * b > 0)
return a * a < b * b;
else if (!(a ^ P))
return a.x < b.x;
else
return (a ^ P) < (b ^ P);
}
if (!((P - O) ^ (a - O)) && (P.x - O.x) * (a.x - O.x) > 0)
return 1;
if (!((P - O) ^ (b - O)) && (P.x - O.x) * (b.x - O.x) > 0)
return 0;
if ((((P - O) ^ (a - O)) > 0) != (((P - O) ^ (b - O)) > 0))
return ((P - O) ^ (a - O)) > ((P - O) ^ (b - O));
return ((a - O) ^ (b - O)) > 0;
}
node p[N], b[N];
int n, t, cnt, s[N], v[N];
ll ans, S;
vector<node> h;
int pre(int i) { return i == 0 ? n - 2 : i - 1; }
int nxt(int i) { return i == n - 2 ? 0 : i + 1; }
ll area(vector<node> &v) {
ll res = 0;
vector<node> z;
sort(v.begin(), v.end());
if (v.size() <= 2)
return 0;
s[t = 1] = 0;
for (int i = 1; i < (int)v.size(); i++) {
while (t > 1 && ((v[i] - v[s[t]]) ^ (v[i] - v[s[t - 1]])) > 0)
t--;
s[++t] = i;
}
for (int i = 1; i <= t; i++)
z.pb(v[s[i]]);
s[t = 1] = 0;
for (int i = 1; i < (int)v.size(); i++) {
while (t > 1 && ((v[i] - v[s[t]]) ^ (v[i] - v[s[t - 1]])) < 0)
t--;
s[++t] = i;
}
for (int i = t - 1; i > 1; i--)
z.pb(v[s[i]]);
int sz = z.size();
for (int i = 0; i < sz; i++)
res += (z[i] ^ z[i == sz - 1 ? 0 : i + 1]);
res = abs(res) % lpw;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
p[i].in();
sort(p + 1, p + n + 1);
s[t = 1] = 1;
for (int i = 2; i <= n; i++) {
while (t > 1 && ((p[i] - p[s[t]]) ^ (p[i] - p[s[t - 1]])) > 0)
t--;
s[++t] = i;
}
for (int i = 1; i <= t; i++) {
v[s[i]] = 1;
b[++cnt] = p[s[i]];
}
s[t = 1] = 1;
for (int i = 2; i <= n; i++) {
while (t > 1 && ((p[i] - p[s[t]]) ^ (p[i] - p[s[t - 1]])) < 0)
t--;
s[++t] = i;
}
for (int i = t - 1; i > 1; i--) {
v[s[i]] = 1;
b[++cnt] = p[s[i]];
}
for (int i = 1; i <= cnt; i++)
S += (b[i] ^ b[i == cnt ? 1 : i + 1]);
S = abs(S) % lpw;
for (int i = 1; i <= n; i++) {
if (v[i])
continue;
O = node(p[i].x, p[i].y);
P = node(p[i].x - 1, p[i].y);
h.clear();
for (int j = 1; j <= n; j++)
if (j != i)
h.pb(node(p[j].x, p[j].y, j));
sort(h.begin(), h.end(), cmp);
for (int l = 0; l <= n - 2; l++) {
if (!v[h[l].id])
continue;
int r = nxt(l);
for (;; r = nxt(r))
if (v[h[r].id])
break;
if (r == nxt(l)) {
ll T = abs((p[h[l].id] - p[i]) ^ (p[h[r].id] - p[i])) % lpw;
ans = (ans + S - T + lpw) % lpw;
continue;
}
for (int j = l; j != r; j = nxt(j)) {
vector<node> z;
ll ls = 0, rs = 0;
for (int k = l;; k = nxt(k)) {
z.pb(p[h[k].id]);
if (k == j)
break;
}
z.pb(p[i]);
ls = area(z);
z.clear();
for (int k = nxt(j);; k = nxt(k)) {
z.pb(p[h[k].id]);
if (k == r)
break;
}
z.pb(p[i]);
rs = area(z);
z.clear();
ll T = abs((p[h[l].id] - p[i]) ^ (p[h[r].id] - p[i])) % lpw;
ans = (ans + S - T + ls + rs + lpw) % lpw;
}
}
}
cout << ans << '\n';
return 0;
} | failed | 38_3_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int p = 998244353;
int po(int a, int b) {
if (b == 0)
return 1;
if (b == 1)
return a;
if (b % 2 == 0) {
int u = po(a, b / 2);
return (u * 1LL * u) % p;
} else {
int u = po(a, b - 1);
return (a * 1LL * u) % p;
}
}
int inv(int x) { return po(x, p - 2); }
mt19937 rnd;
#define app push_back
#define all(x) (x).begin(), (x).end()
#ifdef LOCAL
#define debug(...) \
[](auto... a) { ((cout << a << ' '), ...) << endl; }(#__VA_ARGS__, ":", \
__VA_ARGS__)
#define debugv(v) \
do { \
cout << #v << " : {"; \
for (int izxc = 0; izxc < v.size(); ++izxc) { \
cout << v[izxc]; \
if (izxc + 1 != v.size()) \
cout << ","; \
} \
cout << "}" << endl; \
} while (0)
#else
#define debug(...)
#define debugv(v)
#endif
#define lob(a, x) lower_bound(all(a), x)
#define upb(a, x) upper_bound(all(a), x)
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> l(n), r(n);
for (int i = 0; i < n; ++i) {
cin >> l[i] >> r[i];
}
map<int, int> dpx, dpy;
vector<pair<int, pair<int, int>>> ch;
for (int i = 0; i < n; ++i) {
int yy = l[i];
int xx = i;
ch.app({xx + yy, {0, i}});
}
for (int i = 0; i < n; ++i) {
if (i + 1 == n || r[i] != r[i + 1]) {
int yy = r[i];
int xx = i + 1;
ch.app({xx + yy, {1, r[i]}});
}
}
sort(all(ch));
reverse(all(ch));
for (auto u : ch) {
int typ = u.second.first;
if (typ == 0) {
int x = u.second.second;
if (x >= n) {
dpx[x] = 0;
continue;
}
if (x != 0 && l[x] == l[x - 1]) {
continue;
} ///!!!
int j = x;
while (j < n && l[j] == l[x]) {
++j;
}
dpx[x] = max(dpx[x], dpx[l[j]] + 1);
dpx[x] = max(dpx[x], dpy[r[x]] + 1);
} else {
int y = u.second.second;
if (y >= r.back()) {
dpy[y] = 0;
continue;
}
int pos1 = upper_bound(all(r), y) - r.begin() - 1;
if (pos1 < 0 || pos1 >= r.size() || r[pos1] != y) {
continue;
} ///!!!
if (pos1 == r.size() - 1) {
dpy[y] = 0;
continue;
}
dpy[y] = max(dpy[y], dpy[r[pos1 + 1]] + 1);
int pos = upper_bound(all(l), y) - l.begin();
dpy[y] = max(dpy[y], dpx[pos] + 1);
}
}
cout << dpx[0] << '\n';
}
return 0;
}
| failed | 19_1_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define KE ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define flt(x) cout << fixed << setprecision(x);
#define all(x) (x).begin(), (x).end()
#define bcount(t) __builtin_popcount(t)
#define legal(x, lo, hi) (lo <= x && x <= hi)
#define Mod(x, m) (((x) % m + m) % m)
#define flip(x) reverse(x)
#define lowbit(x) (x & (-x))
#define bemax(x, y) x = max(x, y)
#define pb push_back
#define elif else if
#define endl '\n'
#define AA cerr << "AA" << endl;
#define __ << " " <<
const int N = 1e5 + 10;
const int inf = 1e18;
const int mod = 1e9 + 7;
typedef pair<int, int> pii;
int dp[155][155][155][3];
int pre[155][155][155];
void solve() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
int l = s.size();
int unknow[305], cnt = 0;
for (int cur = 0; cur < s.size(); cur++) {
if (s[cur] == '?')
unknow[++cnt] = cur;
}
for (int a = 0; a <= 151; a++) {
for (int b = 0; b <= 151; b++) {
for (int c = 0; c <= 151; c++) {
for (int cur = 0; cur <= 2; cur++) {
dp[a][b][c][cur] = 0;
}
}
}
}
if (!legal(unknow[1] - 1, 0, l - 1)) {
if (!legal(unknow[1] + 1, 0, l - 1)) {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
} else {
if (s[unknow[1] + 1] == 'a') {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
if (s[unknow[1] + 1] == 'b') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
if (s[unknow[1] + 1] == 'c') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
}
if (s[unknow[1] + 1] == '?') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
}
} else {
if (s[unknow[1] - 1] == 'a') {
if (!legal(unknow[1] + 1, 0, l - 1) ||
(legal(unknow[1] + 1, 0, l - 1) && s[unknow[1] + 1] == '?')) {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
} else {
if (s[unknow[1] + 1] == 'a') {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
if (s[unknow[1] + 1] == 'b') {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
if (s[unknow[1] + 1] == 'c') {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
}
}
}
if (s[unknow[1] - 1] == 'b') {
if (!legal(unknow[1] + 1, 0, l - 1) ||
(legal(unknow[1] + 1, 0, l - 1) && s[unknow[1] + 1] == '?')) {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
} else {
if (s[unknow[1] + 1] == 'a') {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
if (s[unknow[1] + 1] == 'b') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 1;
}
if (s[unknow[1] + 1] == 'c') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
}
}
}
if (s[unknow[1] - 1] == 'c') {
if (!legal(unknow[1] + 1, 0, l - 1) ||
(legal(unknow[1] + 1, 0, l - 1) && s[unknow[1] + 1] == '?')) {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
} else {
if (s[unknow[1] + 1] == 'a') {
dp[1][0][0][0] = 0;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
}
if (s[unknow[1] + 1] == 'b') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 0;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
}
if (s[unknow[1] + 1] == 'c') {
dp[1][0][0][0] = 1;
dp[1][0][0][1] = 0;
dp[1][0][0][2] = 0;
dp[0][1][0][0] = 0;
dp[0][1][0][1] = 1;
dp[0][1][0][2] = 0;
dp[0][0][1][0] = 0;
dp[0][0][1][1] = 0;
dp[0][0][1][2] = 0;
}
}
}
}
for (int a = 0; a <= 150; a++) {
for (int b = 0; b <= 150; b++) {
for (int c = 0; c <= 150; c++) {
int nxt = a + b + c + 1;
int sig = (dp[a][b][c][0] + dp[a][b][c][1] + dp[a][b][c][2]) % mod;
if (nxt <= 1)
continue;
if (nxt > cnt)
break;
if (!legal(unknow[nxt] + 1, 0, l - 1) ||
(legal(unknow[nxt] + 1, 0, l - 1) && s[unknow[nxt] + 1] == '?')) {
if (s[unknow[nxt] - 1] == 'a')
dp[a][b + 1][c][1] = (dp[a][b + 1][c][1] + sig) % mod;
if (s[unknow[nxt] - 1] == 'a')
dp[a][b][c + 1][2] = (dp[a][b][c + 1][2] + sig) % mod;
if (s[unknow[nxt] - 1] == 'b')
dp[a + 1][b][c][0] = (dp[a + 1][b][c][0] + sig) % mod;
if (s[unknow[nxt] - 1] == 'b')
dp[a][b][c + 1][2] = (dp[a][b][c + 1][2] + sig) % mod;
if (s[unknow[nxt] - 1] == 'c')
dp[a + 1][b][c][0] = (dp[a + 1][b][c][0] + sig) % mod;
if (s[unknow[nxt] - 1] == 'c')
dp[a][b + 1][c][1] = (dp[a][b + 1][c][1] + sig) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a + 1][b][c][0] =
Mod(dp[a + 1][b][c][0] + sig - dp[a][b][c][0], mod);
if (s[unknow[nxt] - 1] == '?')
dp[a][b + 1][c][1] =
Mod(dp[a][b + 1][c][1] + sig - dp[a][b][c][1], mod);
if (s[unknow[nxt] - 1] == '?')
dp[a][b][c + 1][2] =
Mod(dp[a][b][c + 1][2] + sig - dp[a][b][c][2], mod);
} else {
if (s[unknow[nxt] + 1] == 'a') {
if (s[unknow[nxt] - 1] == 'a')
dp[a][b + 1][c][1] = (dp[a][b + 1][c][1] + sig) % mod;
if (s[unknow[nxt] - 1] == 'a')
dp[a][b][c + 1][2] = (dp[a][b][c + 1][2] + sig) % mod;
if (s[unknow[nxt] - 1] == 'b')
dp[a][b][c + 1][2] = (dp[a][b][c + 1][2] + sig) % mod;
if (s[unknow[nxt] - 1] == 'c')
dp[a][b + 1][c][1] = (dp[a][b + 1][c][1] + sig) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a][b + 1][c][1] =
(dp[a][b + 1][c][1] + sig - dp[a][b][c][1]) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a][b][c + 1][2] =
(dp[a][b][c + 1][2] + sig - dp[a][b][c][2]) % mod;
}
if (s[unknow[nxt] + 1] == 'b') {
if (s[unknow[nxt] - 1] == 'a')
dp[a][b][c + 1][2] = (dp[a][b][c + 1][2] + sig) % mod;
if (s[unknow[nxt] - 1] == 'b')
dp[a + 1][b][c][0] = (dp[a + 1][b][c][0] + sig) % mod;
if (s[unknow[nxt] - 1] == 'b')
dp[a][b][c + 1][2] = (dp[a][b][c + 1][2] + sig) % mod;
if (s[unknow[nxt] - 1] == 'c')
dp[a + 1][b][c][0] = (dp[a + 1][b][c][0] + sig) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a + 1][b][c][0] =
(dp[a + 1][b][c][0] + sig - dp[a][b][c][0]) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a][b][c + 1][2] =
(dp[a][b][c + 1][2] + sig - dp[a][b][c][2]) % mod;
}
if (s[unknow[nxt] + 1] == 'c') {
if (s[unknow[nxt] - 1] == 'a')
dp[a][b + 1][c][1] = (dp[a][b + 1][c][1] + sig) % mod;
if (s[unknow[nxt] - 1] == 'b')
dp[a + 1][b][c][0] = (dp[a + 1][b][c][0] + sig) % mod;
if (s[unknow[nxt] - 1] == 'c')
dp[a + 1][b][c][0] = (dp[a + 1][b][c][0] + sig) % mod;
if (s[unknow[nxt] - 1] == 'c')
dp[a][b + 1][c][1] = (dp[a][b + 1][c][1] + sig) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a + 1][b][c][0] =
(dp[a + 1][b][c][0] + sig - dp[a][b][c][0]) % mod;
if (s[unknow[nxt] - 1] == '?')
dp[a][b + 1][c][1] =
(dp[a][b + 1][c][1] + sig - dp[a][b][c][1]) % mod;
}
}
}
}
}
for (int a = 0; a <= 150; a++) {
for (int b = 0; b <= 150; b++) {
for (int c = 0; c <= 150; c++) {
if (a + b + c == cnt) {
pre[a][b][c] =
(dp[a][b][c][0] + dp[a][b][c][1] + dp[a][b][c][2]) % mod;
}
}
}
}
for (int a = 0; a <= 150; a++) {
for (int b = 0; b <= 150; b++) {
for (int c = 1; c <= 150; c++) {
pre[a][b][c] = (pre[a][b][c] + pre[a][b][c - 1]) % mod;
}
}
}
for (int a = 0; a <= 150; a++) {
for (int b = 1; b <= 150; b++) {
for (int c = 0; c <= 150; c++) {
pre[a][b][c] = (pre[a][b][c] + pre[a][b - 1][c]) % mod;
}
}
}
for (int a = 1; a <= 150; a++) {
for (int b = 0; b <= 150; b++) {
for (int c = 0; c <= 150; c++) {
pre[a][b][c] = (pre[a][b][c] + pre[a - 1][b][c]) % mod;
}
}
}
for (int cur = 0; cur < q; cur++) {
int a, b, c;
cin >> a >> b >> c;
a = min(150ll, a);
b = min(150ll, b);
c = min(150ll, c);
cout << pre[a][b][c] << endl;
}
}
signed main() {
KE;
int T = 1;
// cin >> T;
// flt(3);
while (T--) {
solve();
}
return 0;
} | failed | 2_3_wrong.cpp |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;
struct BlockCutTree {
int n;
std::vector<std::vector<int>> adj;
std::vector<int> dfn, low, stk;
int cnt, cur;
std::vector<std::pair<int, int>> edges;
BlockCutTree() {}
BlockCutTree(int n) { init(n); }
void init(int n) {
this->n = n;
adj.assign(n, {});
dfn.assign(n, -1);
low.resize(n);
stk.clear();
cnt = cur = 0;
edges.clear();
}
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void dfs(int x) {
stk.push_back(x);
dfn[x] = low[x] = cur++;
for (auto y : adj[x]) {
if (dfn[y] == -1) {
dfs(y);
low[x] = std::min(low[x], low[y]);
if (low[y] == dfn[x]) {
int v;
do {
v = stk.back();
stk.pop_back();
edges.emplace_back(n + cnt, v);
} while (v != y);
edges.emplace_back(x, n + cnt);
cnt++;
}
} else {
low[x] = std::min(low[x], dfn[y]);
}
}
}
std::pair<int, std::vector<std::pair<int, int>>> work() {
for (int i = 0; i < n; i++) {
if (dfn[i] == -1) {
stk.clear();
dfs(i);
}
}
return {cnt, edges};
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int h, w;
std::cin >> h >> w;
std::vector<std::string> s(h);
for (int i = 0; i < h; i++) {
std::cin >> s[i];
}
std::vector a(h, std::vector<int>(w));
auto idx = [&](int x, int y) {
int u = x * w + y + 1;
if (u == h * w) {
u = 0;
}
return u;
};
std::vector<int> p(h * w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
std::cin >> a[i][j];
p[idx(i, j)] = a[i][j];
}
}
BlockCutTree g(h * w);
std::vector<bool> emp(h * w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (s[i][j] == '.') {
emp[idx(i, j)] = true;
if (j + 1 < w && s[i][j + 1] == '.') {
g.addEdge(idx(i, j), idx(i, j + 1));
}
if (i + 1 < h && s[i + 1][j] == '.') {
g.addEdge(idx(i, j), idx(i + 1, j));
}
}
}
}
auto [cnt, edges] = g.work();
std::vector<int> par(h * w, -1);
for (auto [u, v] : edges) {
if (v < h * w) {
par[v] = u;
}
}
std::vector<int> parity(cnt);
for (int i = 1; i < h * w; i++) {
if (!emp[i]) {
continue;
}
if (par[i] == -1 || par[i] != par[p[i]]) {
std::cout << "impossble\n";
return 0;
}
}
std::vector<bool> vis(h * w);
for (int i = 1; i < h * w; i++) {
if (!emp[i] || vis[i]) {
continue;
}
int j = i;
int len = 0;
while (!vis[j]) {
vis[j] = true;
j = p[j];
len++;
}
parity[par[i] - h * w] ^= (len - 1) & 1;
}
if (std::find(parity.begin(), parity.end(), 1) == parity.end()) {
std::cout << "possible\n";
} else {
std::cout << "impossible\n";
}
return 0;
} | failed | 63_2_wrong.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define lll __int128_t
#define uint uint32_t
using B = bitset<400001>;
B G[3010];
void solve() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> pz(1010);
int maxn = 1000;
for (int i = 0; i < n; i++)
pz[a[i]].push_back(i);
for (int i = 1; i <= maxn; i++) {
for (int j = max(1, i - k); j <= min(i + k, maxn); j++) {
for (auto k : pz[j])
G[i][k] = 1;
}
}
vector<int> ans(2 * n + 2);
for (int i = 0; i < n; i++) {
ans[2 * i] = min(n - i, i + 1);
ans[2 * i + 1] = min(n - i - 1, i + 1);
}
bitset<400001> del;
B p;
for (int i = n - 1; i >= 0; i--) {
p = p << 1;
B np;
np[i] = 1;
if (i != n - 1 && abs(a[i] - a[i + 1]) <= k)
np[i + 1] = 1;
p = (np | (p & G[a[i]]));
B q = p;
q.flip();
/*
[2*i+1,2*i+1];
[i+1,i+2]
*/
q = q ^ (del >> i);
for (int t = q._Find_next(i); t < n; t = q._Find_next(t)) {
ans[t + i] = (t - i + 2) / 2 - 1;
del[t + i] = 1;
}
}
for (int i = 0; i < n; i++)
cout << ans[2 * i] * 2 - 1 << ' ';
cout << '\n';
for (int i = 0; i < n - 1; i++)
cout << ans[2 * i + 1] * 2 << ' ';
cout << '\n';
}
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
int _ = 1;
// cin>>_;
while (_--) {
solve();
}
} | failed | 34_2_wrong.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.