text
stringlengths 10
22.5k
| status
stringclasses 2
values | name
stringlengths 9
26
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 2e5 + 5, M = 4e7;
constexpr int INF = 0x3f3f3f3f;
int n, m, tot = 1, lnk[N], cur[N], ter[M], nxt[M], cap[M], cost[M], dis[N], ret;
bool vis[N];
int cnt = 2;
void add(int u, int v, int w, int c) {
ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot, cap[tot] = w, cost[tot] = c;
}
void addedge(int u, int v, int w, int c) { add(u, v, w, c), add(v, u, 0, -c); }
bool spfa(int s, int t) {
memset(dis, 0x3f, sizeof(dis));
memcpy(cur, lnk, sizeof(lnk));
std::queue<int> q;
q.push(s), dis[s] = 0, vis[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop(), vis[u] = false;
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (cap[i] && dis[v] > dis[u] + cost[i]) {
dis[v] = dis[u] + cost[i];
if (!vis[v]) q.push(v), vis[v] = true;
}
}
}
return dis[t] != INF;
}
int dfs(int u, int t, int flow) {
if (u == t) return flow;
vis[u] = true;
int ans = 0;
for (int &i = cur[u]; i && ans < flow; i = nxt[i]) {
int v = ter[i];
if (!vis[v] && cap[i] && dis[v] == dis[u] + cost[i]) {
int x = dfs(v, t, std::min(cap[i], flow - ans));
if (x) ret += x * cost[i], cap[i] -= x, cap[i ^ 1] += x, ans += x;
}
}
vis[u] = false;
return ans;
}
void mcmf(int s, int t) {
int ans = 0;
while (spfa(s, t)) {
int x;
while ((x = dfs(s, t, INF))) ans += x;
}
}
typedef long long LL;
void solve()
{
int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; i ++) cin >> a[i];
struct S
{
int id;
int v;
vector<array<int, 2>> fac;
};
unordered_map<int, int> to;
vector<S> nums;
int cnt = 0;
set<int> st;
for(int i = 0; i < n; i ++) st.insert(a[i]);
vector<array<int, 2>> f;
vector<int> p, q;
vector<array<int, 4>> es;
auto get = [&](auto &&self, int u, int v, int cnt) -> void
{
if(u == p.size())
{
f.push_back({v, cnt});
return;
}
int ne = v;
for(int i = 0; i <= q[u]; i ++)
{
self(self, u + 1, ne, cnt + q[u] - i);
ne *= p[u];
}
};
set<int> facs;
while(st.size())
{
int t = *st.rbegin();
st.erase(t);
if(to.count(t)) continue;
if(t == 1)
{
to[t] = cnt;
nums.push_back({cnt ++, 1, {}});
}
else
{
p.clear(), q.clear();
int v = t;
for(int i = 2; i <= v / i; i ++)
if(v % i == 0)
{
int c = 0;
while(v % i == 0) v /= i, c ++;
p.push_back(i);
q.push_back(c);
}
if(v > 1) p.push_back(v), q.push_back(1);
// if(t == 4)
// {
// cout << "test:4 " << '\n';
// for(auto c : p) cout << c << ' ';
// cout << '\n';
// for(auto c : q) cout << c << ' ';
// cout << '\n';
// }
f.clear();
get(get, 0, 1, 0);
to[t] = cnt;
nums.push_back({cnt ++, t, f});
for(auto [fac, cnt] : f) facs.insert(fac);
}
}
for(auto c : facs)
{
if(!to.count(c))
{
// cout << c << ' ';
to[c] = cnt;
nums.push_back({cnt ++, c, {}});
}
}
// cout << '\n';
int m = nums.size();
int S = m, T = m + 1;
// MinCostFlow<int> g(m + 2);
for(int i = 0; i < n; i ++) addedge(S, to[a[i]], 1, 0);
for(auto [id, v, vec] : nums)
{
// cout << v << '\n';
// for(auto [fac, cnt] : vec) cout << fac << ' ' << cnt << '\n';
addedge(id, T, 1, 0);
for(auto [fac, cnt] : vec)
if(fac != v)
addedge(id, to[fac], 1e9, -cnt);
}
mcmf(S, T);
cout << -ret << '\n';
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
// cin >> t;
while(t --)
solve();
return 0;
} | passed | 10_std.cpp |
#include <bits/stdc++.h>
#define int long long
using namespace std;
int32_t main (){
ios_base::sync_with_stdio(0), cin.tie(0);
int t;
string s;
cin >> t;
while (t--){
cin >> s;
int n = s.size(), c1 = 0, c2 = 0, c3 = 0;
for (int i = 0; i < n; i++){
if (s[i] == '0')
c1 -= (i & 1 ? 1 : -1);
else if (s[i] == '1')
c2 -= (i & 1 ? 1 : -1);
else
c3++;
}
cout << max(abs(c1) + abs(c2) - c3, n & 1) << '\n';
}
} | passed | 48_std.cpp |
#include<bits/stdc++.h>
constexpr int maxn = 5e5 + 10;
int n, m;
std::vector<int> to[maxn], son[maxn], par[maxn];
int vis[maxn], dfn[maxn], rdfn[maxn], dn;
int dep[maxn], fa[maxn][20];
int len;
inline void dfs1(int u) {
dfn[u] = ++dn, vis[u] = 1;
dep[u] = dep[fa[u][0]] + 1;
for (int i = 1; i < 20; i++) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
for (int v : to[u]) {
if (v == fa[u][0]) continue;
if (! vis[v]) {
son[u].push_back(v);
fa[v][0] = u, dfs1(v);
} else if (dep[v] < dep[u]) {
par[v].push_back(u);
int l = dep[u] - dep[v] + 1;
len = len && len != l ? -1 : l;
}
}
rdfn[u] = dn;
}
inline int jump(int u, int d) {
for (int i = 0; i < 20; i++) {
if (d >> i & 1) u = fa[u][i];
}
return u;
}
int tr[maxn];
inline void add(int x, int y) {
for (; x <= n; x += x & -x) tr[x] += y;
}
inline int qry(int x) {
int y = 0;
for (; x >= 1; x -= x & -x) y += tr[x];
return y;
}
inline int qry(int l, int r) {
return qry(r) - qry(l - 1);
}
inline void dfs2(int u) {
for (int v : par[u]) add(dfn[v], 1);
for (int v : par[u]) {
if (len == -1);
else if (len % 2 == 0) {
int a = jump(v, len / 2 - 2), b = jump(v, len / 2 - 1), c = jump(v, len - 2);
qry(dfn[a], rdfn[a]) > 1 && (len = -1);
qry(dfn[b], rdfn[b]) != qry(dfn[c], rdfn[c]) && (len = -1);
} else {
int a = jump(v, len - 2);
qry(dfn[a], rdfn[a]) > 1 && (len = -1);
}
}
for (int v : son[u]) dfs2(v);
for (int v : par[u]) add(dfn[v], -1);
}
inline void solve(int tc) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
to[i].clear(), son[i].clear(), par[i].clear(), vis[i] = 0;
}
dn = 0, len = 0;
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
to[x].push_back(y), to[y].push_back(x);
}
dfs1(1), dfs2(1);
puts(len != -1 ? "Yes" : "No");
}
int main() {
int t; scanf("%d", &t);
for (int tc = 1; tc <= t; tc++) solve(tc);
return 0;
}
| passed | 70_std.cpp |
#include<bits/stdc++.h>
// #include<bits/stdc--.h>
using i64 = long long;
#define all(x) std::begin(x), std::end(x)
void solve() {
int n;
std::cin >> n;
if (n == 1) {
std::cout << ".\n";
return;
} else if (n == 2) {
std::cout <<
R"( .
. .
)";
return;
} else if (n == 3) {
std::cout <<
R"( A
A .
. A .
)";
return;
} else if (n == 4) {
std::cout <<
R"( .
. A
. B A
B B A .
)";
return;
} else if (n == 5) {
std::cout <<
R"( .
A B
A B C
D A B C
. D D C .
)";
return;
}
std::vector a(n, std::vector<char>(n, '.'));
auto odd = [&](int k) -> void {
int i = k - 1;
a[i][0] = 'A'; i++;
a[i][0] = 'B'; a[i][1] = 'A'; a[i][2] = 'A'; i++;
a[i][0] = 'C'; a[i][1] = 'B'; a[i][2] = 'B'; i++;
a[i][0] = '.'; a[i][1] = 'C'; a[i][2] = 'C'; i++;
i = k - 1;
a[i][i] = 'D'; i++;
a[i][i] = 'D'; i++;
a[i][i - 1] = 'D'; a[i][i] = 'E'; i++;
a[i][i - 2] = 'E'; a[i][i - 1] = 'E'; a[i][i] = '.'; i++;
char u = 'F', d = 'H';
for (int i = 3; i < k; i += 2, u ^= 1, d ^= 1) {
a[k][i] = a[k][i + 1] = u;
a[k + 1][i] = u; a[k + 1][i + 1] = d;
a[k + 2][i] = d; a[k + 2][i + 1] = d;
}
};
auto eve = [&](int k) -> void {
int i = k - 1;
a[i][0] = 'J'; i++;
a[i][0] = 'J'; i++;
a[i][0] = 'K'; a[i][1] = 'J'; i++;
a[i][0] = '.'; a[i][1] = 'K'; a[i][2] = 'K'; i++;
i = k - 1;
a[i][i] = 'N'; i++;
a[i][i - 1] = 'N'; a[i][i] = 'M'; i++;
a[i][i - 1] = 'N'; a[i][i] = 'M'; i++;
a[i][i - 1] = 'M'; a[i][i] = '.'; i++;
char u = 'P', d = 'R';
for (int i = 1; i < k - 1; i += 2, u ^= 1, d ^= 1) {
a[k][i] = a[k][i + 1] = u;
a[k + 1][i + 1] = d; a[k + 1][i + 1 + 1] = u;
a[k + 2][i + 2] = d; a[k + 2][i + 1 + 2] = d;
}
};
int m = n % 3 + 3;
if (m == 3) {
a[0][0] = 'Z';
a[1][0] = '.'; a[1][1] = 'Z';
a[2][0] = '.'; a[2][1] = 'Z'; a[2][2] = '.';
} else if (m == 4) {
a[0][0] = '.';
a[1][0] = 'Y'; a[1][1] = 'Z';
a[2][0] = 'Y'; a[2][1] = '.'; a[2][2] = 'Z';
a[3][0] = '.'; a[3][1] = 'Y'; a[3][2] = 'Z'; a[3][3] = '.';
} else if (m == 5) {
a[0][0] = '.';
a[1][0] = 'Y'; a[1][1] = 'Z';
a[2][0] = 'Y'; a[2][1] = 'Z'; a[2][2] = 'W';
a[3][0] = 'X'; a[3][1] = 'Y'; a[3][2] = 'Z'; a[3][3] = 'W';
a[4][0] = '.'; a[4][1] = 'X'; a[4][2] = 'X'; a[4][3] = 'W'; a[4][4] = '.';
} else {
assert(0);
}
while (m < n) {
if (m & 1) odd(m);
else eve(m);
m += 3;
}
for (int i = 0; i < n; i++) {
std::cout << std::string(n - 1 - i, ' ');
for (int j = 0; j <= i; j++) {
std::cout << a[i][j] << " \n"[j == i];
}
}
}
signed main() {
std::cin.tie(0) -> sync_with_stdio(0);
int t = 1;
// std::cin >> t;
while (t--) solve();
return 0;
} | passed | 73_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#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()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int MAXV = 200005;
struct Seg {
int l, r;
long long y;
bool enter;
Seg(int left, int right, long long yy, bool e)
: l(left), r(right), y(yy), enter(e) {}
bool operator<(const Seg &o) const {
if (y == o.y) {
return !enter && o.enter;
}
return y < o.y;
}
};
const long long inf = 1e18;
struct Node {
Node *l = 0, *r = 0;
int lo, hi;
long long mset = inf, val = 0;
Node(int left, int high) : lo(left), hi(high) {}
long long query(int L, int R) {
if (R <= lo || hi <= L)
return -inf;
if (L <= lo && hi <= R)
return val;
push();
return max(l->query(L, R), r->query(L, R));
}
void set(int L, int R, long long x) {
if (R <= lo || hi <= L)
return;
if (L <= lo && hi <= R)
mset = val = x;
else {
push(), l->set(L, R, x), r->set(L, R, x);
val = max(l->val, r->val);
}
}
void push() {
if (!l) {
int mid = lo + (hi - lo) / 2;
l = new Node(lo, mid);
r = new Node(mid, hi);
}
if (mset != inf) {
l->set(lo, hi, mset), r->set(lo, hi, mset), mset = inf;
}
}
};
set<pii>::iterator addInterval(set<pii> &is, int L, int R) {
if (L == R)
return is.end();
auto it = is.lower_bound({L, R}), before = it;
while (it != is.end() && it->first <= R) {
R = max(R, it->second);
before = it = is.erase(it);
}
if (it != is.begin() && (--it)->second >= L) {
L = min(L, it->first);
R = max(R, it->second);
is.erase(it);
}
return is.insert(before, {L, R});
}
void removeInterval(set<pii> &is, int L, int R) {
if (L == R)
return;
auto it = addInterval(is, L, R);
auto r2 = it->second;
if (it->first == L)
is.erase(it);
else
(int &)it->second = L;
if (R != r2)
is.emplace(R, r2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<Seg> segs;
Node *root = new Node(0, MAXV);
for (int i = 0; i < n; i++) {
int l, r, h;
cin >> l >> r >> h;
long long mx = root->query(l, r);
root->set(l, r, mx + h);
segs.emplace_back(l, r, mx, true);
segs.emplace_back(l, r, mx + h, false);
}
sort(segs.begin(), segs.end());
set<pair<int, int>> open;
open.emplace(-5, MAXV);
int prv = 0;
int close = 0;
for (int i = 0; i < (int)segs.size(); i++) {
if (i + 1 == (int)segs.size() || segs[i].y < segs[i + 1].y) {
set<pair<int, int>> merge;
for (int j = prv; j <= i; j++) {
if (segs[j].enter) {
addInterval(merge, segs[j].l, segs[j].r);
}
}
for (auto [l, r] : merge) {
auto it_l = open.lower_bound({l, -1});
while (it_l != open.end() && it_l->second <= r) {
close++;
it_l++;
}
}
for (int j = prv; j <= i; j++) {
if (segs[j].enter) {
removeInterval(open, segs[j].l, segs[j].r);
} else {
addInterval(open, segs[j].l, segs[j].r);
}
}
prv = i + 1;
}
}
cout << close << "\n";
} | passed | 94_std.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 >= max(tot - a[i], 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;
// cout << g << "\n";
lst[i] = {l, r, i};
// cout << l << " " << r << " " << i << "\n";
lst[i + n] = {l + tot, r + tot, i};
}
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;
while(l > r) r += tot;
x = lst[x].r % tot;
if(l <= x && x <= r) return 1;
// cout << x << " " << l << " " << r << "\n";
{
x -= tot;
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;
}
{
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){
// cout << lst[i].id << " " << tlst[i].id << "\n";
// }
// for(int i = 0; i < n * 2; ++i){
// if(lst[i].id != tlst[i].id){
// cout << m << "\n";
// }
// }
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(skip[i]) continue;
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(skip[ptr] || !checkgood(cur, ptr)) ++ptr;
for(int i = 0; i < k; ++i){
while(cnt < n && (skip[ptr] || checkgood(cur, ptr))){
// vis[ptr] = 1;
// cout << cur << " " << ptr << "\n";
++cnt;
++ptr;
ptr %= n;
}
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;
tot += a[i];
}
pos[n] = tot;
for(int i = 0; i < n; ++i){
if(a[i] >= tot / 2){
cout << (tot - a[i]) / 2 << "\n";
return 0;
}
// mx = max(mx, min(a[i], tot - a[i]));
mx = max(mx, a[i]);
}
// if(n == 381043 && k == 1){
// cout << mx << "\n";
// cout << tot << "\n";
// }
// cout << tot << "\n";
// check(2);
// 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";
} | passed | 95_std.cpp |
#include<stdio.h>
#include<string.h>
#include<cmath>
#include<vector>
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int word;
typedef unsigned short hword;
typedef unsigned char byte;
struct game{
char s[9];
inline game(){}
inline game(const game &g)=default;
inline game(const char c[]){
for(word i=0;i<9;++i) s[i]=c[i];
}
inline bool operator()()const{
if(s[0]!='.'&&s[0]==s[1]&&s[0]==s[2]) return 0;
if(s[3]!='.'&&s[3]==s[4]&&s[3]==s[5]) return 0;
if(s[6]!='.'&&s[6]==s[7]&&s[6]==s[8]) return 0;
if(s[0]!='.'&&s[0]==s[3]&&s[0]==s[6]) return 0;
if(s[1]!='.'&&s[1]==s[4]&&s[1]==s[7]) return 0;
if(s[2]!='.'&&s[2]==s[5]&&s[2]==s[8]) return 0;
if(s[0]!='.'&&s[0]==s[4]&&s[0]==s[8]) return 0;
if(s[2]!='.'&&s[2]==s[4]&&s[2]==s[6]) return 0;
return 1;
}
inline word operator*()const{
word get=0;
for(const char &c:s)
if(get*=3,c=='x') ++get;
else if(c=='o') get+=2;
return get;
}
};
bool b[19683];
std::vector<word> L[19683],R[19683];
inline void dfs(const game &g){
const word bef=*g;
b[bef]=1;
for(word i=0;i<9;++i) if(g.s[i]=='.'){
game out=g;
if(out.s[i]='x',out()){
const word get=*out;
L[bef].push_back(get);
if(!b[get]) dfs(out);
}
if(out.s[i]='o',out()){
const word get=*out;
R[bef].push_back(get);
if(!b[get]) dfs(out);
}
}
}
char sn[19683],sg[19683];
struct surreal{
word id;
inline surreal(){}
inline surreal(const surreal&)=default;
inline surreal(word ID):id(ID){}
inline bool operator<=(const surreal &p)const{
if(sn[id]!=127&&sn[p.id]!=127){
if(sn[id]<sn[p.id]) return 1;
if(sn[id]==sn[p.id]&&sg[id]==sg[p.id]) return 1;
return 0;
}
for(const auto &l:L[id])
if(p<=surreal(l)) return 0;
for(const auto &r:R[p.id])
if(surreal(r)<=*this) return 0;
return 1;
}
inline bool operator==(const surreal &p)
const{return *this<=p&&p<=*this;}
};
std::vector<word> ans;
struct READ{
char c,w;
inline READ(){
dfs(game("........."));
for(word id=19683;id--;) if(b[id]){
sn[id]=127;
for(const auto &p:ans)
if(surreal(id)==surreal(p)){
sn[id]=sn[p],sg[id]=sg[p];
break;
}
if(sn[id]==127){
ans.push_back(id);
word lmax=19682,rmin=19682;
for(const auto &l:L[id])
if(lmax==19682||surreal(lmax)<=surreal(l)) lmax=l;
for(const auto &r:R[id])
if(rmin==19682||surreal(r)<=surreal(rmin)) rmin=r;
if(lmax==19682&&rmin==19682) sn[id]=0,sg[id]=0;
else if(lmax==19682) sn[id]=sn[rmin]-8,sg[id]=0;
else if(rmin==19682) sn[id]=sn[lmax]+8,sg[id]=0;
else if(sn[lmax]==sn[rmin]) sn[id]=sn[lmax],sg[id]=1;
else sn[id]=(sn[lmax]+sn[rmin])/2,sg[id]=0;
//if(sg[id]) printf("%.3Lf+*\n",ld(sn[id])/8);
//else printf("%.3Lf\n",ld(sn[id])/8);
}
}
c=getchar();}
template<typename type>
inline READ& operator>>(type &num){
for(w=1;'0'>c||c>'9';c=getchar())
w=c=='-'? -1:1;
for(num=0;'0'<=c&&c<='9';c=getchar())
num=num*10+(c-'0');
return num*=w,*this;
}
inline READ& operator>>(game &g){
while(c!='.'&&c!='x'&&c!='o') c=getchar();
for(word i=0;i<3;++i)
g.s[i]=c,c=getchar();
while(c!='.'&&c!='x'&&c!='o') c=getchar();
for(word i=0;i<3;++i)
g.s[i+3]=c,c=getchar();
while(c!='.'&&c!='x'&&c!='o') c=getchar();
for(word i=0;i<3;++i)
g.s[i+6]=c,c=getchar();
return *this;
}
}cin;
word case_,n;
game g;
int main(){
for(cin>>case_;case_;--case_){
int sumsn=0,sumsg=0;
for(cin>>n;n;--n){
cin>>g;
const word id=*g;
sumsn+=sn[id],sumsg^=sg[id];
}
if(sumsn>0||(sumsn==0&&sumsg!=0)) puts("Alice");
else puts("Bob");
}
return 0;
}
| passed | 50_std.cpp |
#include <bits/stdc++.h>
using namespace std;
string cut(string n) {
for (int i = 0; i < n.size(); i++)
{
if (n[i] >= 'A' && n[i] <= 'Z') return n.substr(i);
}
return "";
}
int main() {
int N;
scanf("%i", &N);
string n;
getline(cin, n);
vector<pair<string, string>> names;
for (int i = 0; i < N; i++)
{
getline(cin, n);
names.push_back({cut(n), n});
}
sort(names.begin(), names.end());
for (auto n: names) cout << n.second << "\n";
} | passed | 57_std.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef __int128 i128;
const int maxn = 1e5 + 5;
struct point3
{
int x, y, z;
}q[maxn];
struct point
{
ll x, y;
bool op;
bool operator == (const point &b)const { return x == b.x && y == b.y && op == b.op; }
point operator - (const point &b)const { return (point){x - b.x, y - b.y, 0}; }
ll operator * (const point &b)const { return x * b.y - y * b.x; }
}p[maxn], p2[maxn];
int id[maxn], tp;
ld len(point a) { return sqrt(a.x * a.x + a.y * a.y); }
ld dot(point a, point b) { return a.x * b.x + a.y * b.y; }
ll cross(point a, point b, point c) { return (a - b) * (b - c); }
vector<int> vec, vec2;
int st[maxn], top;
bool vis[maxn];
void yes()
{
cout << "probably";
exit(0);
}
void no()
{
cout << "not a penguin";
exit(0);
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n, mx = 0; cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> q[i].x >> q[i].y >> q[i].z;
if (q[i].z > mx) mx = q[i].z;
}
if (mx == 0) yes();
for (int i = 1; i <= n; i++) p[i] = (point){q[i].x, q[i].y, (q[i].z && q[i].z < mx)};
sort(p + 1, p + n + 1, [&](point a, point b) { return a.x != b.x ? a.x < b.x : (a.y != b.y ? a.y < b.y : a.op < b.op); });
int l = 1;
while (l <= n)
{
int r = l;
while (r < n && p[r + 1].x == p[l].x && p[r + 1].y == p[l].y) r++;
bool f = 0; for (int i = l; i <= r; i++) f |= (p[i].op);
p2[++tp] = (point){p[l].x, p[l].y, f};
l = r + 1;
}
n = tp; for (int i = 1; i <= n; i++) p[i] = p2[i];
for (int i = 1; i <= n; i++)
{
if (p[i].op) vec.emplace_back(i);
else vec2.emplace_back(i);
}
if (!vec.size()) yes();
if (n == 1) yes();
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1, [&](int a, int b) { return p[a].x != p[b].x ? p[a].x < p[b].x : p[a].y > p[b].y; });
st[top = 1] = id[1], st[top = 2] = id[2];
double ans = 0;
for (int i = 3; i <= n; i++)
{
while (top > 1 && cross(p[st[top - 1]], p[st[top]], p[id[i]]) <= 0) top--;
st[++top] = id[i];
}
for (int i = 1; i <= top; i++) vis[st[i]] = 1;
sort(id + 1, id + n + 1, [&](int a, int b) { return p[a].x != p[b].x ? p[a].x < p[b].x : p[a].y < p[b].y; });
st[top = 1] = id[1], st[top = 2] = id[2];
for (int i = 3; i <= n; i++)
{
while (top > 1 && cross(p[st[top - 1]], p[st[top]], p[i]) >= 0) top--;
st[++top] = id[i];
}
for (int i = 1; i <= top; i++) vis[st[i]] = 1;
if (vec.size() == 1)
{
if (vis[vec[0]]) yes();
else no();
}
else if (vec.size() == 2)
{
int a = vec[0], b = vec[1];
ld mx1 = -2, mx2 = -2;
for (int i = 0; i < vec2.size(); i++)
{
int c = vec2[i];
if (cross(p[a], p[b], p[c]) == 0)
{
if (p[c].x < min(p[a].x, p[b].x) || p[c].x > max(p[a].x, p[b].x)) no();
}
if (cross(p[a], p[b], p[c]) < 0) mx1 = max(mx1, dot(p[c] - p[a], p[c] - p[b]) / len(p[c] - p[a]) / len(p[c] - p[b]));
else mx2 = max(mx2, dot(p[c] - p[a], p[c] - p[b]) / len(p[c] - p[a]) / len(p[c] - p[b]));
}
if (mx1 + mx2 > 0) no();
else yes();
}
else
{
int a = vec[0], b = vec[1], c = vec[2];
if (cross(p[a], p[b], p[c]) == 0) no();
i128 A = p[a] * p[b] + p[b] * p[c] + p[c] * p[a];
i128 B = (i128)(p[a].x * p[a].x + p[a].y * p[a].y) * (p[c].y - p[b].y) + (i128)(p[b].x * p[b].x + p[b].y * p[b].y) * (p[a].y - p[c].y) + (i128)(p[c].x * p[c].x + p[c].y * p[c].y) * (p[b].y - p[a].y);
i128 C = (i128)(p[a].x * p[a].x + p[a].y * p[a].y) * (p[b].x - p[c].x) + (i128)(p[b].x * p[b].x + p[b].y * p[b].y) * (p[c].x - p[a].x) + (i128)(p[c].x * p[c].x + p[c].y * p[c].y) * (p[a].x - p[b].x);
i128 D = (i128)(p[a].x * p[a].x + p[a].y * p[a].y) * (p[b] * p[c]) + (i128)(p[b].x * p[b].x + p[b].y * p[b].y) * (p[c] * p[a]) + (i128)(p[c].x * p[c].x + p[c].y * p[c].y) * (p[a] * p[b]);
for (int i = 3; i < vec.size(); i++)
{
int d = vec[i];
if ((A * p[d].x + B) * p[d].x + (A * p[d].y + C) * p[d].y != D) no();
}
for (int i = 0; i < vec2.size(); i++)
{
int d = vec2[i];
if (A < 0 && (A * p[d].x + B) * p[d].x + (A * p[d].y + C) * p[d].y < D) no();
if (A > 0 && (A * p[d].x + B) * p[d].x + (A * p[d].y + C) * p[d].y > D) no();
}
yes();
}
return 0;
} | passed | 78_std.cpp |
#include <cstdio>
using i32 = int;
constexpr i32 N = 5000;
i32 n, a[N + 1], b[N + 1], c[N + 1];
bool f[N + 1];
signed main() noexcept {
i32 Test;
for (scanf("%d", &Test); Test; --Test)
[]() {
scanf("%d", &n);
for (i32 i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i32 i = 1; i <= n; ++i) f[i] = false;
f[0] = true;
auto print = [](i32 l) noexcept {
printf("%d\n", l);
for (i32 k = 1; k <= l; ++k) printf("%d ", c[k]);
puts("");
};
for (i32 i = 0; i < n; ++i) {
for (i32 j = i; j < n; ++j)
if (f[j]) {
if (j != i * 2 && a[j + 1] == c[j - i + 1])
f[j + 1] = true;
else if (j != i * 2 && a[j + 1] < c[j - i + 1])
return print(i);
}
if (f[n]) return print(i);
i32 min = 114514;
for (i32 j = 0; j < n; ++j)
if (f[j] && a[j + 1] < min) min = a[j + 1];
for (i32 j = n - 1; ~j; --j)
if (f[j] && (f[j] = false, a[j + 1] == min)) f[j + 1] = true;
c[i + 1] = min;
}
print(n);
}();
return 0;
} | passed | 27_std.cpp |
#include<bits/stdc++.h>
#ifdef LOCAL
#define debug(...) printf(__VA_ARGS__)
#define edebug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#define edebug(...)
#endif
#define int ll
#define rep(i, x, y) for(int i = x; i <= y; ++i)
#define nrep(i, x, y) for(int i = x; i >= y; --i)
#define ll long long
#define pii std::pair<int,int>
#define pb emplace_back
#define fi first
#define se second
template <class T>
inline void ckmax(T &a, T b) {
if(a < b) a = b;
}
template <class T>
inline void ckmin(T &a, T b) {
if(a > b) a = b;
}
auto rt_YES = []{puts("YES");};
auto rt_Yes = []{puts("Yes");};
auto rt_NO = []{puts("NO");};
auto rt_No = []{puts("No");};
namespace IO {
#define isdigit(x) (x >= '0' && x <= '9')
inline char gc() {
return getchar();
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
double tmp = 1;
bool sign = 0;
x = 0;
char ch = gc();
for(; !isdigit(ch); ch = gc())
if(ch == '-') sign = 1;
for(; isdigit(ch); ch = gc())
x = x * 10 + (ch - '0');
if(ch == '.')
for(ch = gc(); isdigit(ch); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if(sign) x = -x;
}
inline void read(char *s) {
char ch = gc();
for(; blank(ch); ch = gc());
for(; !blank(ch); ch = gc())
*s++ = ch;
*s = 0;
}
inline void read(char &c) {
for(c = gc(); blank(c); c = gc());
}
inline void push(const char &c) {
putchar(c);
}
template <class T>
inline void print(T x) {
if(x < 0) {
x = -x;
push('-');
}
static T sta[35];
T top = 0;
do {
sta[top++] = x % 10;
x /= 10;
} while(x);
while(top)
push(sta[--top] + '0');
}
template <class T>
inline void print(T x, char lastChar) {
print(x);
push(lastChar);
}
}
using namespace IO;
int X[1000010],Y[1000010];
struct rectangle{
int sx,sy,ex,ey;
}p[500010];
int F[500010];
struct Line{
int x,sy,ey,id;
bool operator<(Line b){return x<b.x;}
}L[1000010];
struct SweepingLine{
int tree[4000010],lazy[4000010];
void pushdown(int p){
if(lazy[p]!=-1){
tree[p<<1]=tree[p<<1|1]=lazy[p];
lazy[p<<1]=lazy[p<<1|1]=lazy[p];
lazy[p]=-1;
}
}
void modify(int p,int l,int r,int x,int y,int k){
// debug("%lld %lld %lld\n",p,l,r);
if(l>=x&&r<=y)return(void)(tree[p]=lazy[p]=k);
pushdown(p);int mid=l+r>>1;
if(mid>=x)modify(p<<1,l,mid,x,y,k);
if(mid<y)modify(p<<1|1,mid+1,r,x,y,k);
}
int query(int p,int l,int r,int x){
if(l==r)return tree[p];pushdown(p);
int mid=l+r>>1;
if(mid>=x)return query(p<<1,l,mid,x);
else return query(p<<1|1,mid+1,r,x);
}
}T;
struct Segtree{
int tree[2000010];
void modify(int p,int l,int r,int x,int k){
// debug("%lld %lld %lld\n",p,l,r);
if(l==r)return(void)(tree[p]+=k);
int mid=l+r>>1;
if(mid>=x)modify(p<<1,l,mid,x,k);
else modify(p<<1|1,mid+1,r,x,k);
tree[p]=tree[p<<1]+tree[p<<1|1];
// debug("%lld %lld %lld %lld\n",p,l,r,tree[p]);
}
int query(int p,int l,int r,int x,int y){
if(l>=x&&r<=y)return tree[p];
int mid=l+r>>1,ans=0;
if(mid>=x)ans+=query(p<<1,l,mid,x,y);
if(mid<y)ans+=query(p<<1|1,mid+1,r,x,y);
return ans;
}
}ST;
std::vector<int>e[500010];
int dep[500010],sz[500010],fa[21][500010];
int dfn[500010],dfncnt,deg[500010];
void dfs(int u,int f){
fa[0][u]=f;rep(i,1,20)fa[i][u]=fa[i-1][fa[i-1][u]];
dep[u]=dep[f]+1,sz[u]=1,dfn[u]=++dfncnt;
for(int i:e[u])if(i!=f){
dfs(i,u);sz[u]+=sz[i];
}
}
int tree[500010],n;
int lowbit(int x){return x&(-x);}
void modify(int x,int k){
while(x<=n)tree[x]+=k,x+=lowbit(x);
}
int query(int x){
int ans=0;
while(x)ans+=tree[x],x-=lowbit(x);
return ans;
}
int C[500010];
void solve(){
int q;read(n),read(q);
// rep(i,1,n-1){
// int u,v;read(u),read(v);
// e[u].pb(v),e[v].pb(u);
// }
rep(i,1,n)read(p[i].sx),read(p[i].sy),read(p[i].ex),read(p[i].ey);
rep(i,1,n)X[i*2-1]=p[i].sx,X[i*2]=p[i].ex;
rep(i,1,n)Y[i*2-1]=p[i].sy,Y[i*2]=p[i].ey;
// rep(i,1,n)rep(j,1,n)if(i!=j&&p[i].sx>=p[j].sx&&p[i].sy>=p[j].sy&&p[i].ex<=p[j].ex&&p[i].ey<=p[j].ey)debug("%lld %lld\n",j,i);
std::sort(X+1,X+n*2+1);std::sort(Y+1,Y+n*2+1);
// rep(i,1,n*2)debug("%lld ",X[i]);debug("\n");
// rep(i,1,n*2)debug("%lld ",Y[i]);debug("\n");
// fflush(stdout);
int N=std::unique(X+1,X+n*2+1)-X;
rep(i,1,n)p[i].sx=std::lower_bound(X+1,X+N+1,p[i].sx)-X;
rep(i,1,n)p[i].ex=std::lower_bound(X+1,X+N+1,p[i].ex)-X;
N=std::unique(Y+1,Y+n*2+1)-Y;
rep(i,1,n)p[i].sy=std::lower_bound(Y+1,Y+N+1,p[i].sy)-Y;
rep(i,1,n)p[i].ey=std::lower_bound(Y+1,Y+N+1,p[i].ey)-Y;
rep(i,1,4*N)T.lazy[i]=-1;
// rep(i,1,n)debug("%lld %lld %lld %lld\n",p[i].sx,p[i].sy,p[i].ex,p[i].ey);
// edebug("!");
rep(i,1,n)L[i*2-1]={p[i].sx,p[i].sy,p[i].ey,i},L[i*2]={p[i].ex,p[i].sy,p[i].ey,i};
std::sort(L+1,L+n*2+1);
rep(i,1,n)F[i]=-1;
rep(i,1,n*2){
// debug("%lld %lld %lld %lld\n",L[i].x,L[i].sy,L[i].ey,L[i].id);
int X=F[L[i].id],Y=T.query(1,1,N,L[i].sy);
// debug("%lld\n",X);
// debug("%lld %lld\n",L[i].sy,L[i].ey);
if(X!=-1)T.modify(1,1,N,L[i].sy,L[i].ey,X);
else{
if(Y)e[Y].pb(L[i].id),deg[L[i].id]=1;
F[L[i].id]=Y;
// debug("%lld %lld\n",L[i].id,Y);
T.modify(1,1,N,L[i].sy,L[i].ey,L[i].id);
}
// rep(j,1,N)debug("%lld ",T.query(1,1,N,j));debug("\n");
}
// rep(i,1,n)for(int j:e[i])debug("%lld %lld\n",i,j);
rep(i,1,n)if(!deg[i])e[n+1].pb(i);++n;
dfs(n,0);
// dfs(1,0); /////////////////
// rep(i,1,n)for(int j:e[i])debug("%lld %lld\n",i,j);
// rep(i,1,n)debug("%lld %lld\n",dep[i],sz[i]);
// fflush(stdout);
while(q--){
char c;int X;
scanf("%c %lld\n",&c,&X);
// debug("%c %lld\n",c,X);fflush(stdout);
if(c=='?')print(query(X+2),'\n');
// print(query(X+1),'\n');
else{
if(C[X]){
C[X]=0;
ST.modify(1,1,n,dfn[X],-1);
if(ST.query(1,1,n,dfn[X],dfn[X]+sz[X]-1))continue;
int u=X;
nrep(i,20,0)if(fa[i][u]&&!ST.query(1,1,n,dfn[fa[i][u]],dfn[fa[i][u]]+sz[fa[i][u]]-1))
u=fa[i][u];
modify(std::max(1ll,dep[u]),-1);modify(dep[X]+1,1);
}
else{
C[X]=1;
if(ST.query(1,1,n,dfn[X],dfn[X]+sz[X]-1)){
ST.modify(1,1,n,dfn[X],1);
continue;
}
int u=X;
nrep(i,20,0)if(fa[i][u]&&!ST.query(1,1,n,dfn[fa[i][u]],dfn[fa[i][u]]+sz[fa[i][u]]-1))
u=fa[i][u];
// debug("%lld ",ST.query(1,1,n,dfn[u],dfn[u]+sz[u]-1));
// debug("%lld %lld %lld %lld %lld %lld\n",dfn[X],dfn[u],sz[u],X,u,dep[u]);
modify(std::max(1ll,dep[u]),1);modify(dep[X]+1,-1);
ST.modify(1,1,n,dfn[X],1);
}
}
}
}
signed main() {
clock_t c1 = clock();
#ifdef LOCAL
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
#endif
//------------------------------------------------------------------
solve();
//------------------------------------------------------------------
end:
std::cerr << "Time : " << clock() - c1 << " ms" << std::endl;
return 0;
} | passed | 75_std.cpp |
#include <bits/stdc++.h>
#define int long long
using namespace std;
void solve () {
int n, a, b;
cin >> n >> a >> b;
vector dp (n + 1, vector <int> (n + 1));
dp[0][0] = 1;
vector <set <int>> st (n + 1);
st[0].insert (0);
auto check = [&] (int x, int y) {
if (x > n || y > n) {
return;
}
if (! dp[x][y]) {
dp[x][y] = 1;
st[x].insert (y);
}
};
for (int w = 0; w < n; w ++) {
int al, ar, bl, br;
cin >> al >> ar >> bl >> br;
al = max (al, a);
ar = min (ar, a + n - 1);
bl = max (bl, b);
br = min (br, b + n - 1);
al -= a;
ar -= a;
bl -= b;
br -= b;
vector <pair <int, int>> p;
for (int i = al; i <= ar; i ++) {
while (true) {
auto it = st[i].lower_bound (bl);
if (it == st[i].end () || *it > br) {
break;
}
p.push_back ({i, *it + 1});
p.push_back ({i + 1, *it});
st[i].erase (it);
}
}
for (auto [x, y] : p) {
check (x, y);
}
}
int maxx = 0;
for (int i = 0; i <= n; i ++) {
for (int j = 0; j <= n; j ++) {
if (dp[i][j]) {
maxx = max (maxx, i + j);
}
}
}
cout << maxx << '\n';
}
signed main () {
ios::sync_with_stdio (false);
cin.tie (nullptr);
int T = 1;
// cin >> T;
while (T --) {
solve ();
}
return 0;
} | passed | 110_std.cpp |
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#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")
struct Functional {
int n;
vector<int> par;
int cyclesLen;
vector<int> lens;
vector<vector<int>> cycles;
// cycle id or -1
vector<int> on;
// forest
vector<vector<int>> graph;
int zeit;
vector<int> dis, fin, dep;
// root is cycle[k][l]
vector<int> ks, ls;
vector<int> hei;
Functional() {}
Functional(const vector<int> &par_) : par(par_) {
n = par.size();
for (int u = 0; u < n; ++u) {
assert(0 <= par[u]); assert(par[u] < n);
}
cycles.clear();
vector<int> vis(n, -1);
for (int s = 0; s < n; ++s) {
int u = s;
for (; !~vis[u]; u = par[u]) {
vis[u] = s;
}
if (vis[u] == s) {
vector<int> cycle;
for (int v = u; ; ) {
cycle.push_back(v);
if ((v = par[v]) == u) break;
}
cycles.push_back(cycle);
}
}
cyclesLen = cycles.size();
lens.resize(cyclesLen);
on.assign(n, -1);
for (int k = 0; k < cyclesLen; ++k) {
lens[k] = cycles[k].size();
for (const int u : cycles[k]) {
on[u] = k;
}
}
graph.assign(n, {});
for (int u = 0; u < n; ++u) if (!~on[u]) {
graph[par[u]].push_back(u);
}
zeit = 0;
dis.assign(n, -1);
fin.assign(n, -1);
dep.assign(n, 0);
ks.assign(n, -1);
ls.assign(n, -1);
hei.assign(n, 0);
for (int k = 0; k < cyclesLen; ++k) {
for (int l = 0; l < lens[k]; ++l) {
dfs(k, l, cycles[k][l]);
}
}
}
void dfs(int k, int l, int u) {
dis[u] = zeit++;
ks[u] = k;
ls[u] = l;
for (const int v : graph[u]) {
dep[v] = dep[u] + 1;
dfs(k, l, v);
chmax(hei[u], 1 + hei[v]);
}
fin[u] = zeit;
}
// min d s.t. f^d(u) = v, or -1
int dist(int u, int v) const {
if (ks[u] != ks[v]) return -1;
if (~on[v]) {
int dl = ls[v] - ls[u];
if (dl < 0) dl += lens[ks[u]];
return dep[u] + dl;
}
return (dis[v] <= dis[u] && dis[u] < fin[v]) ? (dep[u] - dep[v]) : -1;
};
};
////////////////////////////////////////////////////////////////////////////////
constexpr int DX[4] = {+1, 0, -1, 0};
constexpr int DY[4] = {0, +1, 0, -1};
const string DRUL = "DRUL";
char buf[200'010];
int M, N, K;
char S[210];
vector<string> A;
int U;
vector<vector<int>> id;
int nxt[200'010][4];
Functional F;
int main() {
for (; ~scanf("%d%d%d", &M, &N, &K); ) {
scanf("%s", S);
A.resize(M);
for (int x = 0; x < M; ++x) {
scanf("%s", buf);
A[x] = buf;
}
U = 0;
id.assign(M, vector<int>(N, -1));
for (int x = 0; x < M; ++x) for (int y = 0; y < N; ++y) if (A[x][y] == '1') {
id[x][y] = U++;
}
for (int x = 0; x < M; ++x) for (int y = 0; y < N; ++y) if (A[x][y] == '1') {
const int u = id[x][y];
for (int dir = 0; dir < 4; ++dir) {
const int xx = x + DX[dir];
const int yy = y + DY[dir];
nxt[u][dir] = (0 <= xx && xx < M && 0 <= yy && yy < N && A[xx][yy] == '1') ? id[xx][yy] : u;
}
}
#define M do_not_use
#define N do_not_use
#define A do_not_use
vector<int> par(U);
for (int s = 0; s < U; ++s) {
int u = s;
for (int k = 0; k < K; ++k) {
const int dir = DRUL.find(S[k]);
u = nxt[u][dir];
}
par[s] = u;
}
F = Functional(par);
// cerr<<"cycles = "<<F.cycles<<", graph = "<<F.graph<<endl;
// vertex u has kangaroo at the beginning of iterations [0, hs[u]]
auto hs = F.hei;
for (int u = 0; u < U; ++u) if (~F.on[u]) hs[u] = U;
// cerr<<"hs = "<<hs<<endl;
vector<int> ans;
vector<int> ss(U);
for (int s = 0; s < U; ++s) ss[s] = s;
for (int k = 0; k < K; ++k) {
const int dir = DRUL.find(S[k]);
vector<int> ts(U, -1);
for (int u = 0; u < U; ++u) {
int s = ss[u];
if (~s) {
const int v = nxt[u][dir];
int &t = ts[v];
if (~t) {
if (hs[t] < hs[s]) swap(t, s);
// cerr<<"merge "<<t<<" "<<s<<"; hs[t] = "<<hs[t]<<", hs[s] = "<<hs[s]<<endl;
for (int h = 0; h <= hs[s]; ++h) {
ans.push_back(h * K + k + 1);
}
} else {
t = s;
}
}
}
// cerr<<"k = "<<k<<", ts = "<<ts<<endl;
ss.swap(ts);
}
sort(ans.begin(), ans.end());
ans.resize(U - 1, -1);
reverse(ans.begin(), ans.end());
#undef M
#undef N
ans.resize(M * N, 0);
for (const int t : ans) {
printf("%d\n", t);
}
}
return 0;
} | passed | 47_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
mt19937_64 rng(time(0));
ll get(ll l, ll r) {
return uniform_int_distribution<ll>(l, r)(rng);
}
constexpr db eps = 1e-9;
void solve() {
int d, w;
cin >> d >> w;
vector<string> roll(d);
set<string> ws;
int S = 1 << (3 * d);
vector G(S, vector<int>());
for(int i = 0; i < d; i++) {
cin >> roll[i];
}
for(int i = 0; i < w; i++) {
string s;
cin >> s;
sort(s.begin(), s.end());
ws.insert(s);
}
int flg = 0;
vector<int> states;
vector<db> f(S), g(S);
vector<int> count(S), pw6(d + 1);
pw6[0] = 1;
for(int i = 1; i <= d; i++) pw6[i] = pw6[i - 1] * 6;
for(int i = 1; i < (S); i++) {
count[i] = count[i >> 3] + ((i & 7) != 0);
}
auto dfs = [&](auto self, int x, string t, int cur) {
if(x == d) {
sort(t.begin(), t.end());
states.push_back(cur);
if(ws.count(t)) flg = 1;
else f[cur] = get(9e8, 1e9);
for(int i = 1; i < (1 << d); i++) {
int to = cur;
for(int j = 0; j < d; j++) if(i >> j & 1) {
to &= ~(7 << (3 * j));
}
G[cur].push_back(to);
}
return;
}
for(int i = 1; i <= 6; i++) {
self(self, x + 1, t + roll[x][i - 1], cur | (i << (3 * x)));
}
};
dfs(dfs, 0, "", 0);
// cerr << "ok\n";
if(!flg) {
cout << "impossible\n";
return;
}
double delta = 0;
// for(auto st : states) {
// // ans += f[st];
// // cerr << f[st] << '\n';
// cerr << st << ": ";
// for(auto nst : G[st]) {
// cerr << nst << ' ';
// }
// cerr << '\n';
// }
// // return;
do {
g.assign(S, 0);
for(auto st : states) {
for(auto nst : G[st]) {
g[nst] += f[st];
}
}
for(int i = 0; i < S; i++) {
assert(count[i] <= d && count[i] >= 0);
g[i] /= pw6[d - count[i]];
// cerr << g[i] << '\n';
}
delta = 0;
for(auto st : states) if(f[st] >= eps) {
double nxt = 1e9;
for(auto nst : G[st]) {
nxt = fmin(nxt, g[nst]);
}
nxt += 1;
// cerr << nxt << ' ' << fabs(nxt - f[st]) << '\n';
delta += fabs(nxt - f[st]);
f[st] = nxt;
}
// cerr << "-----------------\n";
// break;
} while(delta >= eps);
db ans = 0;
for(auto st : states) {
ans += f[st];
// cerr << f[st] << '\n';
}
cout << setprecision(20) << ans / pw6[d] + 1 << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
// cin >> t;
while(t--) solve();
return 0;
} | passed | 118_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const int INF = 0x3f3f3f3f;
const i64 mod = 1e9 + 7;
const int N = 200005;
i64 n;
void solve() {
i64 l, r;
cin >> l >> r;
if(2*l > r) {
if((r-l)%2) {
cout << "Bob\n";
}
else {
cout << "Alice\n";
}
}
else if(2*l == r) {
cout << "Alice\n";
}
else {
if(l%2) {
cout << "Alice\n";
}
else {
cout << "Bob\n";
}
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int t;
cin >>t;
while(t--) {
solve();
}
return 0;
} | passed | 68_std.cpp |
#include <bits/stdc++.h>
#define int long long
#define INF 0x3f3f3f3f
#define llINF 0x3f3f3f3f3f3f3f3f
#define all(x) x.begin(), x.end()
#define alll(x, t) x.begin() + t, x.end()
#define rall(x) x.rbegin(), x.rend()
#define ull unsigned long long
#define PII pair<int, int>
#define fi first
#define se second
#define pb push_back
#define lowbit(x) ((x) & (-x))
#define debug(x) cout << #x << " = " << x << "\n";
#define debugar(x) for (auto &i : x) cout << i << " "; cout << "\n";
using namespace std;
using ll = long long;
int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);}
int lcm(int a, int b) {return (a / gcd(a, b)) * b;}
const int mod = 1e9 + 7;
inline ll qpow(ll n, ll m)//有的时候用的时候记住删掉mod,long long最多为2^63,约等于9e18
{
ll res = 1;
while (m)
{
if (m & 1)
res = res * n;
n = n * n;
m >>= 1;
}
return res;
}
inline bool isp(int x)
{
if (x == 1) return false;
if (x <= 3) return true;
for (int i = 2; i <= x / i; i++)
{
if (x % i == 0)return false;
}
return true;
}
//cout << fixed << setprecision(3) << s;
struct Bit//树状数组
{
int n;
vector<int> s;
Bit(int a) : s(a + 1, 0)
{
n = a;
}
void init(int n)
{
s.assign(n + 1, 0);
}
inline void add(int x, int value)//树状数组加点
{
while (x <= n)
{
s[x] += value;
x += lowbit(x);
}
}
inline int query(int x)//树状数组查询
{
int res = 0;
while (x > 0)
{
res += s[x];
x -= lowbit(x);
}
return res;
}
};
inline void kfk_dm()
{
//-----> 注 意 数 据 范 围 , 试 试 开 long long <-----
int n;
cin >> n;
vector<array<int, 2>> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i][0];
}
for (int i = 1; i <= n; i++) {
cin >> a[i][1];
}
vector<array<int, 2>> b = a;
sort(alll(b, 1), [&](array<int, 2> x, array<int, 2> y){
return x[0] < y[0];
});
Bit T(n);
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += (T.query(n) - T.query(b[i][1]));
T.add(b[i][1], 1);
}
cout << (ans % 2 == 0 ? "B" : "A");
for (int i = 1; i < n; i++) {
char c;
cin >> c;
int l, r, d;
cin >> l >> r >> d;
ans += ((1LL * (r - l) * d));
cout << (ans % 2 == 0 ? "B" : "A");
}
cout << "\n";
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--)
kfk_dm();
return 0;
} | passed | 82_std.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
const int maxn = 1e6 + 100;
const int lg = 31;
const int mod = 1e9 + 7;
const int inf = 3e8 + 100;
const ll INF = 1e18;
#define rep(i, a, b) for(int i = (a); i < (b); i++)
#define fast_io ios::sync_with_stdio(false);cin.tie(0);
#define file_io freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
#define pb push_back
#define F first
#define S second
#define SZ(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define sonic(x) sort(all(x));(x).resize(unique(all(x)) - (x).begin());
#define lc (id << 1)
#define rc (lc | 1)
struct frac{
ll a, b, c;
frac(ll a, ll b, ll c) : a(a), b(b), c(c) {}
bool operator > (frac f){
if(a == f.a) return __int128(b) * f.c > __int128(f.b) * c;
return a > f.a;
}
};
int n, m, c;
ll a[maxn], b[maxn];
ll dp[maxn];
frac calc(int i, int j){
int o = upper_bound(b, b + m + 1, a[j] - a[i]) - b - 1;
if(o == m) return frac(dp[i] + o - c, 0, 1);
return frac(dp[i] + o - c, a[j] - a[i] - b[o], b[o + 1] - b[o]);
}
vector<pii> opts;
int main(){
fast_io;
int t;
cin >> t;
while(t--){
cin >> n >> m >> c;
rep(i, 1, n + 1){
cin >> a[i];
a[i] += a[i - 1];
}
rep(i, 1, m + 1){
cin >> b[i];
b[i] += b[i - 1];
}
opts.clear();
opts.pb({1, 0});
rep(i, 1, n + 1){
dp[i] = calc(opts[upper_bound(all(opts), make_pair(i, inf)) - opts.begin() - 1].S, i).a;
while(!opts.empty() && opts.back().F > i && calc(i, opts.back().F) > calc(opts.back().S, opts.back().F)) opts.pop_back();
int l = max(i, opts.back().F);
int r = n + 1;
while(r - l > 1){
int mid = (l + r) >> 1;
if(calc(i, mid) > calc(opts.back().S, mid)) r = mid;
else l = mid;
}
if(r <= n) opts.pb({r, i});
}
cout << dp[n] << "\n";
}
return 0;
} | passed | 32_std.cpp |
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
typedef long long ll;
const ll inf=4e18;
int n,k,c[N],to[N],nc[N],num[N],nv[N],p[21][N],fa[N],ansc[N];
ll ansv[N];
vector<int>son[N];
int prt[N],up[N],dep[N],up1[N];
int gf(int x){if(x==prt[x])return x;return prt[x]=gf(prt[x]);}
void merge(int x,int y){x=gf(x),y=gf(y);if(x!=y)prt[x]=y;}
int kth(int x,int k){for(int i=0;i<=20;i++)if(k>>i&1)x=p[i][x];return x;}
ll gettime(int x,int nrt)
{
if(num[x]>=k)return dep[x]-dep[kth(x,k-1)];
int now=k-num[x];ll nans=dep[x];
if(!nc[c[x]])return inf;
int temp=(now-1)/nc[c[x]];now-=nc[c[x]]*temp;
nans+=1ll*(dep[to[nrt]]+1)*temp;
//cout<<"?"<<x<<" "<<nrt<<" "<<k<<" "<<num[x]<<" "<<nc[c[x]]<<" "<<now<<" "<<nans<<" "<<up1[to[nrt]]<<endl;
nans+=dep[to[nrt]]-dep[kth(up1[c[x]],now-1)]+1;
return nans;
}
vector<int>col;
void dfs1(int x,int nrt)
{
int temp=nv[c[x]];nv[c[x]]=x,col.push_back(c[x]);
num[x]=num[up[x]]+1,p[0][x]=up[x];
for(int i=1;i<=20;i++)p[i][x]=p[i-1][p[i-1][x]];
if(x==to[nrt])for(auto i:col)up1[i]=nv[i],nc[i]=num[up1[i]];
for(auto y:son[x])
{
fa[y]=x,up[y]=nv[c[y]];
dep[y]=dep[x]+1,dfs1(y,nrt);
}
nv[c[x]]=temp;
}
void dfs2(int x,int nrt)
{
ll now=gettime(x,nrt);
if(now<=ansv[to[x]]+1)ansv[x]=now,ansc[x]=c[x];else ansv[x]=ansv[to[x]]+1,ansc[x]=ansc[to[x]];
for(auto y:son[x])dfs2(y,nrt);
}
vector<int>rt;
void solve()
{
scanf("%d %d",&n,&k),rt.clear();
for(int i=1;i<=n;i++)scanf("%d",&c[i]),prt[i]=i,up[i]=0,dep[i]=0,up1[i]=0,son[i].clear(),ansc[i]=0,fa[i]=0,nv[i]=0,num[i]=0,nc[i]=0;
for(int i=1;i<=n;i++)scanf("%d",&to[i]);
for(int i=1;i<=n;i++)if(gf(i)!=gf(to[i]))merge(i,to[i]),son[to[i]].push_back(i);else rt.push_back(i);
for(int i=1;i<=n;i++)ansv[i]=inf;
for(auto x:rt)
{
col.clear(),dfs1(x,x);
vector<int>cir;int now=to[x];
while(now)cir.push_back(now),now=fa[now];
reverse(cir.begin(),cir.end());
//cout<<x<<endl;
//cout<<num[2]<<" "<<dep[2]<<" "<<nc[2]<<" "<<(dep[to[x]]+1)<<endl;
//for(int i=1;i<=n;i++)cout<<gettime(i,x)<<" ";cout<<endl;
for(auto i:cir)
{
ll now=gettime(i,x);
if(now<=ansv[to[i]]+1)ansv[i]=now,ansc[i]=c[i];else ansv[i]=ansv[to[i]]+1,ansc[i]=ansc[to[i]];
}
dfs2(x,x);
for(auto i:col)nv[i]=up1[i]=nc[i]=0;
}
ll anss=0;
//for(int i=1;i<=n;i++)cout<<ansc[i]<<" "<<ansv[i]<<endl;
for(int i=1;i<=n;i++)anss+=1ll*i*ansc[i];
printf("%lld\n",anss);
}
int T;
int main()
{
//freopen(".in","r",stdin);
scanf("%d",&T);
while(T--)solve();
return 0;
} | passed | 29_std.cpp |
#include <bits/stdc++.h>
#define ll long long
#define poly vector<int>
using namespace std;
const int N = 1e6 + 10, P = 998244353;
inline int ksm(int a, int b, int mod)
{
int z = 1;
while (b)
{
if (b & 1)
z = 1ll * z * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return z;
}
namespace Poly
{
const int mod = 998244353, g = 3, invg = 332748118;
int lim, len, rev[N], invlim;
inline void init(int l1, int l2)
{
lim = 1, len = 0;
while (lim <= l1 + l2)
lim <<= 1, len++;
for (int i = 0; i < lim; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (len - 1));
invlim = ksm(lim, mod - 2, mod);
}
inline void NTT(poly &f, int type)
{
for (int i = 0; i < lim; i++)
if (i < rev[i])
swap(f[i], f[rev[i]]);
for (int m = 2; m <= lim; m <<= 1)
{
int wn = ksm(type ? g : invg, (mod - 1) / m, mod);
for (int i = 0; i < lim; i += m)
{
int w = 1;
for (int j = 0; j < m / 2; j++)
{
int u = f[i + j], v = 1ll * w * f[i + j + m / 2] % mod;
f[i + j] = (u + v) % mod, f[i + j + m / 2] = (u - v + mod) % mod;
w = 1ll * wn * w % mod;
}
}
}
if (!type)
{
for (int i = 0; i < lim; i++)
f[i] = 1ll * f[i] * invlim % mod;
}
}
inline void mul(poly &f, poly g)
{
int lf = f.size(), lg = g.size();
init(lf, lg);
f.resize(lim), g.resize(lim);
NTT(f, 1);
NTT(g, 1);
for (int i = 0; i < lim; i++)
f[i] = 1ll * f[i] * g[i] % mod;
NTT(f, 0);
}
}
int n;
poly f, g;
poly A, B;
int fac[N], inv[N], ifac[N], a[N];
void cdq1(int l, int r)
{
if (l == r)
{
if (l)
g[l] = (g[l] + fac[l]) % P;
return;
}
int mid = l + r >> 1;
cdq1(l, mid);
A.resize(mid - l + 1);
B.resize(r - l + 1);
for (int i = l; i <= mid; i++)
A[i - l] = g[i];
for (int i = 0; i <= r - l; i++)
B[i] = fac[i];
Poly::mul(A, B);
for (int i = mid + 1; i <= r; i++)
g[i] = (g[i] + P - A[i - l]) % P;
cdq1(mid + 1, r);
}
void cdq2(int l, int r)
{
if (l == r)
{
if (l > 1)
{
f[l] = (f[l] + 1ll * fac[l] * g[l]) % P * ksm(1 + P - g[l], P - 2, P) % P;
}
return;
}
int mid = l + r >> 1;
cdq2(l, mid);
A.resize(mid - l + 1);
B.resize(r - l + 1);
for (int i = l; i <= mid; i++)
A[i - l] = f[i];
for (int i = 0; i <= r - l; i++)
B[i] = 1ll * g[i] * fac[i] % P;
Poly::mul(A, B);
for (int i = mid + 1; i <= r; i++)
f[i] = (f[i] + A[i - l]) % P;
A.resize(mid - l + 1);
B.resize(r - l + 1);
for (int i = l; i <= mid; i++)
A[i - l] = 1ll * g[i] * f[i] % P;
for (int i = 0; i <= r - l; i++)
B[i] = fac[i];
Poly::mul(A, B);
for (int i = mid + 1; i <= r; i++)
f[i] = (f[i] + A[i - l]) % P;
A.resize(mid - l + 1);
B.resize(r - l + 1);
for (int i = l; i <= mid; i++)
A[i - l] = 1ll * g[i] * fac[i] * (i > 1) % P;
for (int i = 0; i <= r - l; i++)
B[i] = fac[i];
Poly::mul(A, B);
for (int i = mid + 1; i <= r; i++)
f[i] = (f[i] + A[i - l]) % P;
cdq2(mid + 1, r);
}
int main()
{
fac[0] = fac[1] = inv[1] = ifac[0] = ifac[1] = 1;
for (int i = 2; i < N; i++)
{
fac[i] = 1ll * fac[i - 1] * i % P;
inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
ifac[i] = 1ll * ifac[i - 1] * inv[i] % P;
}
scanf("%d", &n);
g.resize(n + 1), f.resize(n + 1);
cdq1(0, n);
for (int i = 0; i <= n; i++)
{
g[i] = 1ll * g[i] * ifac[i] % P;
}
cdq2(0, n);
for (int i = 1; i <= n; i++)
{
scanf("%d", a + i);
}
int ans = 0;
for (int l = 1, r; l <= n; l = r + 1)
{
r = l;
int ma = 0, mi = n + 1;
while (r <= n)
{
int tmpr = max(ma, a[r]);
int tmpl = min(mi, a[r]);
if (tmpr == r && tmpl == l)
{
break;
}
ma = tmpr, mi = tmpl;
r++;
}
if (r > l)
ans = (ans + 1ll * f[r - l + 1] * ifac[r - l + 1] + 1) % P;
}
printf("%d", ans);
} | passed | 71_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define rep(i, n) for (int i = 0; i < (n); i += 1)
#define len(a) ((int)(a).size())
mt19937 rnd(234);
const ll inf = 1e9;
#include <bits/extc++.h>
template <typename T, typename C>
class min_cost_flow {
public:
static constexpr T eps = (T)1e-9;
struct edge {
int from;
int to;
T c;
T f;
C cost;
};
int n;
vector<vector<int>> g;
vector<edge> edges;
vector<C> d;
vector<C> pot;
__gnu_pbds::priority_queue<pair<C, int>> q;
vector<typename decltype(q)::point_iterator> its;
vector<int> pe;
const C INF_C = numeric_limits<C>::max() / 2;
explicit min_cost_flow(int n_) : n(n_), g(n), d(n), pot(n, 0), its(n), pe(n) {}
int add(int from, int to, T forward_cap, C edge_cost) {
T backward_cap = 0;
assert(0 <= from && from < n && 0 <= to && to < n);
assert(forward_cap >= 0 && backward_cap >= 0);
int id = static_cast<int>(edges.size());
g[from].push_back(id);
edges.push_back({from, to, forward_cap, 0, edge_cost});
g[to].push_back(id + 1);
edges.push_back({to, from, backward_cap, 0, -edge_cost});
return id;
}
void expath(int st) {
fill(d.begin(), d.end(), INF_C);
q.clear();
fill(its.begin(), its.end(), q.end());
its[st] = q.push({pot[st], st});
d[st] = 0;
while (!q.empty()) {
int i = q.top().second;
q.pop();
its[i] = q.end();
for (int id : g[i]) {
const edge &e = edges[id];
int j = e.to;
if (e.c - e.f > eps && d[i] + e.cost < d[j]) {
d[j] = d[i] + e.cost;
pe[j] = id;
if (its[j] == q.end()) {
its[j] = q.push({pot[j] - d[j], j});
} else {
q.modify(its[j], {pot[j] - d[j], j});
}
}
}
}
swap(d, pot);
}
pair<C, T> solve(int st, int fin) {
T flow = 0;
C cost = 0;
bool ok = true;
for (auto &e : edges) {
if (e.c - e.f > eps && e.cost + pot[e.from] - pot[e.to] < 0) {
ok = false;
break;
}
}
if (ok) {
expath(st);
} else {
vector<int> deg(n, 0);
for (int i = 0; i < n; i++) {
for (int eid : g[i]) {
auto &e = edges[eid];
if (e.c - e.f > eps) {
deg[e.to] += 1;
}
}
}
vector<int> que;
for (int i = 0; i < n; i++) {
if (deg[i] == 0) {
que.push_back(i);
}
}
for (int b = 0; b < (int)que.size(); b++) {
for (int eid : g[que[b]]) {
auto &e = edges[eid];
if (e.c - e.f > eps) {
deg[e.to] -= 1;
if (deg[e.to] == 0) {
que.push_back(e.to);
}
}
}
}
fill(pot.begin(), pot.end(), INF_C);
pot[st] = 0;
if (static_cast<int>(que.size()) == n) {
for (int v : que) {
if (pot[v] < INF_C) {
for (int eid : g[v]) {
auto &e = edges[eid];
if (e.c - e.f > eps) {
if (pot[v] + e.cost < pot[e.to]) {
pot[e.to] = pot[v] + e.cost;
pe[e.to] = eid;
}
}
}
}
}
} else {
que.assign(1, st);
vector<bool> in_queue(n, false);
in_queue[st] = true;
for (int b = 0; b < (int)que.size(); b++) {
int i = que[b];
in_queue[i] = false;
for (int id : g[i]) {
const edge &e = edges[id];
if (e.c - e.f > eps && pot[i] + e.cost < pot[e.to]) {
pot[e.to] = pot[i] + e.cost;
pe[e.to] = id;
if (!in_queue[e.to]) {
que.push_back(e.to);
in_queue[e.to] = true;
}
}
}
}
}
}
while (pot[fin] < INF_C) {
T push = numeric_limits<T>::max();
int v = fin;
while (v != st) {
const edge &e = edges[pe[v]];
push = min(push, e.c - e.f);
v = e.from;
}
v = fin;
while (v != st) {
edge &e = edges[pe[v]];
e.f += push;
edge &back = edges[pe[v] ^ 1];
back.f -= push;
v = e.from;
}
flow += push;
cost += push * pot[fin];
expath(st);
}
return {cost, flow};
}
};
int32_t main() {
if (1) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n, m;
cin >> n >> m;
vector<vector<ll>> d(n, vector<ll>(m));
vector<vector<int>> e(n, vector<int>(m));
rep(i, n) rep(j, m) {
cin >> d[i][j];
}
rep(i, n) rep(j, m) {
cin >> e[i][j];
}
auto get = [&](array<int, 4> max_counts) -> pair<array<int, 4>, ll> {
min_cost_flow<ll, ll> flow(4 + n * m + n + m + 2);
int s = 4 + n * m + n + m;
int t = s + 1;
array<int, 4> starts = {0, 1, 2, 3};
vector<vector<int>> v1(n, vector<int>(m));
vector<int> v2(n), v3(m);
rep(i, n) rep(j, m) {
v1[i][j] = 4 + i * m + j;
}
rep(i, n) {
v2[i] = 4 + n * m + i;
}
rep(j, m) {
v3[j] = 4 + n * m + n + j;
}
rep(i, 4) {
flow.add(s, starts[i], max_counts[i], 0);
}
rep(i, n) rep(j, m) {
flow.add(starts[e[i][j]], v1[i][j], 1, inf - d[i][j]);
flow.add(v1[i][j], v2[i], 1, 0);
flow.add(v1[i][j], v3[j], 1, 0);
}
rep(i, n) {
flow.add(v2[i], t, 1, 0);
}
rep(j, m) {
flow.add(v3[j], t, 1, 0);
}
auto [cost, _] = flow.solve(s, t);
array<int, 4> counts = {0, 0, 0, 0};
for (auto ei : flow.g[s]) {
auto e = flow.edges[ei];
rep(i, 4) {
if (e.to == starts[i]) {
counts[i] += e.f;
}
}
}
return {counts, cost};
};
auto [counts, cost] = get({n + m, n + m, n + m, n + m});
vector<ll> res(4, -1);
int rem = 0;
rep(i, 4) {
rem += counts[i] * i;
}
rem %= 4;
res[rem] = max(res[rem], (n + m) * inf - cost);
for (int d0 = -3; d0 <= 3; d0 += 1) {
for (int d1 = -3; d1 <= 3; d1 += 1) {
for (int d2 = -3; d2 <= 3; d2 += 1) {
int d3 = -(d0 + d1 + d2);
int sum_d = max(0, d0) + max(0, d1) + max(0, d2) + max(0, d3);
if (sum_d > 3) {
continue;
}
if ((d0 * 0 + d1 * 1 + d2 * 2 + d3 * 3) % 4 == 0) {
continue;
}
if (abs(d0 * 0 + d1 * 1 + d2 * 2 + d3 * 3) % 4 == 2 and sum_d > 2) {
continue;
}
auto max_counts = counts;
max_counts[0] += d0;
max_counts[1] += d1;
max_counts[2] += d2;
max_counts[3] += d3;
bool ok = true;
rep(i, 4) {
if (max_counts[i] < 0) {
ok = false;
break;
}
}
if (!ok) {
continue;
}
auto [new_counts, new_cost] = get(max_counts);
int rem = 0;
int sum = 0;
rep(i, 4) {
rem = rem + new_counts[i] * i;
sum += new_counts[i];
}
if (sum < n + m) {
continue;
}
rem %= 4;
ll val = (n + m) * inf - new_cost;
res[rem] = max(res[rem], val);
}
}
}
rep(i, 4) {
cout << res[i] << "\n";
}
return 0;
} | passed | 46_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n;
cin >> n;
vector<long double> x(n + 1, 0), y(n + 1, 0);
for (int i = 1; i <= n; ++i)
{
cin >> x[i] >> y[i];
}
vector<long double> prex(n + 1, 0), prey(n + 1, 0);
for (int i = 1; i <= n; ++i)
{
prex[i] = prex[i - 1] + x[i];
prey[i] = prey[i - 1] + y[i];
}
vector<long double> f(n + 1, 0), g(n + 1, 0), h(n + 1, 0);
long double sum = 0, sum2 = 0;
for (int i = 3; i <= n; ++i)
{
f[i] = f[i - 1] + y[i - 1] * prex[i - 2] - x[i - 1] * prey[i - 2];
g[i] = g[i - 1] + prex[i - 2] - (i - 2) * x[i - 1];
h[i] = h[i - 1] + prey[i - 2] - (i - 2) * y[i - 1];
long double tmp = f[i] - g[i] * y[i] + h[i] * x[i];
// cout << tmp << '\n';
// cout << g[i] << ' ' <<
sum += tmp;
}
// cout << sum << '\n';
for (int i = 2; i < n; ++i)
{
long double tmp = (x[1] - x[i]) * (y[1] - y[i + 1]) - (x[1] - x[i + 1]) * (y[1] - y[i]);
sum2 += abs(tmp);
}
// cout << sum2 << '\n';
long double ans = sum / sum2;
cout << fixed << setprecision(8) << ans << '\n';
} | passed | 67_std.cpp |
#include<bits/stdc++.h>
#ifdef LOCAL
#define debug(...) printf(__VA_ARGS__)
#define edebug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#define edebug(...)
#endif
#define int __int128
#define rep(i, x, y) for(int i = x; i <= y; ++i)
#define nrep(i, x, y) for(int i = x; i >= y; --i)
#define ll long long
#define pii std::pair<int,int>
#define pb emplace_back
#define fi first
#define se second
template <class T>
inline void ckmax(T &a, T b) {
if(a < b) a = b;
}
template <class T>
inline void ckmin(T &a, T b) {
if(a > b) a = b;
}
auto rt_YES = []{puts("YES");};
auto rt_Yes = []{puts("Yes");};
auto rt_NO = []{puts("NO");};
auto rt_No = []{puts("No");};
namespace IO {
#define isdigit(x) (x >= '0' && x <= '9')
inline char gc() {
return getchar();
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
double tmp = 1;
bool sign = 0;
x = 0;
char ch = gc();
for(; !isdigit(ch); ch = gc())
if(ch == '-') sign = 1;
for(; isdigit(ch); ch = gc())
x = x * 10 + (ch - '0');
if(ch == '.')
for(ch = gc(); isdigit(ch); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if(sign) x = -x;
}
inline void read(char *s) {
char ch = gc();
for(; blank(ch); ch = gc());
for(; !blank(ch); ch = gc())
*s++ = ch;
*s = 0;
}
inline void read(char &c) {
for(c = gc(); blank(c); c = gc());
}
inline void push(const char &c) {
putchar(c);
}
template <class T>
inline void print(T x) {
if(x < 0) {
x = -x;
push('-');
}
static T sta[35];
T top = 0;
do {
sta[top++] = x % 10;
x /= 10;
} while(x);
while(top)
push(sta[--top] + '0');
}
template <class T>
inline void print(T x, char lastChar) {
print(x);
push(lastChar);
}
}
using namespace IO;
int a[100010],b[100010],c[100010];
int n;
int findfirst(int X){
int l=1,r=n;
while(l<r){
int mid=l+r>>1;
if(c[mid]>=X)r=mid;
else l=mid+1;
}
return l;
}
int findlast(int X){
int l=1,r=n;
while(l<r){
int mid=r-(r-l>>1);
if(c[mid]<=X)l=mid;
else r=mid-1;
}
return l;
}
bool check(int k){
std::vector<int>L,R;
int S=0;
rep(i,1,n){
if(a[i]>0){
// x=(k-b[i])/a[i]
int X=(k-b[i])/a[i];
while(a[i]*X+b[i]<k)++X;
if(c[n]<X)continue;
else L.pb(findfirst(X));
}else if(a[i]<0){
int X=(k-b[i])/a[i];
while(a[i]*X+b[i]<k)--X;
if(c[1]>X)continue;
else R.pb(findlast(X));
}else if(b[i]>=k)++S;
}
std::sort(R.begin(),R.end());
int sz=R.size(),cur=0,curr=n+1;
rep(i,0,sz-1)if(R[i]>cur)++S,++cur;
std::sort(L.begin(),L.end(),std::greater<int>());
sz=L.size();
rep(i,0,sz-1)if(L[i]<curr&&curr>cur+1)++S,--curr;
return S>=(n+1)/2;
}
void solve(){
read(n);
rep(i,1,n)read(a[i]);
rep(i,1,n)read(b[i]);
rep(i,1,n)read(c[i]);
std::sort(c+1,c+n+1);
int l=-3e18,r=3e18;
while(l<r){
int mid=r-(r-l>>1);
if(check(mid))l=mid;
else r=mid-1;
}
print(l,'\n');
}
signed main() {
clock_t c1 = clock();
#ifdef LOCAL
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
#endif
//------------------------------------------------------------------
int t;read(t);while(t--)solve();
//------------------------------------------------------------------
end:
std::cerr << "Time : " << clock() - c1 << " ms" << std::endl;
return 0;
} | passed | 72_std.cpp |
#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")
////////////////////////////////////////////////////////////////////////////////
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>;
int N;
vector<int> A;
vector<int> vis;
int dim;
void dfs(int h) {
if (!vis[h]) {
vis[h] = 1;
++dim;
for (int e = 0; e < N; ++e)
if (!(h & 1 << e))
dfs(h | 1 << e);
}
}
int main() {
for (int numCases; ~scanf("%d", &numCases);) {
for (int caseId = 1; caseId <= numCases; ++caseId) {
scanf("%d", &N);
A.resize(1 << N);
for (int h = 0; h < 1 << N; ++h) {
scanf("%d", &A[h]);
}
vector<pair<int, int>> ahs(1 << N);
for (int h = 0; h < 1 << N; ++h)
ahs[h] = make_pair(A[h], h);
sort(ahs.begin(), ahs.end());
vector<Mint> wts(1 << N);
wts[0] = 1;
for (int i = 1; i < 1 << N; ++i)
wts[i] = wts[i - 1] * 2;
reverse(wts.begin(), wts.end());
wts[0] += 1;
vis.assign(1 << N, 0);
dim = 0;
Mint ans = 0;
for (const auto &ah : ahs) {
const int l = dim;
dfs(ah.second);
const int r = dim;
Mint w = 0;
for (int i = l; i < r; ++i)
w += wts[i];
ans += w * ah.first;
}
printf("%u\n", ans.x);
}
#ifndef LOCAL
break;
#endif
}
return 0;
}
| passed | 84_std.cpp |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
bool grid[MAXN][MAXN];
int dist[MAXN][MAXN][4];
// R, U, L, D
int dirs[4][2]{{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
string cdirs = "RULD";
int n, q;
void dfs(int r, int c, int dir) {
if (dist[r][c][dir] != 0) {
if (dist[r][c][dir] == -1) {
dist[r][c][dir] = -2;
}
return;
}
dist[r][c][dir] = -1;
int to_d = -1, to_r = -1, to_c = -1;
for (int i = 0; i < 4; i++) {
int cur_d = (dir + i + 3) % 4;
to_r = r + dirs[cur_d][0];
to_c = c + dirs[cur_d][1];
if (to_r < 0 || to_r >= n || to_c < 0 || to_c >= n) {
dist[r][c][dir] = 1;
return;
} else if (!grid[to_r][to_c]) {
to_d = cur_d;
dfs(to_r, to_c, to_d);
break;
}
}
if (to_d == -1 || dist[to_r][to_c][to_d] == -2) {
dist[r][c][dir] = -2;
return;
}
dist[r][c][dir] = dist[to_r][to_c][to_d] + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
for (int i = 0; i < n; i++) {
string line;
cin >> line;
for (int j = 0; j < n; j++) {
grid[i][j] = (line[j] == '#');
for (int k = 0; k < 4; k++)
dist[i][j][k] = 0;
}
}
for (int i = 0; i < q; i++) {
int r, c, dir;
char cd;
cin >> r >> c >> cd;
r--;
c--;
for (int j = 0; j < 4; j++) {
if (cdirs[j] == cd)
dir = j;
}
dfs(r, c, dir);
if (dist[r][c][dir] == -2)
cout << "-1\n";
else
cout << dist[r][c][dir] << "\n";
}
} | passed | 98_std.cpp |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> P;
#define fi first
#define se second
#define mkp make_pair
#define pb emplace_back
#define popcnt __builtin_popcountll
const ll mod = 998244353;
const int INF = 1e9;
inline ll read(){
ll x=0, f=1; char ch=getchar();
while(ch<'0' || ch>'9') { if(ch=='-') f=-1; ch=getchar(); }
while(ch>='0' && ch<='9') x=x*10+ch-'0', ch=getchar();
return x*f;
}
inline int lg2(int x){ return 31^__builtin_clz(x); }
inline ll lg2(ll x){ return 63^__builtin_clzll(x); }
inline void addmod(int &x){ if(x >= mod) x -= mod; }
inline void addmod(ll &x){ if(x >= mod) x -= mod; }
inline ll qpow(ll a,ll b){
ll ans=1, base=a;
while(b){
if(b&1) ans=ans*base%mod;
base=base*base%mod; b>>=1;
}
return ans;
}
inline ll INV(ll x){ return qpow(x, mod-2); };
int n,q; vector<int>E[500005];
int f[21][500005],dfn[500005],tim,cnt;
int get(int x,int y){ return dfn[x]<dfn[y]?x:y; }
struct Node{
int a[2][2],cnt;
Node(){ cnt=0; memset(a,0,sizeof(a)); }
}tr[10000005],pre[300005];
int lc[10000005],rc[10000005];
inline Node operator+ (Node A,Node B){
if(!A.cnt) return B; if(!B.cnt) return A;
Node C; C.cnt=A.cnt+B.cnt;
C.a[0][0]=min(A.a[0][1]+B.a[0][0],A.a[0][0]+B.a[1][0]);
C.a[0][1]=min(A.a[0][1]+B.a[0][1],A.a[0][0]+B.a[1][1]);
C.a[1][0]=min(A.a[1][1]+B.a[0][0],A.a[1][0]+B.a[1][0]);
C.a[1][1]=min(A.a[1][1]+B.a[0][1],A.a[1][0]+B.a[1][1]);
return C;
}
void pushup(int pos){ tr[pos]=tr[lc[pos]]+tr[rc[pos]]; }
void update(int l,int r,int x,Node w,int &pos){
if(!pos) pos=(++cnt);
if(l==r){
tr[pos] = w;
return;
}
int mid=(l+r)>>1;
if(x<=mid) update(l,mid,x,w,lc[pos]);
else update(mid+1,r,x,w,rc[pos]);
pushup(pos);
}
int merge(int x,int y,int l,int r){
if(!x || !y) return x^y;
if(l==r) {
if(!tr[x].cnt) return y;
return x;
}
int mid=(l+r)>>1;
lc[x]=merge(lc[x],lc[y],l,mid);
rc[x]=merge(rc[x],rc[y],mid+1,r);
pushup(x); return x;
}
void dfs(int x,int fa){
dfn[x]=(++tim), f[0][dfn[x]]=fa;
for(auto y: E[x]){
if(y==fa) continue;
dfs(y, x);
}
}
int LCA(int x,int y){
if(x==y) return x;
if((x=dfn[x])>(y=dfn[y])) swap(x,y);
int p=lg2(y-x++);
return get(f[p][x], f[p][y-(1<<p)+1]);
}
int op[300005],x[300005],y[300005],z[300005],rt[500005];
vector<pair<int,int>>tk[500005];
vector<int>qr[500005];
bool flg = 0; Node cur; int lim;
void find(int l,int r,int ql,int qr,int pos){
if(flg || !pos || r<ql || qr<l) return;
int mid=(l+r)>>1;
if(ql<=l && r<=qr) {
if((tr[pos]+cur).a[1][1] <= lim) {
cur=tr[pos]+cur;
// cout<<"merge "<<l<<"->"<<r<<" with "<<cur.a[1][1]<<endl;
return;
}else{
// cout<<"merge "<<l<<"->"<<r<<" fail"<<endl;
// cout<<"will be "<<(tr[pos]+cur).a[1][1]<<endl;
}
if(l==r) { flg=1; return; }
find(mid+1,r,ql,qr,rc[pos]);
find(l,mid,ql,qr,lc[pos]);
flg = 1;
}else{
find(mid+1,r,ql,qr,rc[pos]);
find(l,mid,ql,qr,lc[pos]);
}
}
int check(int t,int h,int pos){
flg = 0; cur = Node(); lim = h;
find(1,q,1,t,pos);
return cur.cnt;
}
int ans[300005];
void songke(int l,int r,int pos){
if(!pos) return;
if(l==r){
// if(tr[pos].cnt) cout<<l<<" ";
return;
}
int mid=(l+r)>>1;
if(l<=mid) songke(l,mid,lc[pos]);
if(mid<r) songke(mid+1,r,rc[pos]);
}
void solve(int x,int fa){
for(auto [op,w]: tk[x])
if(op==1){
update(1,q,w,pre[w],rt[x]);
}
for(auto y: E[x]){
if(y==fa) continue;
solve(y, x);
rt[x]=merge(rt[x],rt[y],1,q);
}
for(auto [op,w]: tk[x])
if(op==2) update(1,q,w,Node(),rt[x]);
// cout<<"node "<<x<<endl;
// songke(1,q,rt[x]); cout<<endl;
for(auto o: qr[x]){
// cout<<"query "<<o<<endl;
ans[o] = check(o,z[o],rt[x]);
}
}
void procedure(){
n=read(),q=read();
for(int i=1;i<n;i++){
int u=read(),v=read();
E[u].pb(v); E[v].pb(u);
}
dfs(1, 0);
for(int i=1;(1<<i)<=n;i++)
for(int j=1;j<=n-(1<<i)+1;j++)
f[i][j]=get(f[i-1][j], f[i-1][j+(1<<i-1)]);
for(int i=1;i<=q;i++){
char s[5]; scanf("%s", s);
if(s[0]=='A') {
op[i]=0;
x[i]=read(),y[i]=read(),z[i]=read();
if(dfn[x[i]]>dfn[y[i]]) swap(x[i],y[i]);
int a=LCA(x[i],y[i]);
// cout<<"addlink "<<x[i]<<","<<y[i]<<" lca="<<a<<" z="<<z[i]<<endl;
if(a==x[i]){
tk[y[i]].pb(1,i);
// cout<<y[i]<<endl;
tk[f[0][dfn[a]]].pb(2,i);
}else{
tk[x[i]].pb(1,i); tk[y[i]].pb(1,i);
// cout<<"put on "<<x[i]<<","<<y[i]<<endl;
tk[f[0][dfn[a]]].pb(2,i);
}
pre[i].cnt=1;
pre[i].a[0][1]=2*z[i];pre[i].a[1][0]=2*z[i];
pre[i].a[0][0]=2*z[i];pre[i].a[1][1]=z[i];
}else{
op[i]=1;
x[i]=read(),z[i]=2*read()-1;
qr[x[i]].pb(i);
}
}
solve(1,0);
for(int i=1;i<=q;i++)
if(op[i]==1) printf("%d\n", ans[i]);
}
int main(){
#ifdef LOCAL
assert(freopen("input.txt","r",stdin));
assert(freopen("output.txt","w",stdout));
#endif
ll T=1;
// math_init();
// NTT::init();
while(T--) procedure();
return 0;
} | passed | 37_std.cpp |
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
const int max1 = 5000;
const int mod = 998244353;
int n, father[max1 + 5];
vector <int> son[max1 + 5];
int inv[max1 + 5], fac[max1 + 5], ifac[max1 + 5];
int siz[max1 + 5], inv_pi[max1 + 5];
vector <int> left_pi[max1 + 5], right_pi[max1 + 5];
int f[max1 + 5][max1 + 5], sum[max1 + 5], ans[max1 + 5];
int C ( int n, int m )
{
if ( n < m || n < 0 || m < 0 )
return 0;
return 1LL * fac[n] * ifac[n - m] % mod * ifac[m] % mod;
}
int main ()
{
scanf("%d", &n);
for ( int i = 1; i <= n; i ++ )
son[i].push_back(0);
for ( int i = 2; i <= n; i ++ )
{
scanf("%d", &father[i]);
son[father[i]].push_back(i);
}
inv[1] = 1;
for ( int i = 2; i <= n; i ++ )
inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
fac[0] = ifac[0] = 1;
for ( int i = 1; i <= n; i ++ )
fac[i] = 1LL * fac[i - 1] * i % mod,
ifac[i] = 1LL * ifac[i - 1] * inv[i] % mod;
for ( int i = n; i >= 1; i -- )
{
int len = son[i].size() - 1;
siz[i] = 1;
for ( int j = 1; j <= len; j ++ )
siz[i] += siz[son[i][j]];
inv_pi[i] = inv[siz[i]];
for ( int j = 1; j <= len; j ++ )
inv_pi[i] = 1LL * inv_pi[i] * inv_pi[son[i][j]] % mod;
left_pi[i].resize(len + 2), left_pi[i][0] = 1;
for ( int j = 1; j <= len; j ++ )
left_pi[i][j] = 1LL * left_pi[i][j - 1] * inv_pi[son[i][j]] % mod;
right_pi[i].resize(len + 2), right_pi[i][len + 1] = 1;
for ( int j = len; j >= 1; j -- )
right_pi[i][j] = 1LL * right_pi[i][j + 1] * inv_pi[son[i][j]] % mod;
}
f[1][1] = 1;
for ( int i = 1; i <= n; i ++ )
{
int len = son[i].size() - 1;
for ( int num = 1; num <= len; num ++ )
{
int v = son[i][num];
sum[0] = 0;
for ( int j = 1; j <= n; j ++ )
sum[j] = (sum[j - 1] + 1LL * f[i][j] * C(n - j - siz[v], siz[i] - siz[v] - 1) % mod * fac[siz[i] - siz[v] - 1] % mod * left_pi[i][num - 1] % mod * right_pi[i][num + 1]) % mod;
for ( int k = 1; k <= n; k ++ )
f[v][k] = sum[k - 1];
}
ans[i] = 1LL * f[i][i] * fac[siz[i]] % mod * inv_pi[i] % mod * C(n - i, siz[i] - 1) % mod;
// printf("i = %d f = %d fac = %d inv_pi = %d siz = %d\n", i, f[i][i], fac[siz[i]], inv_pi[i], siz[i]);
}
for ( int i = 1; i <= n; i ++ )
printf("%d ", ans[i]);
printf("\n");
return 0;
} | passed | 49_std.cpp |
#include <bits/stdc++.h>
#define int long long
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, k;
std::cin >> n >> k;
std::string s;
std::cin >> s;
int tmp = n;
while (tmp % 2 == 0 and k >= 1)
{
tmp /= 2;
--k;
// 暴力一次
std::string t = "";
s = s + s;
s = ' ' + s;
for (int i = 1; i <= 2 * n; i += 2)
{
t.push_back(s[i]);
}
s = t;
}
s = ' ' + s;
int len = tmp;
std::vector<int> next(len + 1, 0);
int cnt = 0;
for (int i = 1; i <= len; i += 2)
{
next[i] = ++cnt;
}
for (int i = 2; i <= len; i += 2)
{
next[i] = ++cnt;
}
std::vector<int> ans(len + 1, 0);
std::vector ne(len + 1, std::vector<int>(61, 0));
for (int i = 1; i <= len; ++i)
{
ne[i][0] = next[i];
}
for (int j = 1; j <= 60; ++j)
{
for (int i = 1; i <= len; ++i)
{
ne[i][j] = ne[ne[i][j - 1]][j - 1];
}
}
std::string res = s;
for (int i = 1; i <= len; ++i)
{
int cur = i;
for (int j = 60; j >= 0; --j)
{
if (k >> j & 1)
{
cur = ne[cur][j];
}
}
res[cur] = s[i];
}
for (int i = len + 1; i <= n; ++i)
{
res[i] = res[(i - 1) % len + 1];
}
for (int i = 1; i <= n; ++i)
{
std::cout << res[i];
}
} | passed | 61_std.cpp |
#include <bits/stdc++.h>
#define endl '\n'
#define int ll
using ll = long long;
typedef unsigned long long ull;
using namespace std;
void GordenGhost();
const ll mod = 998244353;
signed main() {
#ifdef Gorden
freopen("in.txt", "rt", stdin);
freopen("out.txt", "wt", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int t;
cin>>t;
while (t--)
GordenGhost();
return 0;
}
void GordenGhost() {
int n,k;
cin>>n>>k;
ll ans=1;
vector<int>w(n+1);
for (int i = 1; i <= n; ++i) cin>>w[i];
sort(w.begin()+1,w.end(),greater<>());
if (w[1]==0) {
cout<<"0\n";
return;
}
if (w[k]==0) {
cout<<w[1]%mod<<'\n';
return;
}
for (int i = 1; i <=k; ++i) {
ans*=w[i];
ans%=mod;
}
ll now=k+1;
while (now+k-2<=n) {
if (w[now+k-2]==0) break;
for (int i = now; i < now+k-1 ; ++i) ans=ans*w[i]%mod;
now+=k-1;
}
cout<<ans<<'\n';
} | passed | 74_std.cpp |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <cctype>
#include <set>
namespace uvu
{
#define LOCAL ____________DONT_DEFINE_ME____________
// #define ll long long
// #define inf 0x3f3f3f3f
#define int long long
#define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 20);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
return getchar();
#else
if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
return iS == iT ? EOF : *iS++;
#endif
#define getchar ERR
}
void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher(){ Flush(); } }iamflusher;
void putc(char c)
{
#ifdef LOCAL
putchar(c);
#else
*oS++ = c;
if(oS == oT) Flush();
#endif
#define putchar ERR
}
template <typename T = int> T read()
{
T x = 0, f = 1; char c = getc();
for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
for(; isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
return x * f;
}
template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
top = 0;
if(x < 0) putc('-'), x = -x;
if(!x) sta[top = 1] = 0;
for(; x; x /= 10) sta[++top] = x % 10;
for(; top; ) putc(sta[top--] ^ 48);
if(c) putc(c);
}
int readstr(char *s, int base)
{
int idx = base - 1; char c = getc();
for(; !(isdigit(c) || isalpha(c) || c == '(' || c == '?'); c = getc());
for(; isdigit(c) || isalpha(c) || c == '(' || c == '?' ; c = getc()) s[++idx] = c;
return idx - base + 1;
}
void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args>
void printf(const char *s, T x, Args ... rest)
{
for(; *s; s++)
{
if(*s != '%') { putc(*s); continue; }
s++; if(*s == 'd') print(x, 0);
else if(*s == 'c') putc(x);
printf(s + 1, rest ...);
return;
}
}
template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
#define mod 998244353
// #define mod 1000000007
int sm(int x) { return x >= mod ? x - mod : x; }
void plus_(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); }
void mul_(int &x, int y) { x = 1ll * x * y % mod; }
int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }
#define N 400010
int n, m, A, B;
int op_[N], d[N], x_[N];
char s[2];
std::deque <pii> ql, qr;
int pos, base, val;
int sta[N], top;
int calc(int mid)
{
// printf("mid = %d\n", mid);
// int lim = n + n;
// for(int i = -lim; i <= lim; i++) dp[0][i + DT] = dp[1][i + DT] = (node){inf, 0};
// dp[op = 0][mid + DT] = (node){0, 1};
// for(int i = 1; i <= n; i++)
// {
// op ^= 1;
// for(int j = -lim; j <= lim; j++) dp[op][j + DT] = (node){inf, 0};
// for(int j = -lim; j <= lim; j++)
// {
// if(op_[i] == 0) dp[op][j + DT] += dp[op ^ 1][j + DT] + abs(j) * d[i];
// else if(op_[i] == 1 && j != -lim) dp[op][j + DT] += dp[op ^ 1][j - 1 + DT] + abs(j) + abs(j - 1) * (d[i] - 1);
// else if(op_[i] == 2)
// {
// dp[op][j + DT] += dp[op ^ 1][j + DT] + abs(j);
// if(j != lim) dp[op][j + DT] += dp[op ^ 1][j + 1 + DT] + abs(j) + abs(j + 1) * (d[i] - 1);
// }
// }
// }
// return dp[op][mid + DT].mn;
pos = mid, base = 0, val = 1;
ql.clear(), qr.clear();
auto out = [&]() -> void
{
printf("ql : "); for(pii x : ql) printf("[%d %d] ", x.fi, x.se); putc('\n');
printf("pos = %d, base = %d, val = %d\n", pos, base, val);
printf("qr : "); for(pii x : qr) printf("[%d %d] ", x.fi, x.se); putc('\n');
};
for(int i = 1; i <= n; i++)
{
auto flush = [&](int v) -> void
{
// while(pos > 0 && !ql.empty() && ql.back().fi <= v)
// {
// base += ql.back().fi * abs(pos);
// v -= ql.back().fi;
// --pos;
// qr.push_front(mkp(0, val));
// val = ql.back().se;
// ql.pop_back();
// }
// while(pos < 0 && !qr.empty() && qr.front().fi <= v)
// {
// base += qr.front().fi * abs(pos);
// v -= qr.front().fi;
// ++pos;
// ql.push_back(mkp(0, val));
// val = qr.front().se;
// qr.pop_front();
// }
while(pos > 0 && v)
{
int t = v;
if(!ql.empty()) ckmin(t, ql.back().fi);
v -= t;
base += pos * t;
int len = ql.size();
if(0 <= pos - len)
{
if(!ql.empty()) ql.back().fi -= t;
if(!qr.empty()) qr.front().fi += t;
}
else
{
ql.back().fi -= t;
ql[len - pos - 1].fi += 2 * t;
if(!qr.empty()) qr.front().fi += t;
}
if(!ql.empty() && ql.back().fi == 0)
{
pos--;
qr.push_front(mkp(0, val));
val = ql.back().se;
ql.pop_back();
}
}
while(pos < 0 && v)
{
int t = v;
if(!qr.empty()) ckmin(t, qr.front().fi);
v -= t;
base -= pos * t;
int len = qr.size();
if(pos + len <= 0)
{
if(!qr.empty()) qr.front().fi -= t;
if(!ql.empty()) ql.back().fi += t;
}
else
{
qr.front().fi -= t;
qr[-pos].fi += 2 * t;
if(!ql.empty()) ql.back().fi += t;
}
if(!qr.empty() && qr.front().fi == 0)
{
pos++;
ql.push_back(mkp(0, val));
val = qr.front().se;
qr.pop_front();
}
}
if(pos == 0)
{
if(!ql.empty()) ql.back().fi += v;
if(!qr.empty()) qr.front().fi += v;
}
// else if(0 < pos)
// {
// base += pos * v;
// int len = ql.size();
// if(0 <= pos - len)
// {
// if(!ql.empty()) ql.back().fi -= v;
// if(!qr.empty()) qr.front().fi += v;
// }
// else
// {
// ql.back().fi -= v;
// ql[len - pos - 1].fi += 2 * v;
// if(!qr.empty()) qr.front().fi += v;
// }
// }
// else if(pos < 0)
// {
// base -= pos * v;
// int len = qr.size();
// if(pos + len <= 0)
// {
// if(!qr.empty()) qr.front().fi -= v;
// if(!ql.empty()) ql.back().fi += v;
// }
// else
// {
// qr.front().fi -= v;
// qr[-pos].fi += 2 * v;
// if(!ql.empty()) ql.back().fi += v;
// }
// }
};
auto moveright = [&]() -> void
{
pos++;
};
auto moveleft = [&]() -> void
{
top = 0;
while(!ql.empty() && !ql.back().fi) sta[++top] = ql.back().se, ql.pop_back();
std::reverse(sta + 1, sta + 1 + top);
sta[++top] = val;
pos -= top;
while(!qr.empty() && !qr.front().fi) sta[++top] = qr.front().se, qr.pop_front();
sta[0] = 0;
for(int i = 1; i <= top; i++) plus_(sta[i - 1], sta[i]);
for(int i = top; i >= 1; i--) qr.push_front(mkp(0, sta[i]));
val = sta[0];
};
flush(d[i] - 1);
// printf("i = %d, flush(%d)\n", i, d[i] - 1), out();
if(op_[i] == 1) moveright();//, printf("moveright\n"), out();
if(op_[i] == 2) moveleft();//, printf("moveleft\n"), out();
flush(1);
// printf("flush(1)\n"), out();
}
// out();
int dt = 0;
while(pos < mid)
{
if(qr.empty()) debug("???\n");
++pos;
dt += qr.front().fi;
base += dt;
ql.push_back(mkp(-qr.front().fi, val));
val = qr.front().se;
qr.pop_front();
}
while(mid < pos)
{
if(ql.empty()) debug("???\n");
--pos;
dt += ql.back().fi;
base += dt;
qr.push_front(mkp(-ql.back().fi, val));
val = ql.back().se;
ql.pop_back();
}
// while(!ql.empty() && !ql.back().fi) plus_(val, ql.back().se), ql.pop_back();
// while(!qr.empty() && !qr.front().fi) plus_(val, qr.front().se), qr.pop_front();
// out();
// printf("return [%d %d]\n", base, val);
// exit(1);
return base;
}
void solve()
{
// memset(h, idx = -1, sizeof(h));
m = read(), A = read(), B = read(), n = A + B;
for(int i = 1; i <= n; i++)
{
x_[i] = read(); readstr(s, 0);
op_[i] = (s[0] == 'P' ? 1 : 2);
}
// printf("x[%d] = %d, m = %d\n", n, x_[n], m);
x_[0] = x_[n] - m;
for(int i = 1; i <= n; i++) d[i] = x_[i] - x_[i - 1];
pii res = mkp(calc(n), n);
for(int l = -n, r = n, mid, lx, rx; l <= r; )
{
mid = (l + r) >> 1;
lx = calc(mid);
rx = calc(mid + 1);
ckmin(res, mkp(lx, mid));
ckmin(res, mkp(rx, mid + 1));
if(lx <= rx) r = mid - 1;
else l = mid + 1;
}
int ans = 0;
print(res.fi, '\n');
calc(res.se); ans = val;
if(res.fi == calc(res.se - 1)) plus_(ans, val);
if(res.fi == calc(res.se + 1)) plus_(ans, val);
print(ans, '\n');
}
void init()
{
}
char _ED_;
void mian()
{
debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
init(); int T = 1;
for(; T; solve(), T--);
}
#ifdef int
#undef int
#endif
}
int main()
{
uvu::mian(); return 0;
} | passed | 103_std.cpp |
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#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")
using U = unsigned long long;
int N, K;
vector<int> A;
vector<int> ans;
void maximal(int l, int r) {
ans[l + r] = r - l;
}
U match[1010][3200], now[3200];
int main() {
for (; ~scanf("%d%d", &N, &K); ) {
A.resize(N);
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i]);
}
ans.assign(2*N + 1, 0);
memset(match, 0, sizeof(match));
{
auto as = A;
sort(as.begin(), as.end());
as.erase(unique(as.begin(), as.end()), as.end());
for (const int a : as) {
for (int i = 0; i < N; ++i) if (abs(A[i] - a) <= K) {
match[a][i>>6] |= 1ULL << (i&63);
}
}
}
// now[l] := [[l, r) is good]
memset(now, 0, sizeof(now));
now[0] |= 1ULL;
for (int r = 0; r < N; ++r) {
if (now[0] & 1ULL) {
maximal(0, r);
}
// now >>= 1;
for (int x = 0; x <= r>>6; ++x) {
(now[x] >>= 1) |= now[x + 1] << 63;
}
for (int x = 0; x <= r>>6; ++x) {
for (U f = now[x] & ~match[A[r]][x]; f; ) {
const int y = __builtin_ctzll(f);
maximal((x<<6|y) + 1, r);
f ^= 1ULL << y;
}
now[x] &= match[A[r]][x];
}
now[r>>6] |= 1ULL << (r&63);
now[(r+1)>>6] |= 1ULL << ((r+1)&63);
}
for (int i = 0; i <= N; ++i) if (now[i>>6] >> (i&63) & 1) {
maximal(i, N);
}
for (int i = 0; i < N; ++i) {
if (i > 0) printf(" ");
printf("%d", ans[i + (i + 1)]);
}
puts("");
for (int i = 1; i < N; ++i) {
if (i > 1) printf(" ");
printf("%d", ans[i + i]);
}
puts("");
}
return 0;
}
| passed | 34_std.cpp |
#include<bits/stdc++.h>
#define EL puts("Elaina")
typedef long long ll;
using namespace std;
const int maxn=1e3+3;
int n,m,q;double p,f[maxn][maxn];
inline void MyDearMoments(){
scanf("%d%d%d",&n,&m,&q),p=q;
f[1][1]=0;
for(int i=1;i<=n;++i)for(int j=1;j<=m;++j){
if(i==1&&j==1)continue;
if(i==1)f[i][j]=f[i][j-1]+p/double(4);
else if(j==1)f[i][j]=f[i-1][j]+p/double(4);
else{
double A=f[i-1][j],B=f[i][j-1];
if(A<B)swap(A,B);
if(A-B>p)f[i][j]=p/2+B;
else f[i][j]=(A-B)/p*((A-B)/2+B)+(1-(A-B)/p)*A;
f[i][j]+=B,f[i][j]/=2;
}
}
printf("%.8lf\n",f[n][m]);
}
int main(){
// freopen("a.in","r",stdin);
// freopen("a.out","w",stdout);
return MyDearMoments(),0;
} | passed | 105_std.cpp |
#include<bits/stdc++.h>
using namespace std;
string s;
int t,n,k,ans,now;
string p="nanjing";
int check(int l,int r)
{
int sum=0;
now=0;
for(int i=l;i<=r-6;i++)
{
if( s[i]==p[0] )
{
int ok=1;
for(int j=0;j<7;j++)
{
if( s[i+j]!=p[j] )ok=0;
}
sum+=ok;
}
}
return sum;
}
int main()
{
cin>>t;
while(t--)
{
ans=0;
cin>>n>>k;
s="";
cin>>s;
s=' '+s+s;
k++;
for(int i=1;i<=min({10,n,k});i++)
{
ans=max(ans,check(i,n+i-1));
}
cout<<ans<<'\n';
}
} | passed | 51_std.cpp |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
const int mod=998244353;
using namespace std;
int n,fa[100001],dep[100001];
int hed[100001],net[200001],ver[200001],tot;
void add(int x,int y){
ver[++tot]=y;
net[tot]=hed[x];
hed[x]=tot;
}
long long d[100001],g[100001],sum[100001];
int sz[100001],son[100001],top[100001];
void dfs0(int x){
int i;
d[x]=sz[x]=1;
g[x]=son[x]=0;
dep[x]=dep[fa[x]]+1;
for(i=hed[x];i;i=net[i]){
int y=ver[i];
dfs0(y);
sz[x]+=sz[y];
if(sz[y]>sz[son[x]])son[x]=y;
d[x]*=d[y]+1;d[x]%=mod;
g[x]+=g[y];
}
g[x]+=d[x];g[x]%=mod;
}
int dfx[100001],pos[100001],cnt;
void dfs1(int x){
dfx[++cnt]=x;
pos[x]=cnt;
sum[x]=sum[fa[x]]+d[x];
sum[x]%=mod;
if(son[x])top[son[x]]=top[x],dfs1(son[x]);
int i;
for(i=hed[x];i;i=net[i]){
int y=ver[i];
if(y==son[x])continue;
top[y]=y;
dfs1(y);
}
}
long long f[100001],tmp[100001];
void dfs2(int x){
f[x]=1;
int i;
for(i=hed[x];i;i=net[i]){
int y=ver[i];
f[x]*=tmp[y]+1;
f[x]%=mod;
}
tmp[x]=f[x];
vector<int>nb;
vector<long long>tl,pmul,smul;
int tt=0;
for(i=hed[x];i;i=net[i]){
int y=ver[i];
nb.push_back(y);
tl.push_back((tmp[y]+1)%mod);
tt++;
}
long long mul=1;
for(i=0;i<tt;i++)mul=mul*tl[i]%mod,pmul.push_back(mul);
mul=1;
for(i=tt-1;i>=0;i--)mul=mul*tl[i]%mod,smul.push_back(mul);
reverse(smul.begin(),smul.end());
for(i=0;i<tt;i++){
int y=nb[i];
if(y==fa[x])continue;
long long r=1;
if(i)r=r*pmul[i-1]%mod;
if(i+1<tt)r=r*smul[i+1]%mod;
tmp[x]=r;
dfs2(y);
}
nb.resize(0);
tl.resize(0);
pmul.resize(0);
smul.resize(0);
}
long long calc(int x,int y){
long long res=sum[x]+sum[y];
int p=x,q=y,r=top[p],t=top[q];
while(r!=t){
if(dep[r]<=dep[t])q=fa[t],t=top[q];
else p=fa[r],r=top[p];
}
if(dep[p]>dep[q])p=q;
res-=sum[p]*2;
res+=mod*2;res%=mod;
res+=f[p];res%=mod;
return res;
}
void solve(){
int i,q;
scanf("%d%d",&n,&q);
for(i=1;i<=n;i++)hed[i]=0;cnt=tot=0;
for(i=2;i<=n;i++)scanf("%d",&fa[i]),add(fa[i],i);
dfs0(1);
dfs1(1);
for(i=1;i<=n;i++)tmp[i]=d[i];
for(i=2;i<=n;i++)add(i,fa[i]);
dfs2(1);
while(q--){
int x,y;
scanf("%d%d",&x,&y);
printf("%lld\n",calc(x,y));
}
}
int main(){
top[1]=1;
int t;
scanf("%d",&t);
while(t--)solve();
} | passed | 4_std.cpp |
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
const int maxn = 100000 + 5, maxlg = 18;
namespace PAM {
int trans[maxn][26];
int len[maxn], fail[maxn], fa[maxn], tot, last;
int dp[maxn];
void clear() {
for (int i = 1; i <= tot; i++) {
len[i] = fail[i] = fa[i] = 0;
memset(trans[i], 0, sizeof(trans[i]));
}
tot = 2;
len[1] = 0;
len[2] = -1;
fail[1] = fa[1] = 2;
fail[2] = fa[2] = 1;
last = 2;
}
vector<int> build(string S) {
int n = S.length();
vector<int> res(n);
for (int i = 0; i < n; i++) {
while (len[last] == i || S[i - len[last] - 1] != S[i])
last = fail[last];
if (!trans[last][S[i] - 'a']) {
tot++;
fa[tot] = last;
len[tot] = len[last] + 2;
int p = fail[last];
while (S[i - len[p] - 1] != S[i])
p = fail[p];
fail[tot] = trans[p][S[i] - 'a'];
if (!fail[tot])
fail[tot] = 1;
trans[last][S[i] - 'a'] = tot;
}
res[i] = last = trans[last][S[i] - 'a'];
}
return res;
}
void calc() {
dp[1] = dp[2] = -1;
for (int i = 3; i <= tot; i++)
dp[i] = 1 + max(dp[fail[i]], dp[fa[i]]);
}
} // namespace PAM
namespace SAM {
int trans[maxn * 4][27];
int len[maxn * 4], fail[maxn * 4], tot, last;
int in[maxn * 4], out[maxn * 4], dfn;
int anc[maxlg][maxn * 4];
vector<int> G[maxn * 4];
void clear() {
for (int i = 1; i <= tot; i++) {
G[i].clear();
memset(trans[i], 0, sizeof(trans[i]));
len[i] = fail[i] = 0;
in[i] = out[i] = 0;
}
dfn = 0;
tot = last = 1;
}
int extend(int x) {
int p = last;
int np = ++tot;
len[np] = len[p] + 1;
while (p && !trans[p][x]) {
trans[p][x] = np;
p = fail[p];
}
if (!p)
fail[np] = 1;
else {
int q = trans[p][x];
if (len[p] + 1 == len[q])
fail[np] = q;
else {
int nq = ++tot;
memcpy(trans[nq], trans[q], sizeof(int) * 26);
len[nq] = len[p] + 1;
fail[nq] = fail[q];
fail[q] = fail[np] = nq;
while (p && trans[p][x] == q) {
trans[p][x] = nq;
p = fail[p];
}
}
}
last = np;
return last;
}
void dfs(int u) {
in[u] = ++dfn;
for (auto v : G[u])
dfs(v);
out[u] = dfn;
}
void init() {
for (int i = 2; i <= tot; i++)
G[fail[i]].push_back(i);
dfs(1);
for (int i = 1; i <= tot; i++)
anc[0][i] = fail[i];
for (int i = 1; i < maxlg; i++)
for (int j = 1; j <= tot; j++)
anc[i][j] = anc[i - 1][anc[i - 1][j]];
}
int locate(int nd, int l) {
for (int i = maxlg - 1; i >= 0; i--)
if (anc[i][nd] && len[anc[i][nd]] >= l)
nd = anc[i][nd];
return nd;
}
} // namespace SAM
int rt[maxn], n, rt2[maxn], rt3[maxn];
namespace Segtree {
#define ls (x << 1)
#define rs (ls | 1)
int mn[maxn << 4];
void build(int x, int l, int r) {
mn[x] = 0x3f3f3f3f;
if (l == r)
return;
int mid = (l + r) / 2;
build(ls, l, mid);
build(rs, mid + 1, r);
}
void update(int x, int l, int r, int p, int v) {
mn[x] = min(mn[x], v);
if (l == r)
return;
int mid = (l + r) / 2;
if (p <= mid)
update(ls, l, mid, p, v);
else
update(rs, mid + 1, r, p, v);
}
int query(int x, int l, int r, int ql, int qr) {
if (l == ql && r == qr)
return mn[x];
int mid = (l + r) / 2;
if (qr <= mid)
return query(ls, l, mid, ql, qr);
if (ql > mid)
return query(rs, mid + 1, r, ql, qr);
return min(query(ls, l, mid, ql, mid), query(rs, mid + 1, r, mid + 1, qr));
}
#undef ls
#undef rs
} // namespace Segtree
void solve() {
string S, rS;
cin >> S;
n = S.length();
rS = S;
reverse(rS.begin(), rS.end());
PAM::clear();
vector<int> nd = PAM::build(rS);
PAM::calc();
for (int i = 0; i < n; i++)
rt[n - i] = nd[i];
SAM::clear();
for (int i = 0; i < n; i++)
rt2[i + 1] = SAM::extend(S[i] - 'a');
SAM::extend(26);
for (int i = 0; i < n; i++)
rt3[n - i] = SAM::extend(rS[i] - 'a');
SAM::init();
int m = SAM::tot;
Segtree::build(1, 1, m);
int ans = 0;
int curmx = 0;
for (int i = 1; i <= n; i++)
curmx = max(curmx, PAM::dp[rt[i]]);
ans = max(ans, curmx);
for (int i = n; i >= 1; i--) {
int val = PAM::dp[rt[i]];
int cnd = rt[i];
if (val <= ans - 15)
continue;
while (cnd > 2 && PAM::dp[cnd] > ans - 15) {
int L = i, R = i + PAM::len[cnd] - 1;
int res = PAM::dp[cnd];
int nd = SAM::locate(rt2[R], PAM::len[cnd]);
int l = PAM::len[cnd];
while (true) {
int pos = Segtree::query(1, 1, m, SAM::in[nd], SAM::out[nd]);
if (pos == 0x3f3f3f3f)
break;
res++;
int r = pos + l - 1;
l = r - i + 1;
nd = SAM::locate(rt2[r], l);
}
ans = max(ans, res);
cnd = PAM::fail[cnd];
}
Segtree::update(1, 1, m, SAM::in[rt3[i]], i);
}
cout << ans << '\n';
}
int main() {
// freopen("55_0_input.txt", "r", stdin);
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--)
solve();
return 0;
} | passed | 53_std.cpp |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
long long pw[20], inv[4] = {0, 1, (P + 1) / 2, (P + 1) / 3};
long long sum(long long l, long long r) {
return (__int128)(l + r) * (r - l + 1) / 2 % P;
}
void get(long long x, vector< array<long long, 3> > &o, long long &l, long long &r) {
l = 0, r = 1e18;
for (auto [a, b, c] : o) {
if (!c) r = min((__int128)r, (__int128)a * x + b);
else l = max((__int128)l, (__int128)a * x + b);
}
if (l > r) l = 1, r = 0;
l = (l + 1) / 2, r = r / 2;
}
long long POLINT(vector<long long> x, long long y) {
long long res = 0;
for (int i = 0; i <= 3; ++i) {
__int128 mul = x[i] % P;
for (int j = 0; j <= 3; ++j) if (i != j) mul = mul * (y - j) % P;
for (int j = 0; j <= 3; ++j) if (i != j) mul = mul * (i > j ? inv[i - j] : P - inv[j - i]) % P;
res = (res + mul) % P;
}
return res;
}
array<long long, 3> calc(long long mnx, long long mxx, vector< array<long long, 3> > o) {
vector<long long> z;
z.push_back(mnx), z.push_back(mxx + 1);
for (auto [a, b, c] : o) {
for (auto [d, e, f] : o) {
if (e > b && a > d) {
z.push_back((e - b) / (a - d));
z.push_back((e - b) / (a - d) + 1);
}
}
}
vector<long long> tz = z;
for (auto x : tz) {
if (x & 1) z.push_back(x - 1), z.push_back(x + 1);
}
sort(z.begin(), z.end());
z.erase(unique(z.begin(), z.end()), z.end());
reverse(z.begin(), z.end());
while (z.back() != mnx) z.pop_back();
reverse(z.begin(), z.end());
while (z.back() != mxx + 1) z.pop_back();
array<long long, 3> res = {0, 0, 0};
for (int i = 0; i + 1 < (int)z.size(); ++i) {
if (z[i + 1] - z[i] <= 10) {
for (long long j = z[i]; j < z[i + 1]; ++j) {
long long L, R;
get(j, o, L, R);
if (L > R) break;
res[0] = (res[0] + R - L + 1) % P;
res[1] = (res[1] + (R - L + 1) % P * (j % P)) % P;
res[2] = (res[2] + sum(L, R)) % P;
}
continue;
}
vector<long long> val[3] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
int flg = 1;
for (long long j = z[i]; j < z[i] + 8; ++j) {
long long L, R;
get(j, o, L, R);
if (L > R) {
flg = 0;
break;
}
val[0][(j - z[i]) / 2] += (R - L + 1) % P;
val[1][(j - z[i]) / 2] += (R - L + 1) % P * (j % P) % P;
val[2][(j - z[i]) / 2] += sum(L, R);
}
if (!flg) continue;
for (int j = 0; j < 3; ++j) {
for (int k = 1; k <= 3; ++k) val[j][k] = (val[j][k] + val[j][k - 1]) % P;
res[j] = (res[j] + POLINT(val[j], (z[i + 1] - 1 - z[i]) / 2)) % P;
}
}
return res;
}
long long calc1(long long L, int a, int b, int v) {
vector< array<long long, 3> > o;
o.push_back({-2 * pw[b + 1], 2 * (L - v * pw[b]), 0});
o.push_back({20, 2 * v, 0});
o.push_back({2, -2 * v * pw[b] + 1, 1});
o.push_back({11, (1 - pw[b]) * v, 1});
o.push_back({0, 0, 1});
o.push_back({0, 2 * pw[b] - 2, 0});
array<long long, 3> res = calc(pw[a - 1], pw[a] - 1, o);
return (res[1] * 10 + v * res[0] - res[2]) % P;
}
long long calc2(long long L, int a, int b, int v) {
vector< array<long long, 3> > o;
o.push_back({-2 * pw[b + 1], 2 * (L - v * pw[b]), 0});
o.push_back({20, 2 * v, 0});
o.push_back({2, -2 * v * pw[b] + 1, 1});
o.push_back({11, (1 - pw[b]) * v - 1, 0});
o.push_back({0, 0, 1});
o.push_back({0, 2 * pw[b] - 2, 0});
array<long long, 3> res = calc(pw[a - 1], pw[a] - 1, o);
return (v * pw[b] % P * res[0] + res[2] - res[1]) % P;
}
long long pre[20][20];
long long solve(long long R) {
long long len = to_string(R).size(), res = 0;
for (int i = 1; i < len; ++i) {
for (int j = 1; i + j + 1 < len; ++j) {
res += pre[i][j];
}
}
for (int i = 1; i + 1 < len; ++i) {
int j = len - i - 1;
for (int k = 0; k <= 9; ++k) {
res += calc1(R, i, j, k) + calc2(R, i, j, k);
}
}
return res;
}
signed main() {
for (int i = pw[0] = 1; i <= 18; ++i) pw[i] = 10 * pw[i - 1];
for (int i = 1; i <= 18; ++i) {
for (int j = 1; i + j + 1 <= 18; ++j) {
for (int k = 0; k <= 9; ++k) pre[i][j] += calc1(1e18, i, j, k) + calc2(1e18, i, j, k);
}
}
int T; scanf("%d", &T);
for (int te = 1; te <= T; ++te) {
long long L, R, v = 1e18, res = 0; scanf("%lld%lld", &L, &R);
if (R == v) ++res, --R;
for (int i = 1; i <= 9; ++i) {
for (int j = 0; j <= i; ++j) {
for (int k = 1; k <= 18; ++k) {
long long x = i * pw[k] + j;
if (x >= L && x <= R) res += i - j;
}
}
}
for (int i = 1; i <= 9; ++i) {
for (int j = i + 1; j <= 9; ++j) {
int x = i * 10 + j;
if (x >= L && x <= R) res += j - i;
}
}
printf("%lld\n", ((res + solve(R) - solve(L - 1)) % P + P) % P);
}
return 0;
} | passed | 7_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using pii = pair<int, int>;
constexpr int maxn = 500000 + 10;
int a[maxn];
struct node
{
int mn, tag = -1, add, cnt;
i64 sum;
} t[maxn << 2];
void build(int o, int l, int r)
{
if (l == r) return t[o].mn = t[o].sum = a[r], void();
int m = (l + r) >> 1;
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
t[o].mn = min(t[o << 1].mn, t[o << 1 | 1].mn);
t[o].sum = t[o << 1].sum + t[o << 1 | 1].sum;
}
void mktag(int o, int l, int r, int x)
{
t[o].tag = t[o].mn = x;
t[o].add = 0;
t[o].sum = x * (r - l + 1ll);
}
void mkadd(int o, int l, int r, int x)
{
t[o].mn += x;
t[o].add += x;
t[o].sum += x * (r - l + 1ll);
}
void down(int o, int l, int r)
{
int m = (l + r) >> 1;
if (t[o].tag != -1)
{
mktag(o << 1, l, m, t[o].tag);
mktag(o << 1 | 1, m + 1, r, t[o].tag);
t[o].tag = -1;
}
if (t[o].add)
{
mkadd(o << 1, l, m, t[o].add);
mkadd(o << 1 | 1, m + 1, r, t[o].add);
t[o].add = 0;
}
}
void modify(int o, int l, int r, int L, int R, int x)
{
if (L <= l && r <= R) return mktag(o, l, r, x), void();
int m = (l + r) >> 1;
down(o, l, r);
if (L <= m) modify(o << 1, l, m, L, R, x);
if (m < R) modify(o << 1 | 1, m + 1, r, L, R, x);
t[o].mn = min(t[o << 1].mn, t[o << 1 | 1].mn);
t[o].sum = t[o << 1].sum + t[o << 1 | 1].sum;
}
void update(int o, int l, int r, int L, int R, int x)
{
if (L <= l && r <= R) return mkadd(o, l, r, x), void();
int m = (l + r) >> 1;
down(o, l, r);
if (L <= m) update(o << 1, l, m, L, R, x);
if (m < R) update(o << 1 | 1, m + 1, r, L, R, x);
t[o].mn = min(t[o << 1].mn, t[o << 1 | 1].mn);
t[o].sum = t[o << 1].sum + t[o << 1 | 1].sum;
}
i64 query(int o, int l, int r, int L, int R)
{
if (L <= l && r <= R) return t[o].sum;
int m = (l + r) >> 1;
down(o, l, r);
i64 ans = 0;
if (L <= m) ans = query(o << 1, l, m, L, R);
if (m < R) ans += query(o << 1 | 1, m + 1, r, L, R);
return ans;
}
int ok;
void find(int o, int l, int r, int L, int R, int x)
{
if (t[o].mn > x) return;
int m = (l + r) >> 1;
if (l != r) down(o, l, r);
if (L <= l && r <= R)
{
if (t[o].sum == x * (r - l + 1ll) && !t[o].cnt) return ok = 1, t[o].mn += 0x3f3f3f3f, t[o].cnt = 1, void();
else
{
if (t[o << 1].mn == x) find(o << 1, l, m, L, R, x);
if (t[o << 1 | 1].mn == x) find(o << 1 | 1, m + 1, r, L, R, x);
}
}
else
{
if (L <= m) find(o << 1, l, m, L, R, x);
if (m < R) find(o << 1 | 1, m + 1, r, L, R, x);
}
t[o].mn = min(t[o << 1].mn, t[o << 1 | 1].mn);
t[o].cnt = t[o << 1].cnt + t[o << 1 | 1].cnt;
}
void fresh(int o, int l, int r)
{
if (!t[o].cnt) return;
if (t[o].mn >= 0x3f3f3f3f && t[o].cnt == 1) t[o].mn -= 0x3f3f3f3f;
else
{
int m = (l + r) >> 1;
down(o, l, r);
if (t[o << 1].cnt) fresh(o << 1, l, m);
if (t[o << 1 | 1].cnt) fresh(o << 1 | 1, m + 1, r);
t[o].mn = min(t[o << 1].mn, t[o << 1 | 1].mn);
}
t[o].cnt = 0;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i=1;i<=n;++i) cin >> a[i];
build(1, 1, n);
while (m--)
{
int o, l, r, v;
cin >> o >> l >> r;
if (o == 1)
{
cin >> v;
modify(1, 1, n, l, r, v);
}
else if (o == 2)
{
int mex = 0;
for (;;)
{
ok = 0;
find(1, 1, n, l, r, mex);
if (!ok) break;
++mex;
}
fresh(1, 1, n);
update(1, 1, n, l, r, mex);
}
else cout << query(1, 1, n, l, r) << '\n';
}
return 0;
} | passed | 23_std.cpp |
#include <algorithm>
#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 T;
cin >> T;
while (T--) {
int n, m;
ll k;
cin >> n >> k >> m;
vector<char> alphabet;
for (int i = 0; i < min(n, 10); i++) {
alphabet.push_back(char('0' + i));
}
for (int i = 0; i < min(n - 10, 26); i++) {
alphabet.push_back(char('A' + i));
}
for (int i = 0; i < m; i++) {
char x;
cin >> x;
alphabet.erase(find(alphabet.begin(), alphabet.end(), x));
}
ll d = alphabet.size();
string ans;
while (k != 0) {
ans += alphabet[k % d];
k -= (k % d);
k /= d;
}
reverse(ans.begin(), ans.end());
cout << ans << "\n";
}
return 0;
}
| passed | 90_std.cpp |
#include<bits/stdc++.h>
#define int long long
#define F first
#define S second
#define MP make_pair
#define pb push_back
using namespace std;
void solve() {
int n;
cin >> n;
n*=3;
vector <int> g;
vector <int> a(n), b(n);
vector <bool> mark(n);
for(int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
g.pb(a[i]);
g.pb(b[i]);
}
sort(g.begin(), g.end());
g.resize(unique(g.begin(), g.end()) - g.begin());
vector <vector <int>> v(g.size()), e(g.size());
for(int i = 0; i < n; i++) {
a[i] = lower_bound(g.begin(), g.end(), a[i]) - g.begin();
b[i] = lower_bound(g.begin(), g.end(), b[i]) - g.begin();
v[a[i]].pb(i);
e[b[i]].pb(i);
}
set <pair <int, int> > st;
vector <pair <int, pair<int, int> > > ans;
for(int i = 0; i < (int)g.size(); i++) {
for(int t: v[i])
st.insert({b[t], t});
for(int t: e[i]) {
if(mark[t])
continue;
if((int)st.size() < 3) {
cout << "No" << "\n";
return;
}
int f[3];
f[0] = t + 1;
st.erase({b[t], t});
for(int i = 1; i <= 2; i++) {
pair <int, int> p = *st.begin();
st.erase(p);
f[i] = p.second+1;
mark[p.second] = true;
}
ans.pb({f[0], {f[1], f[2]}});
}
}
cout << "Yes" << "\n";
for(auto u : ans)
cout << u.first << " " << u.second.first << " " << u.second.second << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int q = 1;
cin >> q;
while (q--) {
solve();
}
} | passed | 13_std.cpp |
#include "bits/stdc++.h"
using namespace std;
#define all(x) x.begin(),x.end()
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << p.first << " " << p.second; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { string sep; for (const T &x : v) os << sep << x, sep = " "; return os; }
#ifdef LOCAL
#include "debug.h"
#else
#define debug(...) 42
#define ASSERT(...) 42
#endif
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pi;
const int oo = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
map<string,vector<string>> a,b;
int n; cin >> n;
for(int i=0;i<n;++i) {
string s; cin >> s;
a[s.substr(0,4)].push_back(s);
}
for(int i=0;i<n;++i) {
string s; cin >> s;
b[s.substr(0,4)].push_back(s);
}
vector<pair<string,string>> ans;
for(auto [k,v] : a) {
if(v.size()!=b[k].size()) {
cout << "NO\n";
exit(0);
}
for(int i=0;i<v.size();++i) {
ans.push_back({v[i],b[k][i]});
}
}
cout << "YES\n";
for(auto x : ans) {
cout << x << '\n';
}
} | passed | 91_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pil pair<int, ll>
#define x first
#define y second
inline int read() {
int x = 0, f = 0; char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 1e6 + 10;
ll inf = 0x3f3f3f3f3f3f3f3f;
int n, a[N];
vector<pil> fe[N];
ll solve(int l, int r) {
if (l > r) return 0;
auto it = upper_bound(fe[l].begin(), fe[l].end(), make_pair(r, inf));
if (it == fe[l].begin()) return 0;
--it;
return (*it).y;
}
void work() {
n = read();
for (int i = 1; i <= n; ++i)
a[i] = a[i + n] = read();
fe[n * 2].push_back(make_pair(n * 2, a[n * 2]));
for (int i = n * 2 - 1; i >= 1; --i) {
for (auto pi : fe[i + 1]) {
if (fe[i].empty() || pi.y / 2 + a[i] != fe[i].back().y) {
fe[i].push_back(make_pair(pi.x, pi.y / 2 + a[i]));
} else {
fe[i].back().x = pi.x;
}
}
if (fe[i].empty() || a[i] != fe[i].back().y) {
fe[i].push_back(make_pair(i, a[i]));
} else {
fe[i].back().x = i;
}
}
for (int i = 1; i <= n * 2; ++i) reverse(fe[i].begin(), fe[i].end());
vector<pil> e[2];
e[1].push_back(make_pair(1, a[1]));
int now = 1;
for (int i = 2; i <= n * 2; ++i) {
int last = now; now ^= 1; e[now].clear();
for (auto pi : e[last]) {
if (e[now].empty() || pi.y / 2 + a[i] != e[now].back().y) {
e[now].push_back(make_pair(pi.x, pi.y / 2 + a[i]));
} else {
e[now].back().x = pi.x;
}
}
if (e[now].empty() || a[i] != e[now].back().y) {
e[now].push_back(make_pair(i, a[i]));
} else {
e[now].back().x = i;
}
if (i > n) {
ll ans = 0;
for (auto pi : e[now]) {
if (pi.x <= i - n) continue;
ans = max(ans, pi.y + solve(i - n + 1, pi.x - 1) / 2);
}
printf("%lld ", ans);
}
} putchar('\n');
for (int i = 1; i <= n * 2; ++i) fe[i].clear();
}
int main() {
int Tt = read();
while (Tt--) work();
} | passed | 39_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define N 200010
#define K 10
int n, k;
bool B[N][2][2];
int a[N], b[N], w[N];
int ans[K][K][2][2];
bool sol(string a, int p, int q)
{
stack<int>S;
/*
-1 -> '!'
-2 -> '='
-3 -> '&'
-4 -> '|'
-5 -> '^'
-6 -> '('
*/
int len = a.length();
vector<int>ans;
// cout << "??:" << a << endl;
for (int i = 0; i < len; i ++)
{
if (a[i] == 'x') {ans.push_back(p); continue;}
if (a[i] == 'y') {ans.push_back(q); continue;}
if (a[i] == '0') {ans.push_back(0); continue;}
if (a[i] == '1') {ans.push_back(1); continue;}
if (a[i] == '(') {S.push(-6); continue;}
if (a[i] == ')')
{
if (S.empty())while(true);
while (S.top() != -6)
{
int x = S.top();
ans.push_back(x);
S.pop(); if (S.empty())while(true);
}
S.pop();
continue;
}
int op = 0;
if (a[i] == '!') op = -1;
if (a[i] == '=') op = -2;
if (a[i] == '&') op = -3;
if (a[i] == '|') op = -4;
if (a[i] == '^') op = -5;
if (S.empty())while(true);
while(S.top() > op)
{
int x = S.top();
ans.push_back(x);
S.pop();
if (S.empty())while(true);
}
S.push(op);
}
// cout << S.top() << endl;
// assert(S.empty());
if (!S.empty()) while(true);
int n = ans.size();
// cout << "GG:" << p << ' ' << q << endl;
// for (int i = 0; i < n; i ++) cout << ans[i] << ' '; cout << endl;
// cout << "??:" << S.size() << endl;
// while (!S.empty()) {cout << S.top() << ' '; S.pop();} cout << endl;
for (int i = 0; i < n; i ++)
{
if (ans[i] >= 0) S.push(ans[i]);
else
{
if (ans[i] == -1)
{
// if (S.empty())while(true);
int x = S.top(); S.pop();
S.push(!x);
}
else
{
// if (S.empty())while(true);
int x = S.top(); S.pop();
// if (S.empty())while(true);
int y = S.top(); S.pop();
int w;
if (ans[i] == -2) w = (x == y);
if (ans[i] == -3) w = (x & y);
if (ans[i] == -4) w = (x | y);
if (ans[i] == -5) w = (x ^ y);
// cout << "EEE:" << i << " " << w << endl;
S.push(w);
}
}
}
// if(S.empty())while(true);
int Ans = S.top(); S.pop();
// if(!S.empty()) while(true);
// cout << "???:" << Ans << endl;
// assert(S.empty());
return Ans;
}
bool f[1 << K][1 << K];
int Ans1, Ans2;
long long Ans3;
bitset<1 << K>P[1 << K], Q[1 << K];
int main() {
ios::sync_with_stdio(0); cin.tie(nullptr);
cin >> n >> k;
for (int i = 1; i <= n; i ++)
{
cin >> a[i] >> b[i];
a[i] --, b[i] --;
string s;
cin >> s >> w[i];
s = "(" + s + ")";
for (int p = 0; p < 2; p ++)
{
for (int q = 0; q < 2; q ++)
{
B[i][p][q] = sol(s, p, q);
}
}
}
cin >> w[n + 1];
for (int i = 0; i < k; i ++) for (int j = 0; j < k; j ++) for (int p = 0; p < 2; p ++) for (int q = 0; q < 2; q ++) ans[i][j][p][q] = n + 1;
for (int x = 1; x <= n; x ++)
{
for (int p = 0; p < 2; p ++) for (int q = 0; q < 2; q ++) if(B[x][p][q])
{
ans[a[x]][b[x]][p][q] = min(ans[a[x]][b[x]][p][q], x);
}
}
for (int i = 0; i < (1 << k); i ++) for (int j = 0; j < (1 << k); j ++)
{
int id = n + 1;
for (int x = 0; x < k; x ++) for (int y = 0; y < k; y ++)
{
int p = (i >> x) & 1, q = (j >> y) & 1;
id = min(id, ans[x][y][p][q]);
}
f[i][j] = w[id];
}
for (int i = 0; i < (1 << k); i ++)Ans1 += f[i][i];
for (int i = 0; i < (1 << k); i ++)
{
for (int j = 0; j < (1 << k); j ++) if(f[i][j])
{
Ans2 += (f[j][i]);
}
}
for (int i = 0; i < (1 << k); i ++)
{
for (int j = 0; j < (1 << k); j ++) if (f[i][j])
{
P[i][j] = 1, Q[j][i] = 1;
}
}
for (int i = 0; i < (1 << k); i ++)
{
for (int j = 0; j < (1 << k); j ++) if (!f[i][j])
{
Ans3 += (P[i] & Q[j]).count();
}
}
cout << Ans1 << ' ' << Ans2 << ' ' << Ans3 << '\n';
return 0;
} | passed | 101_std.cpp |
#include <bits/stdc++.h>
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m, x, y;
std::cin >> n >> m >> x >> y;
std::vector<int> a(n + 1), b(m + 1);
for (int i = 1; i <= n; ++i)
{
std::cin >> a[i];
}
for (int i = 1; i <= m; ++i)
{
std::cin >> b[i];
}
std::sort(begin(a) + 1, end(a));
std::sort(begin(b) + 1, end(b));
int ans = -1;
int l = 0, r = n;
auto check = [&](int t)
{
int idx = m;
for (int i = n; i >= t + 1; --i)
{
int cnt = x;
while (idx >= 1 and cnt >= 1 and a[i] >= b[idx])
{
--idx;
--cnt;
}
}
for (int i = t; i >= 1; --i)
{
int cnt = y;
while (idx >= 1 and cnt >= 1 and a[i] >= b[idx])
{
--idx;
--cnt;
}
}
if (idx == 0)
{
return true;
}
else
{
return false;
}
};
while (l <= r)
{
int mid = l + r >> 1;
if (check(mid))
{
ans = mid;
l = mid + 1;
}
else
{
r = mid - 1;
}
}
if (ans == -1)
{
std::cout << "impossible" << '\n';
}
else
{
std::cout << ans << '\n';
}
} | passed | 66_std.cpp |
#include<bits/stdc++.h>
#define For(i,a,b) for(int i=(a);i<=(b);++i)
#define Rof(i,a,b) for(int i=(a);i>=(b);--i)
using namespace std;
const int Maxn=1e4,inf=1e9;
int n,m,pos,C[60][60],a[60];
vector<int> ans[60];
inline void dfs(int x,int k)
{
if(k>(pos+1)/2) return; if(k+(pos-x+1)<(pos+1)/2) return;
if(x>pos) {if(k==(pos+1)/2) For(i,1,pos) ans[i].push_back(a[i]+1); return;}
a[x]=0,dfs(x+1,k),a[x]=1,dfs(x+1,k+1);
}
int main()
{
// freopen("1.in","r",stdin);
cin>>n>>m; C[0][0]=1; For(i,1,55)
{C[i][0]=1; For(j,1,i) C[i][j]=min(inf,C[i-1][j]+C[i-1][j-1]);}
For(p,2,m) if(C[p-1][(p+1)/2]>=n) {pos=p; break;}
if(!pos) {puts("infinity"); return 0;}
dfs(2,0); cout<<pos<<endl;
for(int i=1,j=1;i<=m;++i)
{
For(_,0,n-1) cout<<ans[j][_]; cout<<endl;
j=(j==pos?1:j+1);
}
return 0;
} | passed | 111_std.cpp |
#include <cstdint>
#include <ios>
#include <iostream>
#include <vector>
void solve() {
std::int32_t n;
std::int64_t p;
std::cin >> n >> p;
std::vector<std::int64_t> c(n);
for (auto& x : c) {
std::cin >> x;
}
for (std::int32_t i = 0; i < n; ++i) {
if (c[i] - 1 > (p - 1) / (i + 1)) {
std::cout << i << '\n';
return;
}
p -= c[i];
}
std::cout << n << '\n';
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
solve();
return 0;
}
| passed | 107_std.cpp |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int T, n, m, q, pre[maxn], nxt[maxn];
int dfn[maxn], low[maxn], tot, stk[maxn], instk[maxn], top, col[maxn], cnt;
long long lastans, sum[maxn];
vector<int> a[maxn], G[maxn];
void tarjan(int u) {
dfn[u] = low[u] = ++tot, stk[++top] = u, instk[u] = 1;
for(auto v : G[u]) {
if(!dfn[v]) tarjan(v), low[u] = min(low[u], low[v]);
else if(instk[v]) low[u] = min(low[u], dfn[v]);
}
if(dfn[u] == low[u]) {
++cnt;
while(stk[top] != u) col[stk[top]] = cnt, instk[stk[top]] = 0, --top;
col[u] = cnt, instk[u] = 0, --top;
}
}
inline void solve() {
cin >> m >> n >> q, lastans = 0;
for(int i = 1; i <= n; ++i) a[i].resize(m + 1);
for(int i = 1; i <= n; ++i) for(int j = 1; j <= m; ++j) cin >> a[i][j];
for(int i = 1; i <= n; ++i) for(int j = 1; j < m; ++j) G[a[i][j]].push_back(a[i][j + 1]);
tot = cnt = top = 0;
for(int i = 1; i <= m; ++i) dfn[i] = low[i] = col[i] = stk[i] = instk[i] = 0;
for(int i = 1; i <= m; ++i) if(!dfn[i]) tarjan(i);
for(int i = 1; i <= n; ++i) for(int j = 1; j <= m; ++j) a[i][j] = col[a[i][j]];
for(int i = 1; i <= m; ++i) {
if(a[1][i] != a[1][i - 1]) pre[i] = i, sum[i] = sum[i - 1];
else pre[i] = pre[i - 1], sum[i] = sum[i - 1] + i - pre[i];
}
for(int i = m; i; --i) {
if(i == m || a[1][i] != a[1][i + 1]) nxt[i] = i;
else nxt[i] = nxt[i + 1];
}
// for(int i = 1; i <= m; ++i) cout << col[i] << " \n"[i == m];
// for(int i = 1; i <= m; ++i) cout << pre[i] << " \n"[i == m];
// for(int i = 1; i <= m; ++i) cout << nxt[i] << " \n"[i == m];
// for(int i = 1; i <= m; ++i) cout << sum[i] << " \n"[i == m];
int id, l, r;
while(q--) {
cin >> id >> l >> r;
id = (id + lastans) % n + 1, l = (l + lastans) % m + 1, r = (r + lastans) % m + 1;
if(id < 1 || id > n || l < 1 || l > m || r < 1 || r > m || l > r) {
cout << 0 << '\n', lastans = 0;
continue;
}
int len1 = nxt[l] - l + 1, len = r - l + 1;
long long ans = 0;
if(nxt[l] >= r) ans = 1ll * len * (len - 1) / 2;
else ans = 1ll * len1 * (len1 - 1) / 2 + sum[r] - sum[nxt[l]];
cout << ans << '\n', lastans = ans;
}
for(int i = 1; i <= m; ++i) G[i].clear();
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> T;
while(T--) solve();
return 0;
} | passed | 28_std.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long double LD;
const LD eps = 1e-11;
int sgn(LD x) { return x > eps ? 1 : (x < -eps ? -1 : 0); }
struct p2 {
LD x, y;
p2 operator+(const p2 &b) const { return {x + b.x, y + b.y}; }
p2 operator-(const p2 &b) const { return {x - b.x, y - b.y}; }
p2 operator*(const LD &b) const { return {x * b, y * b}; }
p2 operator/(const LD &b) const { return {x / b, y / b}; }
p2 rot90() const { return {-y, x}; }
p2 unit() const { return *this / abs(); }
LD abs() const { return sqrtl(x * x + y * y); }
bool operator<(const p2 &b) const {
return make_pair(x, y) < make_pair(b.x, b.y);
}
friend ostream &operator<<(ostream &os, p2 a) {
return os << a.x << "," << a.y;
}
};
LD det(p2 a, p2 b) { return a.x * b.y - a.y * b.x; }
LD dis(p2 a, p2 b) { return (a - b).abs(); }
int turn(p2 a, p2 b, p2 c) { return sgn(det(b - a, c - a)); }
struct l2 {
p2 s, t;
bool operator<(l2 a) const { return make_pair(s, t) < make_pair(a.s, a.t); }
};
bool two_side(p2 a, p2 b, l2 c) {
return turn(c.s, c.t, a) * turn(c.s, c.t, b) < 0;
}
p2 l2_inter(l2 a, l2 b) { // 直线交点
LD s1 = det(a.t - a.s, b.s - a.s);
LD s2 = det(a.t - a.s, b.t - a.s);
return (b.s * s2 - b.t * s1) / (s2 - s1);
}
vector<p2> cut(const vector<p2> &c, l2 l) {
vector<p2> ret; // 线切凸包
int n = (int)c.size();
if (!n)
return ret;
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
if (turn(l.s, l.t, c[i]) >= 0)
ret.push_back(c[i]);
if (two_side(c[i], c[j], l))
ret.push_back(l2_inter(l, {c[i], c[j]}));
}
return ret;
}
struct p3 {
LD x, y, z;
p3 operator+(const p3 &b) const { return {x + b.x, y + b.y, z + b.z}; }
p3 operator-(const p3 &b) const { return {x - b.x, y - b.y, z - b.z}; }
p3 operator*(const LD &b) const { return {x * b, y * b, z * b}; }
p3 operator/(const LD &b) const { return {x / b, y / b, z / b}; }
LD abs() const { return sqrtl(x * x + y * y + z * z); }
p3 unit() const { return *this / abs(); }
};
p3 cross(p3 a, p3 b) {
return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
}
LD dot(p3 a, p3 b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
LD dis(p3 a, p3 b) { return (a - b).abs(); }
struct plane {
p3 nor;
LD m;
plane(p3 r, p3 a) : nor(r.unit()), m(dot(nor, a)) {}
};
struct l3 {
p3 s, t;
};
p3 intersect(plane a, l3 b) {
LD t = dot(a.nor, a.nor * a.m - b.s) / dot(a.nor, b.t - b.s);
return b.s + (b.t - b.s) * t;
}
const p3 O(0, 0, 0);
void work() {
vector<p3> image, screen;
for (int i = 0; i < 4; i++) {
int x, y, z;
cin >> x >> y >> z;
image.push_back({(LD)x, (LD)y, (LD)z});
}
LD w = dis(image[0], image[1]);
LD h = dis(image[0], image[3]);
LD ratio = w / h;
for (int i = 0; i < 4; i++) {
int u, v, w;
cin >> u >> v >> w;
screen.push_back({(LD)u, (LD)v, (LD)w});
}
plane img = plane(cross(image[1] - image[0], image[3] - image[0]), image[0]);
plane wall =
plane(cross(screen[1] - screen[0], screen[3] - screen[0]), screen[0]);
vector<p3> init_proj;
for (int i = 0; i < 4; i++) {
init_proj.push_back(intersect(wall, {O, image[i]}));
}
// to 2D on wall plane
vector<p2> A, B;
for (int i = 0; i < 4; i++) {
A.push_back(
(p2){dot(init_proj[i] - screen[0], (screen[1] - screen[0]).unit()),
dot(init_proj[i] - screen[0], (screen[3] - screen[0]).unit())});
}
LD area = 0;
for (int i = 0; i < 4; i++) {
area += det(A[i], A[(i + 1) % 4]);
}
if (area < 0) {
// cw -> ccw
reverse(A.begin(), A.end());
}
for (int i = 0; i < 4; i++) {
B.push_back(
(p2){dot(screen[i] - screen[0], (screen[1] - screen[0]).unit()),
dot(screen[i] - screen[0], (screen[3] - screen[0]).unit())});
}
for (int i = 0; i < 4; i++) {
A = cut(A, {B[i], B[(i + 1) % 4]});
}
for (auto &[x, y] : A) {
y *= ratio;
}
rotate(A.begin(), min_element(A.begin(), A.end()), A.end());
int mx = 0;
for (int i = 0; i < A.size(); i++) {
if (A[mx].x < A[i].x)
mx = i;
}
LD L = A[0].x, R = A[mx].x;
vector<l2> upper, lower;
for (int i = 0; i < mx; i++) {
lower.push_back({A[i], A[i + 1]});
lower.back().s.y = -lower.back().s.y;
lower.back().t.y = -lower.back().t.y;
}
for (int i = A.size() - 1; i >= mx; i--) {
upper.push_back({A[(i + 1) % A.size()], A[i]});
}
vector<l2> nu, nl;
for (auto [s, t] : upper) {
if (sgn(s.x - t.x))
nu.push_back({s, t});
}
for (auto [s, t] : lower) {
if (sgn(s.x - t.x))
nl.push_back({s, t});
}
upper = nu;
lower = nl;
auto getp = [](l2 a, LD t) { return a.s + (a.t - a.s) * t; };
auto eval = [&](l2 a, LD x) {
return getp(a, (x - a.s.x) / (a.t.x - a.s.x)).y;
};
auto merge2 = [&](vector<l2> a, vector<l2> b) -> vector<l2> {
if (a.empty())
return {};
int i = 0, j = 0;
LD it = 0, jt = 0;
while (j < b.size() && b[j].s.x < a[i].s.x) {
if (b[j].t.x < a[i].s.x)
j++;
else {
jt = (a[i].s.x - b[j].s.x) / (b[j].t.x - b[j].s.x);
break;
}
}
vector<l2> ret;
while (i < a.size() && j < b.size()) {
p2 as = getp(a[i], it);
p2 bs = getp(b[j], jt);
assert(abs(as.x - bs.x) < eps);
LD ex = min(a[i].t.x, b[j].t.x);
p2 at = getp(a[i], (ex - a[i].s.x) / (a[i].t.x - a[i].s.x));
p2 bt = getp(b[j], (ex - b[j].s.x) / (b[j].t.x - b[j].s.x));
{
if (two_side(as, at, {bs, bt}) && two_side(bs, bt, {as, at})) {
auto inter = l2_inter({as, at}, {bs, bt});
if (as.y < bs.y) {
assert(at.y > bt.y);
ret.push_back({as, inter});
ret.push_back({inter, bt});
} else {
assert(bt.y > at.y);
ret.push_back({bs, inter});
ret.push_back({inter, at});
}
} else if ((as.y + at.y) < (bs.y + bt.y)) {
ret.push_back({as, at});
} else {
ret.push_back({bs, bt});
}
it = (ex - a[i].s.x) / (a[i].t.x - a[i].s.x);
jt = (ex - b[j].s.x) / (b[j].t.x - b[j].s.x);
}
if (it > 1 - eps)
it = 0, i++;
if (jt > 1 - eps)
jt = 0, j++;
}
return ret;
};
auto ok = [&](LD l) {
auto lower2 = lower;
auto upper2 = upper;
for (auto &[s, t] : lower2)
s.x -= l, t.x -= l;
for (auto &[s, t] : upper2)
s.x -= l, t.x -= l;
auto L = merge2(lower, lower2);
auto R = merge2(upper, upper2);
int i = 0, j = 0;
LD ans = 0;
auto check = [&](int i, int j, LD x) {
ans = max(ans, eval(L[i], x) + eval(R[j], x));
};
while (i < L.size() && j < R.size()) {
check(i, j, max(L[i].s.x, R[j].s.x));
check(i, j, min(L[i].t.x, R[j].t.x));
if (L[i].t.x < R[j].t.x) {
i++;
} else {
j++;
}
}
return ans >= l;
};
LD l = 0, r = 8000;
for (int _ = 0; _ < 80; _++) {
LD mid = (l + r) / 2;
if (ok(mid))
l = mid;
else
r = mid;
}
cout << l * l / ratio << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(10) << fixed;
cerr << fixed;
int T;
cin >> T;
while (T--)
work();
} | passed | 15_std.cpp |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main(){
// freopen("t.out","w",stdout);
int T;
cin>>T;
while(T--){
cin>>n>>m;
if(n == 1 || m == 1){
puts("Yes");
if(n == 1 && m == 1){
cout<<"0\n0\n";
}
else if(n == 1){
cout<<"1\n";
for(int i = 0; i <= m - 1; i++){
cout<<i<<" ";
}cout<<endl;
}else{
for(int i = 0; i <= n - 1; i++){
cout<<i<<" ";
}cout<<endl;
cout<<"1\n";
}
}
else if(__gcd(n, m) != 1){
puts("No");
}
else{
puts("Yes");
for(int i = 1; i <= n; i++){
cout<<(i - 1) * m + 1<<" ";
}cout<<endl;
for(int j = 1; j <= m; j++){
cout<<(j - 1) * n + 1<<" ";
}cout<<endl;
}
}
return 0;
} | passed | 80_std.cpp |
#include <bits/stdc++.h>
template <class T>
inline int qlog(T a) {
double x = a;
return ((*(long long*) & x) >> 52 & 2047) - 1023;
}
#define fopen LilyWhite
void fopen(const char *s) {
static char filename[32];
sprintf(filename, "%s.in", s);
freopen(filename, "r", stdin);
sprintf(filename, "%s.out", s);
freopen(filename, "w", stdout);
}
typedef unsigned int u32;
typedef long long ll;
typedef unsigned long long u64;
#define Please return
#define AC 0
#define cin Mizuhashi
#define cout Parsee
#define endl '\n'
class Reader{
private:
static const int BUF_SIZE = 1 << 22;
char BUF_R[BUF_SIZE], *csy1, *csy2;
#ifndef _LOCAL_RUNNING
#define GC (csy1 == csy2 && (csy2 = (csy1 = BUF_R) + fread(BUF_R, 1, BUF_SIZE, stdin), csy1 == csy2) ? EOF : *csy1 ++)
#else
char cur;
#define GC (cur = getchar())
#endif
#define IL inline
public:
IL bool eof() {
#ifndef _LOCAL_RUNNING
return csy1 == csy2 && (csy2 = (csy1 = BUF_R) + fread(BUF_R, 1, BUF_SIZE, stdin), csy1 == csy2);
#else
return cur == EOF;
#endif
}
template <class Ty>
IL Reader& operator >> (Ty &t) {
int u = 0;
char c = GC;
for (t = 0; c < 48 || c > 57; c = GC)
if (c == EOF) break;
else if (c == '-') u = 1;
for ( ; c > 47 && c < 58; c = GC) t = t * 10 + (c ^ 48);
t = u ? -t : t; return *this;
}
IL Reader& operator >> (double &t) {
int tmp, u = 0; char c = GC;
for (tmp = 0; c < 48 || c > 57; c = GC)
if (c == EOF) break;
else if (c == '-') u = 1;
for ( ; c > 47 && c < 58; c = GC) tmp = tmp * 10 + (c ^ 48);
t = (tmp = u ? -tmp : tmp);
if (c == '.') {
double x = 1;
for (c = GC; c > 47 && c < 58; c = GC) t += (x /= 10) * (c ^ 48);
}
return *this;
}
IL Reader& operator >> (char *s) {
char c = GC;
for (*s = 0; c < 33; c = GC) if (c == EOF) return *this;
for ( ; c > 32; c = GC) *s ++ = c;
*s = 0; return *this;
}
IL Reader& operator >> (char &c) {
for (c = GC; c < 33; c = GC) if (c == EOF) return *this;
return *this;
}
}cin;
class Writer{
private:
static const int BUF_SIZE = 1 << 22;
char BUF_W[BUF_SIZE], *csy;
#define IL inline
inline void WC(const char c) {
if (csy - BUF_W == BUF_SIZE) fwrite(BUF_W, 1, BUF_SIZE, stdout), csy = BUF_W;
*csy ++ = c;
}
public:
Writer() : csy(BUF_W) {}
~ Writer() {fwrite(BUF_W, 1, csy - BUF_W, stdout);}
IL void flush() {fwrite(BUF_W, 1, csy - BUF_W, stdout); csy = BUF_W;}
template <class Ty>
IL Writer& operator << (Ty x) {
static int sta[32], top;
if (x < 0) {
WC('-');
do sta[top ++] = - (x % 10); while (x /= 10);
}else do sta[top ++] = x % 10; while (x /= 10);
while (top) WC(sta[-- top] ^ 48);
return *this;
}
IL Writer& operator << (const char &c) {WC(c); return *this;}
IL Writer& operator << (const char *s) {while (*s) WC(*s ++); return *this;}
}cout;
using namespace std;
typedef pair <int, int> pii;
typedef vector <ll> vi;
const int MAX_N = 1000000 + 5;
const int MAX_M = 1 << 21;
const int INF32 = 0x3f3f3f3f;
const ll INF64 = 1e18;
int N, M, b[MAX_N], h[MAX_N][3];
vi a[MAX_N], sum[MAX_N];
vector <pii> sec[MAX_N];
void solve() {
cin >> M >> N;
for (int i = 1; i <= M; i ++) cin >> b[i];
sum[0].resize(M + 1);
for (int i = 1; i <= N; i ++) {
a[i].resize(M + 1);
sum[i].resize(M + 1);
for (int j = 1; j <= M; j ++) {
cin >> a[i][j];
sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + a[i][j];
}
}
for (int i = 1; i <= M; i ++) {
if (b[i] && a[1][i]) {
cout << "-1\n";
return ;
}
}
for (int i = 1; i <= N; i ++) {
char flag = 1;
for (int j = 1; j <= M; j ++) {
if (!a[i][j]) {
flag = 0;
break;
}
}
if (flag) {
cout << "-1\n";
return ;
}
}
map <pii, int> f;
for (int i = 1; i <= M; i ++) {
if (!a[N][i]) f[pair(i, i)] = sum[N][i] - sum[N][i - 1];
}
for (int i = N - 1; i > 0; i --) {
map <pii, int> g;
vi pre(M + 1), suf(M + 2), cnt0(M + 1);
for (auto &x : pre) x = -1;
for (auto &x : suf) x = M + 1;
for (int j = 1; j <= M; j ++) {
pre[j] = a[i][j] ? pre[j - 1] : j;
cnt0[j] = cnt0[j - 1] + (!a[i][j]);
}
for (int j = M; j > 0; j --) {
suf[j] = a[i][j] ? suf[j + 1] : j;
}
auto upd = [&](const pii &k, int val) -> void {
auto it = g.find(k);
if (it == g.end()) g[k] = val;
else g[k] = min(it->second, val);
};
for (auto [seg, val] : f) {
auto [l, r] = seg;
if (cnt0[r] - cnt0[l - 1]) {
upd(seg, val);
}else {
int ll = pre[l - 1], rr = suf[r + 1];
if (ll > 0) upd(pair(ll, r), val + sum[i][l - 1] - sum[i][ll - 1]);
if (rr <= M) upd(pair(l, rr), val + sum[i][rr] - sum[i][r]);
}
}
swap(f, g);
}
for (int i = 1; i <= M; i ++) sec[i].clear();
for (auto [seg, val] : f) sec[seg.second].emplace_back(seg.first, val);
h[0][1] = h[0][2] = INF32;
for (int i = 1; i <= M; i ++) {
if (b[i]) {
h[i][0] = INF32;
h[i][1] = h[i - 1][1];
h[i][2] = min(h[i - 1][0], min(h[i - 1][1], h[i - 1][2]));
}else {
h[i][0] = min(h[i - 1][0], h[i - 1][1]);
h[i][1] = h[i - 1][1] + a[1][i];
h[i][2] = min(h[i - 1][0], min(h[i - 1][1], h[i - 1][2])) + a[1][i];
}
for (auto [l, val] : sec[i]) h[i][1] = min(h[i][1], min(h[l - 1][0], h[l - 1][2]) + val);
}
cout << min(h[M][0], h[M][1]) << '\n';
}
int main() {
int T = 1;
cin >> T;
while (T --) solve();
return 0;
} | passed | 81_std.cpp |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
#define rep(i,n) for(int i=0; i<int(n); i++)
using namespace std;
#include <initializer_list>
namespace nachia{
bool IsPrime(unsigned long long x) noexcept {
if(x <= 1) return false;
if(x % 2 == 0) return x == 2;
using u64 = unsigned long long;
using u128 = __uint128_t;
u64 d = x-1;
int s = 0;
int q = 63;
while(!(d&1)){ d >>= 1; s++; }
while(!(d >> q)) q--;
u64 r = x; for(int t=0; t<6; t++) r*=2-r*x;
u128 n2 = -(u128)x % x;
auto red = [=](u128 t) noexcept -> u64 {
u64 t2 = (t + (u128)((u64)t*-r)*x) >> 64;
return (t2 >= x || t2 < (t >> 64)) ? t2-x : t2;
};
u64 one = red(n2);
for(u64 base : { 2, 325, 9375, 28178, 450775, 9780504, 1795265022 }){
if(base%x==0) continue;
u64 a = base = red(base%x*n2);
for(int e=q-1; e>=0; e--){ a = red((u128)a*a); if((d>>e)&1) a = red((u128)a*base); }
if(a == one) continue;
for(int t=1; t<s&&a!=x-one; t++) a = red((u128)a*a);
if(a != x-one) return false;
}
return true;
}
} // namespace nachia
namespace nachia{
int Popcount(unsigned long long c) noexcept {
#ifdef __GNUC__
return __builtin_popcountll(c);
#else
c = (c & (~0ull/3)) + ((c >> 1) & (~0ull/3));
c = (c & (~0ull/5)) + ((c >> 2) & (~0ull/5));
c = (c & (~0ull/17)) + ((c >> 4) & (~0ull/17));
c = (c * (~0ull/257)) >> 56;
return c;
#endif
}
// please ensure x != 0
int MsbIndex(unsigned long long x) noexcept {
#ifdef __GNUC__
return 63 - __builtin_clzll(x);
#else
using u64 = unsigned long long;
int q = (x >> 32) ? 32 : 0;
auto m = x >> q;
constexpr u64 hi = 0x88888888;
constexpr u64 mi = 0x11111111;
m = (((m | ~(hi - (m & ~hi))) & hi) * mi) >> 35;
m = (((m | ~(hi - (m & ~hi))) & hi) * mi) >> 31;
q += (m & 0xf) << 2;
q += 0x3333333322221100 >> (((x >> q) & 0xf) << 2) & 0xf;
return q;
#endif
}
// please ensure x != 0
int LsbIndex(unsigned long long x) noexcept {
#ifdef __GNUC__
return __builtin_ctzll(x);
#else
return MsbIndex(x & -x);
#endif
}
}
namespace nachia{
std::vector<std::pair<unsigned long long, int>> Factorize(unsigned long long x){
if(x == 1) return {};
if(IsPrime(x)) return {{x,1}};
using u64 = unsigned long long;
using u128 = __uint128_t;
u64 X = x;
std::vector<u64> p;
for(u64 i=2; i<100; i+=1+i%2) if(x%i==0){ p.push_back(i); while(x%i==0) x/=i; }
u64 r=1; u128 n2=1;
auto updX = [&](){
r = x; for(int t=0; t<6; t++) r*=2-r*x;
n2 = -(u128)x % x;
};
auto red = [&](u128 t) noexcept -> u64 {
u64 s = ((u128)x*((u64)t*r)) >> 64;
u64 t2 = t >> 64;
return t2-s + (t2 < s ? x : 0);
};
auto mult = [&](u64 a, u64 b) noexcept { return red((u128)red((u128)a*n2)*b); };
auto gcd = [](u64 a, u64 b) noexcept {
if(!a || !b) return a|b;
int q = LsbIndex(a|b);
b >>= LsbIndex(b);
a >>= LsbIndex(a);
while(a!=b){
if(a<b){ b-=a; b>>=LsbIndex(b); }
else{ a-=b; a>>=LsbIndex(a); }
}
return a<<q;
};
static u64 v = 7001;
p.push_back(x);
for(int pi=p.size()-1; pi<(int)p.size(); pi++) while(p[pi] != 1 && !IsPrime(p[pi])){
x = p[pi]; updX();
while(p[pi] == x){
v^=v<<13; v^=v>>7; v^=v<<17; // Xorshift https://www.jstatsoft.org/article/download/v008i14/916
u64 c = red(v); if(c == 0) continue;
auto f = [=](u64 a) noexcept -> u64 { return red((u128)a*a+c); };
u64 a=0, b=f(a);
u64 buf = 1, sz = 1, nx = 10;
while(true){
while(nx != sz && a != b){
buf = mult(buf, a<=b?b-a:a-b); sz++;
a = f(a); b = f(f(b));
}
u64 g = gcd(buf, x);
if(g != 1){
while(p[pi] % g == 0) p[pi] /= g;
p.push_back(g);
break;
}
if(a == b) break;
nx = sz * 3 / 2;
}
}
}
std::vector<std::pair<u64, int>> res;
for(u64 q : p) if(q != 1){
int e=0; while(X%q == 0){ e++; X/=q; }
if(e) res.push_back({ q, e });
}
return res;
}
unsigned long long Totient(unsigned long long x){
auto F = Factorize(x);
for(auto f : F) x -= x / f.first;
return x;
}
} // namespace nachia
namespace nachia{
template<class Int> Int Gcd(Int a, Int b){
if(a < 0) a = -a;
if(b < 0) b = -b;
if(!a || !b) return a + b;
while(b){ a %= b; std::swap(a, b); }
return a;
}
}
namespace nachia{
struct EnumerateDivisors{
using u64 = unsigned long long;
u64 raw;
std::vector<u64> divord;
std::vector<int> dims;
std::vector<int> dimcum;
std::vector<std::pair<u64, int>> I;
std::vector<std::pair<u64, int>> pfs;
EnumerateDivisors(
std::vector<std::pair<unsigned long long, int>> pf
)
: pfs(std::move(pf))
{
raw = 1;
int n = pfs.size();
dims.resize(n);
dimcum.assign(n+1, 1);
divord = {1};
for(int i=0; i<n; i++){
dims[i] = pfs[i].second;
dimcum[i+1] = dimcum[i] * (dims[i] + 1);
int q = dimcum[i];
for(int t=q; t<dimcum[i+1]; t++) divord.push_back(divord[t-q] * pfs[i].first);
for(int t=0; t<pfs[i].second; t++) raw *= pfs[i].first;
}
I.resize(divord.size());
for(int i=0; i<dimcum.back(); i++) I[i] = std::make_pair(divord[i], i);
std::sort(I.begin(), I.end());
}
EnumerateDivisors(unsigned long long n)
: EnumerateDivisors(Factorize(n)) {}
int id(unsigned long long d) const {
d = Gcd(d, raw);
return std::lower_bound(I.begin(), I.end(), d, [](std::pair<u64, int> e, u64 v){ return e.first < v; })->second;
}
int numDivisors() const { return dimcum.back(); }
unsigned long long divisor(int i){ return divord[i]; }
template<class Elem>
void Zeta(std::vector<Elem>& A) const {
int Z = numDivisors();
for(int d=0; d<(int)dims.size(); d++){
int w = dims[d] * dimcum[d];
int y = dimcum[d];
for(int i=0; i<Z; i+=dimcum[d+1]){
for(int j=0; j<w; j++) A[i+j+y] += A[i+j];
}
}
}
template<class Elem>
void RevZeta(std::vector<Elem>& A) const {
int Z = numDivisors();
for(int d=0; d<(int)dims.size(); d++){
int w = dims[d] * dimcum[d];
int y = dimcum[d];
for(int i=0; i<Z; i+=dimcum[d+1]){
for(int j=w-1; j>=0; j--) A[i+j] += A[i+j+y];
}
}
}
template<class Elem>
void Mobius(std::vector<Elem>& A) const {
int Z = numDivisors();
for(int d=0; d<(int)dims.size(); d++){
int w = dims[d] * dimcum[d];
int y = dimcum[d];
for(int i=0; i<Z; i+=dimcum[d+1]){
for(int j=w-1; j>=0; j--) A[i+j+y] -= A[i+j];
}
}
}
template<class Elem>
void RevMobius(std::vector<Elem>& A) const {
int Z = numDivisors();
for(int d=0; d<(int)dims.size(); d++){
int w = dims[d] * dimcum[d];
int y = dimcum[d];
for(int i=0; i<Z; i+=dimcum[d+1]){
for(int j=0; j<w; j++) A[i+j] -= A[i+j+y];
}
}
}
};
}
namespace nachia{
// ax + by = gcd(a,b)
// return ( x, - )
std::pair<long long, long long> ExtGcd(long long a, long long b){
long long x = 1, y = 0;
while(b){
long long u = a / b;
std::swap(a-=b*u, b);
std::swap(x-=y*u, y);
}
return std::make_pair(x, a);
}
} // namespace nachia
namespace nachia{
template<unsigned int MOD>
struct StaticModint{
private:
using u64 = unsigned long long;
unsigned int x;
public:
using my_type = StaticModint;
template< class Elem >
static Elem safe_mod(Elem x){
if(x < 0){
if(0 <= x+MOD) return x + MOD;
return MOD - ((-(x+MOD)-1) % MOD + 1);
}
return x % MOD;
}
StaticModint() : x(0){}
StaticModint(const my_type& a) : x(a.x){}
StaticModint& operator=(const my_type&) = default;
template< class Elem >
StaticModint(Elem v) : x(safe_mod(v)){}
unsigned int operator*() const { return x; }
my_type& operator+=(const my_type& r) { auto t = x + r.x; if(t >= MOD) t -= MOD; x = t; return *this; }
my_type operator+(const my_type& r) const { my_type res = *this; return res += r; }
my_type& operator-=(const my_type& r) { auto t = x + MOD - r.x; if(t >= MOD) t -= MOD; x = t; return *this; }
my_type operator-(const my_type& r) const { my_type res = *this; return res -= r; }
my_type operator-() const noexcept { my_type res = *this; res.x = ((res.x == 0) ? 0 : (MOD - res.x)); return res; }
my_type& operator*=(const my_type& r){ x = (u64)x * r.x % MOD; return *this; }
my_type operator*(const my_type& r) const { my_type res = *this; return res *= r; }
bool operator==(const my_type& r) const { return x == r.x; }
my_type pow(unsigned long long i) const {
my_type a = *this, res = 1;
while(i){ if(i & 1){ res *= a; } a *= a; i >>= 1; }
return res;
}
my_type inv() const { return my_type(ExtGcd(x, MOD).first); }
unsigned int val() const { return x; }
static constexpr unsigned int mod() { return MOD; }
static my_type raw(unsigned int val) { auto res = my_type(); res.x = val; return res; }
my_type& operator/=(const my_type& r){ return operator*=(r.inv()); }
my_type operator/(const my_type& r) const { return operator*(r.inv()); }
};
} // namespace nachia
using Modint = nachia::StaticModint<998244353>;
int main(){
ios::sync_with_stdio(false); cin.tie(nullptr);
i64 N, M; cin >> N >> M;
auto divs = nachia::EnumerateDivisors(N);
i64 n = divs.numDivisors();
vector<i64> D(n); rep(i,n) D[i] = divs.divisor(i);
auto dims = divs.dimcum;
i64 dimn = dims.size() - 1;
vector<Modint> A(n);
rep(i,n) A[i] = M / D[i];
divs.RevMobius(A);
vector<Modint> C(n); C[0] = -1;
divs.Mobius(C);
vector<Modint> dp(n);
i64 maskx = 1 << dimn;
vector<i64> offset(maskx), offsetv(maskx,1);
rep(t,dimn) rep(i,1<<t) offset[i+(1<<t)] = offset[i] + dims[t];
rep(t,dimn) rep(i,1<<t) offsetv[i+(1<<t)] = offsetv[i] * D[dims[t]];
vector<Modint> buf(1<<dimn);
for(i64 i=n-1; i>=0; i--){
dp[i] += A[i];
if(i == 0) break;
i64 mask = 0;
rep(t,dimn) if(i % dims[t+1] >= dims[t]) mask |= 1ll << t;
buf[0] = dp[i];
for(i64 jx=(mask-1)&mask; ; jx=(jx-1)&mask){
i64 j = mask - jx;
buf[j] = (buf[j-(j&-j)].pow(offsetv[j&-j]));
dp[i-offset[j]] += C[offset[j]] * buf[j];
if(jx == 0) break;
}
}
cout << dp[0].val() << "\n";
return 0;
}
| passed | 42_std.cpp |
#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
typedef long long ll;
struct Node{
ll id;
ll score;
bool operator <(const Node &a)const{
if(a.score == score){
return id < a.id;
}
else{
return score > a.score;
}
}
}play[N];
int now;
map<pair<int, int>, bool> ed;
ll lv[N];
void solve(){
ll n, m, q;
cin >> n >> m >> q;
int now = -1;
for(int i = 1; i <= n; i++){
lv[i] = m;
}
for(int i = 1; i <= m; i++){
play[i].score = 0;
play[i].id = i;
}
ed.clear();
while(q--){
int op; cin >> op;
if(op == 1){
int x; cin >> x;
now = x;
}
else if(op == 2){
int id, x;
cin >> id >> x;
if(x == now && ed[{id, x}] == false){
play[id].score += lv[x];
lv[x]--;
ed[{id, x}] = true;
}
}
else{
int id, x; cin >> id >> x;
if(x == now)
ed[{id, x}] = true;
//lv[x]--;
}
}
sort(play + 1, play + 1 + m);
//cout << "-----\n";
for(int i = 1; i <= m; i++){
cout << play[i].id << " " << play[i].score << "\n";
}//cout << "-----\n";
}
int main(){
int t; cin >> t;
while(t--){
solve();
//cout << "\n";
}
} | passed | 9_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#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 all(x) (x).begin(),(x).end()
#define SZ(x) ((ll)(x).size())
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define fi first
#define se second
#define endl '\n'
typedef vector<int> vi;
typedef vector<long long> vl;
typedef long long ll;
typedef pair<int,int> pii;
typedef double db;
mt19937 mrand(random_device{}());
int rnd(int x){return mrand()%x;}
const ll mod=998244353;
const ll INF=(ll(1)<<60)-1;
const int inf=(int(1)<<30)-1;
// int size(256<<20); // 256M
// cout<<fixed<<setprecision(10);
const int N=5E4+10,LOGN=19;
template<class T>
struct STTable {
int n;
T g[LOGN+1][N];
void init(vector<T> a) {
n=SZ(a);
assert(n<(1<<LOGN)&&n<N);
rep(i,0,n) g[0][i]=a[i];
rep(j,1,LOGN) for (int i=0;i+(1<<j)-1<n;i++) {
g[j][i]=__gcd(g[j-1][i],g[j-1][i+(1<<(j-1))]);
}
}
T query(int l,int r) {
assert(l<=r);
int len=31-__builtin_clz(r-l+1);
return abs(__gcd(g[len][l],g[len][r-(1<<len)+1]));
}
};
STTable<ll> f;
void solve(int testid) {
ll n,k;
cin>>n>>k;
vl a(n+1),b(n+1);
rep(i,1,n+1) {
cin>>a[i];
b[i]=a[i]-a[i-1];
}
f.init(b);
vector<array<ll,2>> stk{{0,0}};
vl l(n+1),r(n+1);
auto okok=[&](ll pos,ll x)->bool {
if (stk[pos][0]>=x) return true;
return false;
};
rep(i,1,n+1) {
while (SZ(stk)&&(stk.back())[0]>=a[i]) {
stk.pop_back();
}
stk.pb({a[i],i});
ll pl=0,pr=SZ(stk)-1;
while (pr>pl+1) {
ll mid=(pl+pr)/2;
if (!okok(mid,a[i])) pl=mid;
else pr=mid;
}
l[i]=stk[pl][1];
}
stk.clear();
stk.pb({0,n+1});
per(i,1,n+1) {
while (SZ(stk)&&(stk.back())[0]>=a[i]) {
stk.pop_back();
}
stk.pb({a[i],i});
ll pl=0,pr=SZ(stk)-1;
while (pr>pl+1) {
ll mid=(pl+pr)/2;
if (!okok(mid,a[i])) pl=mid;
else pr=mid;
}
r[i]=stk[pl][1];
}
map<ll,ll> res;
map<ll,vl> mem;
ll anum=0;
rep(i,1,n+1) {
// cout<<l[i]+1<<" "<<r[i]-1<<endl;
if (l[i]+1==r[i]-1) {
continue;
} else {
ll mn=a[i];
ll hh=f.query(l[i]+2,r[i]-1);
if (hh==0) continue;
vl qwq;
if (!mem.count(hh)) {
for (ll i=1;i*i<=hh;i++) {
if (hh%i==0) {
ll ha=hh/i;
qwq.pb(ha);
if (i*i!=hh) {
ll hb=hh/ha;
qwq.pb(hb);
}
}
}
mem[hh]=qwq;
}
else qwq=mem[hh];
for (auto x : qwq) {
if (x>mn&&x-mn<=k) {
res[x-mn]++;
}
}
// for (auto x : qwq) cerr<<x<<" ";
// cerr<<endl;
anum++;
}
}
ll ansx=0,ansv=0;
for (auto [a,b] : res) {
// cerr<<a<<" "<<b<<" "<<anum<<endl;
if (b==anum) {
ansx++;
ansv+=a;
}
}
if (!anum) {
ansx=k;
ansv=(1+k)*k/2;
}
cout<<ansx<<" "<<ansv<<endl;
}
void clear(int testid) {
}
signed main() {
fastio;
int i=1,tc=0;
for (cin>>tc;i<=tc;i++) {
solve(i);
clear(i);
}
return 0;
} | passed | 33_std.cpp |
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+12;
int ans,t,m,n,k,x,a,b;
bool vis[N];
set<int>edge[N];
map<pair<int,int>,int>mp;
struct node{
int sum,id,l;
}p[N];
int main()
{
cin>>t;
while(t--)
{
cin>>n>>m>>k;
int ma1=0,ma2=0;
ans=0;
for(int i=1;i<=k;i++)
{
p[i]={0,0,0};
edge[i].clear();
vis[i]=0;
}
mp.clear();
for(int i=1;i<=n;i++)
{
cin>>x;
vis[x]=1;
}
int now=0;
while(m--)
{
cin>>a>>b;
if( vis[a] && vis[b] )
{
ans++;
}
else if( vis[a] || vis[b] || a==b )
{
p[a].sum++;
if(a!=b) p[b].sum++;
}
else{
mp[{a,b}]++;
mp[{b,a}]++;
edge[a].insert(b);
edge[b].insert(a);
}
}
for(int i=1;i<=k;i++)
{
if( vis[i] ) continue;
if( p[i].sum>ma1 )
{
ma2=ma1;
ma1=p[i].sum;
}
else if( p[i].sum>ma2 )
{
ma2=p[i].sum;
}
for( auto j:edge[i] )
{
now=max( now,p[i].sum+p[j].sum+mp[{i,j}] );
}
}
now=max(now,ma1+ma2);
cout<<ans+now<<'\n';
}
}
| passed | 55_std.cpp |
#include<bits/stdc++.h>
#define int long long
#define F first
#define S second
#define MP make_pair
#define PB push_back
using namespace std;
const int N = 2e5 + 100;
vector<int>v[N];
int h[N], ans[N];
void dfs(int x, int px=-1) {
if(px == -1) {
h[x] = 0;
}
else {
h[x] = h[px] + 1;
}
for(int u: v[x]) {
if(u != px) {
dfs(u, x);
}
}
}
void solve() {
int n;
cin >> n;
for(int i = 0 ; i < 2 * n + 10 ; i++) {
h[i] = 0;
ans[i] = -1;
v[i].clear();
}
for(int i = 0 ; i < 2 * n - 1 ; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
v[x].PB(y);
v[y].PB(x);
}
if(n == 1) {
cout << "1 0\n";
return;
}
int root = -1;
for(int i = 0 ; i < 2 * n ; i++) {
if((int)v[i].size()!=1) {
root = i;
break;
}
}
//cout << root << '\n';
dfs(root);
int r_b = 0, r = 0, b = 1;
for(int i = 0 ; i < 2 * n ; i++) {
if((int)v[i].size() != 1) {
if(h[i] % 2 == 0) {
ans[i] = 0;
r_b++;
}
else {
ans[i] = 1;
r_b--;
}
}
}
for(int i = 0 ; i < 2 * n ; i++) {
if(ans[i] == -1) {
if(r_b > 0) {
ans[i] = 1;
r_b--;
}
else {
ans[i] = 0;
r_b++;
}
}
}
for(int i = 0 ; i < 2 * n ; i++) {
cout << ans[i] << ' ';
}
cout << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int q = 1;
cin >> q;
while (q--) {
solve();
}
} | passed | 20_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int K = 8;
vector<vector<pair<int, array<int, K>>>> g;
vector<array<int, K>> all;
int who(const array<int, K> &v) {
return lower_bound(all.begin(), all.end(), v) - all.begin();
}
constexpr int A = 6561;
array<vector<array<int, K>>,A> tot;
void solve() {
for(auto &v : tot)v.clear();
int n;
cin >> n;
array<int, K> cur{};
tot[who(cur)].push_back(cur);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
--x;
++cur[x];
auto z = cur;
for (auto &i: z)i %= 3;
tot[who(z)].push_back(cur);
}
ll res = 0;
for (int x = 0; x < tot.size(); ++x) {
if (!tot[x].size())continue;
for (auto &[y, z]: g[x]) {
if (tot[y].empty())continue;
int pos = tot[y].size() - 1;
auto ok = [&](const array<int, K> &lhs, const array<int, K> &rhs) {
if (lhs == rhs)return 0;
for (int i = 0; i < K; ++i) {
if (lhs[i] - rhs[i] < z[i])return 0;
}
return 1;
};
for (auto &v: views::reverse(tot[x])) {
if (!~pos)break;
while (~pos && !ok(v, tot[y][pos]))--pos;
res += pos + 1;
}
}
}
cout << res << "\n";
}
void go(int pos, array<int, K> cur) {
if (pos == K) {
all.push_back(cur);
return;
}
for (int i = 0; i < 3; ++i) {
auto ncur = cur;
ncur[pos] = i;
go(pos + 1, ncur);
}
}
int main() {
cin.tie(0)->sync_with_stdio(0);
go(0, {});
sort(all.begin(), all.end());
g.resize(all.size());
for (int i = 0; i < all.size(); ++i) {
auto &v = all[i];
auto gen = [&](auto &&gen, int pos, array<int, K> z, array<int, K> cur) {
if (pos + 2 == K) {
for (int j = 0; j < 2; ++j) {
cur[pos + j] = (v[pos + j] + z[pos + j]) % 3;
if (cur[pos + j] < 0)cur[pos + j] += 3;
int x = v[pos + j] - cur[pos + j];
if (x < 0)x += 3;
z[pos + j] += x;
}
for (auto &x: z) {
x = abs(min(0, x));
}
int other = who(cur);
g[i].push_back({other, z});
return;
}
for (int b = 0; b < 3; ++b) {
auto ncur = cur;
ncur[pos] = b;
int val = v[pos] - b;
if (val < 0)val += 3;
auto nz = z;
nz[pos] += val;
if (nz[pos] % 3) {
int x = nz[pos] % 3;
if(x<0)x+=3;
for (int j = 0; j < 3; ++j)nz[pos + j] -= x;
}
gen(gen, pos + 1, nz, ncur);
}
};
gen(gen, 0, {}, {});
}
int t;
cin >> t;
while (t--)solve();
} | passed | 41_std.cpp |
#include <bits/stdc++.h>
using namespace std;
bool kmp(const vector<int>& text, const vector<int>& pattern) {
int m = pattern.size();
if (m == 0) return false;
vector<int> lps(m, 0);
int len = 0;
for (int i = 1; i < m;) {
if (pattern[i] == pattern[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
int i = 0, j = 0;
while (i < text.size()) {
if (text[i] == pattern[j]) {
i++;
j++;
if (j == m) {
return true;
}
} else {
if (j != 0) {
j = lps[j - 1];
} else {
i++;
}
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<int> d(n);
for (int& x : d) cin >> x;
vector<int> t(m);
for (int& x : t) cin >> x;
vector<int> s1 = d;
s1.insert(s1.end(), d.begin(), d.end());
vector<int> reversed_d(d.rbegin(), d.rend());
vector<int> s2 = reversed_d;
s2.insert(s2.end(), reversed_d.begin(), reversed_d.end());
bool found = kmp(s1, t) || kmp(s2, t);
cout << (found ? 1 : 0) << endl;
return 0;
} | passed | 102_std.cpp |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
void D(int n, int k, int *p1, int *p2)
{
if (!n) return p1[0] = p2[0] = 0, void();
if (n == 1) return p1[0] = p2[1] = 0, p1[1] = p2[0] = 1, void();
int mid = 1 << (n - 1);
if (k < mid) D(n - 1, k, p1, p1 + mid);
else D(n - 1, k - mid, p1 + mid, p1);
for (int i = 0; i < (1 << n); i++) p2[i] = p1[(1 << n) - 1 - i];
for (int i = mid; i < (1 << n); i++) p1[i] += mid;
for (int i = 0; i < mid; i++) p2[i] += mid;
}
void C(int x, int *p1, int *p2)
{
if (!x) return;
if (x == 1) return p1[0] = p2[0] = 0, void();
if (x == 2) return p1[0] = p2[1] = 0, p1[1] = p2[0] = 1, void();
int l = 1, n = 0, k;
while ((l << 1) <= x) l <<= 1, n++; k = x - l;
C(k, p1, p1 + l);
for (int i = 0; i < k; i++) p1[i] += l;
D(n, k, p2 + l, p2);
for (int i = l; i < x; i++) p2[i] += l;
for (int i = x; i < (l << 1); i++) p1[i - l] = p2[i];
}
int p1[maxn], p2[maxn], p[maxn];
bool vis[maxn];
void work()
{
int n; cin >> n;
for (int i = 0; i < n; i++) vis[i] = 0;
if (n == 1) return cout << "Yes\n0\n0\n", void();
if (n & 3) return cout << "No\n", void();
C(n / 4, p1, p2);
for (int i = 0; i < n / 4; i++)
{
int a = (i << 2), b = a | 1, c = a | 2, d = b | 2;
p[a] = p1[i] << 2, p[b] = (p1[i] << 2) | 2;
if (vis[p[a] ^ a] || vis[p[b] ^ b]) p[a] ^= 2, p[b] ^= 2;
vis[p[a] ^ a] = vis[p[b] ^ b] = 1;
p[c] = (p2[i] << 2) | 3, p[d] = (p2[i] << 2) | 1;
if (vis[p[c] ^ c] || vis[p[d] ^ d]) p[c] ^= 2, p[d] ^= 2;
vis[p[c] ^ c] = vis[p[d] ^ d] = 1;
}
cout << "Yes\n";
for (int i = 0; i < n; i++) cout << i << " "; cout << "\n";
for (int i = 0; i < n; i++) cout << p[i] << " "; cout << "\n";
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0);
int T; cin >> T;
while (T--) work();
return 0;
} | passed | 56_std.cpp |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, m;
long long a[maxn];
struct node {
long long sum, zero, tag;
}t[maxn << 2];
inline void update(int d) {
t[d].sum = t[d << 1].sum & t[d << 1 | 1].sum;
t[d].zero = (t[d << 1].zero & t[d << 1 | 1].sum) | (t[d << 1].sum & t[d << 1 | 1].zero);
}
inline void pushdown(int d, int l, int r) {
int mid = l + r >> 1;
t[d << 1].sum &= t[d].tag, t[d << 1].tag &= t[d].tag;
t[d << 1 | 1].sum &= t[d].tag, t[d << 1 | 1].tag &= t[d].tag;
if(l == mid) t[d << 1].zero = t[d << 1].sum ^ LONG_LONG_MAX;
else t[d << 1].zero &= t[d].tag;
if(r == mid + 1) t[d << 1 | 1].zero = t[d << 1 | 1].sum ^ LONG_LONG_MAX;
else t[d << 1 | 1].zero &= t[d].tag;
t[d].tag = LONG_LONG_MAX;
}
void build(int d, int l, int r) {
t[d].tag = LONG_LONG_MAX;
if(l == r) return t[d].sum = a[l], t[d].zero = a[l] ^ LONG_LONG_MAX, void();
int mid = l + r >> 1;
build(d << 1, l, mid), build(d << 1 | 1, mid + 1, r), update(d);
// cout << "build " << l << ' ' << r << ' ' << t[d].sum << ' ' << t[d].zero << endl;
}
void modify(int d, int l, int r, int dl, int dr, long long x) {
if(dl <= l && r <= dr) {
if(l == r) return t[d].sum &= x, t[d].zero = t[d].sum ^ LONG_LONG_MAX, void();
else return t[d].sum &= x, t[d].tag &= x, t[d].zero &= x, void();
}
if(t[d].tag != LONG_LONG_MAX) pushdown(d, l, r);
int mid = l + r >> 1;
if(dl <= mid) modify(d << 1, l, mid, dl, dr, x);
if(dr > mid) modify(d << 1 | 1, mid + 1, r, dl, dr, x);
update(d);
}
void modify(int d, int l, int r, int des, long long x) {
if(l == r) return t[d].sum = x, t[d].zero = x ^ LONG_LONG_MAX, void();
if(t[d].tag != LONG_LONG_MAX) pushdown(d, l, r);
int mid = l + r >> 1;
if(des <= mid) modify(d << 1, l, mid, des, x);
else modify(d << 1 | 1, mid + 1, r, des, x);
update(d);
}
pair<long long, long long> query_zero(int d, int l, int r, int dl, int dr) {
if(dl <= l && r <= dr) return {t[d].sum, t[d].zero};
if(t[d].tag != LONG_LONG_MAX) pushdown(d, l, r);
int mid = l + r >> 1;
pair<long long, long long> res = {LONG_LONG_MAX, 0};
if(dl <= mid) res = query_zero(d << 1, l, mid, dl, dr);
if(dr > mid) {
pair<long long, long long> tmp = query_zero(d << 1 | 1, mid + 1, r, dl, dr);
res.second = (res.second & tmp.first) | (res.first & tmp.second);
res.first &= tmp.first;
}
// cout << "query_zero " << l << ' ' << r << ' ' << dl << ' ' << dr << ' ' << res.first << ' ' << res.second << endl;
return res;
}
long long query_sum(int d, int l, int r, int dl, int dr) {
if(dl > dr) return LONG_LONG_MAX;
if(dl <= l && r <= dr) return t[d].sum;
if(t[d].tag != LONG_LONG_MAX) pushdown(d, l, r);
int mid = l + r >> 1;
long long res = LONG_LONG_MAX;
if(dl <= mid) res = query_sum(d << 1, l, mid, dl, dr);
if(dr > mid) res &= query_sum(d << 1 | 1, mid + 1, r, dl, dr);
return res;
}
int find_zero(int d, int l, int r, int dl, int dr, int digit) {
if(l == r) return (t[d].zero >> digit & 1) ? l : -1;
if(t[d].tag != LONG_LONG_MAX) pushdown(d, l, r);
int mid = l + r >> 1;
if(dl <= l && r <= dr) {
// cout << "find_zero " << l << ' ' << r << ' ' << dl << ' ' << dr << ' ' << digit << ' ' << t[d].zero << endl;
if(!(t[d].zero >> digit & 1)) return -1;
if(t[d << 1].zero >> digit & 1) return find_zero(d << 1, l, mid, dl, dr, digit);
else return find_zero(d << 1 | 1, mid + 1, r, dl, dr, digit);
} else {
int res = -1;
if(dl <= mid) res = find_zero(d << 1, l, mid, dl, dr, digit);
if(res == -1 && dr > mid) res = find_zero(d << 1 | 1, mid + 1, r, dl, dr, digit);
// cout << "find_zero " << l << ' ' << r << ' ' << dl << ' ' << dr << ' ' << digit << ' ' << res << endl;
return res;
}
}
inline void solve() {
cin >> n >> m;
for(int i = 1; i <= n; ++i) cin >> a[i];
build(1, 1, n);
int op = 0, l = 0, r = 0, s = 0;
long long x = 0;
while(m--) {
cin >> op;
if(op == 1) cin >> l >> r >> x, modify(1, 1, n, l, r, x);
else if(op == 2) cin >> s >> x, modify(1, 1, n, s, x);
else {
cin >> l >> r;
long long zero = query_zero(1, 1, n, l, r).second;
// cout << "zero = " << zero << endl;
if(!zero) cout << query_sum(1, 1, n, l, r) << '\n';
else {
int d = -1;
for(int i = 62; i >= 0; --i) if(zero >> i & 1) { d = i; break; }
int zero_pos = find_zero(1, 1, n, l, r, d);
// cout << "zero_pos = " << zero_pos << endl;
long long ans = query_sum(1, 1, n, l, zero_pos - 1) & query_sum(1, 1, n, zero_pos + 1, r);
cout<< ans << '\n';
// if(ans == 123145302835200ll) {
// cout << l << ' ' << r << ' ' << query_sum(1, 1, n, l, r) << '\n';
// for(int i = l; i <= r; ++i) cout << (query_sum(1, 1, n, l, i - 1) & query_sum(1, 1, n, i + 1, r)) << ' '; cout << '\n';
// for(int i = l; i <= r; ++i) cout << query_sum(1, 1, n, i, i) << ' '; cout << '\n';
// }
}
}
// if(n == 10) cout << "[" << op << ' ' << l << ' ' << r << ' ' << s << ' ' << x << "] ";
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
solve();
return 0;
} | passed | 25_std.cpp |
#include <bits/stdc++.h>
#define int long long
#define INF 0x3f3f3f3f
#define llINF 0x3f3f3f3f3f3f3f3f
#define all(x) x.begin(), x.end()
#define alll(x, t) x.begin() + t, x.end()
#define rall(x) x.rbegin(), x.rend()
#define ull unsigned long long
#define PII pair<int, int>
#define fi first
#define se second
#define pb push_back
#define lowbit(x) ((x) & (-x))
#define debug(x) cout << #x << " = " << x << "\n";
#define debugar(x) for (auto &i : x) cout << i << " "; cout << "\n";
using namespace std;
using ll = long long;
int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);}
int lcm(int a, int b) {return (a / gcd(a, b)) * b;}
const int mod = 1e9 + 7;
inline ll qpow(ll n, ll m)//有的时候用的时候记住删掉mod,long long最多为2^63,约等于9e18
{
ll res = 1;
while (m)
{
if (m & 1)
res = res * n;
n = n * n;
m >>= 1;
}
return res;
}
inline bool isp(int x)
{
if (x == 1) return false;
if (x <= 3) return true;
for (int i = 2; i <= x / i; i++)
{
if (x % i == 0)return false;
}
return true;
}
//cout << fixed << setprecision(3) << s;
const int N = 28;
vector<int> a(4);
vector<vector<int>> g(1 << 16, vector<int>(16, llINF));
vector<vector<int>> c(N, vector<int>(N, llINF));
vector<vector<int>> f(N, vector<int>(N, llINF));
inline void kfk_dm()
{
//-----> 注 意 数 据 范 围 , 试 试 开 long long <-----
int m;
cin >> m;
vector<vector<int>> p(N, vector<int>(5));
string s;
int res = 0;
for (int i = 1; i <= m; i++) {
cin >> s;
p[i][0] = s[0] - '0';
p[i][1] = s[1] - '0';
cin >> s;
p[i][2] = s[0] - '0';
p[i][3] = s[1] - '0';
int x = 0;
for (int j = 0; j < 4; j++) {
x = (x << 1) + p[i][j];
}
res |= (1 << (15 - x));
}
int ans = llINF;
for (int i = 0; i < (1 << 4); i++) {
ans = min(ans, g[res][i]);
}
cout << ans << "\n";
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
for (int i = 0; i < 4; i++) {
cin >> a[i];
}
auto ID = [&](int x, int y, int z, int w) -> int {
return x * 8 + y * 4 + z * 2 + w;
};
for (int i = 0; i < (1 << 4); i++) {
int D = i % 2, C = (i / 2) % 2, B = (i / 4) % 2, A = i / 8;
c[i][ID(A ^ 1, B, C, D)] = min(c[i][ID(A ^ 1, B, C, D)], a[0]);
c[i][ID(A, B ^ 1, C, D)] = min(c[i][ID(A, B ^ 1, C, D)], a[0]);
c[i][ID(A, B, C ^ 1, D)] = min(c[i][ID(A, B, C ^ 1, D)], a[0]);
c[i][ID(A, B, C, D ^ 1)] = min(c[i][ID(A, B, C, D ^ 1)], a[0]);
c[i][ID(A ^ 1, B ^ 1, C, D)] = min(c[i][ID(A ^ 1, B ^ 1, C, D)], a[1]);
c[i][ID(A ^ 1, B, C ^ 1, D)] = min(c[i][ID(A ^ 1, B, C ^ 1, D)], a[2]);
c[i][ID(A, B ^ 1, C, D ^ 1)] = min(c[i][ID(A, B ^ 1, C, D ^ 1)], a[2]);
c[i][ID(A, B, C ^ 1, D ^ 1)] = min(c[i][ID(A, B, C ^ 1, D ^ 1)], a[1]);
c[i][ID(A ^ 1, B ^ 1, C ^ 1, D ^ 1)] = min(c[i][ID(A ^ 1, B ^ 1, C ^ 1, D ^ 1)], a[3]);
}
for (int i = 1; i <= 15; i++) {
f[i][i] = 0;
}
f[0][0] = (*min_element(all(a))) * 2; // 处理初始就是已经开了的情况
for (int i = 0; i < (1 << 4); i++) {
for (int j = 0; j < (1 << 4); j++) {
f[i][j] = min(f[i][j], c[i][j]);
}
}
for (int k = 0; k < (1 << 4); k++) {
for (int i = 0; i < (1 << 4); i++) {
for (int j = 0; j < (1 << 4); j++) {
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
}
}
for (int i = 0; i < (1 << 4); i++) {
g[1 << i][i] = f[0][i];
}
for (int s = 2; s < (1 << 16); s++) {
for (int j = 0; j < (1 << 4); j++) {
//不能得到j这一位-> 不能从j这一位往下扩展
if (((1 << j) & s) == 0) continue;
for (int k = 0; k < (1 << 4); k++) {
//k为扩到的位置，看能不能扩展到
if (j == k || (s & (1 << k)) == 0) continue;
g[s][k] = min(g[s][k], g[s ^ (1 << k)][j] + f[j][k]);
}
}
}
while (t--)
kfk_dm();
return 0;
} | passed | 83_std.cpp |
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define all(x) (x).begin(),(x).end()
typedef long long i64;
typedef pair<int, int> pii;
void solve() {
string s; cin >> s;
int n = s.length();
vector<pii> nxt(n + 2);
for(int i = n, nxtr = n + 1; i >= 0; i--) {
nxt[i].second = nxtr;
if(i && s[i - 1] == 'R') nxtr = i;
}
for(int i = n, nxtl = n + 1; i >= 0; i--) {
nxt[i].first = nxtl;
if(i && s[i - 1] == 'L') nxtl = i;
}
int q; cin >> q;
while(q--) {
string t; cin >> t;
if(s[0] == 'L' && t[0] != 'L') {
cout << "NO" << endl;
continue;
}
if(s.back() == 'R' && t.back() != 'R') {
cout << "NO" << endl;
continue;
}
int j = 0, f = 1;
for(char ch : t) {
if(ch == 'L') {
j = nxt[j].first;
} else {
j = nxt[j].second;
}
if(j == n + 1) {
f = 0;
break;
}
}
if(f) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int T; cin >> T;
while(T--) solve();
return 0;
} | passed | 44_std.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 200000 + 5;
const int MAX_M = 1 << 23;
const int P = 998244353;
int power(int a, ll n) {
int ans = 1;
while (n) {
if (n & 1) ans = 1ll * ans * a % P;
a = 1ll * a * a % P; n >>= 1;
}
return ans;
}
int N, suf[MAX_N];
vector <int> edge[MAX_N];
struct BIT{
int c[MAX_N];
void modify(int x, int v) {
for (int i = x; i <= N; i += i & -i) c[i] += v;
}
int query(int l, int r) {
l --;
int res = 0;
while (l < r) {
res += c[r];
r -= r & -r;
}
while (r < l) {
res -= c[l];
l -= l & -l;
}
return res;
}
}bit;
int dfsn[MAX_N], Tm;
struct SegmentNode{
int ls, rs, sum;
}node[MAX_M];
int rt[MAX_N], tot;
inline int add(int a, int b, int p = P) {return a + b < p ? a + b : a + b - p;}
ll dfs1(int u, int fa) {
dfsn[u] = ++ Tm;
ll res = bit.query(1, u);
if (fa) bit.modify(u, 1);
for (auto v : edge[u]) {
if (v != fa) {
res += dfs1(v, u);
}
}
if (fa) bit.modify(u, -1);
return res;
}
int dfs2(int u, int fa, ll sum = 0) {
if (fa) sum += suf[u];
int res = power(2, sum);
for (auto v : edge[u]) {
if (v != fa) {
res = add(res, dfs2(v, u, sum));
}
}
return res;
}
void segment_modify(int &i, int l, int r, int x) {
node[i = ++ tot].sum ++;
if (l == r) return ;
int mid = l + r >> 1;
mid < x ? segment_modify(node[i].rs, mid + 1, r, x) : segment_modify(node[i].ls, l, mid, x);
}
void segment_merge(int &li, int ri, int l, int r) {
if (!li || !ri) {
li |= ri;
return ;
}
node[++ tot] = node[li];
li = tot;
if (l == r) {
node[li].sum += node[ri].sum;
return ;
}
int mid = l + r >> 1;
segment_merge(node[li].ls, node[ri].ls, l, mid);
segment_merge(node[li].rs, node[ri].rs, mid + 1, r);
node[li].sum = node[node[li].ls].sum + node[node[li].rs].sum;
}
int segment_query(int i, int l, int r, int ql, int qr) {
if (!i) return 0;
if (l < ql || r > qr) {
int mid = l + r >> 1, res = 0;
if (ql <= mid) res = segment_query(node[i].ls, l, mid, ql, qr);
if (mid < qr) res += segment_query(node[i].rs, mid + 1, r, ql, qr);
return res;
}else {
return node[i].sum;
}
}
ll dfs3(int u, int fa) {
dfsn[u] = ++ Tm;
ll res = bit.query(1, u);
if (fa) bit.modify(u, 1);
segment_modify(rt[u], 1, N, u);
for (auto v : edge[u]) {
if (v != fa) {
res += dfs3(v, u);
segment_merge(rt[u], rt[v], 1, N);
}
}
if (fa) bit.modify(u, -1);
return res;
}
int dfs4(int u, int fa, ll cur) {
if (fa && fa < N) {
cur += suf[fa + 1] - segment_query(rt[u], 1, N, fa + 1, N);
}
int res = power(2, cur + suf[u + 1]);
for (auto v : edge[u]) {
if (v != fa) {
res = add(res, dfs4(v, u, cur - segment_query(rt[v], 1, N, v, N) + 1));
}
}
if (fa) {
cur -= suf[fa] - segment_query(rt[u], 1, N, fa, N);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> N;
for (int i = 1; i <= N - 2; i ++) {
int x, y;
cin >> x >> y;
edge[x].emplace_back(y);
edge[y].emplace_back(x);
}
for (int i = 1; i <= N; i ++) {
sort(edge[i].begin(), edge[i].end());
}
int k1 = power(2, dfs1(1, 0));
for (int i = 1; i <= N; i ++) {
if (!dfsn[i]) {
rt[0] = i;
suf[i] = 1;
}else {
dfsn[i] = 0;
}
}
for (int i = N - 1; i > 0; i --) suf[i] += suf[i + 1];
int k2 = dfs2(1, 0); Tm = 0;
int k3 = dfs4(rt[0], 0, dfs3(rt[0], 0));
int ans = 1ll * k1 * k2 % P * k3 % P;
if (suf[1] == 1) ans = add(ans, k1);
cout << ans << endl;
return 0;
} | passed | 85_std.cpp |
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define all(x) (x).begin(),(x).end()
typedef long long i64;
typedef pair<int, int> pii;
bool check(vector<string> mp) {
int n = mp.size();
int m = mp.at(0).length();
for(int i = n - 1; i > 0; i--) {
for(int j = 0; j < m - 1; j++) {
if(mp.at(i).at(j) == '1') {
mp.at(i).at(j) ^= 1;
mp.at(i - 1).at(j + 1) ^= 1;
}
}
}
for(int j = 0; j < m; j++) {
if(mp.at(0).at(j) == '1') {
return false;
}
}
for(int i = 0; i < n; i++) {
if(mp.at(i).at(m - 1) == '1') {
return false;
}
}
return true;
}
string build1(vector<pii> v) {
string ret;
int i = 0, j = 0;
for(auto p : v) {
assert(i <= p.first && j <= p.second);
while(j < p.second) {
j++;
ret.push_back('R');
}
while(i < p.first) {
i++;
ret.push_back('D');
}
}
return ret;
}
string build2(vector<pii> v) {
string ret;
int i = 0, j = 0;
for(auto p : v) {
assert(i <= p.first && j <= p.second);
while(i < p.first) {
i++;
ret.push_back('D');
}
while(j < p.second) {
j++;
ret.push_back('R');
}
}
return ret;
}
void modify(vector<string> &mp, string s) {
int i = 0, j = 0;
mp.at(i).at(j) ^= 1;
for(char ch : s) {
if(ch == 'R') j++;
else i++;
mp.at(i).at(j) ^= 1;
}
}
// void print(vector<string> &mp) {
// cerr << "--------------------" << endl;
// for(auto s : mp) cerr << s << endl;
// cerr << endl;
// }
void solve() {
int n, m; cin >> n >> m;
vector<string> mp(n);
vector<string> ans;
for(auto &s : mp) {
cin >> s;
for(auto &ch : s) {
if(ch == 'W') {
ch = '0';
} else {
ch = '1';
}
}
}
if(mp.at(0).at(0) == '1') {
for(auto &s : mp) {
for(auto &ch : s) {
ch ^= 1;
}
}
}
// print(mp);
if(check(mp)) {
cout << "YES" << endl;
} else {
string s;
for(int i = 0; i < n - 1; i++) {
mp[i][0] ^= 1;
s.push_back('D');
}
for(auto &ch : mp.back()) {
ch ^= 1;
s.push_back('R');
}
s.pop_back();
ans.push_back(s);
if(mp.at(0).at(0) == '1') {
for(auto &s : mp) {
for(auto &ch : s) {
ch ^= 1;
}
}
}
// print(mp);
if(check(mp)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
return;
}
}
for(int t = n - 1; ; t -= 2) {
int a = t, b = t - 1;
int c = t - 2, d = t - 3;
if(c < 1 - m) break;
vector<pii> w1, w2;
int i = a, j = 0;
if(i < 0) {j -= i; i = 0;}
while(i < n && j < m) {
if(mp[i][j] == '1') {
w1.push_back({i, j});
if(i - 1 >= 0 && j + 1 < m) {
w2.push_back({i - 1, j + 1});
}
// assert(i - 1 >= 0 && j + 1 < m);
} else {
if(i - 1 >= 0 && j + 1 < m) {
w1.push_back({i - 1, j + 1});
w2.push_back({i - 1, j + 1});
}
// assert(i - 1 >= 0 && j + 1 < m);
}
i++; j++;
}
i = b, j = 0;
if(i < 0) {j -= i; i = 0;}
while(i < n && j < m) {
if(mp[i][j] == '1') {
w1.push_back({i, j});
if(i - 1 >= 0 && j + 1 < m) {
w2.push_back({i - 1, j + 1});
}
} else {
w1.push_back({i, j});
w2.push_back({i, j});
}
i++; j++;
}
sort(all(w1)); sort(all(w2));
w1.push_back({n - 1, m - 1});
w2.push_back({n - 1, m - 1});
string s = build1(w1);
ans.push_back(s);
modify(mp, s);
s = build2(w2);
ans.push_back(s);
modify(mp, s);
}
// for(auto &s : mp) {
// cout << s << endl;
// for(auto ch : s) {
// if(ch != '0') {
// cout << "NO" << endl;
// return;
// }
// }
// }
// cout << "YES" << endl;
assert(ans.size() <= 400);
cout << ans.size() << endl;
for(auto &s : ans) {
cout << s << endl;
assert(s.length() == n + m - 2);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int T; cin >> T;
while(T--) solve();
return 0;
} | passed | 45_std.cpp |
#include "bits/stdc++.h"
using namespace std;
#define all(x) begin(x), end(x)
#define sz(x) (int) (x).size()
#define int long long
namespace static_rmq {
//see yosupo for usage details
const int K = 19;
const int mxn = 5e5+5;
int N;
int st[K+1][mxn];
void build() {
for (int i=1; i<=K; i++)
for (int j=0; j+(1<<i)<=N; j++)
st[i][j]=min(st[i-1][j],st[i-1][j+(1<<(i-1))]);
}
void init(vector<int> &a) {
copy(all(a),st[0]);
N = sz(a);
build();
}
void init(int* arr, int size) {
copy(arr,arr+size,st[0]);
N = size;
build();
}
int query(int l, int r) {
// cout<<l<<" ~~ "<<r<<endl;
int i=log2(r-l+1);
return min(st[i][l],st[i][r-(1<<i)+1]);
}
};
const int mxn = 2e5+5;
int n,k,p[mxn],f[mxn],fl[mxn];
vector<array<int,6>> ord;
inline int get(int ind, const array<int,6> &a) {
if (a[0]==ind) return a[1];
if (a[2]==ind) return a[3];
if (a[4]==ind) return a[5];
int mn = min({a[1],a[3],a[5]});
int mx = max({a[1],a[3],a[5]});
if (p[ind] < mn) {
if (p[ind]%2) return p[ind]-1;
return p[ind]+1;
} else {
if (p[ind]%2) return p[ind]+1;
return p[ind]-1;
}
}
int iter = 0;
bool cc(const array<int,6> &a, const array<int,6> &b) {
int ma = max({a[1],a[3],a[5]});
int mb = max({b[1],b[3],b[5]});
int na = min({a[1],a[3],a[5]});
int nb = min({b[1],b[3],b[5]});
vector<int> kp = {a[0],a[2],a[4],b[0],b[2],b[4]};
if (ma<nb) {
kp.push_back(static_rmq::query(ma,nb-1));
// cout<<static_rmq::query(ma,nb-1)<<"\n";
}
if (mb<na) {
kp.push_back(static_rmq::query(mb,na-1));
// cout<<static_rmq::query(mb,na-1)<<"\n";
}
sort(all(kp)); kp.erase(unique(all(kp)),kp.end());
/*
cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<" "<<a[3]<<" "<<a[4]<<" "<<a[5]<<"\n";
cout<<b[0]<<" "<<b[1]<<" "<<b[2]<<" "<<b[3]<<" "<<b[4]<<" "<<b[5]<<"\n";
for (int i=0; i<n; i++) cout<<get(i,a)<<" ";
cout<<"\n";
for (int i=0; i<n; i++) cout<<get(i,b)<<" ";
cout<<"\n";
for (int i :kp) cout<<i<<" ";
cout<<"\n\n";
*/
for (int i : kp) {
if (get(i,a) < get(i,b)) {/*cout<<"1\n\n";*/return 1;}
if (get(i,a) > get(i,b)) {/*cout<<"0\n\n";*/return 0;}
}
return 0;
}
void solve() {
cin>>n>>k;
for (int i=0; i<n; i++) {
cin>>p[i]; --p[i]; f[p[i]] = i;
}
if (n%2==0) {
if (k > 1) {
cout<<"-1\n";
return;
}
for (int i=0; i<n; i+=2) {
swap(p[f[i]],p[f[i+1]]);
}
for (int i=0; i<n; i++) {
cout<<p[i]+1<<" ";
}
cout<<"\n";
return;
}
static_rmq::init(f,n);
ord.clear();
for (int i=0; i+2<n; i+=2) {
int p1 = f[i];
int p2 = f[i+1];
int p3 = f[i+2];
for (int i1=i+1; i1<=i+2; i1++) for (int i2=i; i2<=i+2; i2+=2) for (int i3=i; i3<=i+1; i3++) {
if (i1==i2 || i1==i3 || i2==i3) continue;
ord.push_back({p1,i1,p2,i2,p3,i3});
}
}
sort(all(ord),cc);
if (sz(ord) < k) {
cout<<"-1\n"; return;
}
/* for (auto a : ord) {
for (int j=0; j<n; j++) {
cout<<get(j,a)+1<<" ";
}
cout<<"\n";
}
*/
for (int i=0; i<n; i++) {
int v = get(i,ord[k-1]);
cout<<v+1<<" ";
}
cout<<"\n";
// cout<<"\n\n\n\n";
}
signed main() {
ios::sync_with_stdio(false); cin.tie(nullptr);
int t; cin>>t;
while (t--) {
solve();
}
} | passed | 3_std.cpp |
#include <bits/stdc++.h>
#define int int64_t
constexpr int mod = 998244353;
void chmax(int &a, int b) {
if(b > a) a = b;
}
void chmin(int &a, int b) {
if(b < a) a = b;
}
void add(int &a, int b) {
if((a += b) >= mod) a -= mod;
}
void work() {
int n, m; std::cin >> n >> m;
std::vector<int> a(n), b(n);
for(auto &a: a) std::cin >> a;
for(auto &b: b) std::cin >> b;
int k; std::cin >> k;
std::vector<int> c(k + 1);
for(int i = 1; i <= k; ++i) std::cin >> c[i];
std::vector<std::array<int, 101>> prep(m + 1);
for(int i = 0; i <= m; ++i) for(int j = 0; j <= 100; ++j)
prep[i][j] = 0;
for(int i = 0; i < n; ++i)
for(int j = 1; j <= k; ++j)
chmax(prep[b[i] - 1][j], a[i] + b[i] + j - 1);
for(int j = 1; j < k; ++j)
for(int i = m; i >= 1; --i)
chmax(prep[i - 1][j + 1], prep[i][j]);
int hkr = 0;
for(int i = 0; i < n; ++i) chmax(hkr, a[i] + b[i]);
const int U = 2 * m + 2 * k + 100;
std::vector<std::array<int, 100>>
dp1(U + 1),
dp2(U + 1);
for(int i = 0; i <= U; ++i) for(int j = 0; j < 100; ++j)
dp1[i][j] = 0x3fffffffffffffffLL, dp2[i][j] = 0;
dp1[0][0] = 0;
dp2[0][0] = 1;
int ans = 0x3fffffffffffffffLL, ans_count = 0;
for(int i = 0; i <= U; ++i) for(int j = 0; j < k; ++j) {
if(i >= hkr + j) {
if(dp1[i][j] < ans) ans = dp1[i][j], ans_count = dp2[i][j]; else
if(dp1[i][j] == ans) add(ans_count, dp2[i][j]);
}
for(int x = 1; x <= k && i + x <= U; ++x) {
int ncost = dp1[i][j] + c[x];
int ni = i + x;
int nj = j;
if(i <= m) chmax(nj, prep[i][x] - hkr);
if(ncost < dp1[ni][nj]) {
dp1[ni][nj] = ncost;
dp2[ni][nj] = dp2[i][j];
} else
if(ncost == dp1[ni][nj]) {
add(dp2[ni][nj], dp2[i][j]);
}
}
}
std::cout << ans << ' ' << ans_count << char(10);
return ;
}
int32_t main() {
std::ios::sync_with_stdio(false);
int T; std::cin >> T; while(T--) work();
return 0;
}
| passed | 35_std.cpp |
421877339
| passed | 38_2_output.txt |
#include<bits/stdc++.h>
using namespace std;
template<typename T>
void read(T &a){
#define gc getchar()
char c;a=0;int f=1;
while(!isdigit(c=gc))if(c=='-')f=-1;
do a=a*10+c-'0';
while(isdigit(c=gc));
a*=f;
}
template<typename T>
void write(T a){
if(a<0)putchar('-'),a=-a;
if(a>=10)write(a/10);
putchar('0'+a%10);
}
char GC(){
char c=getchar();
while(c<=32)c=getchar();
return c;
}
template<typename T>
void chmin(T &x,T y){if(x>y)x=y;}
template<typename T>
void chmax(T &x,T y){if(x<y)x=y;}
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int,int> PII;
typedef pair<ll,int> PLI;
typedef __int128 lll;
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
int n,m;
int a[200010];
int b[200010][2];
int ufa[400010*3],sz[400010*3],sum[400010*3];
int fl[400010*3];
int gf(int x){return ufa[x]==x?x:ufa[x]=gf(ufa[x]);}
void merge(int x,int y){
if((x=gf(x))==(y=gf(y)))return;
if(sz[x]>sz[y])swap(x,y);
ufa[x]=y;
sz[y]+=sz[x];
sum[y]+=sum[x];
}
int get_st(int x){
if(fl[gf(x)])return 0;
else if(fl[gf(x+m)])return 1;
else if(fl[gf(x+m+m)])return 2;
else return -1;
}
signed main(){
cin>>n>>m;
for(int i=1;i<=n;++i){
char c;cin>>c;
if(c=='R')a[i]=0;
else if(c=='G')a[i]=1;
else a[i]=2;
}
for(int i=1;i<=m*3;++i){
ufa[i]=i;
sz[i]=1;
sum[i]=(i-1)/m;
fl[i]=0;
}
for(int i=1;i<=m;++i){
int k;read(k);
for(int j=1;j<=k;++j){
int x;read(x);
if(!b[x][0])b[x][0]=i;
else b[x][1]=i;
}
}
// for(int i=1;i<=n;++i)printf("%d %d\n",b[i][0],b[i][1]);
for(int i=1;i<=n;++i)
if(b[i][1]){
if(a[i]==0){
merge(b[i][0],b[i][1]);
merge(b[i][0]+m,b[i][1]+m*2);
merge(b[i][0]+m*2,b[i][1]+m);
}else if(a[i]==1){
merge(b[i][0],b[i][1]+m*2);
merge(b[i][0]+m,b[i][1]+m);
merge(b[i][0]+m*2,b[i][1]);
}else{
merge(b[i][0],b[i][1]+m);
merge(b[i][0]+m,b[i][1]);
merge(b[i][0]+m*2,b[i][1]+m*2);
}
}
int ans=0;
for(int i=1;i<=n;++i)
if(b[i][0]&&!b[i][1]){
int ST=get_st(b[i][0]);
// printf("- %d\n",i);
if(a[i]==0){
if(ST==-1){
fl[gf(b[i][0])]=1;
ans+=sum[gf(b[i][0])];
}else if(ST!=0){
puts("impossible");
return 0;
}
}else if(a[i]==1){
if(ST==-1){
fl[gf(b[i][0]+m+m)]=1;
ans+=sum[gf(b[i][0]+m+m)];
}else if(ST!=2){
puts("impossible");
return 0;
}
}else{
if(ST==-1){
fl[gf(b[i][0]+m)]=1;
ans+=sum[gf(b[i][0]+m)];
}else if(ST!=1){
puts("impossible");
return 0;
}
}
}
for(int i=1;i<=n;++i)
if(!b[i][0]&&a[i]){
// printf("- %d %d %d\n",i,b[i][0],b[i][1]);
puts("impossible");
return 0;
}
// return 0;
for(int i=1;i<=m;++i){
int x=fl[gf(i)],y=fl[gf(i+m)],z=fl[gf(i+m+m)];
int xs=sum[gf(i)],ys=sum[gf(i+m)],zs=sum[gf(i+m+m)];
if(gf(i)==gf(i+m)||gf(i+m)==gf(i+m+m)||gf(i+m+m)==gf(i)){
puts("impossible");
return 0;
}
if(x+y+z>1){
puts("impossible");
return 0;
}else if(x+y+z==0){
if(xs<=ys&&xs<=zs){
ans+=xs;
fl[gf(i)]=1;
}else if(ys<=zs){
ans+=ys;
fl[gf(i+m)]=1;
}else{
ans+=zs;
fl[gf(i+m+m)]=1;
}
}
}
printf("%d\n",ans);
return 0;
} | passed | 116_std.cpp |
#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) {
if ((v ^ (1 << ind)) != 0)
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 (l.size() == 0 && r.size() == 0) {
return {inda, inda};
}
else 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 if (l.size() == 0) {
nd[indp].nxt = inda;
nd[inda].nxt = orr;
nd[orr].nxt = S.first;
nd[S.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();
}
} | passed | 17_std.cpp |
#include <bits/stdc++.h>
#ifdef LOCAL
#include "dd/debug.h"
#else
#define dbg(...) 42
#define dbg_proj(...) 420
#define dbg_rproj(...) 420420
void nline() {}
void bar() {}
void start_clock() {}
void end_clock() {}
#endif
namespace rs = std::ranges;
namespace rv = std::views;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
template <class T> constexpr T INF = T{};
template <std::floating_point T>
constexpr T INF<T> = std::numeric_limits<T>::infinity();
template <> constexpr int INF<int> = 0x3f3f3f3f; // 1061109567
template <>
constexpr long long INF<long long> =
0x3f3f3f3f3f3f3f3fLL; // 4557430888798830399
template <class T> struct Line {
T a = 0, b = INF<T>;
T operator()(T x) const { return a * x + b; }
};
template <class T, class Comp = std::less<>> struct LiChao {
static constexpr Comp comp{};
struct Node {
Line<T> line;
std::array<int, 2> ch{-1, -1};
bool is_leaf() const { return ch[0] == -1 && ch[1] == -1; }
};
T lb, ub;
std::vector<Node> data{Node()};
explicit LiChao(T r) : lb{0}, ub{r} {}
LiChao(T l, T r) : lb{l}, ub{r} {}
void alloc(int& ch, Line<T> line) {
ch = static_cast<int>(data.size());
data.push_back(Node{line});
}
void upd(Line<T> line, int ind, T l, T r) {
if (l == r) {
if (comp(line(l), data[ind].line(l))) {
data[ind].line = line;
}
return;
}
T mid = std::midpoint(l, r);
bool llt = comp(line(l), data[ind].line(l));
bool mlt = comp(line(mid), data[ind].line(mid));
if (mlt) {
std::swap(line, data[ind].line);
}
if (llt != mlt) {
if (data[ind].ch[0] != -1) {
upd(line, data[ind].ch[0], l, mid);
} else {
alloc(data[ind].ch[0], line);
}
} else if (data[ind].ch[1] != -1) {
upd(line, data[ind].ch[1], mid + 1, r);
} else {
alloc(data[ind].ch[1], line);
}
}
void upd(Line<T> line) { upd(line, 0, lb, ub); }
void upd(T a, T b) { upd(Line{a, b}); }
Line<T> query(T v, int ind, T l, T r) const {
if (data[ind].is_leaf()) {
return data[ind].line;
}
T mid = std::midpoint(l, r);
Line<T> res;
if (v <= mid) {
if (data[ind].ch[0] != -1) {
res = query(v, data[ind].ch[0], l, mid);
}
} else if (data[ind].ch[1] != -1) {
res = query(v, data[ind].ch[1], mid + 1, r);
}
if (comp(data[ind].line(v), res(v))) {
return data[ind].line;
}
return res;
}
Line<T> query_line(T v) const { return query(v, 0, lb, ub); }
T query(T v) const { return query_line(v)(v); }
};
constexpr int MAXB = 1e6;
struct Station {
int li;
int lpos;
bool operator==(const Station& rhs) const = default;
auto operator<=>(const Station& rhs) const = default;
};
struct Node {
i64 cost;
Station s;
bool operator==(const Node& rhs) const = default;
auto operator<=>(const Node& rhs) const = default;
};
int main() {
#ifndef LOCAL
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
#endif
int n, k;
std::cin >> n >> k;
std::vector<i64> a(k), b(k);
for (i64& v : a) {
std::cin >> v;
}
for (i64& v : b) {
std::cin >> v;
}
std::vector<int> p(k);
std::vector<std::vector<int>> x(k), pos(k);
std::vector<std::vector<i64>> w(k);
std::vector<std::vector<Station>> st(n);
std::vector<std::vector<i64>> dist(k);
for (int i = 0; i < k; ++i) {
std::cin >> p[i];
x[i].resize(p[i]);
w[i].resize(p[i] - 1);
pos[i].resize(p[i]);
dist[i].resize(p[i], INF<i64>);
std::cin >> x[i][0];
--x[i][0];
st[x[i][0]].emplace_back(i, 0);
for (int j = 0; j < p[i] - 1; ++j) {
std::cin >> w[i][j] >> x[i][j + 1];
--x[i][j + 1];
st[x[i][j + 1]].emplace_back(i, j + 1);
}
}
std::vector<std::vector<bool>> vis(n);
for (int i = 0; i < n; ++i) {
rs::sort(st[i], {}, [&](const Station& s) { return a[s.li]; });
vis[i].resize(st[i].size(), i == 0);
for (int j = 0; j < std::ssize(st[i]); ++j) {
pos[st[i][j].li][st[i][j].lpos] = j;
}
}
std::priority_queue<Node, std::vector<Node>, std::greater<>> pq;
std::vector<int> ind(n);
std::vector<LiChao<i64>> lc(n, LiChao<i64>{MAXB});
ind[0] = (int)st[0].size();
for (int i = 0; i < std::ssize(st[0]); ++i) {
pq.emplace(0, st[0][i]);
dist[st[0][i].li][st[0][i].lpos] = 0;
}
while (!pq.empty()) {
auto [d, stat] = pq.top();
pq.pop();
if (dist[stat.li][stat.lpos] != d) {
continue;
}
auto [li, lpos] = stat;
if (lpos < p[li] - 1 && dist[li][lpos + 1] > dist[li][lpos] + w[li][lpos]) {
dist[li][lpos + 1] = dist[li][lpos] + w[li][lpos];
pq.emplace(dist[li][lpos + 1], Station{li, lpos + 1});
}
int node = x[li][lpos];
int npos = pos[li][lpos];
vis[node][npos] = true;
lc[node].upd(b[li], dist[li][lpos]);
while (ind[node] < std::ssize(st[node]) && vis[node][ind[node]]) {
++ind[node];
}
if (ind[node] < std::ssize(st[node])) {
auto [ili, ilpos] = st[node][ind[node]];
i64 dd = lc[node].query(a[ili]);
if (dist[ili][ilpos] > dd) {
dist[ili][ilpos] = dd;
pq.emplace(dist[ili][ilpos], st[node][ind[node]]);
}
}
}
std::vector<i64> ans(n, INF<i64>);
for (int i = 0; i < k; ++i) {
for (int j = 0; j < p[i]; ++j) {
ans[x[i][j]] = std::min(ans[x[i][j]], dist[i][j]);
}
}
for (i64 val : ans | rv::drop(1)) {
std::cout << val << ' ';
}
std::cout << '\n';
} | passed | 52_std.cpp |
#include <bits/stdc++.h>
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<double, double>
#define F first
#define S second
#define all(x) x.begin(), x.end()
using namespace std;
const int C = 500 * 500;
int n, m, arr[505][505], p[505 * 505], vis[505 * 505], notp[C + 5];
pii pos[505 * 505];
char s[505][505], f[505][505], tmp[505][505];
vector<int> prime;
void moveL()
{
for (int i = 0; i < n; i++){
vector<int> have;
for (int j = 0; j < m; j++)
if (arr[i][j] != 0)
have.emplace_back(arr[i][j]);
for (int j = 0; j < m; j++){
if (have.size() > j)
arr[i][j] = have[j];
else arr[i][j] = 0;
}
}
}
void moveR(){
for (int i = 0; i < n; i++){
vector<int> have;
for (int j = 0; j < m; j++)
if (arr[i][j] != 0)
have.emplace_back(arr[i][j]);
for (int j = m - 1; j >= 0; j--){
if (!have.empty())
arr[i][j] = have.back(), have.pop_back();
else arr[i][j] = 0;
}
}
}
void moveU(){
for (int j = 0; j < m; j++){
vector<int> have;
for (int i = 0; i < n; i++)
if (arr[i][j] != 0)
have.emplace_back(arr[i][j]);
for (int i = 0; i < n; i++){
if (have.size() > i)
arr[i][j] = have[i];
else arr[i][j] = 0;
}
}
}
void moveD()
{
for (int j = 0; j < m; j++){
vector<int> have;
for (int i = 0; i < n; i++)
if (arr[i][j] != 0)
have.emplace_back(arr[i][j]);
for (int i = n - 1; i >= 0; i--){
if (!have.empty())
arr[i][j] = have.back(), have.pop_back();
else arr[i][j] = 0;
}
}
}
void execute(char c)
{
if (c == 'U')
moveU();
else if (c == 'D')
moveD();
else if (c == 'L')
moveL();
else if (c == 'R')
moveR();
}
char inv(char c)
{
if (c == 'U') return 'D';
else if (c == 'D') return 'U';
else if (c == 'L') return 'R';
else if (c == 'R') return 'L';
assert(0);
}
void print()
{
// for (int i = 0; i < n; i++)
// for (int j = 0; j < m; j++)
// cerr << arr[i][j] << " \n"[j == m - 1];
// cerr << '\n';
}
void dfs(int u, string &buf, char ext[505][505], bool reset)
{
vis[u] = 1;
buf.push_back(ext[pos[u].F][pos[u].S]);
if (!vis[p[u]])
dfs(p[u], buf, ext, reset);
if (reset)
vis[u] = 0;
}
vector<int> KMP(string s, string t)
{
t = " "s + t;
vector<int> f(t.size(), 0);
f[0] = -1;
for (int i = 1, j = -1; i < (int)t.size(); i++)
{
while (j >= 0 && t[j + 1] != t[i])
j = f[j];
f[i] = ++j;
}
vector<int> match;
for (int i = 0, j = 0; i < s.size(); i++)
{
while (j >= 0 && t[j + 1] != s[i])
j = f[j];
if (++j + 1 == t.size()) match.emplace_back(i), j = f[j];
}
return match;
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 2; i <= n * m; i++)
if (!notp[i])
{
prime.emplace_back(i);
for (int j = i * 2; j <= n * m; j += i)
notp[j] = 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
{
cin >> s[i][j];
if (s[i][j] == '.') s[i][j] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
{
cin >> f[i][j];
if (f[i][j] == '.') f[i][j] = 0;
}
auto check = [&]()
{
bool flag = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (f[i][j] != arr[i][j])
flag = false;
return flag;
};
auto copy = [&]()
{
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
arr[i][j] = s[i][j];
};
if ((copy(), check()) || (copy(), moveD(), check()) || (copy(), moveU(), check()) || (copy(), moveL(), check()) || (copy(), moveR(), check()))
{
cout << "yes\n";
return 0;
}
for (auto a1 : "UDLR"s)
for (auto a2 : "UDLR"s)
{
if ("LR"s.find(a1) != string::npos && "LR"s.find(a2) != string::npos)
continue;
if ("UD"s.find(a1) != string::npos && "UD"s.find(a2) != string::npos)
continue;
auto check_prefix = [&](string ops)
{
// cerr << "check " << ops << '\n';
copy();
for (auto op : ops)
execute(op);
int k = 0;
bool bad = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
{
tmp[i][j] = arr[i][j];
if (arr[i][j])
arr[i][j] = ++k, vis[k] = 0;
if ((arr[i][j] > 0) != (f[i][j] > 0))
bad = 1;
}
if (bad)
return;
print();
execute(inv(ops.end()[-2]));
execute(inv(ops.end()[-1]));
execute(ops.end()[-2]);
execute(ops.end()[-1]);
print();
for (int i = 0, t = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (arr[i][j])
p[++t] = arr[i][j], pos[t] = pii(i, j);
map<int, int> cond;
auto add_cond = [&](int pkmod, int rem)
{
if (cond.find(pkmod) != cond.end() && cond[pkmod] != rem)
bad = true;
cond[pkmod] = rem;
};
for (int i = 1; i <= k; i++)
if (!vis[i])
{
string orig, after;
dfs(i, orig, tmp, true);
dfs(i, after, f, false);
auto v = KMP(orig + orig, after);
if (v.size() == 0)
{
bad = true;
break;
}
int offset = v[0], mod;
if (v.size() >= 2)
mod = v[1] - v[0];
else
mod = orig.size();
for (int j = 2; j <= mod; j++)
if (mod % j == 0)
{
int mul = 1;
while (mod % j == 0)
mul *= j, mod /= j;
add_cond(mul, offset % mul);
}
}
for (auto pr : prime)
{
ll i = 1, last = -1, r = -1;
while (i <= n * m)
{
if (cond.find(i) != cond.end())
{
if (r != -1 && cond[i] % last != r)
bad = true;
r = cond[i], last = i;
}
i *= pr;
}
}
if (!bad)
{
cout << "yes\n";
exit(0);
}
};
string ops = ""s + a1 + a2;
for (int _ = 0; _ < 4; _++)
check_prefix(ops), ops += inv(ops.end()[-2]);
}
cout << "no\n";
} | passed | 115_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define tr(x) (((x) - 1) / m + 1)
#define tc(x) (((x) - 1) % m + 1)
ll n, m, k;
bool ck(ll x, vector<ll> &p) {
vector<vector<ll>> a(n + 1, vector<ll>(m + 1));
for (ll i = 1; i <= x; ++i) {
a[tr(p[i])][tc(p[i])] = 1;
}
ll minv = LLONG_MAX;
for (ll i = 1; i <= n; ++i) {
ll cnt = 0;
for (ll j = 1; j <= m; ++j) {
cnt += a[i][j] == 0;
}
if (cnt < minv)
minv = cnt;
}
if (minv <= k) return true;
return false;
}
void solve() {
cin >> n >> m >> k;
ll nm = n * m;
vector<ll> p(nm + 1);
for (ll i = 1; i <= nm; ++i)
cin >> p[i];
ll L = m, R = nm;
while (L < R) {
ll mid = (L + R >> 1) + (L + R & 1 ? 1 : 0);
if (ck(mid, p)) {
R = mid - 1;
}
else {
L = mid;
}
}
if (ck(R, p)) cout << R << "\n";
else cout << R + 1 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
} | passed | 31_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
using pii = pair<int,int>;
#define fi first
#define se 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
const int MAXN = 4e5 + 5;
struct Info {
int mn, cnt;
int tag;
} t[MAXN << 2];
void push_up(int cur, int l, int r){
t[cur].mn = min(t[cur << 1].mn, t[cur << 1 | 1].mn);
t[cur].cnt = t[cur << 1].cnt * (t[cur << 1].mn == t[cur].mn) + t[cur << 1 | 1].cnt * (t[cur << 1 | 1].mn == t[cur].mn);
}
void push_down(int cur, int l, int r){
t[cur << 1].mn += t[cur].tag;
t[cur << 1 | 1].mn += t[cur].tag;
t[cur << 1].tag += t[cur].tag;
t[cur << 1 | 1].tag += t[cur].tag;
t[cur].tag = 0;
}
int len[MAXN];
void build(int cur, int l, int r){
if(l == r){
t[cur].cnt = len[l];
return;
}
int mid = (l + r) >> 1;
build(cur << 1, l, mid);
build(cur << 1 | 1, mid + 1, r);
push_up(cur, l, r);
}
void update(int cur, int l, int r, int ql, int qr, int val){
if(l > qr || r < ql) return;
if(l >= ql && r <= qr){
t[cur].mn += val;
t[cur].tag += val;
return;
}
push_down(cur, l, r);
int mid = (l + r) >> 1;
update(cur << 1, l, mid, ql, qr, val);
update(cur << 1 | 1, mid + 1, r, ql, qr, val);
push_up(cur, l, r);
}
int q, w;
pii qs[MAXN];
signed main() {
cin.tie(0)->sync_with_stdio(0);
cin >> q >> w;
vector <int> lst;
for(int i = 1; i <= q; ++i){
int x, y;
cin >> x >> y;
int l = x - y, r = x + y;
l = max(l, 0ll);
r = min(r, w);
lst.push_back(l);
lst.push_back(r);
qs[i] = {x, y};
}
sort(all(lst));
lst.erase(unique(all(lst)), lst.end());
int tn = lst.size();
for(int i = 1; i < tn; ++i){
len[i] = lst[i] - lst[i - 1];
}
int tlen = lst.back() - lst.front();
build(1, 1, tn);
set <pii> st;
for(int i = 1; i <= q; ++i){
int pl = qs[i].first - qs[i].second;
int pr = qs[i].first + qs[i].second;
pl = max(pl, 0ll);
pr = min(pr, w);
int l = lower_bound(all(lst), pl) - lst.begin() + 1;
int r = lower_bound(all(lst), pr) - lst.begin();
if(!st.count(qs[i])){
update(1, 1, tn, l, r, 1);
st.insert(qs[i]);
}
else{
update(1, 1, tn, l, r, -1);
st.erase(qs[i]);
}
int ans = tlen - t[1].cnt * !t[1].mn;
cout << fixed << setprecision(10) << sqrtl(2) * ans << "\n";
}
} | passed | 106_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, q;
cin >> n >> q;
stack<int> stk;
stk.push(0);
vector<int> a(n + 1, 1e18), nxt(n + 1, 0), cur(n + 1, 0);
for (int i = 1; i <= n; ++i)
{
cin >> a[i];
while (a[i] > a[stk.top()])
{
nxt[stk.top()] = i;
stk.pop();
}
stk.push(i);
}
vector<int> fa(n + 1);
iota(fa.begin(), fa.end(), 0);
auto find = [&](auto find, int x) -> int
{
return x == fa[x] ? x : fa[x] = find(find, fa[x]);
};
while (q--)
{
char t;
int l, x;
cin >> t;
if (t == '+')
{
cin >> l >> x;
int p = find(find, l);
while (x)
{
if (x <= a[p] - cur[p])
{
cur[p] += x;
x -= x;
}
else
{
x -= a[p] - cur[p];
cur[p] = a[p];
fa[p] = nxt[p];
}
p = find(find, p);
}
}
else
{
cin >> l;
cout << cur[l] << '\n';
}
}
} | passed | 62_std.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 n, w;
std::cin >> n >> w;
std::vector<std::array<int, 3>> shadow(2 * n);
for (int i = 0; i < n; i++) {
int x, yl, yh;
std::cin >> x >> yl >> yh;
shadow[i << 1] = {x, yl, 1};
shadow[i << 1 | 1] = {x, yh, -1};
}
std::vector<int> p(2 * n);
std::iota(p.begin(), p.end(), 0);
std::sort(p.begin(), p.end(), [&](int i, int j) {
auto [xa, ya, za] = shadow[i];
auto [xb, yb, zb] = shadow[j];
if (1ll * ya * xb != 1ll * yb * xa) {
return 1ll * ya * xb < 1ll * yb * xa;
}
if (ya != yb) {
return ya < yb;
}
if (za != zb) {
return za > zb;
}
return xa < xb;
});
std::vector<int> invp(2 * n);
for (int i = 0; i < 2 * n; i++) {
invp[p[i]] = i;
}
int bad = 0;
std::vector<int> f(2 * n);
for (int i = 0; i + 1 < 2 * n; i++) {
f[i + 1] = f[i] + shadow[p[i]][2];
if (f[i + 1] == 0) {
bad++;
}
}
std::vector<std::tuple<double, int, int, int, int>> points;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
auto [xa, ya, za] = shadow[i];
auto [xb, yb, zb] = shadow[j];
if (ya < yb) {
double X = double(xa) - double(ya) * (xb - xa) / (yb - ya);
if (X < 0) {
points.push_back({-X, ya, yb, i, j});
}
}
}
}
std::sort(points.begin(), points.end());
double last = 0, ans = 0;
for (auto& [t, yi, yj, i, j] : points) {
if (!bad) {
ans += t - last;
}
last = t;
// std::cout << invp[i] << " " << invp[j] << '\n';
// assert(i + 1 == j);
int k = invp[j];
std::swap(p[k], p[k + 1]);
std::swap(invp[i], invp[j]);
bad -= f[k + 1] == 0;
f[k + 1] -= shadow[j][2];
f[k + 1] += shadow[i][2];
bad += f[k + 1] == 0;
}
if (!bad) {
std::cout << -1 << '\n';
return 0;
}
std::cout << std::fixed << std::setprecision(10) << ans << '\n';
return 0;
} | passed | 108_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
#define make_unique(x) sort(all(x)), x.erase(unique(all(x)), x.end())
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 Rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 20;
const int M = 2e5;
template<int mod>
class Mdl {
public:
int val;
Mdl() : val(0) {}
Mdl(int new_val) : val(new_val) {}
// Mdl(long long new_val) : val(new_val % mod) {} // AFFECTS OPERATOR* (because it has one more %)
friend Mdl operator+(const Mdl& a, const Mdl& b) {
if (a.val + b.val >= mod) return a.val + b.val - mod;
else return a.val + b.val;
}
friend Mdl operator-(const Mdl& a, const Mdl& b) {
if (a.val - b.val < 0) return a.val - b.val + mod;
else return a.val - b.val;
}
friend Mdl operator*(const Mdl& a, const Mdl& b) { return 1ll * a.val * b.val % mod; }
friend Mdl binpow(Mdl a, long long n) {
Mdl res = 1;
for (; n; n >>= 1) {
if (n & 1) res *= a;
a *= a;
}
return res;
}
/*
friend Mdl inv(const Mdl& a) {
Mdl x, y;
gcd(a.val, mod, x, y);
return x;
}
*/
friend Mdl inv(const Mdl& a) { return binpow(a, mod - 2); }
friend Mdl operator^(const Mdl& a, const long long& b) {
if (b >= 0)
return binpow(a, b % (mod - 1));
return binpow(inv(a), (-b) % (mod - 1));
}
/* ALTERNATIVE INVERSE FUNCTION USING EXTENDED EUCLIDEAN ALGORITHM
friend void gcd(int a, int b, Mdl& x, Mdl& y) {
if (a == 0) {
x = Mdl(0);
y = Mdl(1);
return;
}
Mdl x1, y1;
gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
}
*/
Mdl operator/(const Mdl& ot) const { return *this * inv(ot); }
Mdl& operator++() {
if (val + 1 == mod) val = 0;
else ++val;
return *this;
}
Mdl operator++(int) {
Mdl tmp = *this;
++(*this);
return tmp;
}
Mdl operator+() const { return *this; }
Mdl operator-() const { return 0 - *this; }
Mdl& operator+=(const Mdl& ot) { return *this = *this + ot; }
Mdl& operator-=(const Mdl& ot) { return *this = *this - ot; }
Mdl& operator*=(const Mdl& ot) { return *this = *this * ot; }
Mdl& operator/=(const Mdl& ot) { return *this = *this / ot; }
bool operator==(const Mdl& ot) const { return val == ot.val; }
bool operator!=(const Mdl& ot) const { return val != ot.val; }
bool operator<(const Mdl& ot) const { return val < ot.val; }
bool operator>(const Mdl& ot) const { return val > ot.val; }
explicit operator int() const { return val; }
};
template<int mod>
istream& operator>>(istream& istr, Mdl<mod>& x) {
return istr >> x.val;
}
template<int mod>
ostream& operator<<(ostream& ostr, const Mdl<mod>& x) {
return ostr << x.val;
}
const int mod = 998244353;
using mint = Mdl<mod>;
//USE WITH Mdl
typedef vector<mint> vl;
const mint root = 62;
void ntt(vl &a) {
int n = sz(a), L = 31 - __builtin_clz(n);
vl rt(2, 1);
for (int k = 2, s = 2; k < n; k *= 2, s++) {
rt.resize(n);
mint z[] = {mint(1), root^(mod>>s)};
for (int i=k; i < 2*k; ++i) rt[i] = rt[i/2]*z[i&1];
}
vector<int> rev(n);
for (int i = 0; i < n; ++i) rev[i] = (rev[i / 2] | (i&1) << L) / 2;
for (int i = 0; i < n; ++i) if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int k=1; k < n; k *= 2)
for (int i = 0; i < n; i += 2*k) for (int j = 0; j < k; ++j) {
mint z = rt[j+k] * a[i + j +k], &ai = a[i + j];
a[i+j+k] = ai - z;
ai += z;
}
}
vl conv(const vl &a, const vl &b) {
if (a.empty() || b.empty()) return {};
int s = sz(a) + sz(b) - 1, B = 32 - __builtin_clz(s), n = 1<<B;
mint inv = mint(1) / n;
vl L(a), R(b), out(n);
L.resize(n), R.resize(n);
ntt(L), ntt(R);
for (int i = 0; i < n; ++i)
out[-i&(n-1)] = L[i] * R[i] * inv;
ntt(out);
return {out.begin(), out.begin() + s};
}
int n, m, arr[N];
mint fact[N], invf[N];
vl f, g, h;
mint C(int n, int k) {
if (k < 0 || k > n) return mint(0);
return fact[n] * invf[n-k] * invf[k];
}
mint get(int a) {
int b = n*m-a;
return h[n*m+b] * fact[a];
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n * m; ++i) {
cin >> arr[i];
}
g.resize(n*m+1);
f.resize(n*m+1);
for (int d = 0; d <= n * m; ++d) {
f[d] = 0;
g[n*m-d] = invf[d];
}
for (int x = 0; x <= n; ++x) {
for (int y = 0; y <= m; ++y) {
if ((x + y) & 1) f[x * y] += C(n, x) * C(m, y);
else f[x * y] -= C(n, x) * C(m, y);
}
}
for (int d = 0; d <= n * m; ++d) {
f[d] *= fact[d];
}
h = conv(f, g);
sort(arr + 1, arr + n * m + 1);
mint ans = 0;
for (int i = 1, j = 0; i <= n * m; ++i) {
if (i == n * m || arr[i] != arr[i + 1]) {
mint t = get(i) - get(j);
ans += arr[i] * t;
}
if (i < n*m && arr[i] != arr[i + 1]) j = i;
}
if ((n+m)&1) ans = -ans;
cout << ans << '\n';
}
int main() {
cin.tie(0)->sync_with_stdio(0);
fact[0] = 1;
for (int i = 1; i <= M; ++i) fact[i] = fact[i - 1] * i;
invf[M] = mint(1) / fact[M];
for (int i = M; i >= 1; --i) invf[i - 1] = invf[i] * i;
int T = 1;
cin >> T;
while (T--) solve();
} | passed | 54_std.cpp |
#include <bits/stdc++.h>
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define pb push_back
#define FIO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
const int N = 5007, M = 1e5 + 7, inf = 2e9;
int n, m;
int dp[N][N][2], fl[N][N], fr[N][N];
vector <int> adl[N], adr[N];
pair <pii, int> iv[M];
void smin(int& x, int y) {x = min(x, y);}
void task() {
cin >> n >> m;
vector <int> r(n);
for (int i = 0; i < n; i++) {
adl[i].clear();
adr[i].clear();
}
for (int i = 0; i < n; i++) cin >> r[i];
for (int i = 0; i < m; i++) {
int x, d, t; cin >> x >> d >> t;
if (r[x] >= n/2) iv[i].F = {0, n-1};
else iv[i].F = {(x-d-r[x]+2*n)%n, (x-d+r[x]+n)%n};
iv[i].S = t;
adl[iv[i].F.F].pb(i);
adr[iv[i].F.S].pb(i);
}
for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) fl[i][j] = fr[i][j] = inf;
for (int i = 0; i < n; i++) {
for (auto x : adl[i]) {
smin(fl[i][iv[x].F.S], iv[x].S);
}
for (auto x : adr[i]) {
smin(fr[i][iv[x].F.F], iv[x].S);
}
for (int j = i+1; j < i+n; j++) smin(fl[i][j%n], fl[i][(j-1+n)%n]);
for (int j = i-1; j > i-n; j--) smin(fr[i][(j+n)%n], fr[i][(j+1+n)%n]);
}
for (int i = 0; i < n; i++) dp[(i+1)%n][i][0] = dp[(i+1)%n][i][1] = inf;
for (int j = n-2; j >= 0; j--) {
for (int i = 0; i < n; i++) {
int co[2] = {1, j+1};
for (int o = 0; o < 2; o++) {
int l1 = (i+n-1)%n, r1 = (i+j+1)%n;
dp[i][(i+j)%n][o] = max(min(dp[l1][(i+j)%n][0], fr[l1][r1])-co[o], min(dp[i][r1][1], fl[r1][l1])-co[o^1]);
}
}
}
for (int i = 0; i < n; i++) cout << (dp[i][i][0] >= 0);
cout << "\n";
}
int main () {
FIO;
int tt; cin >> tt;
while (tt--) task();
return 0;
}
| passed | 77_std.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;
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;
int op=sign(cross(a[st]-s,a[st+1]-s));
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;
}
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;
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)<=0||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);
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();
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 | passed | 26_std.cpp |
#include<bits/stdc++.h>
using namespace std;
#define N 2055
const int inf=1e9;
int t,n,m,a[N],ans,dep[N],d[N];
bool vis[N];
vector<int>s[N],now;
bool check(){
// printf("\n-------------\n");
// for(auto v:now){printf("%d ",v);}
for(int i=2;i<=m;++i)d[i]=d[i>>1]+1;
for(int i=0;i<(int)now.size();++i)if(d[now[i]]>n-i)return 0;
return 1;
}
void dfs(){
if(now.size()>n)return;
for(int i=1;i<=m;++i)s[i].clear();
for(int i=1;i<=m;++i){
if(a[i]==-1||dep[i>>1]==-1)dep[i]=-1;
else dep[i]=dep[i>>1]+a[i];
}
for(int i=(1<<n);i<=m;++i)s[i].push_back(dep[i]);
int u=0;
for(int i=(1<<n)-1;i;--i){
int p1=0,p2=0;
auto &a=s[i<<1],&b=s[i<<1|1],&c=s[i];
while(p1<(int)a.size()&&p2<(int)b.size())
c.push_back(a[p1]<b[p2]?a[p1++]:b[p2++]);
while(p1<(int)a.size())c.push_back(a[p1++]);
while(p2<(int)b.size())c.push_back(b[p2++]);
for(int j=1;j<(int)c.size();++j)
if(c[j]==c[j-1]&&c[j]!=-1){u=i;break;}
if(u)break;
}
if(!u){
if(check())ans=min(ans,(int)now.size());
}else{
int x=a[u<<1],y=a[u<<1|1];
a[u<<1]=-1;now.push_back(u<<1);dfs();now.pop_back();a[u<<1]=x;
a[u<<1|1]=-1;now.push_back(u<<1|1);dfs();now.pop_back();a[u<<1|1]=y;
}
}
void sol(){
scanf("%d",&n);m=(1<<(n+1))-1;
for(int i=2;i<=m;++i)scanf("%d",&a[i]);
ans=inf;dfs();printf("%d\n",ans==inf?-1:ans);
}
int main(){
scanf("%d",&t);
while(t--)sol();
return 0;
} | passed | 86_std.cpp |
#include<bits/stdc++.h>
using namespace std;
#define N 2000
#define B 40
int f[N+2][N+2][N/B+8],res[N+2][N+2];
int diff[N+2][B+2];
int ans[N+2][N+2];
#define mod 998244353
int main(){
f[0][0][0]=1;
for(int i=0;i<=N;i++)for(int j=0;j<=N;j++)for(int k=0;k<=N/B;k++)if(j+k*(B+1)<=N){
(res[i][j+k*(B+1)]+=f[i][j][k])%=mod;
if(i)(f[i+1][j][k]+=f[i][j][k])%=mod;
(f[i+1][j][k+1]+=f[i][j][k])%=mod;
(f[i][j+k][k]+=f[i][j][k])%=mod;
}
memset(f,0,sizeof(f));
for(int i=0;i<=N;i++){
for(int j=1;j<=N;j++)for(int k=1;k<=B+1;k++)(f[i][j][k]+=f[i][j-1][k-1])%=mod;
for(int j=0;j<=N;j++){
(f[i][j][B+1]+=res[i][j])%=mod;
// if(res[i][j])printf("res[%d][%d]=%d\n",i,j,res[i][j]);
}
for(int j=1;j<=N;j++)for(int k=1;k<=B+1;k++){
(diff[j][k]+=diff[j][k-1])%=mod;
(f[i][j][k]+=diff[j][k])%=mod;
}
memset(diff,0,sizeof(diff));
for(int j=0;j<=N;j++)for(int k=1;k<=B+1;k++){
// printf("f[%d][%d][%d]=%d\n",i,j,k,f[i][j][k]);
(ans[i][j]+=f[i][j][k])%=mod;
int d=min({N-j,k,B});
(f[i+1][j+1][1]+=f[i][j][k])%=mod;
(f[i+1][j+d+1][d+1]+=mod-f[i][j][k])%=mod;
if(i>0){
d=min(k,B);
(diff[j][1]+=f[i][j][k])%=mod;
(diff[j][d+1]+=mod-f[i][j][k])%=mod;
}
}
}
int Tc;
scanf("%d",&Tc);
while(Tc--){
int n,m;
scanf("%d%d",&n,&m);
printf("%d\n",ans[n][m]);
}
return 0;
} | passed | 79_std.cpp |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=998244353;
const int N=2e5+5;
int n;
ll dg[N],hd[N],nw[N];
ll g0[N],g1[N],g2[N],g3[N];
int main(){
ios::sync_with_stdio(false);cin.tie(0);
cin >> n;
hd[n]=dg[n]=1;
for(int m=n; m>=1 ;m=(m-1)/2){
for(int i=0; i<=m ;i++){
nw[i]=g1[i]=g2[i]=0;
g3[i]=hd[i];
}
int b=m;
for(int i=1; ;i++){
for(int j=0; j*i<=b ;j++){
nw[j]=(nw[j]+g1[j*i]+g2[j*i])%mod;
}
b-=i;
if(b<0) break;
for(int j=b; j>=0 ;j--){
g0[j]=g2[j]=g3[j+i];
if(j+i<=b){
g0[j]=(g0[j]+g0[j+i])%mod;
g2[j]=(g2[j]+2*g2[j+i])%mod;
}
g1[j]=(mod-g0[j]);
}
for(int j=0; j<=b ;j++) g3[j]=g0[j];
/*for(int j=0; j<=3 ;j++) cout << g3[j] << ' ';
cout << endl;*/
}
for(int i=0; i<=m ;i++){
dg[i]=(dg[i]+nw[i])%mod;
hd[i]=nw[i];
}
}
int m=n;
{
for(int i=0; i<=m ;i++){
nw[i]=0;
g3[i]=dg[i];
}
int b=m;
for(int i=1; ;i++){
for(int j=0; j<=b ;j++){
nw[j]=(nw[j]+g3[j])%mod;
}
b-=i;
if(b<0) break;
for(int j=b; j>=0 ;j--){
g0[j]=g3[j+i];
if(j+i<=b){
g0[j]=(g0[j]+g0[j+i])%mod;
}
}
for(int j=0; j<=b ;j++) g3[j]=g0[j];
}
for(int i=0; i<=m ;i++){
cout << nw[m-i] << ' ';
}
cout << '\n';
}
cout << endl;
} | passed | 21_std.cpp |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
using ldb = long double;
struct pt {
ldb x, y;
pt operator+(const pt& o) const { return {x + o.x, y + o.y}; };
pt operator-(const pt& o) const { return {x - o.x, y - o.y}; };
pt operator*(const ldb o) const { return {x * o, y * o}; };
ldb operator*(const pt& o) const { return o.x * x + o.y * y; }
ldb operator^(const pt& o) const { return x * o.y - y * o.x; }
};
pt rotate(const pt& a, const pt& v2) {
return {v2 * a, v2 ^ a};
}
struct seg {
pt a, b;
bool operator<(const seg& o) const {
if (a.y != o.a.y) a.y < o.a.y;
return b.y < o.b.y;
}
pt at(ldb y) const {
return (b * (y - a.y) + a * (b.y - y)) * (1 / (b.y - a.y));
}
};
struct poly {
ldb t, a0, a1, a2, a3;
bool operator<(const poly& o) const { return t < o.t; }
};
struct item {
ldb t, v1, v2;
};
int t;
const ldb eps = 1e-12;
void solve() {
pt a0, v;
ldb z0, z1, z2;
cin >> a0.x >> a0.y >> z0 >> v.x >> v.y;
int n1, n2;
cin >> n1 >> z1;
vector<pt> c1(n1);
for (int i = 0; i < n1; ++i) cin >> c1[i].x >> c1[i].y;
cin >> n2 >> z2;
vector<pt> c2(n2);
for (int i = 0; i < n2; ++i) cin >> c2[i].x >> c2[i].y;
ldb alp1 = z0 / (z0 - z1);
ldb alp2 = z0 / (z0 - z2);
v = v * (alp1 - alp2);
ldb beta = v * v;
v = v * (1 / beta);
for (auto& u : c1) u = rotate((u - a0) * alp1, v);
for (auto& u : c2) u = rotate((u - a0) * alp2, v);
vector<seg> s1, s2, s3, s4;
for (int i = 0; i < n1; ++i) {
auto a = c1[i], b = c1[i == n1 - 1 ? 0 : i + 1];
if (abs(a.y - b.y) < eps) continue;
if (a.y > b.y)
s1.push_back({b, a});
else
s2.push_back({a, b});
}
for (int i = 0; i < n2; ++i) {
auto a = c2[i], b = c2[i == n2 - 1 ? 0 : i + 1];
if (abs(a.y - b.y) < eps) continue;
if (a.y > b.y)
s3.push_back({b, a});
else
s4.push_back({a, b});
}
sort(s1.begin(), s1.end());
sort(s2.begin(), s2.end());
sort(s3.begin(), s3.end());
sort(s4.begin(), s4.end());
vector<item> q;
auto update = [&](const seg& s, const seg& t, ldb z0, ldb z1, int f) -> void {
if (abs(z0 - z1) < eps) return;
auto a = s.at(z0), b = s.at(z1);
auto c = t.at(z0), d = t.at(z1);
ldb t1 = c.x - a.x, t2 = d.x - b.x;
if (t1 < t2) swap(t1, t2);
ldb val = z1 - z0;
if (abs(t1 - t2) > eps) {
q.push_back({t1, 0, f * val / (t2 - t1)});
q.push_back({t2, 0, -f * val / (t2 - t1)});
} else {
q.push_back({t2, f * val, 0});
}
};
int cc = 0;
for (const auto& s : {s3, s4}) {
for (const auto& t : {s1, s2}) {
cc++;
int f = cc == 1 || cc == 4 ? -1 : 1;
ldb lst_z = max(s[0].a.y, t[0].a.y);
for (int i = 0, j = 0; i < s.size() && j < t.size();) {
if (s[i].b.y < t[j].a.y) {
i++;
continue;
}
if (t[j].b.y < s[i].a.y) {
j++;
continue;
}
ldb nz = min(s[i].b.y, t[j].b.y);
update(s[i], t[j], lst_z, nz, f);
lst_z = nz;
if (nz == t[j].b.y)
j++;
else
i++;
}
}
}
sort(q.begin(), q.end(), [&](const item& a, const item& b) { return a.t < b.t; });
vector<poly> ans;
ldb v0 = 0, v1 = 0, s = 0, ss = 0;
ldb lt = -1e50;
ans.push_back({lt, s, v0, v1});
for (int i = 0; i < q.size(); ++i) {
auto t = q[i].t;
auto dt = t - lt;
ss += s * dt + v0 * dt * dt / 2 + v1 * dt * dt * dt / 6;
s += v0 * dt + v1 * dt * dt / 2;
v0 += v1 * dt;
v0 += q[i].v1, v1 += q[i].v2;
lt = t;
ans.push_back({q[i].t, ss, s, v0, v1});
}
ans.back().a1 = ans.back().a2 = ans.back().a3 = 0;
auto query = [&](ldb t) -> ldb {
auto [lt, a0, a1, a2, a3] = *(--upper_bound(ans.begin(), ans.end(), poly{t, 0, 0, 0}));
t -= lt;
return a0 + a1 * t + a2 * t * t / 2 + a3 * t * t * t / 6;
};
auto query2 = [&](ldb t) -> ldb {
auto [lt, a0, a1, a2, a3] = *(--upper_bound(ans.begin(), ans.end(), poly{t, 0, 0, 0}));
t -= lt;
return a1 + a2 * t + a3 * t * t / 2;
};
int cq;
cin >> cq;
for (int i = 0; i < cq; ++i) {
ldb t1, t2;
cin >> t1 >> t2;
ldb result = t1 == t2 ? query2(t1) : (query(t2) - query(t1)) / (t2 - t1);
printf("%.8LF\n", result * beta);
}
}
int main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
cin >> t;
while (t--) solve();
} | passed | 12_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
// a component contains no articulation point, so P2 is a component
struct BlockCutTree {
int n, cnt = 0, cur = 0;
vector<int> low, dfn, stk;
vector<vector<int>> adj, bct;
BlockCutTree(int n) : n(n), low(n), dfn(n, -1), adj(n), bct(n) {}
void build(int root = 0) { dfs(root); }
void add_edge(int u, int v) { adj[u].push_back(v), adj[v].push_back(u); }
void dfs(int u) {
low[u] = dfn[u] = cur++;
stk.push_back(u);
for (auto v : adj[u]) {
if (dfn[v] == -1) {
dfs(v);
low[u] = min(low[u], low[v]);
if (low[v] == dfn[u]) {
bct.emplace_back();
int x;
do {
x = stk.back();
stk.pop_back();
bct[n + cnt].push_back(x);
bct[x].push_back(n + cnt);
} while (x != v);
bct[n + cnt].push_back(u);
bct[u].push_back(n + cnt);
cnt++;
}
} else {
low[u] = min(low[u], dfn[v]);
}
}
}
};
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
auto solve = [&]() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
vector a(n, vector<int>(m));
vector<int> p(n * m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 0) {
a[i][j] = n * m - 1;
} else {
a[i][j]--;
}
p[i * m + j] = a[i][j];
}
}
BlockCutTree g(n * m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
if (i + 1 < n && s[i + 1][j] == '.') {
g.add_edge(i * m + j, (i + 1) * m + j);
}
if (j + 1 < m && s[i][j + 1] == '.') {
g.add_edge(i * m + j, i * m + j + 1);
}
}
}
}
g.build(n * m - 1);
int cnt = g.cnt;
vector<vector<int>> groups(cnt);
auto dfs = [&](auto dfs, int u, int p) -> void {
if (u < n * m && p != -1) {
groups[p - n * m].push_back(u);
}
for (auto v : g.bct[u]) {
if (v != p) {
dfs(dfs, v, u);
}
}
};
dfs(dfs, n * m - 1, -1);
vector<int> vis(n * m);
for (auto &inds : groups) {
vector<int> vals;
for (auto i : inds) {
vals.push_back(p[i]);
}
sort(inds.begin(), inds.end());
sort(vals.begin(), vals.end());
if (inds != vals) {
cout << "impossible" << '\n';
return;
}
int parity = 0;
for (auto i : inds) {
if (!vis[i]) {
parity ^= 1;
for (int j = i; !vis[j]; j = p[j]) {
vis[j] = true;
parity ^= 1;
}
}
}
if (parity != 0) {
cout << "impossible\n";
return;
}
}
cout << "possible\n";
};
solve();
return 0;
} | passed | 63_std.cpp |
#include<bits/stdc++.h>
using namespace std;
const long double eps=1e-10;
const int maxn=2e5+5;
long long s[maxn];
long double f[maxn];
int n,m;
inline long double val(int l,int r){
return f[l]+sqrtl((s[r]-s[l])*(r-l));
}
// int dp(long double sy){
// static int cnt[maxn];
// for(int i=1;i<=n;i++){
// f[i]=val(0,i)+sy;
// cnt[i]=1;
// for(int j=i-1;j>=0;j--){
// long double vc=val(j,i)+sy;
// if(vc<=f[i]){
// f[i]=vc,cnt[i]=cnt[j]+1;
// }
// }
// }
// return cnt[n];
// }
int dp(long double sy){
static int tak[maxn],adv[maxn],cnt[maxn],top;
tak[top=1]=0,adv[top]=1;
for(int i=1;i<=n;i++){
int p=upper_bound(adv+1,adv+1+top,i)-(adv+1);
f[i]=val(tak[p],i)+sy,cnt[i]=cnt[tak[p]]+1;
int mydv=n+1;
while(top){
if(adv[top]>i and val(tak[top],adv[top])>val(i,adv[top])){
top--;
continue;
}
int l=max(adv[top],i+1),r=n,mid;
while(l<=r){
mid=(l+r)>>1;
if(val(tak[top],mid)>val(i,mid)){
mydv=mid,r=mid-1;
}else{
l=mid+1;
}
}
break;
}
if(mydv!=n+1){
top++,tak[top]=i,adv[top]=mydv;
}
}
return cnt[n];
}
long double wqs(int m){
long double l=-1e9,r=+1e9,mid;//补贴
while(l+eps<r){
mid=(l+r)/2;
if(m<=dp(mid)){
l=mid;
}else{
r=mid;
}
}
return f[n]-l*m;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)scanf("%lld",&s[i]);
// if(m==1){
// long double ans=0;
// for(int i=1;i<=n;i++)ans+=s[i];printf("%.10lf",sqrt(ans*n));return 0;
// }
// if(m==n){
// long double ans=0;
// for(int i=1;i<=n;i++)ans+=sqrt(s[i]);printf("%.10lf",ans);return 0;
// }
sort(s+1,s+1+n);
for(int i=1;i<=n;i++){
s[i]+=s[i-1];
}
printf("%.10Lf",wqs(m));
return 0;
} | passed | 5_std.cpp |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, cnt, prob, penalty, curp, curt;
string s;
bool finished;
struct Submisson {
bool sol;
int num, t;
} res[N];
int gtn(int l, int r) { return stoi(s.substr(l, r - l + 1)); }
string gts(int l, int r) { return s.substr(l, r - l + 1); }
void dfs(int now, int type) {
if (cnt > m) return;
if (now > n) {
if (curp == prob && curt == penalty) {
cout << prob << " " << penalty;
for (int i = 1; i <= cnt; i++) {
cout << " ";
if (res[i].sol) cout << res[i].t << " ";
cout << res[i].num << " " << (res[i].num > 1 ? "tries" : "try");
}
cout << '\n';
finished = 1;
}
return;
}
// prob
if (type == 1) {
prob = gtn(1, 1);
dfs(2, 2);
if (finished) return;
if (isdigit(s[2])) {
prob = gtn(1, 2);
dfs(3, 2);
}
return;
}
int pos = now;
// penalty
if (type == 2) {
while (pos < n && pos - now <= 3 && isdigit(s[pos + 1])) pos += 1;
for (int i = now; i <= pos; i++) {
penalty = gtn(now, i);
dfs(i + 1, 3);
if (finished) return;
}
return;
}
// submissons
if (!isdigit(s[now])) return;
while (pos < n && isdigit(s[pos + 1])) pos += 1;
if (pos - now > 5) return;
int nxt = pos + 1;
while (nxt < n && islower(s[nxt + 1])) nxt += 1;
string p = gts(pos + 1, pos + 3);
bool tries = 0;
if (p == "tri") tries = 1;
// unaccepted
int num = gtn(now, pos);
if ((num == 1 && !tries) || (num > 1 && tries)) {
if (s[now] != '0' && num <= 100) {
res[++cnt] = {0, num, 0};
dfs(nxt + 1, 3);
if (finished) return;
cnt -= 1;
}
}
// accepted
for (int i = now; i < pos; i++) {
int t = gtn(now, i), num = gtn(i + 1, pos);
if (s[i + 1] == '0') continue;
if (num == 0) continue;
if (tries && num == 1) continue;
if (!tries && num > 1) continue;
if (t >= 300) continue;
if (num > 100) continue;
curp += 1;
curt += (num - 1) * 20 + t;
res[++cnt] = {1, num, t};
dfs(nxt + 1, 3);
if (finished) return;
curp -= 1;
curt -= (num - 1) * 20 + t;
cnt -= 1;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int T;
cin >> T >> m;
while (T--) {
cnt = finished = 0;
curp = curt = 0;
cin >> s;
n = s.length();
s = "#" + s;
dfs(1, 1);
}
} | passed | 16_std.cpp |
#include <bits/stdc++.h>
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<double, double>
#define F first
#define S second
#define all(x) x.begin(), x.end()
using namespace std;
pdd operator+(pdd a, pdd b)
{
return pdd(a.F + b.F, a.S + b.S);
}
pdd operator-(pdd a)
{
return pdd(-a.F, -a.S);
}
pdd operator-(pdd a, pdd b)
{
return a + (-b);
}
pdd operator*(pdd a, double b)
{
return pdd(a.F * b, a.S * b);
}
pdd operator/(pdd a, double b)
{
return pdd(a.F / b, a.S / b);
}
double dot(pdd a, pdd b)
{
return a.F * b.F + a.S * b.S;
}
double abs2(pdd a)
{
return dot(a, a);
}
pdd orth(pdd p)
{
return pdd(-p.S, p.F);
}
pdd interpo(pdd p, pdd q, double t)
{
return p * t + q * (1 - t);
}
double h1, h2;
pdd p1, q1, p2, q2;
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> p1.F >> p1.S >> q1.F >> q1.S >> h1;
cin >> p2.F >> p2.S >> q2.F >> q2.S >> h2;
pdd v1 = q1 - p1, v2 = q2 - p2;
pdd b1 = p1 + v1 / 2.0 + orth(v1) / 2.0;
pdd b2 = p2 + v2 / 2.0 + orth(v2) / 2.0;
double ans = 1e18;
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
const int S = 100;
int T = 200;
double l1 = 0, r1 = 1, l2 = 0, r2 = 1;
while (T--)
{
double d1 = (r1 - l1) / S;
double d2 = (r2 - l2) / S;
pii best(0, 0);
double cur = 1e18;
for (int t1 = 0; t1 <= S; t1++)
for (int t2 = 0; t2 <= S; t2++)
{
pdd x = interpo(p1, q1, l1 + t1 * d1);
pdd y = interpo(p2, q2, l2 + t2 * d2);
double dis = sqrt(abs2(b1 - x) + h1 * h1) +
sqrt(abs2(x - y)) +
sqrt(abs2(b2 - y) + h2 * h2);
if (dis < cur)
cur = dis, best = pii(t1, t2);
}
auto [t1, t2] = best;
ans = min(ans, cur);
l1 = max(0.0, l1 + (t1 - 30) * d1);
l2 = max(0.0, l2 + (t2 - 30) * d2);
r1 = min(1.0, l1 + (t1 + 30) * d1);
r2 = min(1.0, l2 + (t2 + 30) * d2);
}
p2 = p2 + v2;
v2 = orth(v2);
q2 = q2 + v2;
}
p1 = p1 + v1;
v1 = orth(v1);
q1 = q1 + v1;
}
cout << fixed << setprecision(10) << ans << '\n';
} | passed | 113_std.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 long long ll;
typedef vector<ll> VI;
typedef basic_string<int> BI;
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 f[1111],ret,g[30][30][1111],tg[30][1111];
map<pair<VI,VI>,map<ll,ll>> hs;
map<ll,ll> count(VI s,VI coef) {
map<ll,ll> v;
if (s[0]==0) {
bool z=1;
for (auto x:s) z&=(x==0);
if (z) v[0]=1;
return v;
}
if (hs.count(mp(s,coef))) return hs[mp(s,coef)];
if (SZ(s)>=2) {
VI ss=s,cc=coef;
ss.pop_back(); cc.pop_back();
if (count(ss,cc).empty()) return v;
}
for (int j=1;j<=s[0];j++) for (int k=1;k*j<=s[0];k++) {
VI ncoef=coef,ns=s; ncoef.insert(ncoef.begin(),k);
bool val=1;
rep(l,0,SZ(s)) {
ns[l]=ns[l]-j*ncoef[l];
if (ns[l]<0) { val=0; break; }
}
ncoef.pop_back();
if (val) {
auto d=count(ns,ncoef);
for (auto [key,val]:d) v[key+j*coef.back()]+=val;
}
}
return hs[mp(s,coef)]=v;
}
vector<array<VI,3>> ret;
void dfs(VI s,VI coef,VI p1,VI p2) {
//printf("?? %lld %d\n",s[0],SZ(p1));
if (s[0]==0) {
bool z=1;
for (auto x:s) z&=(x==0);
if (z) {
reverse(all(p1));
reverse(all(p2));
int d=SZ(p2);
VI p3=p2;
while (1) {
__int128_t x=0;
rep(j,0,d) x+=(__int128_t)p1[j]*p3[SZ(p3)-d+j];
if (x>=(1ll<<62)||SZ(p3)>=100) break;
p3.pb(x);
}
p3=VI(p3.begin()+d,p3.end());
ret.pb({p3,p1,p2});
}
}
if (!hs.count(mp(s,coef))) return;
if (hs[mp(s,coef)].empty()) return;
//assert(hs.count(mp(s,coef)));
//if (count(s,coef).empty()) return;
for (int j=1;j<=s[0];j++) for (int k=1;k*j<=s[0];k++) {
VI ncoef=coef,ns=s; ncoef.insert(ncoef.begin(),k);
bool val=1;
rep(l,0,SZ(s)) {
ns[l]=ns[l]-j*ncoef[l];
if (ns[l]<0) { val=0; break; }
}
VI q1=p1,q2=p2; q1.pb(j); q2.pb(k);
ncoef.pop_back();
if (val) dfs(ns,ncoef,q1,q2);
}
}
int K;
VI seq;
int main() {
scanf("%d",&K);
rep(i,1,25) {
auto d=count(VI{i},VI{i});
ll z=0;
for (auto [key,val]:d) {
z+=val;
}
if (K>z) {
K-=z;
} else {
seq.pb(i);
break;
}
}
ll v=0;
rep(rd,1,10) {
auto d=count(seq,seq);
for (auto [key,val]:d) {
if (K>val) {
K-=val;
} else {
seq.pb(key);
fprintf(stderr,"%lld %lld\n",key,val);
v=val;
break;
}
}
if (v<=400000) break;
}
//printf("?? %d\n",SZ(seq));
count(seq,seq);
dfs(seq,seq,VI{},VI{});
assert(SZ(ret)==v);
sort(all(ret));
fprintf(stderr,"!! %d\n",K);
auto [p3,p1,p2]=ret[K-1];
printf("%d\n",SZ(p1));
p3.resize(10);
for (auto x:p1) printf("%lld ",x); puts("");
for (auto x:p2) printf("%lld ",x); puts("");
for (auto x:p3) printf("%lld ",x); puts("");
} | passed | 114_std.cpp |
#include <algorithm>
#include <cstdint>
#include <ios>
#include <iostream>
#include <numeric>
#include <vector>
void solve() {
std::int32_t n;
std::cin >> n;
std::vector<std::int32_t> a(n);
std::vector<std::int32_t> b(n);
for (std::int32_t i = 0; i < n; ++i) {
std::cin >> a[i] >> b[i];
}
const std::int32_t sz = std::accumulate(std::begin(a), std::end(a), std::int32_t(1));
std::vector dp(sz, std::accumulate(std::begin(b), std::end(b), std::int32_t(1)));
dp[0] = 0;
for (std::int32_t i = 0; i < n; ++i) {
for (std::int32_t j = sz - 1; j >= 0; --j) {
dp[j] += b[i];
if (j >= a[i]) {
dp[j] = std::min(dp[j], dp[j - a[i]]);
}
}
}
std::int32_t mn_tm = dp[0] + 1;
for (std::int32_t i = 0; i < sz; ++i) {
mn_tm = std::min(mn_tm, std::max(i, dp[i]));
}
std::cout << mn_tm << '\n';
}
int main() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
solve();
return 0;
} | passed | 99_std.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 = 200;
int idx;
int ed, cnt;
bool vis[10];
int sta[N + 3];
struct node {
int op, a, b;
} p[N + 3];
int calc(int x) {
if (x < 10)
return 1;
x -= 9;
int a = calc(p[x].a), b = calc(p[x].b);
if (p[x].op == 0) {
return std::min(a, b);
}
if (p[x].op == 1) {
return a <= b;
}
if (p[x].op == 2) {
return std::max(a, b);
}
if (p[x].op == 3) {
return a < b;
}
return -1;
}
void output(int x) {
if (x < 10) {
printf("%c", x + 'a');
return;
}
x -= 9;
// fprintf(stderr, "%d %d %d\n", p[x].op, p[x].a, p[x].b);
if (p[x].op == 0) {
printf("(min ");
output(p[x].a);
printf(" ");
output(p[x].b);
printf(")");
}
if (p[x].op == 1) {
printf("(");
output(p[x].a);
printf(" <= ");
output(p[x].b);
printf(")");
}
if (p[x].op == 2) {
printf("((min (");
output(p[x].a);
printf(" <= ");
for (int i = 0; i < 10; ++i) {
if (!vis[i])
continue;
if (i != ed)
printf("(min %c ", i + 'a');
else
printf("%c", i + 'a');
}
for (int i = 1; i < cnt; ++i) {
printf(")");
}
printf(") (");
output(p[x].b);
printf(" <= ");
for (int i = 0; i < 10; ++i) {
if (!vis[i])
continue;
if (i != ed)
printf("(min %c ", i + 'a');
else
printf("%c", i + 'a');
}
for (int i = 1; i < cnt; ++i) {
printf(")");
}
printf(")");
printf(")");
printf(" <= ");
for (int i = 0; i < 10; ++i) {
if (!vis[i])
continue;
if (i != ed)
printf("(min %c ", i + 'a');
else
printf("%c", i + 'a');
}
for (int i = 1; i < cnt; ++i) {
printf(")");
}
printf(")");
}
if (p[x].op == 3) {
printf("(min (");
output(p[x].a);
printf(" <= ");
for (int i = 0; i < 10; ++i) {
if (!vis[i])
continue;
if (i != ed)
printf("(min %c ", i + 'a');
else
printf("%c", i + 'a');
}
for (int i = 1; i < cnt; ++i) {
printf(")");
}
printf(") ");
output(p[x].b);
printf(")");
}
}
int main() {
#ifdef LOCAL
file(a);
#endif
char ch;
memset(p, 0xff, sizeof(p));
while ((ch = gc()) != EOF) {
if (ch == '(') {
++idx;
if (sta[0]) {
if (~p[sta[sta[0]]].a)
p[sta[sta[0]]].b = idx + 9;
else
p[sta[sta[0]]].a = idx + 9;
}
sta[++sta[0]] = idx;
}
if (ch == ')') {
--sta[0];
}
if (ch == 'm') {
char ch1 = gc();
gc();
if (ch1 == 'a')
p[sta[sta[0]]].op = 2;
if (ch1 == 'i')
p[sta[sta[0]]].op = 0;
}
if (ch == '<') {
char ch1 = gc();
if (ch1 == ' ')
p[sta[sta[0]]].op = 3;
if (ch1 == '=')
p[sta[sta[0]]].op = 1;
}
if ('a' <= ch && ch <= 'j') {
if (!vis[ch - 'a']) {
++cnt;
vis[ch - 'a'] = 1;
}
ed = std::max(ed, ch - 'a');
if (sta[0]) {
if (~p[sta[sta[0]]].a)
p[sta[sta[0]]].b = ch - 'a';
else
p[sta[sta[0]]].a = ch - 'a';
} else {
printf("YES\n");
pc(ch);
return 0;
}
}
}
int status = calc(10);
// assert(status != -1);
if (!status) {
printf("NO\n");
return 0;
}
printf("YES\n");
output(10);
return 0;
} | passed | 93_std.cpp |
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define all(x) (x).begin(),(x).end()
typedef long long i64;
typedef pair<int, int> pii;
const int N = 1e6 + 10;
i64 nxt[N][26], cnt[N], score[N], ans, sz;
vector<i64> son[N];
void insert(string &s) {
int j = 0;
for(auto ch : s) {
int t = ch - 'a';
if(!nxt[j][t]) nxt[j][t] = ++sz;
j = nxt[j][t];
++cnt[j];
for(auto k : son[cnt[j]]) {
ans ^= (k * score[k]);
++score[k];
ans ^= (k * score[k]);
}
}
}
void solve() {
memset(nxt[0], 0, sizeof(nxt[0]));
ans = sz = 0;
int n; cin >> n;
for(int i = 1; i <= n; i++) {
string s; cin >> s;
insert(s);
cout << ans << ' ';
}
cout << endl;
while(sz) {
cnt[sz] = 0;
score[sz] = 0;
memset(nxt[sz], 0, sizeof(nxt[sz]));
--sz;
}
for(int i = 1; i <= n; i++) {
score[i] = 0;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
for(int i = 1; i <= 500000; i++) {
for(int j = i; j <= 500000; j += i) {
son[j].push_back(i);
}
}
int T; cin >> T;
while(T--) solve();
return 0;
} | passed | 40_std.cpp |
#include <bits/stdc++.h>
using ll = long long;
int main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m, k;
std::cin >> n >> m >> k;
bool f = false;
std::vector<std::vector<std::pair<int, int>>> g(n);
for (int i = 0; i < m; i++)
{
int u, v, w;
std::cin >> u >> v >> w;
u--, v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
std::vector<long double> pro(n);
for (int i = 0; i < k; i++)
{
int x;
long double p;
std::cin >> x >> p;
x--;
pro[x] = p;
if (p == 1.0)
{
f = true;
}
}
if (!f)
{
std::cout << "impossible\n";
return 0;
}
std::vector<ll> dis(n);
auto dij = [&](int s)
{
std::vector<ll> D(n, -1);
std::priority_queue<std::pair<ll, int>, std::vector<std::pair<ll, int>>, std::greater<>> q;
q.push({0, s});
while (!q.empty())
{
auto [d, x] = q.top();
q.pop();
if (D[x] != -1)
{
continue;
}
D[x] = d;
for (auto &[y, w] : g[x])
{
q.push({d + w, y});
}
}
for (int i = 0; i < n; i++)
{
dis[i] += D[i];
}
};
dij(0);
dij(n - 1);
std::vector<int> p(n);
std::iota(p.begin(), p.end(), 0);
std::sort(p.begin(), p.end(), [&](int i, int j)
{ return dis[i] < dis[j]; });
long double imp = 1;
long double ans = 0;
for (auto &i : p)
{
if (pro[i] == 0)
{
continue;
}
ans += imp * pro[i] * dis[i];
imp *= 1.0 - pro[i];
}
std::cout << std::fixed << std::setprecision(10) << ans << '\n';
} | passed | 65_std.cpp |
#include <bits/stdc++.h>
const int inf = 1e9;
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m;
std::cin >> n >> m;
std::vector<int> col(n + 1, 0);
for (int i = 1; i <= n; ++i)
{
std::cin >> col[i];
}
std::vector<int> din(2 * n + 1, 0);
std::vector<std::vector<int>> g(2 * n + 1);
std::vector<std::array<int, 4>> dp(2 * n + 1, {-inf, -inf, -inf, -inf});
std::array<int, 4> ans = {};
for (int i = 1; i <= m; ++i)
{
int u, v;
std::cin >> u >> v;
if (col[u] ^ col[v]) // 异色
{
g[u + n].push_back(v);
g[v + n].push_back(u);
din[v]++;
din[u]++;
}
else
{
g[u].push_back(v + n);
g[v].push_back(u + n);
din[u + n]++;
din[v + n]++;
}
}
std::queue<int> q;
int cnt = 2 * n;
for (int i = 1; i <= 2 * n; ++i)
{
if (!din[i])
{
q.push(i);
}
}
while (q.size())
{
int u = q.front();
q.pop();
--cnt;
if (u > n)
{
dp[u][2 + col[u - n]] = std::max(dp[u][2 + col[u - n]], 1);
}
else
{
dp[u][col[u]] = std::max(dp[u][col[u]], 1);
}
for (auto v : g[u])
{
for (int i = 0; i < 4; ++i)
{
dp[v][i] = std::max(dp[v][i], dp[u][i] + 1);
}
if (--din[v] == 0)
{
q.push(v);
}
}
for (int i = 0; i < 4; ++i)
{
ans[i] = std::max(ans[i], dp[u][i]);
}
}
if (cnt)
{
std::cout << "infinity\n";
}
else
{
std::sort(begin(ans), end(ans));
std::cout << ans.front() + 1 << '\n';
}
} | passed | 58_std.cpp |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> P;
const int N = 5e5 + 10;
int a[N];
void solve() {
int n;
cin >> n;
for(int i = 1; i <= n; i++) cin >> a[i];
int k = 0;
vector <int> ans;
for(int i = 1; i <= n; i++) {
if(a[i] > a[k]) {
ans.clear();
ans.push_back(i);
k = i;
} else if(a[i] == a[k]) ans.push_back(i);
}
for(auto x : ans) cout << x << ' ';
cout << '\n';
}
int main() {
// freopen("1.in", "r", stdin);
// freopen("1.out", "w", stdout);
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T = 1;
cin >> T;
while(T--) solve();
return 0;
} | passed | 36_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, qq;
cin >> n >> m >> qq;
vector<vector<pii>> e(n + 1);
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
a = (a % n + n) % n;
int y = ((a + b) % n + n) % n;
e[a].push_back({y, b});
}
vector<int> dfn(n + 1), low(n + 1), ins(n + 1), c(n + 1);
int tot = 0, cnt = 0;
vector<int> st;
vector<vector<int>> scc;
function<void(int)> tarjan = [&](int x) -> void {
low[x] = dfn[x] = ++tot;
st.push_back(x);
ins[x] = 1;
for (auto [j, w] : e[x]) {
if (!dfn[j]) {
tarjan(j);
low[x] = min(low[x], low[j]);
} else if (ins[j]) {
low[x] = min(low[x], dfn[j]);
}
}
if (low[x] == dfn[x]) {
int y;
cnt++;
scc.push_back({});
do {
y = st.back();
st.pop_back();
c[y] = cnt;
scc.back().push_back(y);
ins[y] = 0;
} while (y != x);
}
return;
};
for (int i = 0; i <= n - 1; i++) {
if (!dfn[i]) {
tarjan(i);
}
}
vector<int> ok(cnt + 1, 0);
vector<int> h(n + 1, -1), v(n + 1, 0), vis(n + 1);
function<void(int)> dfs = [&](int x) -> void {
for (auto [j, w] : e[x]) {
if (!v[j])
continue;
if (!vis[j]) {
vis[j] = 1;
h[j] = h[x] + w;
dfs(j);
} else {
if (h[j] != h[x] + w)
ok[c[x]] = 1;
}
}
};
for (auto p : scc) {
for (auto x : p)
v[x] = 1;
h[p[0]] = 0;
vis[p[0]] = 1;
dfs(p[0]);
for (auto x : p)
h[x] = -1, vis[x] = v[x] = 0;
}
vector<vector<int>> e1(cnt + 1);
vector<int> in(cnt + 1);
for (int i = 0; i <= n - 1; i++) {
for (auto [j, w] : e[i]) {
if (c[j] != c[i]) {
e1[c[j]].push_back(c[i]);
in[c[i]]++;
}
}
}
queue<int> q;
for (int i = 1; i <= cnt; i++) {
if (!in[i])
q.push(i);
}
while (q.size()) {
int x = q.front();
q.pop();
for (auto j : e1[x]) {
ok[j] |= ok[x];
if (!--in[j]) {
q.push(j);
}
}
}
for (int i = 1; i <= qq; i++) {
int x;
cin >> x;
x = (x % n + n) % n;
if (ok[c[x]]) {
cout << "Yes" << '\n';
} else
cout << "No" << '\n';
}
} | passed | 89_std.cpp |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
void exgcd(int A,int B,LL &x,LL &y){
if(!B) return x=1,y=0,void();
exgcd(B,A%B,y,x);
y=y-A/B*x;
}
unordered_map<long long,bool>used;
int main(){
cin.tie(0)->sync_with_stdio(0);
int T;
cin>>T;
while(T--){
LL A,B,n;cin>>A>>B>>n;
bool flg=0;LL Lst=n,x=0,inv=0;
exgcd(A,B,x,inv);inv=(inv+A)%A;
int tmp=Lst%B,ct=0;
for(int t=100;t;t--){
if(n%A==0){
n/=A;
}
else{
LL t=(A-n%A)*inv%A;
if(n<Lst) t=min(t,(Lst-n+B-1)/B);
n+=B*t;
}
if(n==Lst) {flg=1;break;}
}
if(Lst==tmp)flg=1;
n=tmp;
for(int t=100;t;t--){
if(n%A==0){
n/=A;
}
else{
LL t=(A-n%A)*inv%A;
if(n<Lst) t=min(t,(Lst-n+B-1)/B);
n+=B*t;
}
if(n==Lst) {flg=1;break;}
}
if(flg) puts("Yes");else puts("No");
}
return 0;
} | passed | 18_std.cpp |
#include<bits/stdc++.h>
#ifdef LOCAL
#define debug(...) printf(__VA_ARGS__)
#define edebug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#define edebug(...)
#endif
#define int ll
#define rep(i, x, y) for(int i = x; i <= y; ++i)
#define nrep(i, x, y) for(int i = x; i >= y; --i)
#define ll long long
#define pii std::pair<int,int>
#define pb emplace_back
#define fi first
#define se second
template <class T>
inline void ckmax(T &a, T b) {
if(a < b) a = b;
}
template <class T>
inline void ckmin(T &a, T b) {
if(a > b) a = b;
}
auto rt_YES = []{puts("YES");};
auto rt_Yes = []{puts("Yes");};
auto rt_NO = []{puts("NO");};
auto rt_No = []{puts("No");};
namespace IO {
#define isdigit(x) (x >= '0' && x <= '9')
inline char gc() {
return getchar();
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
double tmp = 1;
bool sign = 0;
x = 0;
char ch = gc();
for(; !isdigit(ch); ch = gc())
if(ch == '-') sign = 1;
for(; isdigit(ch); ch = gc())
x = x * 10 + (ch - '0');
if(ch == '.')
for(ch = gc(); isdigit(ch); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if(sign) x = -x;
}
inline void read(char *s) {
char ch = gc();
for(; blank(ch); ch = gc());
for(; !blank(ch); ch = gc())
*s++ = ch;
*s = 0;
}
inline void read(char &c) {
for(c = gc(); blank(c); c = gc());
}
inline void push(const char &c) {
putchar(c);
}
template <class T>
inline void print(T x) {
if(x < 0) {
x = -x;
push('-');
}
static T sta[35];
T top = 0;
do {
sta[top++] = x % 10;
x /= 10;
} while(x);
while(top)
push(sta[--top] + '0');
}
template <class T>
inline void print(T x, char lastChar) {
print(x);
push(lastChar);
}
}
using namespace IO;
int a[1000010];
void solve(){
int n;read(n);
rep(i,1,n)scanf("%1d",&a[i]);
if(a[n]==0&&a[n-1]==0){rt_Yes();return;}
if(n==3){rt_No();return;}
int r=0;
rep(i,1,n-2){
while(r<=n-2&&a[r+1]==1)++r;
if(r<i)r=i;
if(r>=n-2)break;
if(a[i]&&i!=r)a[r+1]=1,a[i+1]=0;
}
if(a[n-1]){
if(a[n-3]||(a[n-4]&&a[n-2]))rt_Yes();
else rt_No();
}
else if(a[n-2]&&(a[n-3]||a[n-4]))rt_Yes();
else rt_No();
}
signed main() {
clock_t c1 = clock();
#ifdef LOCAL
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
#endif
//------------------------------------------------------------------
int t;read(t);while(t--)solve();
//------------------------------------------------------------------
end:
std::cerr << "Time : " << clock() - c1 << " ms" << std::endl;
return 0;
} | passed | 69_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
using ll = long long;
using db = double;
int n, m;
const db eps = 1e-10;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int ct, c[maxn * 6];
int al[maxn * 6], ar[maxn * 6];
int bl[maxn * 6], br[maxn * 6];
db cross(pair<db, db> p, pair<db, db> q) {
return p.first * q.second - p.second * q.first;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
c[++ct] = a[i];
c[++ct] = a[i] + 1;
if (a[i] - 1)
c[++ct] = a[i] - 1;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> b[i];
c[++ct] = b[i];
if (b[i] - 1)
c[++ct] = b[i] - 1; // ?
c[++ct] = b[i] + 1;
}
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
long long f1 = 0, f2 = 0;
for (int i = 1; i <= n; i++) {
f1 += lower_bound(b + 1, b + m + 1, a[i]) - b - 1;
}
for (int i = 1; i <= m; i++) {
f2 += lower_bound(a + 1, a + n + 1, b[i]) - a - 1;
}
// cerr << f1 << " " << f2 << "\n";
if (f1 < f2) {
swap(n, m);
for (int i = 1; i <= max(n, m); i++) {
swap(a[i], b[i]);
}
}
sort(c + 1, c + ct + 1);
ct = unique(c + 1, c + ct + 1) - c - 1;
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(c + 1, c + ct + 1, a[i]) - c;
}
for (int i = 1; i <= m; i++) {
b[i] = lower_bound(c + 1, c + ct + 1, b[i]) - c;
}
for (int i = 1; i <= ct; i++) {
al[i] = lower_bound(a + 1, a + n + 1, i) - a;
ar[i] = upper_bound(a + 1, a + n + 1, i) - a;
}
for (int i = 1; i <= ct; i++) {
bl[i] = lower_bound(b + 1, b + m + 1, i) - b;
br[i] = upper_bound(b + 1, b + m + 1, i) - b;
}
db l = 0, r = 1;
// l = r = 0;
int timer = 1;
timer = 25;
while (timer--) {
db mid = (l + r) / 2.;
vector<pair<pair<db, db>,int> > candidate;
int flag = 0;
for (int i = 1; i <= ct; i++) {
// db t2 = 1. * (-(m - br[i] + 1) + (bl[i] - 1));
// db t1 = 1. * ((al[i] - 1) + (br[i] - al[i]) * .5) - mid * n;
db t1 = 1. * (-(n - ar[i] + 1) + (al[i] - 1));
db t2 = 1. * ((bl[i] - 1) + (br[i] - bl[i]) * .5) - mid * m;
if (abs(t1) > eps || abs(t2) > eps)
// cerr << c[i] << " " << t1 << " " << t2 << "\n",
candidate.push_back({make_pair(t1, t2),i});
else {
flag = 1;
}
}
// cerr << "\n";
auto cmp = [&](pair<pair<db, db>,int> a, pair<pair<db, db>,int> b) {
auto half = [&](pair<db,db> p) {
if (abs(p.second) < eps) {
if (p.first < 0) return 0;
return 1;
}
if (p.second > 0) return 1;
return 0;
};
int ha = half(a.fi), hb = half(b.fi);
if (ha != hb) return ha < hb;
db tmp=cross(a.fi,b.fi);
if(abs(tmp)<eps){
return a.se<b.se;
}
return tmp>0;
};
sort(candidate.begin(), candidate.end(), cmp);
// for(int i=0;i<candidate.size();i++){
// cout<<candidate[i].fi.fi<<" "<<candidate[i].fi.se<<" "<<candidate[i].se<<" $$\n";
// }
pair<pair<db, db>,int> o1(make_pair(0, -1),-1), o2(make_pair(1, 0),ct+10);
// pair<db, db> o1(0, -1), o2(1, 0);
for (int i = 0; i + 1 < candidate.size(); i++) {
auto p = candidate[i];
auto q = candidate[i + 1];
if (cross(p.fi, q.fi) <= 0) continue;
pair<pair<db, db>,int> s1 = max(o1, p, cmp);
pair<pair<db, db>,int> s2 = min(o2, q, cmp);
if (cmp(s1, s2)) {
// cerr<<p.fi.fi<<" "<<p.fi.se<<" "<<p.se<<" ##\n";
// cerr<<q.fi.fi<<" "<<q.fi.se<<" "<<q.se<<" ##\n";
flag = 1;
break;
}
}
// cerr << mid << " " << flag << " flag\n\n";
if (flag)
r = mid;
else
l = mid;
}
cout <<fixed<<setprecision(20)<< l << " ";
l = 0, r = 1;
// l = r = 0;
// int timer = 1;
timer = 25;
while (timer--) {
db mid = (l + r) / 2.;
vector<pair<pair<db, db>,int> > candidate;
int flag = 0;
for (int i = 1; i <= ct; i++) {
db t2 = 1. * ((m - br[i] + 1) - (bl[i] - 1));
db t1 = 1. * ((al[i] - 1) + (ar[i] - al[i]) * .5) - mid * n;
// db t1 = 1. * (-(n - ar[i] + 1) + (al[i] - 1));
// db t2 = 1. * ((bl[i] - 1) + (br[i] - bl[i]) * .5) - mid * m;
if (abs(t1) > eps || abs(t2) > eps)
// cerr << c[i] << " " << t1 << " " << t2 << "\n",
candidate.push_back({make_pair(t1, t2),i});
else {
flag = 1;
}
}
// cerr << "\n";
auto cmp = [&](pair<pair<db, db>,int> a, pair<pair<db, db>,int> b) {
auto half = [&](pair<db,db> p) {
if (abs(p.second) < eps) {
if (p.first < 0) return 0;
return 1;
}
if (p.second > 0) return 1;
return 0;
};
int ha = half(a.fi), hb = half(b.fi);
if (ha != hb) return ha < hb;
db tmp=cross(a.fi,b.fi);
if(abs(tmp)<eps){
return a.se<b.se;
}
return tmp>0;
};
sort(candidate.begin(), candidate.end(), cmp);
// for(int i=0;i<candidate.size();i++){
// cout<<candidate[i].fi.fi<<" "<<candidate[i].fi.se<<" "<<candidate[i].se<<" $$\n";
// }
pair<pair<db, db>,int> o1(make_pair(1, 0),-1), o2(make_pair(0, 1),ct+10);
// pair<db, db> o1(0, -1), o2(1, 0);
for (int i = 0; i + 1 < candidate.size(); i++) {
auto p = candidate[i];
auto q = candidate[i + 1];
if (cross(p.fi, q.fi) <= 0) continue;
pair<pair<db, db>,int> s1 = max(o1, p, cmp);
pair<pair<db, db>,int> s2 = min(o2, q, cmp);
if (cmp(s1, s2)) {
// cerr<<p.fi.fi<<" "<<p.fi.se<<" "<<p.se<<" ##\n";
// cerr<<q.fi.fi<<" "<<q.fi.se<<" "<<q.se<<" ##\n";
flag = 1;
break;
}
}
// cerr << mid << " " << flag << " flag\n\n";
if (!flag)
r = mid;
else
l = mid;
}
cout <<fixed<<setprecision(20)<< l << " ";
}
/*
6 1 1 6 6 8 8
3 2 4 9
0 -6 -0.9
1 -4 -0.9
2 -2 -0.4
3 -2 0.1
4 -2 0.6
5 -2 1.1
6 0 1.1
7 2 1.1
8 4 1.1
9 6 1.6
10 6 2.1
0.3 0 flag
0.3
*/
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t = 1;
// cin >> t;
while (t--) solve();
return 0;
} | passed | 112_std.cpp |
#include<bits/stdc++.h>
using namespace std;
int Pow(int a, int b, int p) {
if (b == 0)
return 1;
int k = Pow(a, b / 2, p);
k = 1ll * k * k % p;
if (b & 1)
k = 1ll * k * a % p;
return k;
}
void solve() {
int n, m;
cin >> n >> m;
vector <vector <int>> adj(n + 1);
vector <int> uu(m), vv(m);
for (int i = 0; i < m; i++) {
cin >> uu[i] >> vv[i];
int u = uu[i];
int v = vv[i];
adj[u].push_back(v);
adj[v].push_back(u);
}
vector <int> primes{100000007, 1000000009};
const int T = primes.size();
int k;
cin >> k;
vector <vector <int>> b(k);
map <array <int, 2>, int> mp;
vector <int> cnt(n + 1);
for (int i = 0; i < k; i++) {
int t;
cin >> t;
b[i].resize(t);
array <int, 2> hsh = {0, 0};
for (int j = 0; j < t; j++) {
cin >> b[i][j];
cnt[b[i][j]]++;
for (int ii = 0; ii < T; ii++) {
hsh[ii] = (hsh[ii] + 1ll * Pow(2, b[i][j], primes[ii]) + primes[ii]) % primes[ii];
}
}
mp[hsh] = i;
}
set <pair <int, int>> st;
array <int, 2> hsh = {0, 0};
auto hshadd = [&](int u, int val) -> void {
for (int ii = 0; ii < T; ii++) {
hsh[ii] = (hsh[ii] + 1ll * val * Pow(2, u, primes[ii]) + primes[ii]) % primes[ii];
}
};
auto add = [&](int u) -> void {
st.insert({cnt[u], u});
hshadd(u, +1);
};
auto erase = [&](int u) -> void {
if (!st.count({cnt[u], u}))
return;
st.erase({cnt[u], u});
hshadd(u, -1);
};
add(1);
vector <int> time(n + 1), vis(n + 1), par(n + 1, -1);
vector <int> mark(k);
int tme = 0;
while (st.size()) {
int u = st.begin()->second;
if (cnt[u] == 0) {
erase(u);
time[u] = tme++;
vis[u] = 1;
for (int v: adj[u]) {
if (!vis[v] && !st.count({cnt[v], v})) {
par[v] = u;
add(v);
}
}
}
else {
if (mp.count(hsh)) {
int ind = mp[hsh];
mark[ind] = 1;
for (int i = 0; i < int(b[ind].size()); i++) {
int v = b[ind][i];
if (st.count({cnt[v], v})) {
erase(v);
cnt[v]--;
add(v);
}
else
cnt[v]--;
}
}
else {
cout << "No\n";
return;
}
}
}
for (int i = 0; i < k; i++) {
if (!mark[i]) {
cout << "No\n";
return;
}
}
cout << "Yes\n";
const int INF = 1000000000;
for (int i = 0; i < m; i++) {
if (par[uu[i]] == vv[i] || par[vv[i]] == uu[i]) {
cout << abs(time[uu[i]] - time[vv[i]]) << " ";
}
else
cout << INF << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int q = 1;
cin >> q;
while (q--) {
solve();
}
} | passed | 22_std.cpp |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
# define rep(i, a, b) for(int i = a; i < (b); ++i)
# define A first
# define B second
# define pb push_back
# define SZ(x) int(x.size())
# define all(x) x.begin(), x.end()
const int xn = 2e5 + 100;
const int lg = 20;
const int mod = 1e9 + 7;
int power(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
int calc(int n, int r) {
if (r > n) return 0;
int res = 1;
rep(i, 0, r) {
res = 1ll * res * (n - i) % mod;
res = 1ll * res * power(i + 1, mod - 2) % mod;
}
// if (res < 0) cout << "FUCK\n";
return res;
}
int f[2][1 << lg], n[2], C[2][xn];
int m, k, adj[xn], a[xn], b[xn];
int main(){
ios::sync_with_stdio(0);cin.tie(0);
int qq; cin >> qq;
while (qq --) {
cin >> n[0] >> n[1] >> m >> k;
rep(id, 0, 2) rep(i, 1, m + 1)
C[id][i] = calc(n[id] - 1, i - 1);
fill(adj, adj + m, 0);
int tot = 0;
rep(i, 0, k) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
tot |= (1 << a[i]);
tot |= (1 << b[i]);
adj[a[i]] |= (1 << b[i]);
adj[b[i]] |= (1 << a[i]);
}
rep(id, 0, 2) {
rep(mask, 0, (1 << m)) {
f[id][mask] = 0;
bool flag = true;
rep(i, 0, m) if (!(mask >> i & 1))
flag &= ((adj[i] & mask) == adj[i]);
if (!flag) continue;
f[id][mask] = C[id][__builtin_popcount(mask)];
// cout << "!! " << mask << " : " << f[id][mask] << "\n";
}
}
rep(i, 0, m) rep(mask, 0, (1 << m))
if (!(mask >> i & 1))
f[1][mask] = (f[1][mask] + f[1][mask ^ (1 << i)]) % mod;
int ans = 0;
rep(mask, 0, (1 << m)) {
ans = (ans + 1ll * f[0][mask] * f[1][tot - (tot & mask)] % mod) % mod;
}
cout << ans << "\n";
// return 0;
}
return 0;
} | passed | 30_std.cpp |
#include<bits/stdc++.h>
using namespace std;
int n;
struct BIT{
int c[1000010];
void add(int x,int v){
for(;x<=n;x+=x&-x) c[x]+=v;
}
int query(int x){
int res=0;
for(;x;x-=x&-x) res+=c[x];
return res;
}
}BT;
struct T1{
vector<int>vec[1000010];
int fa[1000010],dep[1000010];
int Fa[1000010][21];
void addedge(int u,int v){
vec[u].push_back(v);
vec[v].push_back(u);
}
void dfs(int x,int f){
fa[x]=f,dep[x]=dep[f]+1;
Fa[x][0]=f;
for(int i=1;i<20;++i) Fa[x][i]=Fa[Fa[x][i-1]][i-1];
for(int v:vec[x]){
if(v==f)continue;
dfs(v,x);
}
}
int LCA(int x,int y){
if(dep[x]<dep[y]) swap(x,y);
for(int i=20;i>=0;--i) if(dep[Fa[x][i]]>=dep[y]) x=Fa[x][i];
if(x==y) return x;
for(int i=20;i>=0;--i) if(Fa[x][i]!=Fa[y][i]) x=Fa[x][i],y=Fa[y][i];
return Fa[x][0];
}
int res[1000010],tar[1000010],sdfn[1000010],ssz[1000010];
void set(int i,int x,int y){ sdfn[i]=x; ssz[i]=y;}
struct qry{
int l,r,k,id;
};
vector<qry>Q[1000010];
void add(int u,int v,int l,int r,int id){
int lca=LCA(u,v);
Q[u].push_back({l,r,1,id});
Q[v].push_back({l,r,1,id});
Q[lca].push_back({l,r,-1,id});
Q[fa[lca]].push_back({l,r,-1,id});
tar[id]=dep[u]+dep[v]-dep[lca]*2+1;
}
void dfs2(int x){
BT.add(sdfn[x],1);
for(qry q:Q[x]){
res[q.id]+=q.k*(BT.query(q.r)-BT.query(q.l-1));
}
for(int v:vec[x]){
if(v==fa[x])continue;
dfs2(v);
}
BT.add(sdfn[x],-1);
}
int ps[1000010];
void work(){
dfs2(1);
int tr=0;
for(int i=2;i<=n;++i) {
// cerr<<tar[i]<<" "<<res[i]<<endl;
if(tar[i]==2) continue ;
if(res[i]==1){
++tr;
ps[sdfn[i]]++;
ps[sdfn[i]+ssz[i]]--;
}
else if(res[i]==tar[i]-1){
ps[sdfn[i]]--;
ps[sdfn[i]+ssz[i]]++;
}
else ps[1]=-1e9;
}
for(int i=1;i<=n;++i) ps[i]+=ps[i-1];
for(int i=1;i<=n;++i) if(ps[sdfn[i]]==tr) printf("1");else printf("0");
printf("\n");
}
}T1;
struct T2{
vector<int>vec[1000010];
int idx;
int fa[1000010],dfn[1000010],sz[1000010];
void addedge(int u,int v){
vec[u].push_back(v);
vec[v].push_back(u);
}
void dfs2(int x,int f){
fa[x]=f;
sz[x]=1;dfn[x]=++idx;
for(int v:vec[x]){
if(v==f)continue;
dfs2(v,x);
sz[x]+=sz[v];
}
}
void prework(){
for(int i=1;i<=n;++i) T1.set(i,dfn[i],sz[i]);
for(int i=2;i<=n;++i){
T1.add(i,fa[i],dfn[i],dfn[i]+sz[i]-1,i);
}
}
}T;
int main(){
scanf("%d",&n);
for(int i=1;i<n;++i){
int u,v;scanf("%d%d",&u,&v);
T1.addedge(u,v);
}
for(int i=1;i<n;++i){
int u,v;
scanf("%d%d",&u,&v);
T.addedge(u,v);
}
T1.dfs(1,0);
T.dfs2(1,0);
T.prework();
T1.work();
} | passed | 43_std.cpp |
#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll N=2e5+7,mod=1e9+7;
#define fi first
#define se second
using pll=pair<ll,ll>;
using pii=pair<int,int>;
#define all(x) (x).begin(),(x).end()
ll pre[305][305][305];
ll dp[305][305][305][3];
ll MOD(ll x){
return (x%mod+mod)%mod;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
ll n,q;
cin>>n>>q;
string s;cin>>s;s=' '+s;
bool f[3];
ll cq=0;
for(int i=1;i<=n;i++){
if(s[i]=='?')cq++;
if(i==1){
if(s[i]=='?'){
dp[i][1][0][0]=dp[i][0][1][1]=dp[i][0][0][2]=1;
if(i<n&&s[i+1]!='?'){
if(s[i+1]=='a')dp[i][1][0][0]=0;
else if(s[i+1]=='b')dp[i][0][1][1]=0;
else if(s[i+1]=='c')dp[i][0][0][2]=0;
}
}else{
if(s[i]=='a')dp[i][0][0][0]=1;
else if(s[i]=='b')dp[i][0][0][1]=1;
else if(s[i]=='c')dp[i][0][0][2]=1;
}
continue;
}
f[0]=f[1]=f[2]=1;
if(s[i]=='?'){
if(i<n&&s[i+1]!='?')f[s[i+1]-'a']=0;
for(int j=0;j+1<=cq;j++){
for(int k=0;j+k+1<=cq;k++){
if(f[0])dp[i][j+1][k][0]=1ll*(dp[i][j+1][k][0]+dp[i-1][j][k][1]+dp[i-1][j][k][2])%mod;
if(f[1])dp[i][j][k+1][1]=1ll*(dp[i][j][k+1][1]+dp[i-1][j][k][0]+dp[i-1][j][k][2])%mod;
if(f[2])dp[i][j][k][2]=1ll*(dp[i][j][k][2]+dp[i-1][j][k][0]+dp[i-1][j][k][1])%mod;
}
}
}else{
int kk=s[i]-'a';
for(int j=0;j<=cq;j++){
for(int k=0;j+k<=cq;k++){
dp[i][j][k][kk]=1ll*(dp[i-1][j][k][(kk+1)%3]+dp[i-1][j][k][(kk+2)%3])%mod;
}
}
}
}
for(int j=0;j<=cq;j++){
for(int k=0;j+k<=cq;k++){
pre[j+1][k+1][cq-j-k+1]=1ll*(dp[n][j][k][0]+dp[n][j][k][1]+dp[n][j][k][2])%mod;
}
}
for(int i=1;i<=301;i++){
for(int j=1;j<=301;j++){
for(int k=1;k<=301;k++){
pre[i][j][k]=1ll*(pre[i][j][k]+pre[i-1][j-1][k-1]+pre[i-1][j][k]+pre[i][j-1][k]+pre[i][j][k-1]-pre[i-1][j-1][k]-pre[i-1][j][k-1]-pre[i][j-1][k-1])%mod;
pre[i][j][k]=MOD(pre[i][j][k]);
}
}
}
while(q--){
ll x,y,z;
cin>>x>>y>>z;
cout<<MOD(pre[x+1][y+1][z+1])<<'\n';
}
} | passed | 2_std.cpp |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using pii = pair<int, int>;
const int INF = 0x3f3f3f3f;
const i64 mod = 1e9 + 7;
const int N = 200005;
i64 n;
void solve() {
vector<pii> p;
set<pii> S;
for(int i = 0; i < 5; ++i) {
int x, y;
cin >> x >> y;
if(S.count({x, y})) {
continue;
}
p.push_back({x, y});
S.insert({x, y});
}
auto cmp1 = [](pii a, pii b) {
return a.first > b.first;
};
auto cmp2 = [](pii a, pii b) {
return a.second < b.second;
};
auto cmp3 = [](pii a, pii b) {
return a.second > b.second;
};
int ans = 0;
pii p1, p2;
while(p.size() > 1) {
sort(p.begin(), p.end());
p1 = *(p.end()-1);
p2 = *(p.end()-2);
if(p1.first != p2.first) {
p.pop_back();
ans += abs(p1.first-p2.first);
p1.first = p2.first;
if(!S.count(p1)) {
S.insert(p1);
p.push_back(p1);
}
continue;
}
sort(p.begin(), p.end(), cmp1);
p1 = *(p.end()-1);
p2 = *(p.end()-2);
if(p1.first != p2.first) {
p.pop_back();
ans += abs(p1.first-p2.first);
p1.first = p2.first;
if(!S.count(p1)) {
S.insert(p1);
p.push_back(p1);
}
continue;
}
sort(p.begin(), p.end(), cmp2);
p1 = *(p.end()-1);
p2 = *(p.end()-2);
if(p1.second != p2.second) {
p.pop_back();
ans += abs(p1.second-p2.second);
p1.second = p2.second;
if(!S.count(p1)) {
S.insert(p1);
p.push_back(p1);
}
continue;
}
sort(p.begin(), p.end(), cmp3);
p1 = *(p.end()-1);
p2 = *(p.end()-2);
if(p1.second != p2.second) {
p.pop_back();
ans += abs(p1.second-p2.second);
p1.second = p2.second;
if(!S.count(p1)) {
S.insert(p1);
p.push_back(p1);
}
continue;
}
break;
}
int l, r, u, d;
p1 = p[0];
l = r = p1.first;
u = d = p1.second;
for(auto [x, y] : p) {
l = min(l, x);
r = max(r, x);
u = max(u, y);
d = min(d, y);
}
ans += 2*(r+u-l-d);
for(auto [x, y] : p) {
if(x!=l and x!=r and y!=u and y!=d) {
ans += min(r-l, u-d);
break;
}
}
cout << ans << '\n';
};
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int t;
t = 1;
while(t--) {
solve();
}
return 0;
}
| passed | 59_std.cpp |
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, sum = 0;
cin >> n;
vector<int> a(n + 1, 0);
for (int i = 1; i <= n; ++i)
{
cin >> a[i];
sum += a[i];
}
sort(a.begin() + 1, a.end(), greater<int>());
int target = sum / 2 + 1, ans = 0;
vector<int> f(sum + 1, 0);
f[0] = 1;
for (int i = 1; i <= n; ++i)
{
for (int j = sum; j >= a[i]; --j)
{
f[j] += f[j - a[i]];
if (j >= target and j - a[i] < target)
{
ans += f[j - a[i]];
}
}
}
cout << ans << '\n';
} | passed | 60_std.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.