solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000050;
inline int eval(int x, int y, char op) {
if (op == '&')
return x & y;
else if (op == '|')
return x | y;
else
return x ^ y;
}
bitset<16> analyze(char *s, char *&e) {
char ch = *s, *t;
bitset<16> r = 0;
switch (ch) {
case '0':
r[0] = 1;
e = s;
break;
case '1':
r[15] = 1;
e = s;
break;
case '?':
r[12] = r[10] = 1;
e = s;
break;
default:
bitset<16> x = analyze(s + 1, t), y = analyze(t + 2, e);
for (int i = 0; i < 16; ++i)
for (int j = 0; j < 16; ++j)
if (x[i] && y[j]) r[eval(i, j, t[1])] = 1;
e = e + 1;
}
return r;
}
char buff[N];
int main() {
bitset<16> obj, res;
obj[1] = obj[2] = obj[4] = obj[8] = obj[14] = obj[13] = obj[11] = obj[7] =
obj[12] = obj[10] = obj[3] = obj[5] = 1;
scanf("%*d%s", buff);
char *dum;
res = analyze(buff, dum);
if ((res & obj).any())
puts("YES");
else
puts("NO");
}
| 9 |
#include <bits/stdc++.h>
#define int long long
#define endl "\n"
using namespace std;
void solve() {
string s; cin >> s;
int n = s.size();
if(n<=3) {
cout << "YES" << endl;
return;
}
int adj1 = -1; int adj0 = -1; int zero = -1; int one = -1;
for(int i=0; i<n-1; i++) {
if(s[i]=='1' && s[i+1]=='1' && adj1==-1) adj1 = i;
if(s[i]=='0' && s[i+1]=='0' && adj0==-1) adj0 = i;
if(s[i]=='0') zero = i;
if(s[i]=='1') one = i;
}
if(zero==-1 ||one==-1) {
cout << "YES" << endl;
return;
}
if(adj0>adj1 && adj1!=-1) {
cout << "NO" << endl;
return;
}
if(adj1==-1 || adj0==-1) {
cout << "YES" << endl;
return;
}
for(int i=adj1+1; i<n; i++) {
if(s[i]=='0' && s[i+1]=='0') {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int tc=1; cin >> tc;
while(tc--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
long long cont = 0;
long long ans = 0;
cin >> s;
while (s.back() == 'a') {
s.pop_back();
}
for (int i = s.size() - 1; i > -1; i--) {
if (s[i] == 'b') {
cont += 1;
cont %= 1000000007;
}
if (s[i] == 'a') {
ans += (cont + ans) % 1000000007;
}
}
cout << ans % 1000000007;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, x1, y1, x2, y2;
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
int d1 = abs(x1 - x2) - 1, d2 = abs(y1 - y2) - 1;
if (d1 > d2) swap(d1, d2);
if (d1 >= 4 || d2 >= 4)
puts("Second");
else if ((d1 == 3 && d2 == 3) || (d1 == 3 && d2 == 4))
puts("Second");
else if ((d1 == 2 && d2 == 3))
puts("Second");
else
puts("First");
return 0;
}
| 6 |
#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
#define ll long long
#define vi vector<int>
#define ii pair<int,int>
#define vii vector<ii>
#define rep(i,a,b) for(int i = a; i < b; ++i)
#define per(i,a,b) for(int i = b - 1; i >= a; --i)
#define pv(v) rep(__,0,sz(v)) cout<<v[__]<<' ';
#define nl cout<<'\n'
#define gv(v) rep(__,0,sz(v)) cin>>v[__];
#define rv(v) reverse(v.begin(),v.end());
#define all(v) v.begin(),v.end()
#define rd(x) cin>>x;
const int MOD = 998244353;
const double pi = acos(-1);
const double EPS = 1e-9;
const int N = 2e5 + 10;
const int M = 2e6 + 10;
const int width = 20;
const int bits = 6;
ll binpow(ll a, ll b)
{
ll ret = 1;
while (b)
{
if (b & 1)
ret = (ret * a);
a = (a * a);
b >>= 1;
}
return ret;
}
typedef ll nodeData;
const int MaxNodes = 2e5 + 2;
extern struct node nodes[MaxNodes];
enum DIR {
LF, RI
};
struct node {
nodeData val, lzAdd, mn;
bool isRev;
int par, Sz, ch[2];
node() {
memset(this, 0, sizeof * this);
mn = INT_MAX;
}
void set(nodeData nodeValue) {
ch[0] = ch[1] = par = 0;
mn = val = nodeValue;
lzAdd = 0;
isRev = 0;
Sz = 1;
}
void push_up() {
Sz = 1 + nodes[ch[LF]].Sz + nodes[ch[RI]].Sz;
mn = min(val, min(nodes[ch[LF]].mn, nodes[ch[RI]].mn));
}
void add_lazy(nodeData lazyValue) {
if (this == &nodes[0]) {
return void();
}
lzAdd += lazyValue;
val += lazyValue;
mn += lazyValue;
}
void push_down() {
if (isRev) {
for (int i = 0; i < 2; ++i) {
if (ch[i]) {
nodes[ch[i]].reverse();
}
}
isRev = 0;
}
if (lzAdd) {
for (int i = 0; i < 2; ++i) {
if (ch[i]) {
nodes[ch[i]].add_lazy(lzAdd);
}
}
lzAdd = 0;
}
}
void reverse() {
swap(ch[LF], ch[RI]);
isRev ^= 1;
}
} nodes[MaxNodes];
int freeList[MaxNodes], freeListSz, nextNodeId;
inline int getFreeNodeId() {
if (freeListSz) {
return freeList[--freeListSz];
}
return nextNodeId++;
}
inline void init() {
nextNodeId = 1;
freeListSz = 0;
}
inline void makeFree(int nodeId) {
freeList[freeListSz++] = nodeId;
}
inline void link(int par, int child, DIR d) {
if (par) {
nodes[par].ch[d] = child;
nodes[par].push_up();
}
if (child) {
nodes[child].par = par;
}
}
inline DIR getDir(int par, int child) {
return (DIR)(nodes[par].ch[RI] == child);
}
/*
* gp
* |
* |
* p
* / \d
* a q
* / \
* b c
*/
inline void rotate(int q) {
int p = nodes[q].par;
DIR d = getDir(p, q);
int gp = nodes[p].par;
// p -> q -> gp
link(p, nodes[q].ch[!d], d);
link(q, p, (DIR)!d);
link(gp, q, getDir(gp, p));
}
/*
* gp
* |
* |
* q
* / \
* p c
* / \
* a b
*/
/*
* gp
* gpd/ \
* p
* / \pd
* nodeid
*/
inline void splay(int nodeId, int& root) {
int p;
while (p = nodes[nodeId].par)
{
int gp = nodes[p].par;
if (!gp) rotate(nodeId);
else
{
rotate(getDir(gp, p) == getDir(p, nodeId) ? p : nodeId);
rotate(nodeId);
}
}
root = nodeId;
}
inline nodeData getByIdx(int& root, int index) {
int cur = root, lftsz;
while (nodes[cur].push_down(), lftsz = nodes[nodes[cur].ch[LF]].Sz, lftsz > index or index >= lftsz + 1) {
if (lftsz > index) {
cur = nodes[cur].ch[LF];
}
else {
index -= lftsz + 1;
cur = nodes[cur].ch[RI];
}
}
splay(cur, root);
return nodes[cur].val;
}
inline void splayMax(int& root) {
int cur;
for (cur = root; nodes[cur].push_down(), nodes[cur].ch[RI]; cur = nodes[cur].ch[RI]);
splay(cur, root);
}
inline int merge(int ls, int gr) {
if (!ls) return gr;
splayMax(ls);
link(ls, gr, RI);
return ls;
}
inline void split(int root, int lfSz, int& ls, int& gr) {
if (lfSz >= nodes[root].Sz) {
ls = root;
gr = 0;
return void();
}
getByIdx(root, lfSz);
ls = nodes[root].ch[LF];
link(root, 0, LF);
link(0, ls, LF);
gr = root;
}
inline void print(int node, int depth) {
if (!node) {
return void();
}
print(nodes[node].ch[LF], depth + 1);
printf("%s(%2d,%2d)\n", string(7 * depth, ' ').c_str(), nodes[node].val, nodes[node].mn);
print(nodes[node].ch[RI], depth + 1);
}
inline void print(int node) {
puts("--------------");
print(node, 0);
puts("--------------");
fflush(stdout);
}
inline void pushDownFromRoot(int node) {
if (!node) return;
pushDownFromRoot(nodes[node].par);
nodes[node].push_down();
}
inline int getIdx(int cur) {
pushDownFromRoot(cur);
int ret = nodes[nodes[cur].ch[LF]].Sz;
while (cur) {
int p = nodes[cur].par;
if (getDir(p, cur) == RI)
ret += nodes[nodes[p].ch[LF]].Sz + 1;
cur = p;
}
return ret;
}
inline void insert(int& cur, int pos, nodeData val) {
int bef, aft, btwn;
split(cur, pos, bef, aft);
btwn = getFreeNodeId();
nodes[btwn].set(val);
//nodes[aft].add_lazy(1);
cur = merge(btwn, aft);
cur = merge(bef, cur);
}
inline void del(int& cur, int pos) {
int bef, aft, btwn;
split(cur, pos + 1, cur, aft);
split(cur, pos, bef, btwn);
makeFree(btwn);
// nodes[aft].add_lazy(-1);
cur = merge(bef, aft);
}
inline void fastscan(ll& number) {
//variable to indicate sign of input number
bool negative = false;
register int c;
number = 0;
// extract current character from buffer
while (c = getchar(), isspace(c));
if (c == '-') {
// number is negative
negative = true;
// extract the next character from the buffer
c = getchar();
}
// Keep on extracting characters if they are integers
// i.e ASCII Value lies from '0'(48) to '9' (57)
for (; (c > 47 && c < 58); c = getchar())
number = (number << 3) + (number << 1) + c - 48;
// if scanned input has a negative sign, negate the
// value of the input number
if (negative)
number = -number;
}
inline void reverse(int& cur, int st, int en) {
int bef, aft, btwn;
split(cur, en + 1, cur, aft);
split(cur, st, bef, btwn);
nodes[btwn].reverse();
cur = merge(btwn, aft);
cur = merge(bef, cur);
}
inline void add(int& cur, int st, int en, nodeData val) {
int bef, aft, btwn;
split(cur, en + 1, cur, aft);
split(cur, st, bef, btwn);
nodes[btwn].add_lazy(val);
cur = merge(btwn, aft);
cur = merge(bef, cur);
}
inline nodeData mn(int& cur, int st, int en) {
int bef, aft, btwn;
split(cur, en + 1, cur, aft);
split(cur, st, bef, btwn);
nodeData ret = nodes[btwn].mn;
cur = merge(btwn, aft);
cur = merge(bef, cur);
return ret;
}
inline void rot(int& cur, int st, int en, int sh) {
int bef, aft, btwn;
split(cur, en + 1, cur, aft);
split(cur, st, bef, btwn);
int pre, suf;
split(btwn, nodes[btwn].Sz - sh, pre, suf);
btwn = merge(suf, pre);
cur = merge(btwn, aft);
cur = merge(bef, cur);
}
inline void fastscan(char str[]) {
register int c;
while (c = getchar(), isspace(c));
int len = 0;
do str[len++] = c; while (c = getchar(), !isspace(c));
str[len] = 0;
}
int cn;
void solve()
{
int n;
cin >> n;
int t = n * 2;
vi a(t);
for (int i = 0; i < t; ++i)
cin >> a[i];
sort(all(a));
vi x, y;
for (int i = 0; i < n; ++i)
x.push_back(a[i]);
for (int i = 0; i < n; ++i)
y.push_back(a[i + n]);
reverse(all(x));
reverse(all(y));
vi ans(t);
for (int i = 0; i < t; ++i)
{
if (i % 2 == 0)
{
ans[i] = x.back();
x.pop_back();
}
else
{
ans[i] = y.back();
y.pop_back();
}
}
for (int i = 0; i < t; ++i)
cout << ans[i] << ' ';
nl;
}
int main(void)
{
//freopen("in.txt", "r", stdin);
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tc = 1;
cin >> tc;
while (tc--)
{
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int fact[700005], inv[700005], factinv[700005];
int main() {
int n, c;
cin >> n >> c;
fact[1] = inv[1] = factinv[1] = 1;
fact[0] = inv[0] = factinv[0] = 1;
for (int i = 2; i <= 700000; i++) {
fact[i] = (i * 1LL * fact[i - 1]) % 1000003;
inv[i] = (1000003 - (((1000003 / i) * 1LL * inv[1000003 % i]) % 1000003)) %
1000003;
factinv[i] = (inv[i] * 1LL * factinv[i - 1]) % 1000003;
}
int res = 0;
for (int i = 1; i <= n; i++) {
int tmp = (fact[i + c - 1] * 1LL * factinv[i]) % 1000003;
tmp = (tmp * 1LL * factinv[c - 1]) % 1000003;
res += tmp;
if (res >= 1000003) res -= 1000003;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int c[1000001];
int gcd(int u, int v) {
if (!u) return v;
return gcd(v % u, u);
}
int main() {
scanf("%d%d", &n, &k);
long long m = 1;
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
int u = gcd(k, c[i]);
long long t = (long long)m * u / (gcd(m, u));
if (t > k) {
cout << "No";
return 0;
}
m = t;
}
if (m == k)
cout << "Yes";
else
cout << "No";
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 200010;
void bye() {
std::cout << "No\n";
exit(0);
}
int head[MAXN], nxt[MAXN << 1], to[MAXN << 1], tot;
void addedge(int b, int e) {
nxt[++tot] = head[b];
to[head[b] = tot] = e;
nxt[++tot] = head[e];
to[head[e] = tot] = b;
}
int ansl[MAXN];
int n, K;
void simpledfs(int u, int fa = 0, int col = 1) {
ansl[u] = col;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) simpledfs(to[i], u, col ^ 1);
}
int dis[MAXN];
void dfsx(int u, int fa = 0) {
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
dis[to[i]] = dis[u] + 1;
dfsx(to[i], u);
}
}
const int INF = 0x3f3f3f3f;
struct data {
int a[3];
data() { a[0] = a[1] = a[2] = -INF; }
void insert(int x) {
if (x >= a[0])
a[2] = a[1], a[1] = a[0], a[0] = x;
else if (x >= a[1])
a[2] = a[1], a[1] = x;
else if (x >= a[2])
a[2] = x;
}
void shift() { ++a[0], ++a[1], ++a[2]; }
} val[MAXN], vt[MAXN];
void dfs1(int u, int fa = 0) {
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
dfs1(to[i], u);
val[u].insert(std::max(val[to[i]].a[0], 0) + 1);
}
}
void dfs2(int u, int fa = 0, int upv = 0) {
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
int tv = std::max(upv, val[u].a[val[to[i]].a[0] + 1 == val[u].a[0]]) + 1;
dfs2(to[i], u, tv);
}
vt[u] = val[u];
if (fa) vt[u].insert(upv);
if (vt[u].a[2] + vt[u].a[1] + 1 >= K) bye();
}
int li[MAXN], inc[MAXN];
bool mark(int u, int dst, int fa = 0) {
if (u == dst) {
li[dis[u]] = u;
return true;
}
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) {
if (mark(to[i], dst, u)) {
li[dis[u]] = u;
return true;
}
}
return false;
}
int R;
void dfsmk(int u, int fa, int now, int delta) {
now = (now + delta) % K;
ansl[u] = now;
for (int i = head[u]; i; i = nxt[i])
if (to[i] != fa) dfsmk(to[i], u, now, delta);
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> K;
for (int i = 1, t1, t2; i < n; ++i) {
std::cin >> t1 >> t2;
addedge(t1, t2);
}
if (K == 2)
simpledfs(1);
else {
dfs1(1);
dfs2(1);
dis[1] = 0;
dfsx(1);
int at = 1, rt;
for (int i = 2; i <= n; ++i)
if (dis[i] > dis[at]) at = i;
dis[at] = 0;
dfsx(rt = at);
at = 1;
for (int i = 2; i <= n; ++i)
if (dis[i] > dis[at]) at = i;
R = dis[at] + 1;
mark(rt, at);
for (int i = 0; i < R; ++i) inc[li[i]] = true;
for (int i = 0; i < R; ++i) {
ansl[li[i]] = i % K;
int dta = R - 1 - i > i ? K - 1 : 1;
for (int j = head[li[i]]; j; j = nxt[j])
if (!inc[to[j]]) dfsmk(to[j], li[i], i, dta);
}
}
std::cout << "Yes" << std::endl;
for (int i = 1; i <= n; ++i) std::cout << ansl[i] + 1 << ' ';
std::cout << std::endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 5e5, mxK = 100;
int n, k, p, ps[mxN + 1], dp[2][mxN + 1];
struct ftree {
int a[mxK + 1];
inline void rst() { memset(a, 69, sizeof(a)); }
inline void upd(int i, int x) {
for (++i; i <= p; i += i & -i) a[i] = min(x, a[i]);
}
inline int qry(int i) {
int r = INT_MAX;
for (; i; i -= i & -i) r = min(a[i], r);
return r;
}
} ft1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> p;
for (int i = 0; i < n; ++i) {
int ai;
cin >> ai;
ps[i + 1] = (ps[i] + ai) % p;
}
for (int i = 1; i <= k; ++i) {
ft1.rst();
memset(dp[i & 1], 0, sizeof(dp[i & 1]));
ft1.upd(ps[i - 1], dp[i & 1 ^ 1][i - 1] - ps[i - 1]);
int m2 = dp[i & 1 ^ 1][i - 1] - ps[i - 1];
for (int j = i; j <= n; ++j) {
dp[i & 1][j] = min(ft1.qry(ps[j] + 1), m2 + p) + ps[j];
if (i > 1) {
ft1.upd(ps[j], dp[i & 1 ^ 1][j] - ps[j]);
m2 = min(dp[i & 1 ^ 1][j] - ps[j], m2);
}
}
}
cout << dp[k & 1][n];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 2000005;
int n, m, k;
bool a[MAXN];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
a[x] = 1;
}
int ans = 0, ala = 0;
for (int i = 0; i < m; ++i) ala += a[i];
for (int i = m - 1; i > -1; --i) {
if (ala < k)
break;
else {
if (a[i]) {
ala--;
ans++;
a[i] = 0;
}
}
}
int i = 0, j = m;
while (j != 1000005) {
ala -= a[i];
ala += a[j];
if (ala == k) {
ala--;
ans++;
a[j] = 0;
}
i++;
j++;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x;
bool F(int n) {
int m = n / 2;
vector<int> T;
int c2 = 0, c4 = 0, c = 0;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (n); ++(j)) {
int a = ((i % 2) == (j % 2));
if (a == 0) continue;
c++;
if (i == m && j == m)
T.push_back(1);
else if (i == m || j == m)
c2++;
else
c4++;
}
if (c < x) return false;
for (int(i) = (0); (i) < (c2 / 2); ++(i)) T.push_back(2);
for (int(j) = (0); (j) < (c4 / 4); ++(j)) T.push_back(4);
reverse((T).begin(), (T).end());
for (int(i) = (0); (i) < (T.size()); ++(i))
if (c - T[i] >= x) c -= T[i];
return (c == x);
}
bool FF(int n) {
int m = n / 2;
vector<int> T;
int c2 = 0, c4 = 0, c = 0;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (n); ++(j)) {
int a = ((i % 2) != (j % 2));
if (a == 0) continue;
c++;
if (i == m && j == m)
T.push_back(1);
else if (i == m || j == m)
c2++;
else
c4++;
}
if (c < x) return false;
for (int(i) = (0); (i) < (c2 / 2); ++(i)) T.push_back(2);
for (int(j) = (0); (j) < (c4 / 4); ++(j)) T.push_back(4);
reverse((T).begin(), (T).end());
for (int(i) = (0); (i) < (T.size()); ++(i))
if (c - T[i] >= x) c -= T[i];
return (c == x);
}
int main() {
cin >> x;
for (int i = 1; i <= 1000000000; i += 2) {
if (F(i) || FF(i)) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n - 1; i++) {
if (s[i] > s[i + 1]) {
cout << s.substr(0, i) << s.substr(i + 1, n);
return 0;
}
}
cout << s.substr(0, n - 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k;
scanf("%d", &t);
while (t--) {
cin >> n;
int c = n / 2;
if (n & 1) {
cout << "7";
--c;
}
for (int i = 0; i < c; i++) {
cout << "1";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next, val;
} e[100005 << 1];
int head[100005], cnt, d[100005], n, Q;
inline void add(int x, int y, int z) {
e[cnt] = (node){y, head[x], z};
head[x] = cnt++;
d[x]++;
}
inline int q_pow(int x, int n) {
int ret = 1;
for (; n; n >>= 1, x = (long long)x * x % 1000000007)
if (n & 1) ret = (long long)ret * x % 1000000007;
return ret;
}
struct Segment {
int k, b;
Segment() {}
Segment(int x, int y) { k = x, b = y; }
Segment operator+(const Segment &a) const {
return Segment((k + a.k) % 1000000007, (b + a.b) % 1000000007);
}
Segment operator+(const int &a) const {
return Segment(k, (b + a) % 1000000007);
}
Segment operator*(const int &a) const {
return Segment((long long)k * a % 1000000007,
(long long)b * a % 1000000007);
}
};
Segment dfs(int x, int from) {
if (d[x] == 1 && from != -1) return Segment(0, 0);
Segment ret = Segment(0, 0);
for (int i = head[x]; i != -1; i = e[i].next)
if (e[i].to != from)
ret = ret + (dfs(e[i].to, x) + e[i].val) * q_pow(d[x], 1000000007 - 2);
else
ret = ret +
((long long)e[i].val * q_pow(d[x], 1000000007 - 2) % 1000000007);
int inv = q_pow(1 - ret.k + 1000000007, 1000000007 - 2);
return Segment((long long)inv * q_pow(d[x], 1000000007 - 2) % 1000000007,
(long long)inv * ret.b % 1000000007);
}
int main() {
scanf("%d", &n);
memset(head, -1, sizeof(head));
for (int i = 1, x, y, z; i < n; i++)
scanf("%d%d%d", &x, &y, &z), add(x, y, z), add(y, x, z);
printf("%d\n", dfs(0, -1).b);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % 998244353;
a = a * a % 998244353, b >>= 1;
}
return r;
}
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x * f;
}
long long n, m, b[200005], a[200005], c[200005], ans[200005], d[200005], cnt,
fac[200005], inv[200005], dp[60][60], w[200005];
void insert(long long x) {
for (long long i = (m); i >= (0); --i) {
if (!(x & (1ll << i))) continue;
if (d[i])
x ^= d[i];
else
return d[i] = x, ++cnt, void();
}
}
long long C(long long n, long long m) {
if (n < m) return 0;
return fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
void dfs(long long x, long long S) {
if (x > m) return ++ans[__builtin_popcountll(S)], void();
dfs(x + 1, S);
if (d[x]) dfs(x + 1, S ^ d[x]);
}
void dfs1(long long x, long long S) {
if (x < 0) return ++w[__builtin_popcountll(S)], void();
dfs1(x - 1, S);
if (b[x]) dfs1(x - 1, S ^ b[x]);
}
signed main() {
n = read(), m = read(), inv[0] = fac[0] = 1;
for (long long i = (1); i <= (m); ++i)
fac[i] = fac[i - 1] * i % 998244353, inv[i] = qpow(fac[i], 998244353 - 2);
for (long long i = (1); i <= (n); ++i) a[i] = read(), insert(a[i]);
if (cnt <= 26)
dfs(0, 0);
else {
for (long long i = (m); i >= (0); --i)
for (long long j = (m); j >= (0); --j)
if ((d[j] & (1ll << i)) && (i != j)) d[j] ^= d[i];
for (long long i = (m - 1); i >= (0); --i) {
if (d[i]) continue;
b[i] = (1ll << i);
for (long long j = (0); j <= (m); ++j)
if (d[j] & (1ll << i)) b[i] |= (1ll << j);
}
for (long long i = (0); i <= (m); ++i)
for (long long j = (0); j <= (m); ++j)
for (long long k = (0); k <= (m); ++k) {
if (k & 1)
dp[i][j] =
(dp[i][j] - C(j, k) * C(m - j, i - k) % 998244353 + 998244353) %
998244353;
else
dp[i][j] =
(dp[i][j] + C(j, k) * C(m - j, i - k) % 998244353) % 998244353;
}
dfs1(m, 0);
for (long long i = (0); i <= (m); ++i)
for (long long j = (0); j <= (m); ++j)
ans[j] = (ans[j] + 1ll * dp[j][i] * w[i] % 998244353) % 998244353;
for (long long i = (0); i <= (m); ++i)
ans[i] = qpow(2, cnt) * ans[i] % 998244353 *
qpow(qpow(2, m), 998244353 - 2) % 998244353;
}
for (long long i = (0); i <= (m); ++i)
printf("%lld ", ans[i] * qpow(2, n - cnt) % 998244353);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100002][2];
const int MOD = 1000000007;
void solve() {
string a, b;
int m, cnt = 0, lcnt;
cin >> a >> b >> m;
for (int i = 0; i < a.length(); i++) {
if (b == a.substr(i, a.length() - i) + a.substr(0, i)) cnt++;
}
if (a == b)
dp[0][0] = 1;
else
dp[0][1] = 1;
lcnt = a.length() - cnt;
for (int i = 1; i <= m; i++) {
dp[i][0] = (dp[i - 1][0] * (cnt - 1) + dp[i - 1][1] * cnt) % MOD;
dp[i][1] = (dp[i - 1][0] * (lcnt) + dp[i - 1][1] * (lcnt - 1)) % MOD;
}
cout << dp[m][0] << endl;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * (100000) + 5;
int a[MAXN], b[MAXN];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
int res = 0;
int j = 0;
for (int i = 0; i < n && j < n; ++i) {
while (j < n && a[i] != b[j]) {
j++;
res++;
}
j++;
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
int main() {
int n, m, k;
string str;
cin >> n >> m >> k;
vector<vector<int> > a(n), b(n), c(n);
for (int i = 0; i < n; i++) {
a[i].resize(m);
b[i].resize(m);
c[i].resize(m);
}
for (int i = 0; i < n; i++) {
cin >> str;
for (int j = 0; j < m; j++) {
cin >> a[i][j] >> b[i][j] >> c[i][j];
}
}
int prib[m][n][n];
for (int i = 0; i < m; i++) {
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
prib[i][i1][i2] = b[i2][i] - a[i1][i];
}
}
}
vector<pair<int, int> > buf;
int maxprib = 0, ans = 0;
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
buf.clear();
for (int i = 0; i < m; i++) {
buf.push_back(make_pair(prib[i][i1][i2], c[i1][i]));
}
sort(buf.begin(), buf.end(), greater<pair<int, int> >());
if (buf[0].first <= 0)
continue;
else {
int kk = k;
maxprib = 0;
for (int j = 0; j < buf.size(); j++)
if (buf[j].first > 0) {
if (buf[j].second >= kk) {
maxprib += buf[j].first * kk;
break;
}
kk -= buf[j].second;
maxprib += buf[j].second * buf[j].first;
}
if (maxprib > ans) ans = maxprib;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f[100010], a[100010];
int n, i, flag, ans, u, v, vis[100010], now, s[100010], tot;
vector<int> vec[2];
int gf(int x) {
int p, t;
p = x;
while (p != f[p]) p = f[p];
while (x != t) {
t = f[x];
f[x] = p;
x = t;
}
return p;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i] = i;
}
flag = 1;
for (i = 1; i <= n; i++) vec[now].push_back(i);
while (flag) {
flag = 0;
now = 1 - now;
vec[now].clear();
for (i = 1; i <= tot; i++) vis[s[i]] = 0;
tot = 0;
for (i = 0; i < vec[1 - now].size(); i++) {
u = vec[1 - now][i];
v = gf(u) + 1;
if ((v <= n) && (a[u] > a[v])) {
f[gf(u)] = gf(v);
flag = 1;
vis[v] = 1;
tot++;
s[tot] = v;
if (vis[u] == 0) vec[now].push_back(u);
}
}
if (flag) ans++;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
unsigned int c;
int x = 0;
while (((c = getchar()) - '0') >= 10) {
if (c == '-') return -getint();
if (!~c) exit(0);
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while (((c = getchar()) - '0') < 10);
return x;
}
int height, width;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
inline bool inside(int x, int y) {
return 0 <= x and x < height and 0 <= y and y < width;
}
inline bool move(int &nx, int &ny, int x, int y, int d) {
nx = x + dx[d], ny = y + dy[d];
return inside(nx, ny);
}
char grid[111][111];
int check(int x, int y) {
int res = 0, d, xx, yy;
for (d = 0; d < 4; d++)
if (move(xx, yy, x, y, d)) {
if (grid[xx][yy]) {
res = res | (1 << grid[xx][yy] - 'A');
}
}
return res;
}
void solve(int x, int y) {
int chk = check(x, y);
int extend = 0;
int minc;
for (int i = 0;; i++) {
if ((chk >> i & 1) == 0) {
minc = i;
break;
}
}
int forbit = (1 << minc) - 1;
for (extend = 1;; extend++) {
int xlim = x + extend;
int ylim = y + extend;
if (xlim == height or ylim == width) break;
if (grid[xlim][y] != 0) break;
if (grid[x][ylim] != 0) break;
int chkx = check(x, ylim);
int chky = check(xlim, y);
if ((chkx & forbit) != forbit) break;
if ((chkx >> minc) & 1) break;
}
for (int xx = x; xx < x + extend; xx++) {
for (int yy = y; yy < y + extend; yy++) {
grid[xx][yy] = 'A' + minc;
}
}
}
int main() {
int i, j, tcc, tc = 1 << 28;
for (tcc = 0; tcc < tc; tcc++) {
height = getint(), width = getint();
memset(grid, 0, sizeof(grid));
for (i = 0; i < height; i++)
for (j = 0; j < width; j++) {
if (grid[i][j] == 0) {
solve(i, j);
}
}
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++) cout << grid[i][j];
puts("");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[100005];
int v[100005], n, m;
int check(int x, int y) {
int i;
for (i = 0; i < s[x].size(); i++)
if (s[x][i] == y) return 1;
return 0;
}
void reset() {
random_shuffle(v, v + n);
int i;
for (i = 0; i < min(n - 1, m); i++)
if (check(v[i], v[i + 1])) return;
if (n == m && check(v[0], v[n - 1])) return;
for (i = 0; i < min(n - 1, m); i++) printf("%d %d\n", v[i], v[i + 1]);
if (n == m) printf("%d %d\n", v[0], v[n - 1]);
exit(0);
}
int main() {
int i, x, y;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
s[x].push_back(y);
s[y].push_back(x);
}
for (i = 0; i < n; i++) v[i] = i + 1;
for (i = 0; i < 1000; i++) {
reset();
}
puts("-1");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int num = 1;
struct node {
int to;
int next;
} road[400010];
int head[200010];
int low[100010], dfn[100010], cut[200010], tot = 0;
int cnt = 0, vis[100010], belong[100010];
int pre[200010][20], deep[200010];
void build(int from, int to) {
road[++num].next = head[from];
road[num].to = to;
head[from] = num;
}
void tarjan(int x, int in_edge) {
low[x] = dfn[x] = ++tot;
for (int i = head[x]; i; i = road[i].next) {
int y = road[i].to;
if (!dfn[y]) {
tarjan(y, i);
low[x] = min(low[x], low[y]);
if (dfn[x] < low[y]) {
cut[i] = cut[i ^ 1] = 1;
}
} else if (i != (in_edge ^ 1))
low[x] = min(low[x], dfn[y]);
}
}
void dfs(int x) {
vis[x] = 1;
belong[x] = cnt;
for (int i = head[x]; i; i = road[i].next) {
if (cut[i]) continue;
int y = road[i].to;
if (vis[y]) continue;
dfs(y);
}
}
void dfs2(int x, int fa) {
pre[x][0] = fa;
deep[x] = deep[fa] + 1;
for (int i = 1; i <= 18; i++) {
pre[x][i] = pre[pre[x][i - 1]][i - 1];
}
for (int i = head[x]; i; i = road[i].next) {
int y = road[i].to;
if (y == fa) continue;
dfs2(y, x);
}
}
int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
int k = deep[x] - deep[y];
for (int i = 0; i <= 18; i++) {
if ((k >> i) & 1) x = pre[x][i];
}
if (x == y) return x;
for (int i = 18; i >= 0; i--) {
if (pre[x][i] != pre[y][i]) {
x = pre[x][i];
y = pre[y][i];
}
}
return pre[x][0];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
build(a, b);
build(b, a);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i, 0);
}
cnt = n;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt++;
dfs(i);
}
}
for (int x = 1; x <= n; x++) {
for (int i = head[x]; i; i = road[i].next) {
int y = road[i].to;
if (belong[x] == belong[y]) continue;
build(belong[x], belong[y]);
}
}
dfs2(n + 1, 0);
scanf("%d", &k);
while (k--) {
int s, l;
scanf("%d%d", &s, &l);
printf("%d\n", deep[belong[s]] + deep[belong[l]] -
2 * deep[lca(belong[s], belong[l])]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, L;
cin >> n >> L;
++n;
vector<int> X(n), B(n);
X[0] = 0;
B[0] = 0;
for (int i = 1; i < n; ++i) cin >> X[i] >> B[i];
double l = 0, r = sqrt(fabs(double(X.back() - L))) / B.back() + 0.000001;
vector<double> S(n);
for (int it = 0; it < 50; ++it) {
double m = (l + r) / 2;
S.assign(n, 1000000000);
S[0] = 0.0;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < i; ++j) {
double tmp = S[j] + sqrt(fabs(double(X[i] - X[j] - L))) - m * B[i];
if (tmp < S[i]) S[i] = tmp;
}
}
if (S.back() < 0)
r = m;
else
l = m;
}
vector<int> F(n, -1);
S.assign(n, 1000000000);
S[0] = 0.0;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < i; ++j) {
double tmp = S[j] + sqrt(fabs(double(X[i] - X[j] - L))) - l * B[i];
if (tmp < S[i]) {
S[i] = tmp;
F[i] = j;
}
}
}
vector<int> ans;
int cur = n - 1;
while (cur != 0) {
ans.push_back(cur);
cur = F[cur];
}
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fun(int aa[], int bb[], int q, int w) {
int j = min(aa[q], bb[w]);
aa[q] -= j;
bb[w] -= j;
};
int main() {
int i, j = 0, k, l = 0, o[3], p[3], oo[3], pp[3];
cin >> k;
cin >> p[0] >> p[1] >> p[2];
cin >> o[0] >> o[1] >> o[2];
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
i += min(p[0], o[1]) + min(p[1], o[2]) + min(p[2], o[0]);
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
pp[0] = p[0];
pp[1] = p[1];
pp[2] = p[2];
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
if (min(oo[0], pp[2]) > min(oo[1], pp[0])) {
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
} else {
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
}
l = max(l, j);
j = 0;
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
pp[0] = p[0];
pp[1] = p[1];
pp[2] = p[2];
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
if (min(oo[2], pp[1]) > min(oo[0], pp[2])) {
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
} else {
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
}
l = max(l, j);
j = 0;
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
pp[0] = p[0];
pp[1] = p[1];
pp[2] = p[2];
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
if (min(oo[1], pp[0]) > min(oo[2], pp[1])) {
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
} else {
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
}
l = max(l, j);
j = 0;
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
pp[0] = p[0];
pp[1] = p[1];
pp[2] = p[2];
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
if (min(oo[0], pp[2]) > min(oo[1], pp[0])) {
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
} else {
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
}
l = max(l, j);
j = 0;
j = 0;
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
pp[0] = p[0];
pp[1] = p[1];
pp[2] = p[2];
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
if (min(oo[2], pp[1]) > min(oo[0], pp[2])) {
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
} else {
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
}
l = max(l, j);
j = 0;
oo[0] = o[0];
oo[1] = o[1];
oo[2] = o[2];
pp[0] = p[0];
pp[1] = p[1];
pp[2] = p[2];
j += min(oo[2], pp[0]);
fun(oo, pp, 2, 0);
j += min(oo[2], pp[2]);
fun(oo, pp, 2, 2);
j += min(oo[1], pp[2]);
fun(oo, pp, 1, 2);
j += min(oo[1], pp[1]);
fun(oo, pp, 1, 1);
if (min(oo[1], pp[0]) > min(oo[2], pp[1])) {
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
} else {
j += min(oo[0], pp[1]);
fun(oo, pp, 0, 1);
j += min(oo[0], pp[0]);
fun(oo, pp, 0, 0);
}
l = max(l, j);
j = 0;
;
cout << k - l << " " << i;
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1000100];
int s[1000100];
bool v[1000100];
int dfs(int node) {
int tmp = 0;
v[node] = 1;
for (auto u : adj[node]) {
if (!v[u]) tmp += dfs(u);
}
return tmp + adj[node].size() + 2 * s[node];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
long long int t1, t2;
int cn;
for (int i = 0; i < m; i++) {
cin >> t1 >> t2;
if (t1 == t2)
s[t1]++;
else {
adj[t1].push_back(t2);
adj[t2].push_back(t1);
}
cn = t1;
}
if (dfs(cn) != 2 * m) {
cout << 0 << endl;
return 0;
}
long long int ans = 0;
t2 = 0;
for (int i = 1; i <= n; i++) {
t1 = adj[i].size();
ans += (t1 * (t1 - 1)) / 2;
ans += (s[i] * (m - 1));
t2 += s[i];
}
ans -= (t2 * (t2 - 1)) / 2;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MAXN = 60 + 3, MAXK = 1000 + 23, INF = 1e9;
long long n, m, r, dp[MAXN][MAXN][MAXK], d[MAXN][MAXN][MAXN], opt[MAXN][MAXN];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> n >> m >> r;
for (long long c = 0; c < m; c++)
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) cin >> d[c][i][j];
for (long long c = 0; c < m; c++)
for (long long k = 0; k < n; k++)
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
d[c][i][j] = min(d[c][i][j], d[c][i][k] + d[c][k][j]);
memset(opt, 63, sizeof opt);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
for (long long c = 0; c < m; c++) opt[i][j] = min(opt[i][j], d[c][i][j]);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) dp[i][j][0] = opt[i][j];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
for (long long k = 1; k < MAXK; k++) dp[i][j][k] = INF;
for (long long i = 0; i < n; i++)
for (long long k = 1; k < MAXK; k++)
for (long long j = 0; j < n; j++)
for (long long c = 0; c < n; c++)
dp[i][j][k] = min(dp[i][j][k], dp[i][c][k - 1] + opt[c][j]);
while (r--) {
long long s, t, k;
cin >> s >> t >> k;
cout << dp[--s][--t][k] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long k, m, n;
int main() {
scanf("%lld", &k);
if (k <= 1) {
printf("-1");
return 0;
}
if (k % 2 == 0)
m = (k * (k / 2)) / 2 - 1, n = m + 2;
else
m = k * (k / 2) + k / 2, n = m + 1;
if (m != 0 && n != 0)
printf("%lld %lld", m, n);
else
printf("-1");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {};
long long A[1000005], B[1000005], C[1000005];
int main() {
long long i, j, k, l, m, n, x, y, z, a, b, c, d, t;
string str;
struct node s;
cin >> n;
for (i = 0; i < n; i++) cin >> A[i];
cin >> m;
for (i = 0; i < m; i++) cin >> B[i];
sort(A, A + n);
sort(B, B + m);
i = n - 1;
j = m - 1;
long long cnt = 0;
while (i >= 0 && j >= 0) {
if (abs(A[i] - B[j]) <= 1) {
cnt++;
i--;
j--;
} else if (A[i] > B[j])
i--;
else
j--;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int i, k, b, n, a[N];
long long sum[N + 1];
int main() {
scanf("%d %d %d", &k, &b, &n);
for (i = 0; i < n; i++) scanf("%d", a + i);
long long result = 0;
map<long long, int> cnt, mod;
sum[n] = 0, cnt[0]++, mod[0]++;
long long zero = 0;
for (i = n - 1; i >= 0; i--) {
sum[i] = sum[i + 1] + a[i];
zero += cnt[sum[i]];
result += mod[(sum[i] + (k - 1) - b) % (k - 1)];
cnt[sum[i]]++;
mod[sum[i] % (k - 1)]++;
}
if (b == 0)
cout << zero << endl;
else {
if (b == k - 1) result -= zero;
cout << result << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, oo = 0x7fffffff;
int n, a[N], f[2][N], ans, ls;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i <= n; i++) f[0][i] = f[1][i] = oo;
f[0][0] = -oo;
for (int i = 1; i <= n; i++) {
int s1 = upper_bound(f[1], f[1] + n + 1, a[i] - i + 1) - f[1];
ans = max(ans, s1), ans = max(ans, ls);
f[1][s1] = a[i] - i + 1, f[1][ls] = min(f[1][ls], f[0][ls]);
ls = upper_bound(f[0], f[0] + n + 1, a[i] - i) - f[0];
f[0][ls] = a[i] - i;
}
printf("%d", n - ans - 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
int n, p[N], w[N], a[N], b[N];
bool ans;
long long x[N], xsum[N], dp[N], dp1[N], wt[N], dc[N];
vector<int> g[N];
vector<int> num[N];
void dfs1(int v, int k, int parent) {
for (int i = 0; i < g[v].size(); i++)
if (g[v][i] != parent) dfs1(g[v][i], num[v][i], v);
xsum[v] = 0;
long long W = 0, D = 0;
for (int i = 0; i < g[v].size(); i++)
if (g[v][i] != parent) {
W += wt[g[v][i]];
D += dp[g[v][i]];
xsum[v] += x[g[v][i]];
}
dp1[v] = D;
if (p[k] < W) {
if (D < W - p[k]) {
ans = false;
} else {
D -= W - p[k];
x[v] = W - p[k];
W = p[k];
}
}
xsum[v] += x[v];
dc[v] = min(1ll * w[k] - 1, p[k] - (W - D));
dp[v] = D + dc[v];
wt[v] = W + w[k];
}
void dfs2(int v, int parent) {
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] != parent) {
long long tmp = min(x[v], dp1[g[v][i]] - x[g[v][i]]);
x[g[v][i]] += tmp;
x[v] -= tmp;
long long cur = min(x[v], dc[g[v][i]]);
p[num[v][i]] -= cur;
w[num[v][i]] -= cur;
x[v] -= cur;
dfs2(g[v][i], v);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d%d", &a[i], &b[i], &w[i], &p[i]);
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
num[a[i]].push_back(i);
num[b[i]].push_back(i);
}
ans = true;
for (int i = 0; i < g[1].size(); i++) dfs1(g[1][i], num[1][i], 1);
if (ans) {
for (int i = 0; i < g[1].size(); i++) dfs2(g[1][i], 1);
cout << n << endl;
for (int i = 1; i < n; i++) {
cout << a[i] << " " << b[i] << " " << w[i] << " " << p[i] << endl;
}
} else {
cout << -1;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
for (char& c : s) c = c == ',' ? ' ' : c;
stringstream ss;
ss << s;
vector<string> res;
for (string z; ss >> z; res.push_back(z))
;
return res;
}
void debug_out(vector<string> args, int idx) { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, Head H, Tail... T) {
if (idx > 0) cerr << ", ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, T...);
}
void localTest() {}
const long long N = 3e5 + 5, MOD = 1e9 + 9;
long long first[N], A[N];
struct node {
long long a, b, sum;
node() : a(0), b(0), sum(0) {}
} T[N << 2];
long long fibo(long long x, long long y, long long k) {
if (k == 1) return x;
if (k == 2) return y;
return (x * first[k - 2] + y * first[k - 1]) % MOD;
}
long long fiboSum(long long x, long long y, long long k) {
if (k == 1) return x % MOD;
if (k == 2) return (x + y) % MOD;
return (fibo(x, y, k + 2) - y + MOD) % MOD;
}
void build(long long node, long long lo, long long hi) {
if (lo == hi) {
T[node].sum = A[lo];
return;
}
long long mid = (lo + hi) >> 1;
build(node << 1, lo, mid);
build(node << 1 | 1, mid + 1, hi);
T[node].sum = (T[node << 1].sum + T[node << 1 | 1].sum) % MOD;
return;
}
void push(long long node, long long lo, long long hi) {
long long mid = (lo + hi) >> 1;
T[node].sum += fiboSum(T[node].a, T[node].b, hi - lo + 1);
T[node].sum %= MOD;
if (lo != hi) {
T[node << 1].a += T[node].a;
T[node << 1].b += T[node].b;
T[node << 1].a %= MOD;
T[node << 1].b %= MOD;
T[node << 1 | 1].a += fibo(T[node].a, T[node].b, mid - lo + 2);
T[node << 1 | 1].b += fibo(T[node].a, T[node].b, mid - lo + 3);
T[node << 1 | 1].a %= MOD;
T[node << 1 | 1].b %= MOD;
}
T[node].a = T[node].b = 0;
return;
}
void update(long long node, long long lo, long long hi, long long l,
long long r) {
if (T[node].a) push(node, lo, hi);
if (l > hi || r < lo) return;
long long mid = (lo + hi) >> 1;
if (lo >= l && hi <= r) {
T[node].sum = (T[node].sum +
fiboSum(first[lo - l + 1], first[lo - l + 2], hi - lo + 1)) %
MOD;
if (lo != hi) {
T[node << 1].a += first[lo - l + 1];
T[node << 1].b += first[lo - l + 2];
T[node << 1].a %= MOD;
T[node << 1].b %= MOD;
T[node << 1 | 1].a += first[mid - l + 2];
T[node << 1 | 1].b += first[mid - l + 3];
T[node << 1 | 1].a %= MOD;
T[node << 1 | 1].b %= MOD;
}
return;
}
update(node << 1, lo, mid, l, r);
update(node << 1 | 1, mid + 1, hi, l, r);
T[node].sum = (T[node << 1].sum + T[node << 1 | 1].sum) % MOD;
return;
}
long long query(long long node, long long lo, long long hi, long long l,
long long r) {
if (T[node].a) push(node, lo, hi);
if (l > hi || r < lo) return 0;
if (lo >= l && hi <= r) return T[node].sum;
long long mid = (lo + hi) >> 1;
return (query(node << 1, lo, mid, l, r) +
query(node << 1 | 1, mid + 1, hi, l, r)) %
MOD;
}
int main() {
localTest();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
first[1] = 1;
for (long long i = 2; i < N; ++i)
first[i] = (first[i - 1] + first[i - 2]) % MOD;
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> A[i];
build(1, 1, n);
while (m--) {
long long ty, x, y;
cin >> ty >> x >> y;
if (ty == 1)
update(1, 1, n, x, y);
else
cout << query(1, 1, n, x, y) << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 998244353;
int n, m, k, t;
long long a[maxn];
int sg[510][3];
int period;
int mex(int x, int y, int z) {
if (x > y) swap(x, y);
if (x > z) swap(x, z);
if (y > z) swap(y, z);
int ret = 0;
if (ret == x) ret++;
if (ret == y) ret++;
if (ret == z) ret++;
return ret;
}
int mex(int x, int y) {
if (x > y) swap(x, y);
int ret = 0;
if (ret == x) ret++;
if (ret == y) ret++;
return ret;
}
void init_sg(int x, int y, int z) {
for (int i = 1; i <= 500; i++) {
sg[i][0] =
mex(sg[max(i - x, 0)][0], sg[max(i - y, 0)][1], sg[max(i - z, 0)][2]);
sg[i][1] = mex(sg[max(i - x, 0)][0], sg[max(i - z, 0)][2]);
sg[i][2] = mex(sg[max(i - x, 0)][0], sg[max(i - y, 0)][1]);
}
period = -1;
for (int i = 1;; i++) {
bool f = true;
for (int j = 500; j >= 400; j--) {
for (int k = 0; k < 3; k++) {
if (sg[j][k] != sg[j - i][k]) {
f = false;
break;
}
}
if (!f) break;
}
if (f) {
period = i;
break;
}
}
}
int get_sg(long long x, int y) {
if (x < 0) return 0;
if (x <= 500) return sg[x][y];
return sg[(x - 400) % period + 400][y];
}
int main() {
int i, j;
scanf("%d", &t);
while (t--) {
int x, y, z;
scanf("%d%d%d%d", &n, &x, &y, &z);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
init_sg(x, y, z);
int win = 0;
for (i = 1; i <= n; i++) {
win ^= get_sg(a[i], 0);
}
if (!win)
puts("0");
else {
int ret = 0;
for (i = 1; i <= n; i++) {
if ((win ^ get_sg(a[i], 0) ^ get_sg(a[i] - x, 0)) == 0) ret++;
if ((win ^ get_sg(a[i], 0) ^ get_sg(a[i] - y, 1)) == 0) ret++;
if ((win ^ get_sg(a[i], 0) ^ get_sg(a[i] - z, 2)) == 0) ret++;
}
printf("%d\n", ret);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long solve() {
long long a[5], ans = 0;
for (long long i = 1; i < 5; i++) cin >> a[i];
for (long long i = 1; i < 5; i++)
for (long long y = i + 1; y < 5; y++)
if (a[i] == a[y]) {
ans++;
break;
}
return ans;
}
int main() {
fast();
cout << solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 100010;
const int MAXE = 100010;
int s[MAXE];
int t[MAXE];
long long w[MAXE];
int nxt[MAXE];
int rnxt[MAXE];
int head[MAXV];
int rhead[MAXV];
int len = 1;
long long ds[MAXV];
long long dt[MAXV];
int dfn[MAXV];
int low[MAXV];
bool del[MAXE];
bool brg[MAXE];
int cnt = 1;
int V, E, S, T;
void add_edge(int u, int v, long long w_) {
s[len] = u;
t[len] = v;
w[len] = w_;
nxt[len] = head[u];
rnxt[len] = rhead[v];
head[u] = len;
rhead[v] = len;
len++;
}
void dijkstra(int s, int *to, int *nxt, int *head, long long *d) {
memset(d, 0x3f, (V + 1) * sizeof(long long));
d[s] = 0;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(pair<long long, int>(0, s));
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first) continue;
for (int i = head[v]; i != 0; i = nxt[i]) {
int u = to[i];
if (d[u] > d[v] + w[i]) {
d[u] = d[v] + w[i];
q.push(pair<long long, int>(d[u], u));
}
}
}
}
void remove() {
for (int i = 1; i <= E; i++) {
if (ds[s[i]] + w[i] + dt[t[i]] != ds[T]) del[i] = true;
}
}
void tarjan(int v, int par) {
dfn[v] = low[v] = cnt++;
for (int i = head[v]; i != 0; i = nxt[i]) {
if (del[i]) continue;
int u = t[i];
if (!dfn[u]) {
tarjan(u, i);
low[v] = min(low[v], low[u]);
if (dfn[v] < low[u]) brg[i] = true;
} else {
if (par != i) low[v] = min(low[v], dfn[u]);
}
}
for (int i = rhead[v]; i != 0; i = rnxt[i]) {
if (del[i]) continue;
int u = s[i];
if (!dfn[u]) {
tarjan(u, i);
low[v] = min(low[v], low[u]);
if (dfn[v] < low[u]) brg[i] = true;
} else {
if (par != i) low[v] = min(low[v], dfn[u]);
}
}
}
int main() {
scanf("%d%d%d%d", &V, &E, &S, &T);
for (int i = 1; i <= E; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add_edge(u, v, w);
}
dijkstra(S, t, nxt, head, ds);
dijkstra(T, s, rnxt, rhead, dt);
remove();
tarjan(S, 0);
for (int i = 1; i <= E; i++) {
if (!del[i] && brg[i])
printf("YES\n");
else {
long long crt = ds[s[i]] + w[i] + dt[t[i]];
if (crt - ds[T] + 1 < w[i])
printf("CAN %lld\n", crt - ds[T] + 1);
else
printf("NO\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
bitset<N> f[N];
long long a[N][N], n, m;
long long LastTrue(function<bool(long long)> check, long long l, long long r) {
long long ans = -1;
while (r >= l) {
long long m = l + r >> 1;
if (check(m)) {
ans = m;
l = m + 1;
} else {
r = m - 1;
}
}
return ans;
}
bool check(long long x) {
memset(f, 0, sizeof f);
for (int i = 1; i <= m; ++i) {
vector<int> g;
for (int j = 1; j <= n; ++j) {
if (a[j][i] >= x) {
for (int x : g) {
if (f[x][j]) return true;
f[x][j] = 1;
}
g.push_back(j);
}
}
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
cout << LastTrue(check, 0, 1e9) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int N = 1000010;
template <class T>
inline bool scan_d(T& ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c<'0' | c> '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
struct virt {
double r, i;
virt(double r = 0, double i = 0) : r(r), i(i) {}
virt operator+(const virt& x) { return virt(r + x.r, i + x.i); }
virt operator-(const virt& x) { return virt(r - x.r, i - x.i); }
virt operator*(const virt& x) {
return virt(r * x.r - i * x.i, i * x.r + r * x.i);
}
virt operator/(double a) { return virt(r / a, i / a); }
};
virt x[N], y[N], z[N];
void change(virt y[], int len) {
for (int i = 1, j = len / 2; i < len - 1; i++) {
if (i < j) swap(y[i], y[j]);
int k = len / 2;
for (; k <= j; k >>= 1) j -= k;
if (j < k) j += k;
}
}
void fft(virt y[], int len, int on) {
change(y, len);
for (int h = 2; h <= len; h <<= 1) {
virt wn(cos(-on * 2 * PI / h), sin(-on * 2 * PI / h));
for (int j = 0; j < len; j += h) {
virt w = virt(1, 0);
for (int k = j; k < j + h / 2; k++) {
virt u = y[k];
virt t = w * y[k + h / 2];
y[k] = u + t;
y[k + h / 2] = u - t;
w = w * wn;
}
}
}
}
char a[N], b[N];
int ans[210][200100];
int ll[210], rr[210];
const int limit = 1400;
int main() {
scanf("%s%s", a, b);
int lena = strlen(a), lenb = strlen(b);
int mx = lenb + limit, len = 1;
for (; len < mx; len <<= 1)
;
for (int j = 0; b[j]; j++) {
int aa = (b[j] == '0' ? -1 : 1);
y[j] = virt(aa, 0);
}
fft(y, len, 1);
for (int i = 0; i < lena; i += limit) {
ll[i / limit] = i;
rr[i / limit] = i + limit - 1;
int mi = min(lena, i + limit);
for (int j = 0; j < limit; j++) x[j] = virt(0, 0);
for (int j = i; j < mi; j++) {
int aa = (a[j] == '0' ? -1 : 1);
x[limit - (j - i) - 1] = virt(aa, 0);
}
for (int j = limit; j < len; j++) x[j] = virt(0, 0);
fft(x, len, 1);
for (int j = 0; j < len; j++) {
z[j] = x[j] * y[j];
}
fft(z, len, -1);
for (int j = 0; j < len; j++) {
z[j] = z[j] / len;
}
for (int j = 0; j < lenb; j++) {
ans[i / limit][j] = round(z[j + limit - 1].r);
}
}
int q;
scan_d(q);
int p1, q1, L, R, p2;
while (q--) {
int len;
scan_d(p1), scan_d(p2), scan_d(len);
q1 = p1 + len - 1;
L = p1 / limit;
R = q1 / limit;
int ret = 0;
for (int i = L; i <= R; i++) {
if (p1 <= ll[i] && rr[i] <= q1) {
ret += (limit - ans[i][p2]) >> 1;
p1 += limit;
p2 += limit;
} else {
int xx = max(p1, ll[i]), yy = min(q1, rr[i]);
for (int j = xx; j <= yy; j++) {
ret += a[p1] != b[p2];
p1++;
p2++;
}
}
}
printf("%d\n", ret);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, dp[30], msk[30];
vector<int> g[50];
map<int, int> d[2];
bool p[50][50], used[50];
void dfs(int v, int x) {
p[v][x] = true;
msk[x] |= (1 << v);
used[v] = true;
for (int i = 0; i < g[v].size(); i++) {
if (!used[g[v][i]]) dfs(g[v][i], x);
}
}
int rec(int mask, int player) {
bool res[40];
fill(res, res + m + 2, 0);
if (d[player].count(mask)) return d[player][mask];
for (int i = 1; i <= m; i++) {
if (!(mask & (1 << i))) {
int nw_mask = mask;
res[rec(nw_mask | msk[i], player ^ 1)] = true;
}
}
int mex = 0;
while (res[mex]) mex++;
return d[player][mask] = mex;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n;
dp[1] = 1;
dp[2] = 2;
dp[3] = 1;
dp[4] = 4;
dp[5] = 3;
dp[6] = 2;
dp[7] = 1;
dp[8] = 5;
dp[9] = 6;
dp[10] = 2;
dp[11] = 1;
dp[12] = 8;
dp[13] = 7;
dp[14] = 5;
dp[15] = 9;
dp[16] = 8;
dp[17] = 7;
dp[18] = 3;
dp[19] = 4;
dp[20] = 7;
dp[21] = 4;
dp[22] = 2;
dp[23] = 1;
dp[24] = 10;
dp[25] = 9;
dp[26] = 3;
dp[27] = 6;
dp[28] = 11;
dp[29] = 12;
dp[30] = 14;
map<int, bool> used;
int ans = 0, ok = 0;
for (i = 2; i * i <= n; i++) {
if (!used[i]) {
long long pw = i, x = i, cnt = 0;
while (x <= n) {
used[x] = true;
x *= pw;
cnt++;
}
ans ^= dp[cnt];
ok ^= cnt % 2;
}
}
int res = ans ^ ((n - ok) % 2);
if (res == 0)
cout << "Petya";
else
cout << "Vasya";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[10], c[10], n, ans = 0, t[19];
long long dfs(int k, int l) {
if (k == 10) {
long long res = t[l - c[0]];
for (int i = l - 1; i >= l - c[0]; i--) res *= i;
for (int i = 0; i <= 9; i++) res /= t[c[i]];
return res;
}
if (!cnt[k]) {
c[k] = 0;
return dfs(k + 1, l);
}
long long res = 0;
for (int i = 1; i <= cnt[k]; i++) {
c[k] = i;
res += dfs(k + 1, l + i);
}
return res;
}
int main() {
scanf("%I64d", &n);
t[0] = 1;
for (int i = 1; i <= 18; i++) t[i] = t[i - 1] * i;
while (n) {
cnt[n % 10]++;
n /= 10;
}
ans = dfs(0, 0);
printf("%I64d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:16777216")
const int inf = 0x3f3f3f3f;
const long double pi = acos(-1.0);
const string debug_line = "yolo";
const double PI = 4 * atan(1);
double nCr[500100][6];
double dp[100010][105];
int a[100010];
int count1[100010];
double dp1[105];
int main() {
int n;
scanf("%d", &n);
for (int(i) = (1); (i) < (n + 1); ++(i)) {
int temp;
scanf("%d", &temp);
a[i] = temp;
count1[i] = temp;
dp[i][a[i]] = 1.0;
}
nCr[0][0] = 1.0;
for (int(i) = (1); (i) < (500100); ++(i)) {
nCr[i][0] = 1.0;
for (int(j) = (1); (j) < (6); ++(j)) {
nCr[i][j] = (nCr[i - 1][j - 1] + nCr[i - 1][j]);
}
}
int m;
scanf("%d", &m);
double answer1 = 0;
for (int(i) = (1); (i) < (n + 1); ++(i)) {
answer1 = answer1 + dp[i][0];
}
while (m--) {
int a1, b1, c1;
scanf("%d%d%d", &a1, &b1, &c1);
answer1 = answer1 - dp[a1][0];
for (int(j) = (0); (j) < (105); ++(j)) {
dp1[j] = dp[a1][j];
dp[a1][j] = 0;
}
for (int(i) = (0); (i) < (c1 + 1); ++(i)) {
for (int j = 0; j + i <= count1[a1] && j + i <= a[a1]; j++) {
double temp1 = nCr[i + j][i] * nCr[count1[a1] - (i + j)][c1 - i] /
nCr[count1[a1]][c1] * dp1[i + j];
dp[a1][j] += temp1;
}
}
answer1 = answer1 + dp[a1][0];
count1[a1] -= c1;
count1[b1] += c1;
printf("%.12lf\n", answer1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long x = 0, y = 0, n, b;
void f(long long &z) {
long long k;
for (cin >> n >> b; n > 0; n--) {
cin >> k;
z = z * b + k;
}
}
int main() {
f(x);
f(y);
cout << ((x < y) ? '<' : ((x == y) ? '=' : '>'));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long &i : a) cin >> i;
map<long long, vector<pair<long long, long long>>> seg, ans;
for (long long i = 0; i < n; i++) {
long long sum = 0;
for (long long j = i; j < n; j++) {
sum += a[j];
seg[sum].push_back({i, j});
}
}
long long ma = 0;
for (auto it : seg) {
long long cur = 0;
vector<pair<long long, long long>> v = it.second;
ans[it.first].push_back(v[cur]);
for (long long i = 1; i < v.size(); i++) {
if (v[i].first <= v[cur].second) {
if (v[i].second < v[cur].second) {
ans[it.first].pop_back();
ans[it.first].push_back(v[i]);
cur = i;
}
} else {
ans[it.first].push_back(v[i]);
cur = i;
}
}
if (ans[ma].size() < ans[it.first].size()) ma = it.first;
}
cout << ans[ma].size() << endl;
for (auto p : ans[ma]) {
cout << ++p.first << " " << ++p.second << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cin.tie(nullptr);
long long t_c = 1;
while (t_c--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
double x1, y1;
double x2, y2;
int n, ans = 0;
cin >> x1 >> y1;
cin >> x2 >> y2;
double a1 = y1 - y2, b1 = x2 - x1, c1 = (a1 * x1 + b1 * y1) * (-1);
cin >> n;
for (long long int(i) = 0; (i) < (long long int)(n); (i)++) {
double a2, b2, c2;
cin >> a2 >> b2 >> c2;
if (a1 == 0) {
if (a2 == 0) continue;
double y = (double)(-1) * c1 / b1;
double x = (-1) * (c2 + y * b2) / a2;
if ((x > x1 and x < x2) or (x < x1 and x > x2)) ans++;
continue;
}
double y = (double)(c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);
double x = (double)(c1 + (double)b1 * y) * (-1) / a1;
if (x > x1 && x < x2)
ans++;
else if (x < x1 && x > x2)
ans++;
else if (y < y1 && y > y2)
ans++;
else if (y > y1 && y < y2)
ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
bool a1[n];
bool a2[n];
for (int i = 0; i < n; ++i) {
a1[i] = (i != 0 ? a1[i - 1] : true) && a[i] >= i;
}
for (int i = n - 1; i >= 0; --i) {
a2[i] = (i != n - 1 ? a2[i + 1] : true) && a[i] >= (n - i - 1);
}
bool found = false;
for (int i = 0; i < n; ++i) {
if (a1[i] && a2[i]) {
found = true;
break;
}
}
if (found)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd1(int a, int b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long modx(long long base, long long ex) {
long long ans = 1LL, val = base;
while (ex > 0LL) {
if (ex & 1LL) ans = (ans * val) % 1000000009LL;
val = (val * val) % 1000000009LL;
ex = ex >> 1LL;
}
return ans;
}
const int maxn = 505;
set<int> adj[maxn], rev[maxn];
vector<int> v;
int parent[maxn];
int n, m, x, y;
bool recstack[maxn], visit[maxn];
int ind;
void cycle(int t) {
while (t != parent[t]) {
v.push_back(t);
t = parent[t];
}
v.push_back(t);
}
bool dfs(int start, int par) {
visit[start] = true;
parent[start] = par;
recstack[start] = true;
set<int>::iterator it;
for (it = adj[start].begin(); it != adj[start].end(); it++) {
int pt = *it;
;
if (recstack[pt]) {
parent[pt] = pt;
ind = start;
return true;
}
if (!visit[pt] && dfs(pt, start)) return true;
}
recstack[start] = false;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
adj[x].insert(y);
rev[y].insert(x);
}
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
if (!dfs(i, 0))
continue;
else {
cycle(ind);
break;
}
}
}
if (ind == 0) {
cout << "YES" << endl;
return 0;
}
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
int pt = v[i];
int pt2;
if (i == v.size() - 1)
pt2 = v[0];
else
pt2 = v[i + 1];
adj[pt].erase(pt2);
int j = 1;
memset(visit, 0, sizeof(visit));
memset(recstack, 0, sizeof(recstack));
for (j = 1; j <= n; j++) {
if (!visit[j] && dfs(j, 0)) break;
}
if (j <= n) {
adj[pt].insert(pt2);
continue;
} else {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1009], cnt[1009], n, m, MOD, k;
int main() {
int flag = 0;
scanf("%d%d%d", &n, &m, &k);
if (n < m) {
flag = 1;
swap(n, m);
}
for (int i = 1; i <= n; i++) a[i] = 1;
for (int i = 1; i <= k; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (flag) swap(x, y);
a[x] *= z;
cnt[x]++;
}
scanf("%d", &MOD);
flag = 0;
long long ans = 1;
for (int i = 1; i <= n; i++) {
if (!flag && !cnt[i])
flag = 1;
else if (cnt[i] == m && a[i] != -1)
ans = 0;
else
for (int j = 0; j < m - cnt[i] - 1; j++) ans = (ans + ans) % MOD;
}
if ((n + m) % 2 == 1) ans = 0;
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a1 = 0, b1 = 0, a2 = 0, b2 = 0;
for (int i = 0, _e(n); i < _e; i++) {
int t, a, b;
cin >> t >> a >> b;
if (t == 1)
a1 += a, b1 += b;
else
a2 += a, b2 += b;
}
if (a1 >= b1) {
cout << "LIVE" << endl;
} else
cout << "DEAD" << endl;
if (a2 >= b2) {
cout << "LIVE" << endl;
} else
cout << "DEAD" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char x[10], y[10];
cin >> x;
cin >> y;
sort(x, x + strlen(x));
if (x[0] == '0' && strlen(x) > 1) {
x[0] = x[1];
x[1] = '0';
}
if (!strcmp(x, y))
cout << "OK" << endl;
else
cout << "WRONG_ANSWER" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, ans, resX, resY, x[300010], y[300010], maxX, minX, maxY, minY, minD,
maxD;
bool ok(int dist) {
for (int tmpX = max(0, maxX - dist); tmpX <= minX + dist; ++tmpX) {
int tmpY = max(maxD - dist + tmpX, max(0, maxY - dist));
if (tmpY <= minY + dist and tmpY - tmpX <= minD + dist) {
resX = tmpX;
resY = tmpY;
return 1;
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n;
maxX = maxD = maxY = -2e9;
minX = minD = minY = 2e9;
for (int i = 0; i < n; ++i) {
cin >> s;
for (auto c : s) {
if (c == 'B') {
++x[i];
} else {
++y[i];
}
}
maxX = max(x[i], maxX);
maxY = max(y[i], maxY);
maxD = max(y[i] - x[i], maxD);
minD = min(y[i] - x[i], minD);
minY = min(y[i], minY);
minX = min(x[i], minX);
}
int l = 0, r = 1e7, steps = 0;
ans = 1e7;
while (l <= r and steps < 80) {
int mid = (l + r) / 2;
if (ok(mid)) {
ans = min(ans, mid);
r = mid - 1;
} else {
l = mid + 1;
}
++steps;
}
if (resY == resX and !resY) {
resY = resX = 1;
}
cout << ans << '\n';
cout << string(resX, 'B') + string(resY, 'N');
cerr << resX << ' ' << resY << '\n';
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
template <class T>
void out(map<char, T> &a, string s = "(%3c ->%3d)") {
for (auto(it) = (a).begin(); (it) != (a).end(); ++(it))
printf(s.c_str(), it->first, it->second);
printf("\n");
}
template <class T>
void out(vector<T> &a, string s = "%3d ") {
int i, n = a.size();
for ((i) = 0; (i) < (n); (i)++) printf(s.c_str(), a[i]);
printf("\n");
}
template <class T>
void out(T *a, int n, string s = "%3d ") {
int i;
for ((i) = 0; (i) < (n); (i)++) printf(s.c_str(), a[i]);
printf("\n");
}
long long i, j, N, M, n, m, k, p;
int MainSolve(string args = "") {
cout << args;
cin >> n;
int const MOD = 1e9 + 7;
vector<long long> p(n), dp(n + 1);
for ((i) = 0; (i) < (n); (i)++) cin >> p[i], p[i]--;
dp[0] = 0;
for ((i) = (1); (i) < (n + 1); (i)++) {
dp[i] = dp[i - 1];
dp[i] += dp[i - 1];
dp[i] %= MOD;
dp[i] += MOD - dp[p[i - 1]] + 2;
dp[i] %= MOD;
}
cout << dp[n] << endl;
return 0;
}
string ReadAllLines(char *fileName) {
string s = "";
const int NMAX = 1000;
char buf[NMAX];
buf[0] = 0;
FILE *f = fopen(fileName, "r");
while (fgets(buf, NMAX, f)) s = s + string(buf);
return string(s.begin(), find_if(s.rbegin(), s.rend(), [](char c) {
return c != '\n' && c != '\r' && c != '\t' &&
c != ' ';
}).base());
}
int main() {
MainSolve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300500;
const int MAXK = 19;
int par[MAXK][MAXN];
int tin[MAXN], tout[MAXN];
bool used[MAXN];
int h[MAXN];
const int MOD = 1000000009;
const int BASE = 1248217;
int hs[MAXK][MAXN];
int rhs[MAXK][MAXN];
int pows[MAXN];
vector<vector<int> > g;
int n, m;
char buf[MAXN];
void dfs(int x, int pr) {
static int timer = 0;
used[x] = true;
h[x] = h[pr] + 1;
tin[x] = timer++;
par[0][x] = pr;
hs[0][x] = buf[x];
rhs[0][x] = buf[pr];
for (auto son : g[x]) {
if (son != pr) {
dfs(son, x);
}
}
tout[x] = timer++;
}
void propagate() {
for (int lvl = 1; lvl < MAXK; ++lvl) {
for (int i = 1; i <= n; ++i) {
par[lvl][i] = par[lvl - 1][par[lvl - 1][i]];
}
for (int i = 1; i <= n; ++i) {
hs[lvl][i] = (1ll * hs[lvl - 1][i] * pows[1 << (lvl - 1)] +
hs[lvl - 1][par[lvl - 1][i]]) %
MOD;
rhs[lvl][i] =
(1ll * rhs[lvl - 1][par[lvl - 1][i]] * pows[1 << (lvl - 1)] +
rhs[lvl - 1][i]) %
MOD;
}
}
}
void precalc() {
pows[0] = 1;
for (int i = 1; i < MAXN; ++i) {
pows[i] = 1ll * pows[i - 1] * BASE % MOD;
}
}
inline bool is_par(int pr, int son) {
return (tin[pr] <= tin[son] && tout[pr] >= tout[son]);
}
int lca(int u, int v) {
if (is_par(u, v)) {
return u;
}
if (is_par(v, u)) {
return v;
}
int curv = u;
for (int i = MAXK - 1; i >= 0; --i) {
int nextv = par[i][curv];
if (nextv != 0 && !is_par(nextv, v)) {
curv = nextv;
}
}
return par[0][curv];
}
int up_vertex(int u, int height) {
for (int i = MAXK - 1; i >= 0; --i) {
if (height >= (1 << i)) {
u = par[i][u];
height ^= (1 << i);
}
}
return u;
}
int main() {
precalc();
scanf("%d", &n);
g.clear();
g.resize(n + 1);
buf[0] = 0;
h[0] = -1;
scanf(" %s", buf + 1);
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1, 0);
propagate();
scanf("%d", &m);
for (int qid = 0; qid < m; ++qid) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int u1 = lca(a, b), u2 = lca(c, d);
int len1 = h[a] - h[u1], len2 = h[c] - h[u2];
int clen = min(h[a] + h[b] - 2 * h[u1], h[c] + h[d] - 2 * h[u2]);
{
if (len1 > clen) {
len1 = clen;
b = u1 = up_vertex(a, len1);
} else {
b = up_vertex(b, h[b] - h[u1] - (clen - len1));
}
if (len2 > clen) {
len2 = clen;
d = u2 = up_vertex(c, len2);
} else {
d = up_vertex(d, h[d] - h[u2] - (clen - len2));
}
}
if (len1 > len2) {
swap(a, c);
swap(b, d);
swap(u1, u2);
swap(len1, len2);
}
int svlen1 = len1, svlen2 = len2;
int aa = a, bb = b, cc = c, dd = d;
int cur_ans = 0;
{
bool ok = true;
int i = MAXK - 1;
int rlen = len1;
for (; i >= 0 && ok; --i) {
if (rlen >= (1 << i)) {
if (hs[i][a] == hs[i][c]) {
cur_ans += (1 << i);
rlen -= (1 << i);
a = par[i][a], c = par[i][c];
} else {
ok = false;
}
}
}
if (!ok) {
while (i >= 0) {
if (hs[i][a] == hs[i][c]) {
cur_ans += (1 << i);
a = par[i][a], c = par[i][c];
}
--i;
}
}
}
if (cur_ans == len1) {
if (len1 != len2) {
int idealh = len2 - len1;
int fv = a = up_vertex(b, h[b] - h[u1] - idealh), sv = c;
vector<int> vertices;
vertices.reserve(19);
for (int i = 0, curv = fv; i < MAXK; ++i) {
if (idealh & (1 << i)) {
vertices.push_back(curv);
curv = par[i][curv];
}
}
bool ok = true;
int i = MAXK - 1;
for (; i >= 0 && ok; --i) {
if (idealh >= (1 << i)) {
if (rhs[i][vertices.back()] == hs[i][sv]) {
vertices.pop_back();
cur_ans += (1 << i);
idealh -= (1 << i);
sv = par[i][sv];
} else {
ok = false;
}
}
}
if (!ok) {
fv = vertices.back();
while (i >= 0) {
int nextv = par[i][fv];
if (rhs[i][nextv] != hs[i][sv]) {
fv = nextv;
} else {
cur_ans += (1 << i);
sv = par[i][sv];
}
--i;
}
}
}
if (cur_ans == len2) {
int rlen = clen - len2;
int fv = b, sv = d;
vector<int> v1, v2;
v1.reserve(19), v2.reserve(19);
for (int i = 0; i < MAXK; ++i) {
if (rlen & (1 << i)) {
v1.push_back(fv);
v2.push_back(sv);
fv = par[i][fv];
sv = par[i][sv];
}
}
int i = MAXK - 1;
bool ok = true;
for (; i >= 0 && ok; --i) {
if (rlen >= (1 << i)) {
if (rhs[i][v1.back()] == rhs[i][v2.back()]) {
v1.pop_back();
v2.pop_back();
cur_ans += (1 << i);
rlen -= (1 << i);
} else {
ok = false;
}
}
}
if (!ok) {
fv = v1.back(), sv = v2.back();
while (i >= 0) {
int nfv = par[i][fv], nsv = par[i][sv];
if (rhs[i][nfv] != rhs[i][nsv]) {
fv = nfv, sv = nsv;
} else {
cur_ans += (1 << i);
}
--i;
}
}
}
}
if (cur_ans > svlen1) {
aa = up_vertex(bb, clen - cur_ans);
} else {
aa = up_vertex(aa, cur_ans);
}
if (cur_ans > svlen2) {
cc = up_vertex(dd, clen - cur_ans);
} else {
cc = up_vertex(cc, cur_ans);
}
cur_ans += buf[aa] == buf[cc];
printf("%d\n", cur_ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x;
cin >> t;
for (int o = 0; o < t; o++) {
cin >> n;
int f = 1;
for (int i = 0; i < n; i++) {
cin >> x;
x = abs(x);
if (f == 1) {
cout << x * (-1) << " ";
f = 0;
} else {
cout << x << " ";
f = 1;
}
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 7;
const int inf = 0x3f3f3f3f;
int n, k;
int fa[MX];
long long MAX, dis[MX];
bool vis[MX];
vector<pair<int, int> > E[MX];
vector<int> point, Tree, v;
void dfs(int u, int f) {
fa[u] = f;
MAX = max(MAX, dis[u]);
for (auto nw : E[u]) {
int v = nw.first, w = nw.second;
if (v == f || vis[v]) continue;
dis[v] = dis[u] + w;
dfs(v, u);
}
}
void Tree_init() {
dfs(1, -1);
int st, ed;
long long mx = -1;
for (int i = 1; i <= n; i++) {
if (dis[i] > mx) {
mx = dis[i];
st = i;
}
}
memset(dis, 0, sizeof(dis));
dfs(st, -1);
mx = -1;
for (int i = 1; i <= n; i++) {
if (dis[i] > mx) {
mx = dis[i];
ed = i;
}
}
for (int i = ed; i != -1; i = fa[i]) point.push_back(i);
reverse(point.begin(), point.end());
k = min(k, (int)point.size());
for (auto x : point) {
vis[x] = 1;
v.push_back(dis[x]);
}
for (auto x : point) {
MAX = 0;
dis[x] = 0;
dfs(x, -1);
Tree.push_back(MAX);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i < n; i++) {
int uu, vv, w;
cin >> uu >> vv >> w;
E[uu].push_back(make_pair(vv, w));
E[vv].push_back(make_pair(uu, w));
}
Tree_init();
deque<pair<long long, long long> > q;
long long sz = point.size();
long long ans = 1e18;
for (int i = 0, j = 0; i <= sz - k; i++) {
while (j <= i + k - 1) {
while (!q.empty() && Tree[j] > q.back().first) q.pop_back();
q.push_back(make_pair(Tree[j], j));
j++;
}
while (q.front().second < i) q.pop_front();
ans = min(ans,
max(q.front().first,
(long long)max(v[i], v[(int)v.size() - 1] - v[i + k - 1])));
}
cout << ans << endl;
return 0;
}
| 8 |
//Ritik Kumar CSE 'A' BBIT.
#include<bits/stdc++.h>
#define int long long int
typedef unsigned long long ull;
#define pb push_back
#define vec vector<int>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define pll pair<int,int>
#define mll map<int,int>
#define sz(x) (int)((x).size())
#define all(x) (x).begin(),(x).end()
#define F first
#define S second
#define lcm(a,b) (a*b)/(__gcd(a,b))
#define prt(x) cout<<x
#define prtl(x) cout<<x<<endl
#define int long long int
#define check cout<<checkedDude<<endl
const int mod = 1000000007;
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define mem(name, value) memset(name, value, sizeof(name))
const int N = 1000000007;
using namespace std;
void solve(){
int n,k,x;
cin >> n >> k >> x;
vector<int> a(n);
for(int &x:a){
cin >> x;
}
sort(all(a));
vector<int> v;
rep(i,1,n){
// i-1 and i
int d = a[i] - a[i - 1];
if(d <= x) continue;
v.pb((d-1)/x);
}
sort(all(v));
int ans = sz(v) + 1;
for(int y:v){
if(k >= y){
k -= y;
ans--;
}
}
cout << ans;
}
int32_t main()
{
ios::sync_with_stdio(false);
cin.tie(0);
// int t;
// cin>>t;
// while(t--)
// {
solve();
// }
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200005;
int main() {
int n, a, b;
cin >> n >> a >> b;
if (n > a * b) {
cout << -1 << endl;
return 0;
}
vector<vector<int>> s(a + 1, vector<int>(b + 1, 0));
bool flag = false;
int q = 1;
if (b % 2 == 0) {
for (int i = 1; i <= a; i++) {
if (i % 2 == 1) {
for (int j = 1; j <= b; j++) {
s[i][j] = q;
if (n == q) {
flag = true;
break;
}
q++;
}
} else {
for (int j = b; j >= 1; j--) {
s[i][j] = q;
if (n == q) {
flag = true;
break;
}
q++;
}
}
if (flag) {
break;
}
}
} else {
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
s[i][j] = q;
if (n == q) {
flag = true;
break;
}
q++;
}
if (flag) {
break;
}
}
}
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
cout << s[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n >> a;
if (a % 2 == 0) {
cout << ((n - a) / 2) + 1;
} else {
cout << (a + 1) / 2;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, len;
scanf("%d %d", &n, &k);
if (n < k)
printf("-1\n");
else if (k == 1) {
if (n == 1)
printf("a\n");
else
printf("-1\n");
} else {
len = n - k + 2;
k -= 2;
for (i = 0; i < len; i++) cout << char('a' + (i & 1));
if (k != 0) {
for (i = 2; i < k + 2; i++) cout << char('a' + i);
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
struct P {
int x, y;
inline void in() { x = gi(), y = gi(); }
};
inline P operator+(const P &a, const P &b) { return (P){a.x + b.x, a.y + b.y}; }
inline P operator-(const P &a, const P &b) { return (P){a.x - b.x, a.y - b.y}; }
inline long long operator*(const P &a, const P &b) {
return 1LL * a.x * b.y - 1LL * a.y * b.x;
}
inline long long dot(const P &a, const P &b) {
return 1LL * a.x * b.x + 1LL * a.y * b.y;
}
inline bool operator<(const P &a, const P &b) { return a * b > 0; }
P v[100], p[N], q[N], cur[N];
int w[N], lim[N], c[N];
struct work {
double a;
int x, y, z;
inline bool operator<(const work &b) const {
return fabs(a - b.a) < 1e-7 ? z < b.z : a < b.a;
}
} T[N * 3];
long long s[N], ans[N];
inline void add(int k, int x) {
for (; k <= 1e5; k += k & -k) s[k] += x;
}
inline long long sum(int k) {
long long ans = 0;
for (; k; k ^= k & -k) ans += s[k];
return ans;
}
int main() {
int n = gi(), m = gi(), Q = gi(), i, j, cn;
P all = (P){0, 0};
for (i = 1; i <= n; i++) {
v[i].in();
if (v[i].x < 0 || (v[i].x == 0 && v[i].y < 0)) v[i].x *= -1, v[i].y *= -1;
all = all + v[i];
}
sort(v + 1, v + 1 + n);
for (i = 1; i <= m; i++) p[i].in(), w[i] = gi(), c[i] = p[i].x;
sort(c + 1, c + 1 + m);
cn = unique(c + 1, c + 1 + m) - c - 1;
for (i = 1; i <= Q; i++) {
q[i].in(), cur[i] = q[i], lim[i] = gi();
q[i].x -= all.x * lim[i], q[i].y -= all.y * lim[i];
lim[i] <<= 1;
}
for (i = 1; i <= n; i++) {
if (!v[i].x) {
for (j = 1; j <= Q; j++) q[j].y += v[i].y * lim[j];
continue;
}
for (j = 1; j <= m; j++)
T[j] = (work){p[j].y - (double)p[j].x * v[i].y / v[i].x, p[j].x, w[j], 0};
for (j = 1; j <= Q; j++) {
T[m + j] = (work){q[j].y - (double)q[j].x * v[i].y / v[i].x, q[j].x,
q[j].x + v[i].x * lim[j], -j};
q[j].x += v[i].x * lim[j], q[j].y += v[i].y * lim[j];
}
memset(s, 0, sizeof(s));
sort(T + 1, T + 1 + m + Q);
for (j = 1; j <= m + Q; j++)
if (T[j].z)
ans[-T[j].z] -=
sum((upper_bound(c + 1, c + cn + 1, T[j].y) - c - 1)) -
sum((upper_bound(c + 1, c + cn + 1, T[j].x - (i < 2)) - c - 1));
else
add((upper_bound(c + 1, c + cn + 1, T[j].x) - c - 1), T[j].y);
}
for (i = 1; i <= n; i++) {
if (!v[i].x) break;
for (j = 1; j <= m; j++)
T[j] = (work){p[j].y - (double)p[j].x * v[i].y / v[i].x, p[j].x, w[j], 0};
for (j = 1; j <= Q; j++) {
T[m + j] = (work){q[j].y - (double)q[j].x * v[i].y / v[i].x,
q[j].x - v[i].x * lim[j], q[j].x, j};
q[j].x -= v[i].x * lim[j], q[j].y -= v[i].y * lim[j];
}
memset(s, 0, sizeof(s));
sort(T + 1, T + 1 + m + Q);
for (j = 1; j <= m + Q; j++)
if (T[j].z)
ans[T[j].z] +=
sum((upper_bound(c + 1, c + cn + 1, T[j].y - (i > 1)) - c - 1)) -
sum((upper_bound(c + 1, c + cn + 1, T[j].x - 1) - c - 1));
else
add((upper_bound(c + 1, c + cn + 1, T[j].x) - c - 1), T[j].y);
}
for (i = 1; i <= Q; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 7;
const int M = 107;
const int mod = 998244353;
const int inf = 1e9 + 7;
const double pi = acos(-1);
const int maxn = N * 2;
const double PI = acos(-1);
long long lt[] = {10, 100, 1000, 10000, 100000,
1000000, 10000000, 100000000, 1000000000};
int get(int u, int x) { return u % lt[x]; }
set<long long> st;
string s;
vector<int> a;
void init() {
for (int i = (0); i < (2000); i++) {
a.push_back(i);
}
}
set<long long> has;
void solve() {
cin >> s;
int i = 0;
while (s[i] > '9' || s[i] < '0') i++;
int n = 0;
int sl = s.size() - i;
while (i < s.size()) {
n = n * 10 + s[i++] - '0';
}
has.clear();
long long last = -1;
for (int t = (0); t < (sl); t++) {
int current = get(n, t);
for (int i = (0); i < (a.size()); i++) {
long long now = current + (long long)lt[t] * a[i];
if (now >= 1989 && has.count(now) == 0) {
has.insert(now);
last = now;
break;
}
}
}
cout << last << "\n";
}
int main() {
init();
int T = 1;
cin >> T;
for (int i = (1); i < (T + 1); i++) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
using ll = long long;
using P = pair<ll, ll>;
constexpr long double PI = 3.14159265358979323846264338327950288L;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
constexpr ll mod17 = 1e9 + 7;
constexpr ll mod19 = 1e9 + 9;
constexpr ll mod9 = 998244353;
ll mod = mod17;
unordered_map<ll, ll> minvmap;
ll minv(ll a, ll m) {
auto k = a;
auto p = minvmap[a];
if (p != 0) return p;
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
p = (u % m + m) % m;
minvmap[k] = p;
return p;
}
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % mod + mod) % mod) {}
mint& fix() {
x = (x % mod + mod) % mod;
return *this;
}
mint operator-() const { return mint(0) - *this; }
mint& operator+=(const mint& a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint& a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint& a) {
(x *= a.x) %= mod;
return *this;
}
mint& operator/=(const mint& a) {
(x *= minv(a.x, mod)) %= mod;
return *this;
}
mint operator+(const mint& a) const { return mint(*this) += a; }
mint operator-(const mint& a) const { return mint(*this) -= a; }
mint operator*(const mint& a) const { return mint(*this) *= a; }
mint operator/(const mint& a) const { return mint(*this) /= a; }
bool operator<(const mint& a) const { return x < a.x; }
bool operator==(const mint& a) const { return x == a.x; }
};
template <typename T>
T mod_pow(T a, ll x) {
T res = 1;
while (x > 0) {
if (x & 1) res *= a;
a *= a;
x >>= 1;
}
return res;
}
class combination {
public:
std::vector<mint> fact;
public:
std::vector<mint> inv;
combination(int n) {
fact.resize(n + 1);
inv.resize(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
}
inv[n] = mint(1) / fact[n];
for (int i = n - 1; i >= 0; i--) {
inv[i] = inv[i + 1] * (i + 1);
}
}
public:
mint get(int n, int r) {
if (n < r || n < 0 || r < 0) return 0;
return fact[n] * inv[r] * inv[n - r];
}
public:
mint p(int n, int r) {
if (n < r || n < 0) return 0;
return fact[n] * inv[n - r];
}
};
template <typename T>
void fwt_xor(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j], y = f[j | i];
f[j] = x + y, f[j | i] = x - y;
}
}
}
}
template <typename T>
void ifwt_xor(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = f[j], y = f[j | i];
f[j] = (x + y) / 2, f[j | i] = (x - y) / 2;
}
}
}
}
template <typename T>
void fwt_or(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
f[j | i] += f[j];
}
}
}
}
template <typename T>
void ifwt_or(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
f[j | i] -= f[j];
}
}
}
}
template <typename T>
void fwt_and(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
f[j] += f[j | i];
}
}
}
}
template <typename T>
void ifwt_and(vector<T>& f) {
int n = f.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
f[j] -= f[j | i];
}
}
}
}
class E1ChioriAndDollPickingEasyVersion {
public:
void solve(istream& cin, ostream& cout) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
mod = mod9;
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < (int)(n); i++) {
cin >> a[i];
}
vector<ll> vec1, vec2;
for (int k = m; k >= 0; k--) {
ll t = 1LL << k;
ll v = -1;
for (int i = 0; i < (int)(n); i++) {
if (t & a[i]) {
if (v == -1) {
v = a[i];
}
a[i] ^= v;
}
}
if (v != -1) {
if (k >= 18) {
vec1.push_back(v);
} else {
vec2.push_back(v);
}
}
}
unordered_map<ll, ll> mp;
mp[0] = 1;
for (auto e : vec1) {
auto mp2 = mp;
for (auto f : mp) {
mp2[f.first ^ e] += f.second;
}
swap(mp, mp2);
}
vector<vector<ll>> dp1(18, vector<ll>(1 << 18));
for (auto e : mp) {
int u = __builtin_popcount(e.first >> 18);
int s = e.first % (1 << 18);
dp1[u][s] += e.second;
}
mp.clear();
mp[0] = 1;
for (auto e : vec2) {
auto mp2 = mp;
for (auto f : mp) {
mp2[f.first ^ e] += f.second;
}
swap(mp, mp2);
}
vector<ll> dp2(1 << 18);
for (auto e : mp) {
dp2[e.first] += e.second;
}
fwt_xor(dp2);
for (int i = 0; i < (int)(18); i++) {
fwt_xor(dp1[i]);
for (int j = 0; j < (int)(1 << 18); j++) {
dp1[i][j] *= dp2[j];
}
ifwt_xor(dp1[i]);
}
vector<mint> ans(36);
for (int i = 0; i < (int)(18); i++) {
for (int j = 0; j < (int)(1 << 18); j++) {
ans[i + (__builtin_popcount(j))] += dp1[i][j];
}
}
int p = n - vec1.size() - vec2.size();
mint p2 = mod_pow(mint(2), p);
for (int i = 0; i <= m; i++) {
cout << (ans[i] * p2).x << ' ';
}
cout << endl;
}
};
signed main() {
E1ChioriAndDollPickingEasyVersion solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long n, k;
cin >> n >> k;
long long mm = 1;
long long ans = 0;
while (mm < k) {
mm = mm << 1;
ans++;
}
if (n > mm) {
long long num = (n - mm + k - 1) / k;
ans += num;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int sum[1005];
int main() {
int n, m, k, max = 0, a, b;
memset(sum, -1, sizeof(sum));
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
if (sum[a] == -1 || b == 0) sum[a] = b;
if (sum[a] != -1 && sum[a] >= b) sum[a] = b;
}
for (int i = 1; i <= m; i++) max += sum[i];
if (max <= k)
printf("%d\n", max);
else
printf("%d\n", k);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, max_r = -1, cnt = 0, max_c = -1, min_r = 100000, min_c = 100000;
cin >> n >> m;
char x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> x;
if (x == 'B') {
cnt++;
max_c = max(max_c, j);
min_c = min(min_c, j);
max_r = max(max_r, i);
min_r = min(min_r, i);
}
}
}
if (max_r == -1) {
cout << 1 << endl;
return 0;
}
int c, r, len = 0;
c = max_c - min_c + 1;
r = max_r - min_r + 1;
len = max(c, r);
if (cnt == 0)
cout << 1 << endl;
else if (len > n || len > m)
cout << -1 << endl;
else
cout << abs(len * len - cnt) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int INT_MAX_VAL = (int)1e20;
int INT_MIN_VAL = (int)-1e20;
long long LONG_MAX_VAL = (long long)1e20;
long long LONG_MIN_VAL = (long long)-1e20;
int main() {
string s;
cin >> s;
vector<long long> cnt(10);
for (int i = 0; i < s.size(); i++) {
cnt[s[i] - '0']++;
}
vector<long long> r_one;
vector<long long> r_two;
long long max = -1;
for (int i = 1; i <= 5; i++) {
vector<long long> one;
vector<long long> two;
vector<long long> cnt_one = cnt;
vector<long long> cnt_two = cnt;
long long cur = 0;
if (cnt[i] > 0 && cnt[(10 - i) % 10] > 0) {
one.push_back(i);
cnt_one[i]--;
two.push_back((10 - i) % 10);
cnt_two[(10 - i) % 10]--;
cur++;
} else {
continue;
}
for (int i = 0; i <= 9; i++) {
while (cnt_one[i] > 0 && cnt_two[9 - i] > 0) {
one.push_back(i);
two.push_back(9 - i);
cnt_one[i]--;
cnt_two[9 - i]--;
cur++;
}
}
reverse(one.begin(), one.end());
reverse(two.begin(), two.end());
for (int i = 0; i < min(cnt_one[0], cnt_two[0]); i++) {
one.push_back(0);
two.push_back(0);
cur++;
}
long long m = min(cnt_one[0], cnt_two[0]);
cnt_one[0] -= m;
cnt_two[0] -= m;
reverse(one.begin(), one.end());
reverse(two.begin(), two.end());
for (int i = 0; i <= 9; i++) {
while (cnt_one[i] > 0) {
one.push_back(i);
cnt_one[i]--;
}
while (cnt_two[i] > 0) {
two.push_back(i);
cnt_two[i]--;
}
}
if (cur > max) {
r_one = one;
r_two = two;
max = cur;
}
}
if (max == -1) {
for (int i = 0; i <= 9; i++) {
while (cnt[i] > 0) {
r_one.push_back(i);
r_two.push_back(i);
cnt[i]--;
}
}
}
for (int i = r_one.size() - 1; i >= 0; i--) {
cout << r_one[i];
}
cout << '\n';
for (int i = r_two.size() - 1; i >= 0; i--) {
cout << r_two[i];
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n < 4) {
cout << "NO" << endl;
return 0;
}
if (n % 2 == 0)
cout << "NO" << endl;
else
cout << "1 " << (n - 3) / 2 << endl;
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<vector>
#include<queue>
#include<deque>
#include<string>
#include<utility>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<set>
#include<map>
#include<bitset>
#include<stack>
#include<ctime>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,int> pli;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef vector<pli> vpli;
inline ll read(){
ll Hashimoto=0;
bool Kanna=1;
char I_Love=getchar();
while(I_Love<'0'||I_Love>'9'){
if(I_Love=='-')Kanna=0;
I_Love=getchar();
}
while(I_Love>='0'&&I_Love<='9'){
Hashimoto=Hashimoto*10+I_Love-'0';
I_Love=getchar();
}
return (Kanna?Hashimoto:-Hashimoto);
}
template<typename T1,typename T2> inline void Umax(T1 &a,T2 b){
if(a<b)a=b;
}
template<typename T1,typename T2> inline void Umin(T1 &a,T2 b){
if(a>b)a=b;
}
#define YoRHa main
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define filein(s) freopen(s,"r",stdin);
#define fileout(s) freopen(s,"w",stdout);
#define file freopen("I_Love_Hashimoto_Kanna.out","w",stdout);
#define RE cout<<"I_Love_Hashimoto_Kanna"<<endl;
#define Tone(Kanna) cout<<Kanna<<endl;
#define Tall(Hashimoto,Kanna) for(int I_Love=0;I_Love<(Kanna);++I_Love)cout<<Hashimoto[I_Love]<<(I_Love==(Kanna)-1?"\n":" ");
#define FOR(I_Love,Hashimoto,Kanna) for(int I_Love=Hashimoto;I_Love<(Kanna);++I_Love)
#define MP(Hashimoto,Kanna) make_pair(Hashimoto,Kanna)
#define REV(Kanna) reverse(Kanna.begin(),Kanna.end());
#define SORT(Kanna) sort(Kanna.begin(),Kanna.end());
#define UNIQUE(Kanna) Kanna.erase(unique(Kanna.begin(),Kanna.end()),Kanna.end());
#define inf (1000000000)
#define linf (1000000000000000000ll)
#define mod (1000000007)
int n,odd;
void solve(){
cin>>n;odd=0;
FOR(i,0,n*2){
int x;
cin>>x;
if(x%2==0)odd++;
}
if(odd==n){
cout<<"Yes\n";
}
else cout<<"No\n";
}
int YoRHa() {
//完全想清楚了再开始写。
//写不顺、不知道怎么写、很乱的时候，停下来好好想想。
//做得慢总比做不出好。
fastio;
int T;
cin>>T;
while(T--)solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Max_NM(105);
const int Max_V(405);
int N, M, MOD, V, A[Max_V][Max_V], Father[Max_NM * Max_NM];
char B[Max_NM][Max_NM];
inline int Mult(int a, int b) { return a * 1LL * b % MOD; }
inline int Sub(int a, int b) { return a - b < 0 ? a - b + MOD : a - b; }
int Get_Father(int x) {
return Father[x] == x ? x : Father[x] = Get_Father(Father[x]);
}
inline int getnumber(int x, int y) { return (x - 1) * (M + 1) + y; }
int Gauss() {
int Ret(1);
for (int i = 1; i <= V; ++i)
for (int j = 1; j <= V; ++j) A[i][j] = (A[i][j] % MOD + MOD) % MOD;
for (int i = 1; i <= V - 1; ++i) {
for (int j = i + 1, p; j <= V - 1; ++j)
while (A[j][i]) {
p = A[i][i] / A[j][i];
for (int k = i; k <= V - 1; ++k)
A[i][k] = Sub(A[i][k], Mult(A[j][k], p)), swap(A[i][k], A[j][k]);
Ret = Sub(0, Ret);
}
Ret = Mult(Ret, A[i][i]);
}
return Ret;
}
inline void insert(const int &u, const int &v) {
--A[u][v], --A[v][u], ++A[u][u], ++A[v][v];
}
int work(int m) {
for (int i = 1; i <= N + 1; ++i)
for (int j = 1; j <= M + 1; ++j)
if ((i & 1) ^ (j & 1) ^ m) Father[getnumber(i, j)] = getnumber(i, j);
for (int i = 1, u, v; i <= N; ++i)
for (int j = 1; j <= M; ++j)
if (B[i][j] != '*') {
if (B[i][j] == '\\')
if ((i & 1) ^ (j & 1) ^ m)
u = getnumber(i, j), v = getnumber(i + 1, j + 1);
else
continue;
else if ((i & 1) ^ (j & 1) ^ m)
continue;
else
u = getnumber(i + 1, j), v = getnumber(i, j + 1);
if ((u = Get_Father(u)) != (v = Get_Father(v)))
Father[v] = u;
else
return 0;
}
map<int, int> S;
memset(A, 0, sizeof(A)), V = 0;
for (int i = 1; i <= N + 1; ++i)
for (int j = 1; j <= M + 1; ++j)
if ((i & 1) ^ (j & 1) ^ m) S[Get_Father(getnumber(i, j))];
for (map<int, int>::iterator i = S.begin(); i != S.end(); ++i)
i->second = ++V;
for (int i = 1, u, v; i <= N; ++i)
for (int j = 1; j <= M; ++j)
if (B[i][j] == '*') {
if ((i & 1) ^ (j & 1) ^ m)
u = getnumber(i, j), v = getnumber(i + 1, j + 1);
else
u = getnumber(i + 1, j), v = getnumber(i, j + 1);
insert(S[Get_Father(u)], S[Get_Father(v)]);
}
return Gauss();
}
int main() {
scanf("%d%d%d", &N, &M, &MOD);
for (int i = 1; i <= N; ++i) scanf("%s", B[i] + 1);
printf("%d", (work(0) + work(1)) % MOD);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int n = 0;
int nexT[27] = {0};
int last[27] = {0};
int number = 0;
int start[27] = {0};
int len = 0;
char s[100010];
bool isUsed[27] = {false};
int main(int argc, const char* argv[]) {
cin >> n;
bool abort = false;
for (int i = 0; i < n; ++i) {
scanf("%s", str);
if (abort) {
continue;
}
for (int i = 0; i <= strlen(str); ++i) {
if (i == 0) {
if (last[str[i] - 'a' + 1] == 0) {
last[str[i] - 'a' + 1] = -1;
}
continue;
}
isUsed[str[i - 1] - 'a' + 1] = true;
if (i == strlen(str)) {
continue;
}
if (nexT[str[i - 1] - 'a' + 1] == 0 && last[str[i] - 'a' + 1] != 1) {
last[str[i] - 'a' + 1] = 1;
nexT[str[i - 1] - 'a' + 1] = str[i] - 'a' + 1;
} else if (nexT[str[i - 1] - 'a' + 1] == str[i] - 'a' + 1) {
continue;
} else {
abort = true;
break;
}
}
}
for (int i = 1; i <= 26; ++i) {
if (last[i] == -1) {
start[number++] = i;
}
}
if (abort) {
cout << "NO" << endl;
} else {
for (int i = 0; i < number; ++i) {
int pos = start[i];
s[len++] = pos + 'a' - 1;
isUsed[pos] = false;
while (nexT[pos] != 0) {
pos = nexT[pos];
isUsed[pos] = false;
s[len++] = pos + 'a' - 1;
}
}
s[len++] = '\0';
for (int i = 1; i <= 26; ++i) {
if (isUsed[i]) {
abort = true;
}
}
if (abort) {
cout << "NO" << endl;
} else {
cout << s << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, f[35][35][2], pw[35];
void Add(int &x, int y) {
x = (x + y) % mod;
return;
}
int main() {
scanf("%d", &n);
pw[0] = 1;
for (int i = 1; i <= 30; i++) pw[i] = 1ll * pw[i - 1] * 2 % mod;
f[30][0][1] = 1;
for (int i = 30; i >= 1; i--)
for (int j = 0; j <= 30; j++) {
Add(f[i - 1][j + 1][0], f[i][j][0]);
Add(f[i - 1][j][0], 1ll * pw[j] * f[i][j][0] % mod);
int even = j ? pw[j - 1] : 1, odd = j ? pw[j - 1] : 0;
if (!(n & (1 << (i - 1))))
Add(f[i - 1][j][1], 1ll * even * f[i][j][1] % mod);
else {
Add(f[i - 1][j + 1][1], f[i][j][1]);
Add(f[i - 1][j][0], 1ll * f[i][j][1] * even % mod);
Add(f[i - 1][j][1], 1ll * f[i][j][1] * odd % mod);
}
}
int ans = 0;
for (int i = 0; i <= 30; i++) Add(ans, f[0][i][0]), Add(ans, f[0][i][1]);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n / 2 + 1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct Edge {
int x, y, wt;
};
int n, m;
Edge a[N];
set<pair<int, int>> b[N];
int solve() {
for (int i = 1; i <= m; i++) {
auto [x, y, wt] = a[i];
auto it = b[x].lower_bound({wt, -1});
int len;
if (it == b[x].begin()) {
len = 1;
} else {
it--;
assert(it->first < wt);
len = it->second + 1;
}
it = b[y].lower_bound({wt, len});
if (it == b[y].begin())
it = b[y].insert({wt, len}).first;
else {
it--;
if (it->first < wt && it->second < len) {
it = b[y].insert({wt, len}).first;
} else
continue;
}
it++;
while (it != b[y].end() && !(it->first > wt && it->second > len)) {
it = b[y].erase(it);
}
}
int ans = 1;
for (int i = 1; i <= n; i++)
for (auto [_, len] : b[i]) ans = max(ans, len);
return ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i].x >> a[i].y >> a[i].wt;
}
cout << solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int neg = 1, num = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') neg = -1;
for (; isdigit(c); c = getchar()) num = (num << 1) + (num << 3) + c - '0';
return neg * num;
}
int n, a[110][110], vis[110][110];
int dx[] = {-2, -1, 0, 2, 1, 0}, dy[] = {0, -1, -2, 0, 1, 2};
inline void bfs(int sx, int sy) {
queue<pair<int, int> > q;
q.push(make_pair(sx, sy));
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
for (int i = 0; i <= 5; i++) {
int x = u.first + dx[i];
int y = u.second + dy[i];
if (x > n || y > n || x < 1 || y < 1) continue;
if (!vis[x][y]) {
vis[x][y] = 1;
cout << "? " << min(x, u.first) << " " << min(y, u.second) << " "
<< max(x, u.first) << " " << max(y, u.second) << endl;
int w = read();
fflush(stdout);
a[x][y] = a[u.first][u.second] ^ w ^ 1;
q.push(make_pair(x, y));
}
}
}
}
signed main() {
n = read();
vis[1][1] = 1;
a[1][1] = 1;
vis[n][n] = 1;
a[n][n] = 0;
bfs(1, 1);
vis[1][2] = 1;
a[1][2] = 1;
bfs(1, 2);
int w = 0;
for (int i = 1; i <= n - 2; i += 2)
if (a[i][i] != a[i + 2][i + 2]) {
if ((a[i][i] ^ a[i + 1][i] ^ a[i + 1][i + 1] ^ a[i + 2][i + 1]) == 0) {
cout << "? " << i << " " << i << " " << i + 2 << " " << i + 1 << endl;
int x = read();
fflush(stdout);
if (x == 0 && a[i][i] == a[i + 2][i + 1])
w = 1;
else if (x == 1 && a[i][i] != a[i + 2][i + 1])
w = 1;
break;
} else if ((a[i + 1][i] ^ a[i + 1][i + 1] ^ a[i + 2][i + 1] ^
a[i + 2][i + 2]) == 0) {
cout << "? " << i + 1 << " " << i << " " << i + 2 << " " << i + 2
<< endl;
int x = read();
fflush(stdout);
if (x == 0 && a[i + 1][i] == a[i + 2][i + 2])
w = 1;
else if (x == 1 && a[i + 1][i] != a[i + 2][i + 2])
w = 1;
break;
}
}
printf("!\n");
for (int i = 1; i <= n; i++, cout << endl)
for (int j = 1; j <= n; j++)
cout << ((i + j & 1) ? (a[i][j] ^ w) : a[i][j]), fflush(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[27];
char s[100006];
int main() {
scanf("%d", &n);
scanf("%s", s);
if (n > 26 || n == 1) {
printf("Yes\n");
} else {
bool success = false;
for (int i = 0; i < n; i++) {
a[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (a[i] >= 2) {
success = true;
break;
}
}
if (success) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
long long max = a[n - 1];
for (int i = 0; i < n - 1; i++) sum += (max - a[i]);
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
inline int read() {
int ans = 0;
bool f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = getchar();
return f ? ans : -ans;
}
int n, m;
long long b[100010], g[100010];
long long ans;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d", &b[i]);
for (int i = 1; i <= m; i++) scanf("%I64d", &g[i]);
sort(b + 1, b + n + 1);
sort(g + 1, g + m + 1);
if (b[n] > g[1])
cout << -1;
else if (b[n] == g[1]) {
for (int i = 1; i < n; i++) ans += b[i] * m;
for (int i = 1; i <= m; i++) ans += g[i];
cout << ans;
} else {
ans += b[n] + g[1] + b[n - 1] * (m - 1);
for (int i = n - 2; i >= 1; i--) ans += b[i] * m;
for (int i = 2; i <= m; i++) ans += g[i];
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int len = 0;
int c0 = 0;
int c1 = 0;
int m = -1;
while (1) {
char c = getchar();
if (c == 10) break;
if (c == 48) {
++c0;
++m;
} else {
++c1;
m = -1;
}
}
if (c1 == 1) {
printf("%d", c0);
} else {
printf("%d", c0 * 2 + c1 - m);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int a[2333][5], v1[233], v2[233], u[233];
void get(int v) {
u[v] = 1;
printf("? %d\n", v);
fflush(stdout);
scanf("%d", a[v]);
for (int i = 1; i <= a[v][0]; ++i) scanf("%d", a[v] + i);
}
int step(int v) {
for (int i = 1; i <= a[v][0]; ++i)
if (!u[a[v][i]]) return a[v][i];
return a[v][1];
}
void work() {
memset(u, 0, sizeof u);
int n, v = 1, dep;
scanf("%d", &n);
get(v);
if (a[v][0] == 1)
dep = 1;
else {
int n1 = 0, n2 = 0;
for (int t = step(v);; t = step(t)) {
get(t);
v1[++n1] = t;
if (a[t][0] == 1) break;
}
for (int t = step(v);; t = step(t)) {
get(t);
v2[++n2] = t;
if (a[t][0] == 1) break;
}
dep = (n1 + n2) / 2 + 1;
if (n1 > n2) v = v1[n1 - dep + 1];
if (n1 < n2) v = v2[n2 - dep + 1];
}
while (dep < n && dep < 4) {
int n1 = 0;
for (int t = step(v);; t = step(t)) {
get(t);
v1[++n1] = t;
if (a[t][0] == 1) break;
}
dep = (n1 + dep + 1) / 2;
v = v1[n1 - dep + 1];
}
int z, b, c, d, e, f, g;
if (dep < n) {
z = step(v);
get(z);
if (a[z][0] == 2) v = z;
}
if (dep < n - 1) {
b = step(z);
get(b);
if (a[b][0] == 2) v = b;
c = step(z);
get(c);
if (a[c][0] == 2) v = c;
}
if (dep < n - 2) {
d = step(b);
get(d);
if (a[d][0] == 2) v = d;
e = step(b);
get(e);
if (a[e][0] == 2) v = e;
f = step(c);
get(f);
if (a[f][0] == 2) v = f;
g = step(c);
if (a[v][0] != 2) v = g;
}
printf("! %d\n", v);
fflush(stdout);
}
int main() {
int T;
scanf("%d", &T);
while (T--) work();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
map<int, long long> mp;
for (int i = 0; i < n; i++) mp[arr[i] - (i + 1)] += arr[i];
vector<long long> v;
map<int, long long>::iterator it = mp.begin();
while (it != mp.end()) {
v.push_back(it->second);
it++;
}
sort(v.begin(), v.end());
int d = v.size();
cout << v[d - 1];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void testcase() {
int n;
cin >> n;
string s;
cin >> s;
int oc = 0, cc = 0;
for (int i = 0; i <= (n - 1); ++i) {
if (s[i] == '(')
oc++;
else
cc++;
}
if (oc != cc) {
cout << "-1\n";
return;
}
int unmatched = 0, res = 0, pre = -1;
for (int i = 0; i <= (n - 1); ++i) {
if (s[i] == ')') {
unmatched++;
if (unmatched == 1) pre = i;
}
if (s[i] == '(') unmatched--;
if (unmatched == 0) {
if (pre != -1) {
res += (i - pre + 1);
pre = -1;
}
}
}
cout << res << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
if (0) cin >> t;
while (t--) {
testcase();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
int w, h;
std::cin >> h >> w;
std::vector<std::string> picture(h);
for (int i = 0; i < h; i++) std::cin >> picture[i];
std::vector<std::vector<bool>> should_be_plus(h, std::vector<bool>(w, false));
for (int i = 1; i < h - 1; i++) {
for (int j = 1; j < w - 1; j++) {
if (picture[i][j] == '*' && picture[i - 1][j] == '*' &&
picture[i + 1][j] == '*' && picture[i][j + 1] == '*' &&
picture[i][j - 1] == '*') {
int upend = i, downend = i, leftend = j, rightend = j;
while (upend >= 0 && picture[upend][j] == '*')
should_be_plus[upend--][j] = true;
while (downend < h && picture[downend][j] == '*')
should_be_plus[downend++][j] = true;
while (leftend >= 0 && picture[i][leftend] == '*')
should_be_plus[i][leftend--] = true;
while (rightend < w && picture[i][rightend] == '*')
should_be_plus[i][rightend++] = true;
for (int i2 = 0; i2 < h; i2++)
for (int j2 = 0; j2 < w; j2++) {
if (should_be_plus[i2][j2] != (picture[i2][j2] == '*')) {
std::cout << "NO\n";
return 0;
}
}
std::cout << "YES\n";
return 0;
}
}
}
std::cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int judge(double x, double y) {
y += 1;
return sqrt(x * x + y * y) <= (double)n + 1e-6;
}
int main() {
scanf("%d", &n);
long long ans = 1;
double d = sqrt(3) * 3 / 2;
int an = 6, I;
for (I = 2;; I++) {
if (sqrt(d * d + 0.25) <= n)
ans += an;
else
break;
an += 6;
d += sqrt(3);
}
I--;
d -= sqrt(3) / 2 * 3;
double x, y;
x = -d / 2;
y = d / 2 * sqrt(3);
x += sqrt(3) / 2;
y += 1.5;
I--;
for (; x <= 1e-6 && I > 0; I--) {
while (judge(x, y) == 0 && x <= 1e-6) {
I -= 2;
x += sqrt(3);
}
if (x <= 1e-6) ans += 6 * I;
x += sqrt(3) / 2;
y += 1.5;
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
int n;
long long dp[2005][1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
dp[2 * n][0] = 1;
for (int i = 2 * n - 1; i >= 1; --i) {
dp[i][0] = dp[i + 1][1];
if (i % 2 == 0) ++dp[i][0];
dp[i][0] %= 1000000007;
for (int j = 1; j <= n; ++j) {
dp[i][j] = dp[i + 1][j - 1] + dp[i + 1][j + 1];
if (i % 2 == 0 && dp[i][j])
++dp[i][j];
else if (dp[i + 1][j - 1] && dp[i + 1][j + 1])
--dp[i][j];
dp[i][j] %= 1000000007;
}
}
dp[1][1] = (dp[1][1] + 1000000007) % 1000000007;
cout << dp[1][1] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000006;
char s[N];
int idx[N][26];
int main() {
int n, k;
scanf("%d %d %s", &n, &k, s);
int closest[26];
memset(closest, -1, sizeof closest);
for (int i = 0; i < N; ++i) {
closest[s[i] - 'a'] = i;
for (int j = 0; j < 26; ++j) idx[i][j] = closest[j];
}
memset(closest, -1, sizeof closest);
for (int i = N - 1; i >= 0; --i) {
closest[s[i] - 'a'] = i;
for (int j = 0; j < 26; ++j) {
if (idx[i][j] == -1 ||
(closest[j] != -1 && abs(i - closest[j]) < abs(i - idx[i][j])))
idx[i][j] = closest[j];
}
}
while (n--) {
long long res = 0;
scanf("%s", s);
k = strlen(s);
for (int i = 0; i < k; ++i) {
res += idx[i][s[i] - 'a'] == -1 ? k : abs(i - idx[i][s[i] - 'a']);
}
printf("%I64d\n", res);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
struct base {
long double a, b;
base(long double a = 0, long double b = 0) : a(a), b(b) {}
const base operator+(const base &c) const { return base(a + c.a, b + c.b); }
const base operator-(const base &c) const { return base(a - c.a, b - c.b); }
const base operator*(const base &c) const {
return base(a * c.a - b * c.b, a * c.b + b * c.a);
}
};
void fft(vector<base> &p, bool inv = 0) {
int n = p.size(), i = 0;
for (int j = 1; j < n - 1; ++j) {
for (int k = n >> 1; k > (i ^= k); k >>= 1)
;
if (j < i) swap(p[i], p[j]);
}
for (int l = 1, m; (m = l << 1) <= n; l <<= 1) {
long double ang = 2 * PI / m;
base wn = base(cos(ang), (inv ? 1. : -1.) * sin(ang)), w;
for (int i = 0, j, k; i < n; i += m) {
for (w = base(1, 0), j = i, k = i + l; j < k; ++j, w = w * wn) {
base t = w * p[j + l];
p[j + l] = p[j] - t;
p[j] = p[j] + t;
}
}
}
if (inv)
for (int i = 0; i < n; ++i) p[i].a /= n, p[i].b /= n;
}
vector<bool> multiply(vector<bool> &a, vector<bool> &b) {
int n = a.size(), m = b.size(), t = n + m - 1, sz = 1;
while (sz < t) sz <<= 1;
vector<base> x(sz), y(sz), z(sz);
for (int i = 0; i < sz; ++i) {
x[i] = i < a.size() ? base(a[i], 0) : base(0, 0);
y[i] = i < b.size() ? base(b[i], 0) : base(0, 0);
}
fft(x), fft(y);
for (int i = 0; i < sz; ++i) z[i] = x[i] * y[i];
fft(z, 1);
vector<bool> ret(sz);
for (int i = 0; i < sz; ++i) {
long long ds = z[i].a + 0.5;
if (ds == 0)
ret[i] = 0;
else
ret[i] = 1;
}
while (ret.size() > 1 && ret.back() == 0) ret.pop_back();
return ret;
}
int vis[200], casio, cnt;
vector<int> vc[200];
void dfs(int v) {
vis[v] = casio;
cnt++;
for (int i = 0; i < vc[v].size(); i++) {
int w = vc[v][i];
if (vis[w] == casio) continue;
dfs(w);
}
}
string str, str2;
vector<bool> tp[3], cp[3], ret[103][103];
int main() {
int i, j, k, l, m, n;
cin >> str >> str2;
reverse(str2.begin(), str2.end());
for (int i = 97; i <= 102; i++) {
for (int j = i + 1; j <= 102; j++) {
for (int k = 0; k < 2; k++) {
tp[k].clear();
cp[k].clear();
}
for (int k = 0; str[k]; k++) {
if (str[k] == i)
tp[0].push_back(1);
else
tp[0].push_back(0);
if (str[k] == j)
tp[1].push_back(1);
else
tp[1].push_back(0);
}
for (int k = 0; str2[k]; k++) {
if (str2[k] == j)
cp[0].push_back(1);
else
cp[0].push_back(0);
if (str2[k] == i)
cp[1].push_back(1);
else
cp[1].push_back(0);
}
ret[i][j] = multiply(tp[0], cp[0]);
vector<bool> r = multiply(tp[1], cp[1]);
if (r.size() > ret[i][j].size()) ret[i][j].resize(r.size());
for (int k = 0; k < r.size(); k++) {
if (r[k]) ret[i][j][k] = r[k];
}
}
}
int f = str2.size() - 1;
for (int i = 0; str[i]; i++) {
int d = f + i;
if ((i + str2.size() - 1) >= str.size()) break;
for (int k = 97; k <= 102; k++) vc[k].clear();
for (int l = 97; l <= 102; l++) {
for (int k = l + 1; k <= 102; k++) {
if (ret[l][k].size() <= d) continue;
if (ret[l][k][d]) {
vc[l].push_back(k);
vc[k].push_back(l);
}
}
}
casio++;
int ans = 0;
for (int k = 97; k <= 102; k++) {
if (vis[k] == casio) continue;
cnt = 0;
dfs(k);
ans += cnt - 1;
}
printf("%d ", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 5;
const long long MOD = 1e9 + 7;
bool prime[N];
long long p[N];
long long f[N];
int cnt;
void is_prime() {
for (int i = 2; i <= N; i++) prime[i] = true;
for (int i = 2; i * i <= N; i++) {
if (prime[i]) {
p[cnt++] = i;
for (int j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
}
}
int main() {
is_prime();
f[1] = 0;
for (int i = 2; i < N; i++) {
if (prime[i]) {
f[i] = ((long long)i * (i - 1) / 2) % MOD;
} else {
long long factor;
for (int j = 0; j < cnt; j++) {
if (i % p[j] == 0) {
factor = p[j];
break;
}
}
f[i] = (i / factor * f[factor] + f[i / factor]) % MOD;
}
}
long long ans = 0;
long long t, l, r;
cin >> t >> l >> r;
for (int i = r; i >= l; i--) {
ans = (ans * t) % MOD;
ans = (ans + f[i]) % MOD;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 70001;
int n;
map<string, int> d;
string ans[MAXN], s;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s;
ans[i] = s;
for (int j = 0; j < 9; j++) {
for (int k = 1; j + k <= 9; k++) {
int p = d[s.substr(j, k)];
if (p == 0 || p == i)
d[s.substr(j, k)] = i;
else
d[s.substr(j, k)] = -1;
}
}
}
for (auto t : d)
if (t.second > 0) {
if (ans[t.second].size() > t.first.size()) {
ans[t.second] = t.first;
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int findmax(int n) {
for (int i = int(sqrt(2 * n)) + 1; i >= 2; i--) {
if (i * (i - 1) / 2 <= n) return i;
}
return 2;
}
int main() {
ios_base::sync_with_stdio(0);
int N;
cin >> N;
while (N--) {
int n;
cin >> n;
vector<int> v;
while (n > 0) {
int x = findmax(n);
n -= x * (x - 1) / 2;
v.push_back(x);
}
cout << 1;
int sz = v.size(), br = 0;
reverse(v.begin(), v.end());
for (int i = 0; i < sz; i++) {
if (v[i] == v[i - 1]) {
cout << 7;
continue;
}
for (int j = 0; j < v[i] - br; j++) cout << 3;
cout << 7;
br += v[i] - br;
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void print(int x, long long n, long long k) {
if (n == 1) {
cout << x << " ";
return;
}
long long z = ((long long)1) << (n - 2);
if (k < z) {
cout << x << " ";
print(x + 1, n - 1, k);
} else {
print(x + 1, n - 1, k - z);
cout << x << " ";
}
}
int main() {
long long n, k;
cin >> n >> k;
print(1, n, k - 1);
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct ttt {
int c[26];
};
int main() {
string s;
cin >> s;
vector<ttt> p(s.size() + 1);
for (int i = 1; i < p.size(); ++i) {
p[i] = p[i - 1];
++p[i].c[s[i - 1] - 'a'];
}
int q;
cin >> q;
for (int qq = 0; qq < q; ++qq) {
int l, r;
cin >> l >> r;
if (l == r) {
cout << "Yes\n";
continue;
}
int cc = 0;
for (int i = 0; i < 26; ++i) {
if (p[r].c[i] - p[l - 1].c[i] >= 1) ++cc;
}
if (s[l - 1] != s[r - 1]) {
cout << "Yes\n";
continue;
}
if (cc >= 3) {
cout << "Yes\n";
continue;
}
cout << "No\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using std::sort;
using std::vector;
int cmp(const void *x, const void *y) {
return (*((double *)(x))) > (*((double *)(y))) ? 1 : -1;
}
bool v[300], g[300];
int next[300], pre[300];
char str[100005];
bool dfs(int x) {
if (g[x]) return false;
g[x] = true;
if (next[x] == 0) return true;
return dfs(next[x]);
}
int main() {
int n, len;
while (scanf("%d", &n) != EOF) {
memset(next, 0, sizeof(next));
memset(pre, 0, sizeof(pre));
memset(v, false, sizeof(v));
bool flag = true;
for (int i = 0; i < n; i++) {
scanf("%s", str);
len = strlen(str);
for (int j = 0; j < len - 1; j++) {
v[str[j]] = true;
if (next[str[j]] == 0)
next[str[j]] = str[j + 1];
else if (next[str[j]] != str[j + 1])
flag = false;
if (pre[str[j + 1]] == 0)
pre[str[j + 1]] = str[j];
else if (pre[str[j + 1]] != str[j])
flag = false;
}
v[str[len - 1]] = true;
}
for (int i = 'a'; i <= 'z'; i++) {
memset(g, false, sizeof(g));
if (!dfs(i)) flag = false;
}
if (!flag)
printf("NO\n");
else {
len = 0;
for (int i = 'a'; i <= 'z'; i++) {
if (v[i]) {
bool root = true;
for (int j = 'a'; j <= 'z'; j++)
if (next[j] == i) root = false;
if (!root) continue;
int ptr = i;
while (ptr != 0) {
str[len++] = ptr;
v[ptr] = false;
ptr = next[ptr];
}
}
}
str[len] = '\0';
printf("%s\n", str);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long t, id, n, m, x, y, k, c, p, dif, ans, sum, pre, rem, cur, tmp, tot, r,
l, u, d, xx, yy;
long long a[N], vis[N], f[N], b[N], cu[N];
vector<int> v, adj[N];
bool fl, ok;
long long calc(long long pos) {
long long sit = 1, siz = 1, od = 0, ev = 0, rem = pos;
while (rem > 0) {
if (sit & 1) {
od += min(siz, rem);
od %= 1000000007;
} else {
ev += min(siz, rem);
ev %= 1000000007;
}
rem -= siz;
++sit;
siz <<= 1;
}
long long ret = ev * (ev + 1);
ret %= 1000000007;
ret += od * od;
ret %= 1000000007;
return ret;
}
int main() {
scanf("%lld%lld", &l, &r);
ans = calc(r) - calc(l - 1) + 1000000007;
printf("%lld\n", ans % 1000000007);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n;
cin >> n;
long long d = 0;
vector<long long> v;
vector<long long> a;
long long val = 0;
map<long long, long long> m;
long long start = 0, end = -1, count = 0;
for (long long i = 0; i < (long long)n; i++) {
cin >> val;
if (i == 0) {
if (val < 0) {
count++;
break;
} else {
v.push_back(val);
m[val]++;
}
} else {
if (val > 0) {
if (m[val] >= m[-val] && m[val] == 0) {
v.push_back(val);
m[val]++;
} else {
count++;
break;
}
} else {
if (v.size() == 0 && start != end) {
d++;
end = i;
a.push_back(end - start + 1);
start = i + 1;
m.clear();
}
if (m[val] >= m[-val]) {
count++;
break;
} else {
m[val]++;
for (long long j = 0; j < v.size(); j++) {
if (v[j] == (-val)) {
v.erase(v.begin() + j);
break;
}
}
}
if (v.size() == 0 && start != end) {
d++;
end = i;
a.push_back(end - start + 1);
start = i + 1;
m.clear();
}
}
}
}
if (v.size() != 0 || count > 0) {
cout << -1 << "\n";
} else {
cout << d << "\n";
for (long long i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a, b, v;
cin >> k >> a >> b >> v;
int ans = 0;
while (a > 0) {
int cur = min(k - 1, b);
b -= cur;
++cur;
cur *= v;
a -= cur;
++ans;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int D[300001];
int P[300001];
bool S[300001];
vector<pair<int, int>> G[300001];
void solve() {
int n, k, d, x, u, v;
cin >> n >> k >> d;
for (int i = 0; i < k; ++i) {
cin >> x;
S[x] = true;
}
for (int i = 1; i < n; ++i) {
cin >> u >> v;
G[u].push_back({v, i});
G[v].push_back({u, i});
}
queue<int> Q;
fill(D, D + n + 1, -1);
fill(P, P + n + 1, -1);
for (int i = 1; i <= n; ++i)
if (S[i]) {
D[i] = 0;
Q.push(i);
}
vector<int> ans;
while (!Q.empty()) {
int k = Q.front();
Q.pop();
for (auto const& u : G[k]) {
if (P[k] == u.first) continue;
if (D[u.first] != -1) {
if (k < u.first) ans.push_back(u.second);
} else {
D[u.first] = D[k] + 1;
P[u.first] = k;
Q.push(u.first);
}
}
}
cout << ans.size() << '\n';
for (int k : ans) cout << k << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
const int N = 5010;
int n, m;
long long v[N];
long long a[N];
int t[N], d[N];
int l[N], r[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) v[i] = 2 * inf;
for (int i = m - 1; i >= 0; --i) cin >> t[i] >> l[i] >> r[i] >> d[i];
for (int op = 0; op < m; ++op) {
if (t[op] == 1) {
for (int i = l[op] - 1; i < r[op]; ++i) v[i] -= d[op];
} else {
for (int i = l[op] - 1; i < r[op]; ++i)
v[i] = v[i] < d[op] ? v[i] : d[op];
;
}
}
for (int i = 0; i < n; ++i) a[i] = v[i] < inf / 2 ? v[i] : inf / 2;
for (int op = m - 1; op >= 0; --op)
if (t[op] == 1) {
for (int i = l[op] - 1; i < r[op]; ++i) a[i] += d[op];
} else {
int m = a[l[op] - 1];
for (int i = l[op]; i < r[op]; ++i) m = m > a[i] ? m : a[i];
if (m != d[op]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++)
cout << ((v[i] < inf / 2) ? v[i] : inf / 2) << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int c = a;
if (a < b) {
a = b;
b = c;
}
while (a % b) {
c = a % b;
a = b;
b = c;
}
return b;
}
int main() {
int n, x[26], judge = 0, index;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
if (x[i] % 2 == 1) {
judge++;
index = i;
}
}
if (judge >= 2) {
printf("0\n");
for (int i = 0; i < n; i++)
for (int j = 0; j < x[i]; j++) printf("%c", i + 'a');
} else {
int ans = x[0];
for (int i = 1; i < n; i++) ans = gcd(ans, x[i]);
printf("%d\n", ans);
if (judge == 1) {
for (int i = 0; i < ans; i++) {
for (int j = 0; j < n; j++) {
if (j == index) continue;
for (int k = 0; k < x[j] / (ans * 2); k++) printf("%c", j + 'a');
}
for (int k = 0; k < x[index] / ans; k++) printf("%c", index + 'a');
for (int j = n - 1; j >= 0; j--) {
if (j == index) continue;
for (int k = 0; k < x[j] / (ans * 2); k++) printf("%c", j + 'a');
}
}
} else {
for (int i = 0; i < ans; i++) {
if (i % 2 == 0) {
for (int j = 0; j < n; j++)
for (int k = 0; k < x[j] / ans; k++) printf("%c", j + 'a');
} else {
for (int j = n - 1; j >= 0; j--)
for (int k = 0; k < x[j] / ans; k++) printf("%c", j + 'a');
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long modpow(long long a, long long n) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % 1000000007ll;
b = (b * b) % 1000000007ll;
n >>= 1;
}
return (long long)ret;
}
int main() {
int x1, y1, x2, y2;
int x, y;
cin >> x1 >> y1 >> x2 >> y2;
cin >> x >> y;
int ans = true;
ans &= ((x2 - x1) % x == 0);
ans &= ((y2 - y1) % y == 0);
ans &= ((abs(x2 - x1) / x) % 2 == (abs(y2 - y1) / y) % 2);
if (ans)
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, l, t, a[2000 * 1000 + 10];
long double r;
int main() {
cin.sync_with_stdio(false);
cin >> n >> l >> t;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[n + i] = a[i] + l;
}
t *= 2;
long double x = t / l;
t %= l;
for (int i = 0, j = 0; i < n; i++) {
for (; j < 2 * n && a[j] - a[i] <= t; j++)
;
r += j - i - 1;
}
cout << setprecision(7) << fixed << (r + (long double)n * (n - 1) * x) / 4.
<< '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 5000000 + 10;
bool vis[maxn];
int d[maxn], prime[maxn];
void init() {
memset(vis, false, sizeof(vis));
d[1] = 0;
int tot = 0;
for (int i = 2; i <= 5000000; i++) {
if (!vis[i]) {
prime[tot++] = i;
d[i] = 1;
}
for (int j = 0; j < tot; j++) {
if (i * prime[j] > 5000000) break;
vis[i * prime[j]] = true;
d[i * prime[j]] = d[i] + 1;
if (i % prime[j] == 0) break;
}
}
}
long long sum[maxn];
int main() {
init();
sum[0] = 0;
for (int i = 1; i <= 5000000; i++) sum[i] = sum[i - 1] + d[i];
int t;
scanf("%d", &t);
while (t--) {
int a, b;
scanf("%d%d", &a, &b);
printf("%I64d\n", sum[a] - sum[b]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int n, int m) {
if (n % m) return gcd(m, n % m);
return m;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
printf("%d\n", gcd(n - 1, m - 1) + 1);
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.