solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long a, b, k, ans = 0, p = 1, f[500000];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
cin >> a >> b >> k;
long long i, j;
long long temp;
for (i = 2; i <= k; i++) p = p * i / gcd(p, i);
if (a - b <= p) {
for (i = b + 1; i <= a; i++) {
f[i - b] = f[i - 1 - b] + 1;
for (j = 2; j <= k; j++)
if (i - b - i % j >= 0) f[i - b] = min(f[i - b], f[i - b - i % j] + 1);
}
cout << f[a - b] << endl;
return 0;
}
for (i = 1; i <= p; i++) {
f[i] = f[i - 1] + 1;
for (j = 2; j <= k; j++)
if (i - i % j >= 0) f[i] = min(f[i], f[i - i % j] + 1);
}
ans = f[a - a / p * p];
temp = b / p * p;
if (temp < b) temp += p;
ans += (a / p * p - temp) / p * f[p];
b -= b / p * p;
if (b == 0) {
cout << ans << endl;
return 0;
}
f[b] = 0;
for (i = b + 1; i <= p; i++) {
f[i] = f[i - 1] + 1;
for (j = 2; j <= k; j++)
if (i - i % j >= b) f[i] = min(f[i], f[i - i % j] + 1);
}
ans += f[p];
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> numdig(int num) {
vector<int> temp;
for (int i = 0; i < 4; i++) {
temp.push_back(num % 10);
num /= 10;
}
reverse(temp.begin(), temp.end());
return temp;
}
pair<int, int> valid(int a, int b) {
int x = 0, y = 0;
vector<int> A = numdig(a);
vector<int> B = numdig(b);
for (int i = 0; i < 4; i++) {
if (A[i] == B[i]) {
x++;
continue;
}
for (int j = 0; j < 4; j++) {
if (A[i] == B[j]) {
y++;
}
}
}
return make_pair(x, y);
}
int main() {
int queries;
queries = 1;
while (queries--) {
srand(2333333);
vector<int> possibilities, cutshort;
for (int i = 0; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
if (j == i) continue;
for (int k = 0; k <= 9; k++) {
if (k == j || k == i) continue;
for (int l = 0; l <= 9; l++) {
if (l == i || l == j || l == k) continue;
int num = (1000 * i) + (100 * j) + (10 * k) + l;
possibilities.push_back(num);
}
}
}
}
int tries = 1, flag = 1, x, y;
while (tries <= 7) {
random_shuffle(possibilities.begin(), possibilities.end());
vector<int> dig = numdig(possibilities[0]);
for (auto it : dig) {
cout << it;
}
cout << endl;
cin >> x >> y;
if (x == 4 && y == 0) {
break;
}
cutshort.clear();
for (auto it : possibilities) {
if (make_pair(x, y) == valid(it, possibilities[0]))
cutshort.push_back(it);
}
possibilities = cutshort;
tries++;
}
if (flag == 1) {
cout << "tries exceeded" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100001], b[100001];
vector<long long> v[100001];
signed main() {
cin >> n;
long long i;
for (i = 1; i < n + 1; i++) {
cin >> a[i];
v[a[i]].push_back(i);
}
bool ok = 1;
long long clr = 1;
for (i = 0; i < 100001; i++) {
if (!v[i].empty()) {
long long k = v[i].size();
long long j;
if (k % (n - i) != 0) {
ok = 0;
break;
}
long long t = k / (n - i);
long long temp = 1;
j = 0;
while (temp <= t) {
while (j < temp * (n - i)) {
b[v[i][j]] = clr;
j++;
}
clr++;
temp++;
}
}
}
if (ok) {
cout << "Possible\n";
for (i = 1; i < n + 1; i++) cout << b[i] << " ";
} else
cout << "Impossible";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long inf = 2e18 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
long long n, k;
char temp;
cin >> q;
while (q--) {
cin >> n >> k;
string s, t;
cin >> s;
int c = 0;
for (int i = (0); i < (s.length()); i++) {
if (s[i] == '0') {
if (k >= i - c) {
k -= (i - c);
temp = s[c];
s[c] = '0';
s[i] = temp;
} else {
temp = s[i - k];
s[i - k] = '0';
s[i] = temp;
break;
}
c++;
}
}
cout << s << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double LOG(long long N, long long B) { return (log10l(N)) / (log10l(B)); }
string itoa(long long a) {
if (a == 0) return "0";
string ret;
for (long long i = a; i > 0; i = i / 10) ret.push_back((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
int check(int N, int pos) { return (N & (1 << pos)); }
int toggle(int N, int pos) {
if (check(N, pos)) return N = Reset(N, pos);
return N = Set(N, pos);
}
void PBIT(int N) {
printf("(");
for (int i = 10; i >= 0; i--) {
bool x = check(N, i);
cout << x;
}
puts(")");
}
struct node {
int x, i;
bool operator<(const node &p) const {
if (x == p.x) return i < p.i;
return x < p.x;
}
};
vector<int> v;
int a[200002], sh[200002];
int main() {
int n;
cin >> n;
for (int i = 0; i < (int)n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
stable_sort(v.begin(), v.end());
int c = 0;
for (int i = 0; i < (int)v.size(); i++) {
if (v[i] != a[i]) c++;
}
if (c <= 2)
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T sgn(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
int n;
int m;
struct edge {
int u, v, up, f;
};
const int N = 1000010;
edge e[N];
vector<int> g[N];
int cnt = 0;
pair<int, int> v[N], p[N];
int was[N], q[N];
int ct;
bool find_path(int s, int t) {
ct++;
int l = 0, r = 1;
q[l] = s;
while (l < r) {
int x = q[l];
l++;
if (x == t) {
while (x != s) {
e[p[x].second].f++;
e[p[x].second ^ 1].f--;
x = p[x].first;
}
return true;
}
was[x] = ct;
for (auto id : g[x]) {
if (e[id].f < e[id].up && was[e[id].v] != ct) {
q[r++] = e[id].v;
p[e[id].v] = make_pair(x, id);
}
}
}
return false;
}
void make_edge(int u, int v, int up) {
e[cnt] = edge{u, v, up, 0};
g[u].push_back(cnt);
cnt++;
e[cnt] = edge{v, u, 0, 0};
g[v].push_back(cnt);
cnt++;
}
int s, t;
void make_graph(int x) {
cnt = 0;
for (int i = 0; i < n; i++) make_edge(s, i + 1, x);
for (int i = 0; i < m; i++) {
make_edge(v[i].first, i + n + 1, 1);
make_edge(v[i].second, i + n + 1, 1);
make_edge(i + n + 1, t, 1);
}
}
void upd_graph(int x) {
for (int i = 0; i < n; i++) e[2 * i].up = x;
}
int main() {
scanf("%d%d", &n, &m);
s = 0, t = n + m + 1;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[i] = make_pair(x, y);
}
make_graph(0);
int flow = 0;
for (int i = 0; i < n; i++) {
upd_graph(i);
while (find_path(s, t) && flow < m) flow++;
if (flow == m) {
cout << i << endl;
break;
}
}
for (int i = 0; i < cnt; i++) {
if (e[i].u >= 1 && e[i].u <= n) {
pair<int, int> cur = v[(e[i].v - n - 1)];
if (e[i].f == 1)
printf("%d %d\n", e[i].u, cur.first == e[i].u ? cur.second : cur.first);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a;
int m = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
if (a[i] == n) m = i;
}
int flag = 1;
if (a[m] - a[m - 1] == 1 && m == n - 1) {
int k = a[m - 1] - 1;
for (int j = m - 2; j >= 0; j--) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
continue;
}
if (a[m] - a[0] == 1 && m == n - 1) {
int k = a[0] - 1;
for (int j = 1; j < m; j++) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
continue;
}
if (a[m] - a[m + 1] == 1 && m == 0) {
int k = a[m + 1] - 1;
for (int j = m + 2; j < n; j++) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
continue;
}
if (a[m] - a[n - 1] == 1 && m == 0) {
int k = a[n - 1] - 1;
for (int j = n - 2; j > m; j--) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
continue;
}
if (a[m] - a[m - 1] == 1 && m >= 1) {
int k = a[m - 1] - 1;
for (int j = m - 2; j >= 0; j--) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (!flag) {
cout << "NO" << endl;
continue;
}
for (int j = n - 1; j > m; j--) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (!flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
continue;
} else if (a[m] - a[m + 1] == 1 && m <= n - 2) {
int k = a[m + 1] - 1;
for (int j = m + 2; j < n; j++) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (!flag) {
cout << "NO" << endl;
continue;
}
if (m == 0) {
cout << "YES" << endl;
continue;
}
for (int j = 0; j < m; j++) {
if (a[j] == k)
k--;
else {
flag = 0;
break;
}
}
if (!flag) {
cout << "NO" << endl;
continue;
} else {
cout << "YES" << endl;
continue;
}
}
if (n != 1) {
cout << "NO" << endl;
} else
cout << "YES" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') f = ch == '-' ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
const int MAXN = 1010, MAXM = 5010;
int n;
int h[MAXN], tot = 0, cnt[MAXN], check[MAXN];
long long dis[MAXN];
bool vis[MAXN];
struct node {
int u, v;
node() { u = v = 0; }
node(int u, int v) { this->u = u, this->v = v; }
} nd[MAXM];
struct edge {
int v, nxt, w;
edge() { v = nxt = w = 0; }
edge(int v, int nxt, int w) { this->v = v, this->nxt = nxt, this->w = w; }
} e[MAXM << 2];
void add_edge(int x, int y, long long w) {
tot++;
e[tot].v = y;
e[tot].nxt = h[x];
e[tot].w = w;
h[x] = tot;
}
void dfs1(int x) {
if (vis[x]) return;
vis[x] = true;
check[x]++;
for (int i = h[x]; i; i = e[i].nxt)
if (e[i].w > 0) dfs1(e[i].v);
}
void dfs2(int x) {
if (vis[x]) return;
vis[x] = true;
check[x]++;
for (int i = h[x]; i; i = e[i].nxt)
if (e[i].w < 0) dfs2(e[i].v);
}
bool SPFA(int s) {
memset(vis, 0, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
memset(dis, 0x3f, sizeof(dis));
deque<int> q;
q.push_back(s);
dis[s] = 0;
vis[s] = true;
cnt[s]++;
while (!q.empty()) {
int cur = q.front();
q.pop_front();
vis[cur] = false;
if (check[cur] != 2) continue;
for (int i = h[cur]; i; i = e[i].nxt) {
if (check[e[i].v] != 2) continue;
if (dis[e[i].v] > dis[cur] + e[i].w) {
dis[e[i].v] = dis[cur] + e[i].w;
if (!vis[e[i].v]) {
vis[e[i].v] = true;
cnt[e[i].v]++;
if (cnt[e[i].v] >= n) return false;
if (q.empty() || dis[e[i].v] > dis[q.front()])
q.push_back(e[i].v);
else
q.push_front(e[i].v);
}
}
}
}
return true;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
memset(h, 0, sizeof(h));
n = read();
int m = read();
for (int i = (1); i <= (m); i += (1)) {
int a = read(), b = read();
nd[i].u = a, nd[i].v = b;
add_edge(a, b, 2);
add_edge(b, a, -1);
}
memset(check, 0, sizeof(check));
memset(vis, 0, sizeof(vis));
dfs1(1);
memset(vis, 0, sizeof(vis));
dfs2(n);
if (SPFA(1)) {
bool ok = true;
for (int i = (1); i <= (m); i += (1))
if (check[nd[i].u] == 2 && check[nd[i].v] == 2)
if (dis[nd[i].v] - dis[nd[i].u] <= 0 ||
dis[nd[i].v] - dis[nd[i].u] > 2) {
ok = false;
break;
}
if (ok) {
puts("Yes");
for (int i = (1); i <= (m); i += (1)) {
if (dis[nd[i].v] - dis[nd[i].u] < 1 || dis[nd[i].v] - dis[nd[i].u] > 2)
puts("1");
else
printf("%lld\n", dis[nd[i].v] - dis[nd[i].u]);
}
} else
puts("No");
} else
puts("No");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 100000000;
int main() {
int N1, N2, k1, k2;
cin >> N1 >> N2 >> k1 >> k2;
vector<vector<vector<int> > > End_1(
N1 + 1, vector<vector<int> >(N2 + 1, vector<int>(N1 + N2 + 1, 0)));
vector<vector<vector<int> > > End_2(
N1 + 1, vector<vector<int> >(N2 + 1, vector<int>(N1 + N2 + 1, 0)));
End_1[0][0][0] = 1;
for (int n1 = 0; n1 <= N1; n1++) {
for (int n2 = 0; n2 <= N2; n2++) {
for (int k = 0; k <= max(N1, N2); k++) {
if (n1 + 1 <= N1 && k + 1 <= k1) {
End_1[n1 + 1][n2][k + 1] += End_1[n1][n2][k];
End_1[n1 + 1][n2][k + 1] %= Mod;
}
if (n1 + 1 <= N1) {
End_1[n1 + 1][n2][1] += End_2[n1][n2][k];
End_1[n1 + 1][n2][1] %= Mod;
}
if (n2 + 1 <= N2 && k + 1 <= k2) {
End_2[n1][n2 + 1][k + 1] += End_2[n1][n2][k];
End_1[n1][n2 + 1][k + 1] %= Mod;
}
if (n2 + 1 <= N2) {
End_2[n1][n2 + 1][1] += End_1[n1][n2][k];
End_2[n1][n2 + 1][1] %= Mod;
}
}
}
}
int Answer = 0;
for (int i = 0; i <= N1 + N2; i++) {
if (i <= k1) {
Answer += End_1[N1][N2][i];
Answer %= Mod;
}
if (i <= k2) {
Answer += End_2[N1][N2][i];
Answer %= Mod;
}
}
cout << Answer;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void mytimer(string task) {}
void ext(int c) {}
vector<pair<int, int> > *gr = new vector<pair<int, int> >[110000];
int comp[110000];
int cnt;
vector<int> *tree = new vector<int>[110000];
int tin[110000];
int tim;
int dep[110000];
int jmp[110000][20];
int n;
int dfs1(int v, int pr) {
if (tin[v]) return tin[v];
int r = tin[v] = ++tim;
for (int i = 0; i < (int)gr[v].size(); ++i) {
int p = gr[v][i].first;
if (p == pr) continue;
int t = dfs1(p, v);
if (t > tin[v]) gr[v][i].second = 1;
r = min(r, t);
}
return r;
}
void dfs2(int v, int c) {
if (comp[v] != -1) return;
comp[v] = c;
for (int i = 0; i < (int)gr[v].size(); ++i) {
int p = gr[v][i].first;
int t = gr[v][i].second ? cnt++ : c;
dfs2(p, t);
if (c != t) {
tree[c].push_back(t);
tree[t].push_back(c);
}
}
}
void dfs3(int v, int pr, int d) {
jmp[v][0] = pr;
dep[v] = d;
for (int i = 0; i < (int)tree[v].size(); ++i) {
int p = tree[v][i];
if (p == pr) continue;
dfs3(p, v, d + 1);
}
}
void genjmp() {
for (int i = 0; i < (19); ++i) {
for (int v = 0; v < (n); ++v) {
jmp[v][i + 1] = jmp[jmp[v][i]][i];
}
}
}
int todep(int a, int d) {
for (int i = 19; i >= 0; --i)
if (dep[jmp[a][i]] >= d) a = jmp[a][i];
return a;
}
int lca(int a, int b) {
int d = min(dep[a], dep[b]);
a = todep(a, d);
b = todep(b, d);
if (a == b) return a;
for (int i = 19; i >= 0; --i)
if (jmp[a][i] != jmp[b][i]) a = jmp[a][i], b = jmp[b][i];
return jmp[a][0];
}
int main() {
ios_base::sync_with_stdio(false);
int m;
cin >> n >> m;
for (int i = 0; i < (m); ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
gr[a].push_back(make_pair(b, 0));
gr[b].push_back(make_pair(a, 0));
}
for (int i = 0; i < (n); ++i) comp[i] = -1;
dfs1(0, -1);
dfs2(0, cnt++);
n = cnt;
dfs3(0, 0, 0);
genjmp();
int tc;
cin >> tc;
for (int qqq = 0; qqq < (tc); ++qqq) {
int a, b;
cin >> a >> b;
--a;
--b;
a = comp[a];
b = comp[b];
int c = lca(a, b);
cout << dep[a] + dep[b] - 2 * dep[c] << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n == 0) cout << "0 0" << endl;
if (n == 1) cout << "1 0" << endl;
if (n == 2) cout << "0 1" << endl;
if (n >= 3) {
if (n % 3 == 0) {
cout << n / 3 << " " << n / 3 << endl;
} else if (n % 3 == 1) {
cout << n / 3 + 1 << " " << n / 3 << endl;
} else if (n % 3 == 2) {
cout << n / 3 << " " << n / 3 + 1 << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
const int maxN = 2e3 + 5;
int n, k, p;
long long pos[maxN], key[maxN];
long long dp[maxN][maxN];
int res;
long long dist(long long pos, long long key) {
return abs(pos - key) + abs(key - p);
}
long long solve(int i, int j) {
if (i == n + 1) return 0;
if (j == k + 1) return inf;
if (dp[i][j] != inf) return dp[i][j];
res++;
dp[i][j] =
min(solve(i, j + 1), max(solve(i + 1, j + 1), dist(pos[i], key[j])));
return dp[i][j];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> p;
for (int i = (1); i <= ((n)); ++i) cin >> pos[i];
for (int i = (1); i <= ((k)); ++i) cin >> key[i];
sort(pos + 1, pos + n + 1);
sort(key + 1, key + k + 1);
for (int i = (0); i <= ((n + 2) - 1); ++i)
for (int j = (0); j <= ((k + 2) - 1); ++j) dp[i][j] = inf;
for (int i = (0); i <= ((k + 2) - 1); ++i) {
dp[n + 1][i] = 0;
}
for (int i = (n); i >= (1); --i) {
for (int j = (k); j >= (1); --j) {
dp[i][j] = min(dp[i][j + 1], max(dp[i + 1][j + 1], dist(pos[i], key[j])));
}
}
long long maxim = inf;
for (int i = (1); i <= ((n)); ++i) maxim = min(maxim, dp[1][i]);
cout << maxim;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#include <string>
using namespace std;
int main(){
int t,x,n;
cin >> t;
for(int i = 0; i < t;i++){
int cnt = 0;
cin >> n;
for(int j = 0; j < n;j++){
cin >> x;
if(x == 1 || x == 3)
cnt++;
}
cout << cnt << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e10, INF = 1e6, MAXN = 1e5 + 1;
vector<pair<long long, long long> > v[101], w;
long long n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n * n / 2; i++) {
w.push_back(make_pair(i, n * n - i + 1));
}
long long k = 1, j = (w.size() - 1);
while (true) {
if (v[n].size() == n / 2) {
break;
}
if (v[k].size() == n / 2) {
k++;
}
v[k].push_back(w[j]);
j--;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++) {
cout << v[i][j].first << " " << v[i][j].second << " ";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int bi[100003][32];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> v(n);
int cnt[32] = {};
for (int i = 0; i < n; ++i) {
cin >> v[i];
for (int j = 0; j < 32; ++j) {
if (v[i] & (1 << j)) {
bi[i][j] = 1;
++cnt[j];
}
}
}
int idx = 0;
for (int i = 0; i < 32; ++i)
if (cnt[i] == 1) idx = i;
for (int i = 0; i < n; ++i)
if (bi[i][idx] == 1) {
idx = i;
break;
}
for (int i = 0; i < n; ++i) {
cout << v[(idx + i) % n] << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
queue<int> qx, qy;
int d[2][110000];
char s[2][110000];
int n, k;
int main() {
gets(s[0]);
sscanf(s[0], "%d %d", &n, &k);
gets(s[0]);
gets(s[1]);
memset(d, 63, sizeof(d));
d[0][0] = 0;
qx.push(0);
qy.push(0);
for (; qx.size();) {
int x = qx.front();
int y = qy.front();
qx.pop();
qy.pop();
if (d[y][x] > x) continue;
if (x + k >= n) {
printf("YES\n");
return 0;
}
if (s[y][x + 1] == '-') {
if (d[y][x + 1] > d[y][x] + 1) {
d[y][x + 1] = d[y][x] + 1;
qx.push(x + 1);
qy.push(y);
}
}
if (x > 0 && s[y][x - 1] == '-') {
if (d[y][x - 1] > d[y][x] + 1) {
d[y][x - 1] = d[y][x] + 1;
qx.push(x - 1);
qy.push(y);
}
}
if (s[y ^ 1][x + k] == '-') {
if (d[y ^ 1][x + k] > d[y][x] + 1) {
d[y ^ 1][x + k] = d[y][x] + 1;
qx.push(x + k);
qy.push(y ^ 1);
}
}
}
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int expo(int x, int y) {
int res = 1;
x = x % M;
while (y > 0) {
if (y & 1) res = (1ll * res * x) % M;
y = y >> 1;
x = (1ll * x * x) % M;
}
return res;
}
int ncr(int n, int r) {
int res = 1;
if (r > n - r) r = n - r;
for (int i = 0; i < r; i++) {
res *= n - i;
res /= i + 1;
}
return res;
}
bool prime(long long n) {
long long i;
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) {
int n, i, z;
char ch;
cin >> n;
vector<pair<char, int>> v;
for (i = 0; i < n; i++) {
cin >> ch >> z;
v.push_back({ch, z});
}
int a1[10] = {}, b1[10] = {}, a2 = 0, b2 = 1023;
for (i = 0; i < n; i++) {
if (v[i].first == '|') {
a2 |= v[i].second;
b2 |= v[i].second;
} else if (v[i].first == '&') {
a2 &= v[i].second;
b2 &= v[i].second;
} else {
a2 ^= v[i].second;
b2 ^= v[i].second;
}
}
int k = 0;
while (a2 != 0) {
a1[k++] = (a2 % 2);
a2 /= 2;
}
k = 0;
while (b2 != 0) {
b1[k++] = (b2 % 2);
b2 /= 2;
}
int z1 = 0, z2 = 0, z3 = 0;
for (i = 0; i < 10; i++) {
if (a1[i] == 1 && b1[i] == 0) z1 += pow(2, i);
if (a1[i] == 1 && b1[i] == 1) z2 += pow(2, i);
if (!(a1[i] == 0 && b1[i] == 0)) z3 += pow(2, i);
}
cout << 3 << "\n";
cout << "^ " << z1 << "\n";
cout << "| " << z2 << "\n";
cout << "& " << z3 << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int used[1000000];
vector<int> vec[1000000];
vector<int> on[1000000];
vector<pair<int, int>> bad[2][2];
void update(int v) {
used[v] = 1;
while (!on[v].empty()) {
int to = on[v].back();
on[v].pop_back();
update(to);
}
}
bool check() {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < min(vec[i].size(), vec[i + 1].size()); j++) {
if (j == min(vec[i].size(), vec[i + 1].size()) - 1 &&
vec[i][j] == vec[i + 1][j])
if (vec[i].size() > vec[i + 1].size()) return 0;
if (vec[i][j] == vec[i + 1][j]) continue;
if (vec[i][j] < vec[i + 1][j]) {
if (used[vec[i + 1][j]] && !used[vec[i][j]]) return 0;
break;
}
if (vec[i][j] > vec[i + 1][j]) {
if (!(used[vec[i][j]] && !used[vec[i + 1][j]])) return 0;
break;
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int l;
cin >> l;
for (int j = 0; j < l; j++) {
int x;
cin >> x;
vec[i].push_back(x);
}
}
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < min(vec[i].size(), vec[i + 1].size()); j++) {
if (vec[i][j] == vec[i + 1][j]) continue;
if (vec[i][j] < vec[i + 1][j]) {
bad[0][1].push_back(make_pair(vec[i][j], vec[i + 1][j]));
on[vec[i + 1][j]].push_back(vec[i][j]);
if (used[vec[i + 1][j]]) update(vec[i][j]);
break;
}
if (vec[i][j] > vec[i + 1][j]) {
bad[0][1].push_back(make_pair(vec[i][j], vec[i + 1][j]));
bad[0][0].push_back(make_pair(vec[i][j], vec[i + 1][j]));
bad[1][1].push_back(make_pair(vec[i][j], vec[i + 1][j]));
if (used[vec[i + 1][j]]) {
cout << "No" << endl;
return 0;
}
update(vec[i][j]);
break;
}
}
}
for (int i = 0; i <= m; i++)
if (used[i]) update(i);
for (int i = 0; i < bad[0][0].size(); i++) {
int f = bad[0][0][i].first;
int s = bad[0][0][i].second;
if (!used[f] && !used[s]) {
cout << "No" << endl;
return 0;
}
}
for (int i = 0; i < bad[0][1].size(); i++) {
int f = bad[0][1][i].first;
int s = bad[0][1][i].second;
if (!used[f] && used[s]) {
cout << "No" << endl;
return 0;
}
}
for (int i = 0; i < bad[1][0].size(); i++) {
int f = bad[1][0][i].first;
int s = bad[1][0][i].second;
if (used[f] && !used[s]) {
cout << "No" << endl;
return 0;
}
}
for (int i = 0; i < bad[1][1].size(); i++) {
int f = bad[1][1][i].first;
int s = bad[1][1][i].second;
if (used[f] && used[s]) {
cout << "No" << endl;
return 0;
}
}
if (!check()) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
int cnt = 0;
for (int i = 0; i <= m; i++) cnt += used[i];
cout << cnt << endl;
for (int i = 0; i <= m; i++)
if (used[i]) cout << i << ' ';
}
| 6 |
#include <bits/stdc++.h>
int main() {
char a[10000];
gets(a);
if (a[0] >= 'a' && a[0] <= 'z') {
a[0] -= 32;
}
puts(a);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char gchar() {
static char tbuf1[1000], *tmp_st = tbuf1, *tmp_ed = tbuf1;
if (tmp_st == tmp_ed) {
int len = fread(tbuf1, 1, 1000, stdin);
if (len == 0) return -1;
tmp_ed = tbuf1 + len;
tmp_st = tbuf1;
}
return *(tmp_st++);
}
inline bool gn(int &x) {
char c, sg = 0;
while (c = gchar(), (c > '9' || c < '0') && c != '-' && ~c)
;
if (c == -1) return 0;
for ((c == '-' ? sg = 1, c = gchar() : 0), x = 0; c >= '0' && c <= '9';
c = gchar())
x = (x << 1) + (x << 3) + c - '0';
if (sg) x = -x;
return 1;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
return print(-x);
}
if (x < 10) {
putchar('0' + x);
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
template <class T, class T1>
inline bool gn(T &x, T1 &x1) {
bool ok = gn(x);
gn(x1);
return ok;
}
template <class T>
inline void println(T x) {
print(x);
putchar('\n');
}
int head[200001], nxt[200001], to[200001], E;
inline void add(int u, int v) {
nxt[E] = head[u];
to[E] = v;
head[u] = E++;
}
int deep[200001];
struct LCA {
int vst[200001], seq[200001 << 1], rec[200001 << 1], nn;
inline void dfs(int u, int fa = -1) {
vst[u] = nn;
rec[nn] = u;
seq[nn++] = vst[u];
for (int e = head[u]; e != -1; e = nxt[e]) {
int v = to[e];
if (v == fa) continue;
deep[v] = deep[u] + 1;
dfs(v, u);
rec[nn] = u;
seq[nn++] = vst[u];
}
}
int mn[200001 << 1][19];
void pre() {
dfs(1);
for (int i = 0; i < nn; i++) mn[i][0] = seq[i];
for (int j = 1; j < 19; j++)
for (int i = 0; i < nn; i++) {
mn[i][j] = min(mn[i][j - 1], mn[min(nn, i + (1 << j - 1))][j - 1]);
}
}
int lca(int u, int v) {
if (vst[u] > vst[v]) swap(u, v);
int l = 31 - __builtin_clz(vst[v] - vst[u] + 1);
int id = min(mn[vst[u]][l], mn[vst[v] - (1 << l) + 1][l]);
return rec[id];
}
} lca;
inline int dist(int u, int v) {
int w = lca.lca(u, v);
return deep[u] + deep[v] - (deep[w] << 1);
}
inline void update(int &x, int &y, int a, int b, int c, int d) {
x = a, y = b;
if (deep[c] > deep[x]) x = c;
if (deep[c] < deep[y]) y = c;
if (deep[d] > deep[x]) x = d;
if (deep[d] < deep[y]) y = d;
bool A = deep[a] + dist(a, x) != deep[x];
bool B = deep[b] + dist(b, x) != deep[x];
bool C = deep[c] + dist(c, x) != deep[x];
bool D = deep[d] + dist(d, x) != deep[x];
if (A) y = a;
if (B) y = b;
if (C) y = c;
if (D) y = d;
if (A && deep[a] > deep[y]) y = a;
if (B && deep[b] > deep[y]) y = b;
if (C && deep[c] > deep[y]) y = c;
if (D && deep[d] > deep[y]) y = d;
int w = lca.lca(x, y);
if (deep[a] < deep[w] || deep[b] < deep[w] || deep[c] < deep[w] ||
deep[d] < deep[w])
x = 0;
else if (A && deep[a] + dist(a, y) != deep[y])
x = 0;
else if (B && deep[b] + dist(b, y) != deep[y])
x = 0;
else if (C && deep[c] + dist(c, y) != deep[y])
x = 0;
else if (D && deep[d] + dist(d, y) != deep[y])
x = 0;
}
int p[200001], pos[200001];
int LL[800000], RR[800000], x[800000], y[800000];
inline void push_up(int u, int ls, int rs) {
x[u] = 0;
if (x[ls] && x[rs]) {
update(x[u], y[u], x[ls], y[ls], x[rs], y[rs]);
}
}
inline void build(int u, int L, int R) {
LL[u] = L;
RR[u] = R;
if (L + 1 == R) {
x[u] = y[u] = pos[L];
return;
}
int ls = u << 1, rs = ls | 1, mid = L + R >> 1;
build(ls, L, mid);
build(rs, mid, R);
push_up(u, ls, rs);
}
int l, r, flag, X, Y, xx, yy;
inline void update(int u) {
int L = LL[u], R = RR[u];
if (r <= L || R <= l) return;
if (l <= L && R <= r) {
x[u] = y[u] = pos[L];
return;
}
int ls = u << 1, rs = ls | 1;
update(ls), update(rs);
push_up(u, ls, rs);
}
inline int calc(int u) {
if (flag) return 0;
int L = LL[u], R = RR[u];
if (x[u]) {
update(xx, yy, X, Y, x[u], y[u]);
if (xx) {
X = xx, Y = yy;
return R - L;
}
}
if (L + 1 == R) {
flag = 1;
return 0;
}
int ls = u << 1;
L = calc(ls);
if (L) return L + calc(ls | 1);
return 0;
}
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) {
gn(p[i]);
pos[p[i]] = i;
head[i] = -1;
}
for (int i = 2, pa; i <= n; i++) {
gn(pa);
add(pa, i);
}
lca.pre();
build(1, 0, n);
int q;
gn(q);
while (q--) {
int t;
gn(t);
if (t == 1) {
int x, y;
gn(x, y);
swap(p[x], p[y]);
swap(pos[p[x]], pos[p[y]]);
l = p[x], r = l + 1;
update(1);
l = p[y], r = l + 1;
update(1);
} else {
X = Y = pos[0];
flag = 0;
println(calc(1));
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <const unsigned &MOD>
struct _m_uint {
unsigned val;
_m_uint(int64_t v = 0) {
if (v < 0) v = v % MOD + MOD;
if (v >= MOD) v %= MOD;
val = v;
}
static unsigned inv_mod(unsigned a, unsigned m = MOD) {
unsigned g = m, r = a, x = 0, y = 1;
int sign = -1;
while (r != 0) {
unsigned q = g / r;
g %= r;
swap(g, r);
x += q * y;
swap(x, y);
sign = -sign;
}
return sign > 0 ? x : m - x;
}
explicit operator unsigned() const { return val; }
explicit operator uint64_t() const { return val; }
_m_uint &operator+=(const _m_uint &other) {
val = val < MOD - other.val ? val + other.val : val - (MOD - other.val);
return *this;
}
_m_uint &operator-=(const _m_uint &other) {
val = val < other.val ? val + (MOD - other.val) : val - other.val;
return *this;
}
static unsigned fast_mod(uint64_t x, unsigned m = MOD) {
return x % m;
unsigned x_high = x >> 32, x_low = (unsigned)x;
unsigned quot, rem;
asm("divl %4\n" : "=a"(quot), "=d"(rem) : "d"(x_high), "a"(x_low), "r"(m));
return rem;
}
_m_uint &operator*=(const _m_uint &other) {
val = fast_mod((uint64_t)val * other.val);
return *this;
}
_m_uint &operator/=(const _m_uint &other) { return *this *= other.inv(); }
friend _m_uint operator+(const _m_uint &a, const _m_uint &b) {
return _m_uint(a) += b;
}
friend _m_uint operator-(const _m_uint &a, const _m_uint &b) {
return _m_uint(a) -= b;
}
friend _m_uint operator*(const _m_uint &a, const _m_uint &b) {
return _m_uint(a) *= b;
}
friend _m_uint operator/(const _m_uint &a, const _m_uint &b) {
return _m_uint(a) /= b;
}
_m_uint &operator++() {
val = val == MOD - 1 ? 0 : val + 1;
return *this;
}
_m_uint &operator--() {
val = val == 0 ? MOD - 1 : val - 1;
return *this;
}
_m_uint operator++(int) {
_m_uint before = *this;
++*this;
return before;
}
_m_uint operator--(int) {
_m_uint before = *this;
--*this;
return before;
}
_m_uint operator-() const { return val == 0 ? 0 : MOD - val; }
bool operator==(const _m_uint &other) const { return val == other.val; }
bool operator!=(const _m_uint &other) const { return val != other.val; }
_m_uint inv() const { return inv_mod(val); }
_m_uint pow(int64_t p) const {
if (p < 0) return inv().pow(-p);
_m_uint a = *this, result = 1;
while (p > 0) {
if (p & 1) result *= a;
a *= a;
p >>= 1;
}
return result;
}
friend ostream &operator<<(ostream &os, const _m_uint &m) {
return os << m.val;
}
};
auto random_address = [] {
char *p = new char;
delete p;
return (uint64_t)p;
};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
extern const unsigned HASH_P = (unsigned)-13337;
using hash_int = _m_uint<HASH_P>;
const uint64_t HASH_P2 = (uint64_t)HASH_P * HASH_P;
const int HASH_COUNT = 2;
uniform_int_distribution<unsigned> MULT_DIST(0.1 * HASH_P, 0.9 * HASH_P);
const hash_int HASH_MULT[HASH_COUNT] = {MULT_DIST(rng), MULT_DIST(rng)};
const hash_int HASH_INV[HASH_COUNT] = {1 / HASH_MULT[0], 1 / HASH_MULT[1]};
vector<hash_int> hash_pow[HASH_COUNT] = {{1}, {1}};
const int INF = 1e9 + 5;
template <typename T_string = string>
struct string_hash {
static const bool BUILD_REVERSE = false;
T_string str;
vector<hash_int> _prefix_hash[HASH_COUNT];
vector<hash_int> _prefix_inv_hash[HASH_COUNT];
string_hash() { build({}); }
string_hash(const T_string &_str) { build(_str); }
int length() const { return (int)_prefix_hash[0].size() - 1; }
template <typename T_char>
void add_char(const T_char &c) {
str.push_back(c);
for (int h = 0; h < HASH_COUNT; h++) {
_prefix_hash[h].push_back(HASH_MULT[h] * _prefix_hash[h].back() + c);
if (hash_pow[h].size() < _prefix_hash[h].size())
hash_pow[h].push_back(HASH_MULT[h] * hash_pow[h].back());
if (BUILD_REVERSE)
_prefix_inv_hash[h].push_back((_prefix_inv_hash[h].back() + c) *
HASH_INV[h]);
}
}
void pop_char() {
str.pop_back();
for (int h = 0; h < HASH_COUNT; h++) {
_prefix_hash[h].pop_back();
if (BUILD_REVERSE) _prefix_inv_hash[h].pop_back();
}
}
void build(const T_string &_str) {
str = {};
for (int h = 0; h < HASH_COUNT; h++) {
_prefix_hash[h] = {0};
if (BUILD_REVERSE) _prefix_inv_hash[h] = {0};
}
for (auto &c : _str) add_char(c);
}
uint64_t _single_hash(int h, int start, int end) const {
uint64_t power = (uint64_t)hash_pow[h][end - start];
return (power + (uint64_t)_prefix_hash[h][end] + HASH_P2 -
(uint64_t)_prefix_hash[h][start] * power) %
HASH_P;
}
uint64_t substring_hash(int start, int end) const {
assert(0 <= start && start <= end && end <= length());
return _single_hash(0, start, end) +
(HASH_COUNT > 1 ? _single_hash(1, start, end) << 32 : 0);
}
uint64_t _reverse_single_hash(int h, int start, int end) const {
uint64_t power = (uint64_t)hash_pow[h][end - start];
return (power + (uint64_t)_prefix_inv_hash[h][end] * power + HASH_P -
(uint64_t)_prefix_inv_hash[h][start]) %
HASH_P;
}
uint64_t reverse_substring_hash(int start, int end) const {
assert(0 <= start && start <= end && end <= length());
return _reverse_single_hash(0, start, end) +
(HASH_COUNT > 1 ? _reverse_single_hash(1, start, end) << 32 : 0);
}
bool equal(int start1, int start2, int length) const {
return substring_hash(start1, start1 + length) ==
substring_hash(start2, start2 + length);
}
bool is_palindrome(int start, int end) const {
return substring_hash(start, end) == reverse_substring_hash(start, end);
}
int compare(int start1, int start2, int max_length = INF) const;
};
template <typename T_string>
int first_mismatch(const string_hash<T_string> &hash1, int start1,
const string_hash<T_string> &hash2, int start2,
int max_length = INF) {
max_length =
min({max_length, hash1.length() - start1, hash2.length() - start2});
static const int FIRST = 5;
int first = min(max_length, FIRST);
for (int i = 0; i < first; i++)
if (hash1.str[start1 + i] != hash2.str[start2 + i]) return i;
if (hash1.substring_hash(start1, start1 + max_length) ==
hash2.substring_hash(start2, start2 + max_length))
return max_length;
static const int MANUAL = 15;
int low = first, high = max_length - 1;
while (high - low > MANUAL) {
int mid = (low + high + 1) / 2;
if (hash1.substring_hash(start1, start1 + mid) ==
hash2.substring_hash(start2, start2 + mid))
low = mid;
else
high = mid - 1;
}
for (int i = low; i < high; i++)
if (hash1.str[start1 + i] != hash2.str[start2 + i]) return i;
return high;
}
template <typename T_string>
int hash_compare(const string_hash<T_string> &hash1, int start1,
const string_hash<T_string> &hash2, int start2,
int max_length = INF) {
int mismatch = first_mismatch(hash1, start1, hash2, start2, max_length);
int length1 = min(hash1.length() - start1, max_length);
int length2 = min(hash2.length() - start2, max_length);
if (mismatch == min(length1, length2))
return length1 == length2 ? 0 : (length1 < length2 ? -1 : +1);
if (hash1.str[start1 + mismatch] == hash2.str[start2 + mismatch]) return 0;
return hash1.str[start1 + mismatch] < hash2.str[start2 + mismatch] ? -1 : +1;
}
template <typename T_string>
int string_hash<T_string>::compare(int start1, int start2,
int max_length) const {
return hash_compare(*this, start1, *this, start2, max_length);
}
using seq_hash = string_hash<vector<int>>;
int N, bucket_size, n_buckets;
vector<int> S;
vector<bool> invalid_bucket;
vector<seq_hash> bucket_prefix, bucket_suffix;
int which_bucket(int index) {
return index < N ? index / bucket_size : n_buckets;
}
int get_bucket_start(int b) { return bucket_size * b; }
int get_bucket_end(int b) { return min(bucket_size * (b + 1), N); }
vector<int> process_stack(int start, int end) {
vector<int> stack;
for (int i = start; i < end; i++)
if (!stack.empty() && stack.back() > 0 && S[i] == -stack.back())
stack.pop_back();
else
stack.push_back(S[i]);
return stack;
}
void build_bucket(int b) {
assert(0 <= b && b < n_buckets);
int bucket_start = get_bucket_start(b);
int bucket_end = get_bucket_end(b);
vector<int> stack = process_stack(bucket_start, bucket_end);
int size = stack.size();
int prefix = 0, suffix = size;
while (prefix < size && stack[prefix] < 0) prefix++;
while (suffix > 0 && stack[suffix - 1] > 0) suffix--;
if (prefix != suffix) {
invalid_bucket[b] = true;
return;
}
invalid_bucket[b] = false;
bucket_prefix[b] = {};
for (int i = prefix - 1; i >= 0; i--)
bucket_prefix[b].add_char(abs(stack[i]));
bucket_suffix[b] = {};
for (int i = suffix; i < size; i++) bucket_suffix[b].add_char(stack[i]);
}
void init_buckets() {
bucket_size = 1.5 * sqrt(N) + 1;
n_buckets = (N + bucket_size - 1) / bucket_size;
invalid_bucket.assign(n_buckets, false);
bucket_prefix.assign(n_buckets, {});
bucket_suffix.assign(n_buckets, {});
for (int b = 0; b < n_buckets; b++) build_bucket(b);
}
void update(int index, int change) {
assert(0 <= index && index < N);
S[index] = change;
build_bucket(which_bucket(index));
}
struct range {
const seq_hash *hasher = nullptr;
int start = 0, end = 0;
range() {}
range(const seq_hash &_hasher, int _start, int _end)
: hasher(&_hasher), start(_start), end(_end) {}
int length() const { return end - start; }
};
bool query(int start, int end) {
assert(0 <= start && start <= end && end <= N);
int start_b = which_bucket(start), end_b = which_bucket(end);
if (start_b == end_b) return process_stack(start, end).empty();
vector<range> ranges;
vector<int> stack = process_stack(start, get_bucket_end(start_b));
;
for (int x : stack)
if (x < 0) return false;
seq_hash start_hasher(stack);
ranges.emplace_back(start_hasher, 0, start_hasher.length());
for (int b = start_b + 1; b < end_b; b++) {
if (invalid_bucket[b]) return false;
;
int prefix_end = bucket_prefix[b].length();
while (prefix_end > 0) {
if (ranges.empty()) return false;
range &back = ranges.back();
int take = min(prefix_end, back.length());
uint64_t prefix_hash =
bucket_prefix[b].substring_hash(prefix_end - take, prefix_end);
uint64_t range_hash =
back.hasher->substring_hash(back.end - take, back.end);
if (prefix_hash != range_hash) return false;
prefix_end -= take;
back.end -= take;
if (back.length() == 0) ranges.pop_back();
}
assert(prefix_end == 0);
ranges.emplace_back(bucket_suffix[b], 0, bucket_suffix[b].length());
}
stack = process_stack(get_bucket_start(end_b), end);
;
for (int x : stack)
if (x > 0) return false;
for (int x : stack) {
while (!ranges.empty() && ranges.back().length() == 0) ranges.pop_back();
if (ranges.empty()) return false;
range &back = ranges.back();
if (back.hasher->str[back.end - 1] != abs(x)) return false;
back.end--;
}
while (!ranges.empty() && ranges.back().length() == 0) ranges.pop_back();
return ranges.empty();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int _;
cin >> N >> _;
S.resize(N);
for (auto &s : S) cin >> s;
init_buckets();
int Q;
cin >> Q;
for (int q = 0; q < Q; q++) {
int type;
cin >> type;
if (type == 1) {
int index, t;
cin >> index >> t;
index--;
update(index, t);
} else if (type == 2) {
int L, R;
cin >> L >> R;
L--;
cout << (query(L, R) ? "Yes" : "No") << '\n';
} else {
assert(false);
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
int a[51], b[51], c[51], l[51], r[51];
int st[51], ed[51];
struct Dinic {
int V, E, src, tar;
int head[10100], work[10100], dis[10100];
int to[30300], cap[30300], nxt[30300];
int q[10100], qf, qb;
inline void calc(int n, int m) {
for (int i = 1; i <= n; i++) {
add(src, st[i], 0x3f3f3f3f);
for (int j = st[i]; j < ed[i]; j++) {
int x = j - st[i] + l[i];
add(j, j + 1, 1999728 - a[i] * x * x - b[i] * x - c[i]);
}
add(ed[i], tar, 0x3f3f3f3f);
}
while (m--) {
int u, v, d;
scanf("%d %d %d", &u, &v, &d);
for (int i = l[u], j = i - d; i <= r[u] + 1; i++, j++)
if (l[v] <= j && j <= r[v] + 1) {
add(i - l[u] + st[u], j - l[v] + st[v], 0x3f3f3f3f);
}
}
int ans = n * 1999728 - dinic();
printf("%d", ans);
}
inline void init(int n, int s, int t) {
V = n + 1;
E = 0;
src = s;
tar = t;
for (int i = 0; i <= V; i++) head[i] = -1;
}
inline void add(int u, int v, int c) {
to[E] = v;
cap[E] = c;
nxt[E] = head[u];
head[u] = E++;
to[E] = u;
cap[E] = 0;
nxt[E] = head[v];
head[v] = E++;
}
inline bool bfs() {
for (int i = 0; i <= V; i++) dis[i] = -1;
qf = qb = 0;
q[qb++] = src;
dis[src] = 0;
while (qf < qb && dis[tar] == -1) {
int u = q[qf++];
for (int i = head[u]; i >= 0; i = nxt[i]) {
int v = to[i];
if (dis[v] == -1 && cap[i] > 0) {
dis[v] = dis[u] + 1;
q[qb++] = v;
}
}
}
return dis[tar] >= 0;
}
inline int dfs(int u, int &bot) {
int v, bot1, delta;
if (u == tar) return bot;
for (int &i = work[u]; i >= 0; i = nxt[i]) {
int v = to[i];
if (dis[v] != dis[u] + 1 || cap[i] == 0) continue;
bot1 = min(bot, cap[i]);
if (delta = dfs(v, bot1)) {
cap[i] -= delta;
cap[i ^ 1] += delta;
bot = bot1;
return delta;
}
}
return 0;
}
inline int dinic() {
int ans = 0, delta, bot;
while (bfs()) {
memcpy(work, head, sizeof(int) * V);
delta = 0x3f3f3f3f;
while (delta = dfs(src, bot = 0x3f3f3f3f)) ans += delta;
}
return ans;
}
} dinic;
int main() {
int n, m, cur = 0;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d %d %d", a + i, b + i, c + i);
for (int i = 1; i <= n; i++) {
scanf("%d %d", l + i, r + i);
st[i] = cur;
cur += r[i] - l[i] + 1;
ed[i] = cur++;
}
int src = cur++, tar = cur++;
dinic.init(cur, src, tar);
dinic.calc(n, m);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool prime(long long int a) {
if (a == 1) {
return false;
} else {
for (long long int i = 2; i * i <= a; i++) {
if (a % i == 0) {
return false;
}
}
return true;
}
}
long long int gcd(long long int a, long long int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int d = n / 2;
long long int c = 0;
for (long long int i = n - 1; i >= 1; i--) {
cout << arr[i] << " " << arr[0] << endl;
c++;
if (c == d) {
break;
}
}
}
return 0;
}
| 1 |
#define fastIO() ios::sync_with_stdio(false); \
cin.tie(nullptr), cout.tie(nullptr);
#define rep(i, a, b) for (int i = a; i <= b; ++i)
#define rep2(i, a, b) for (int i = a; i < b; ++i)
#define per(i, a, b) for (int i = a; i >= b; --i)
#include <bits/stdc++.h>
using namespace std;
char s[55];
signed main(int argc, char *argv[]) { //fastIO();
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k >> s + 1;
int l, r;
for (int i = 1; i <= n; ++i)
if (s[i] == '*') {
s[i] = 'X';
l = i;
break;
}
for (int i = n; i >= 1; --i)
if (s[i] == '*' || s[i] == 'X') {
s[i] = 'X';
r = i;
break;
}
for (int i = l; i < r; ) {
int pos;
for (int j = i + 1; j <= i + k; ++j)
if (s[j] == '*' || s[j] == 'X') pos = j;
s[pos] = 'X';
i = pos;
}
int ans = 0;
for (int i = 1; i <= n; ++i) ans += s[i] == 'X';
cout << ans << '\n';
}
//system("pause");
return 0;
} | 1 |
#include <bits/stdc++.h>
#define nl '\n'
#define pb push_back
#define ll long long
#define VMAX 100001
#define NMAX 50005
#define INF 1000005000
using namespace std;
ifstream f("provocare.in");
ofstream g("provocare.out");
long long n,k,dp[5005][5005],sz[5005],dist[5005];
vector<int> G[5005];
const int MOD=998244353;
void dfs(int node,int dad)
{
dp[node][0]=1;
for(auto x:G[node])
{
if(x==dad)
{
continue;
}
dfs(x,node);
sz[node]+=sz[x];
vector<ll> aux(n+5,0);
for(int i=0;i<=dist[node];i++)
{
for(int j=0;j<=dist[x];j++)
{
if(i+j+1<=k)
{
aux[max(i,j+1)]=(aux[max(i,j+1)]+(1LL*dp[node][i]*dp[x][j])%MOD)%MOD;
}
aux[i]=(aux[i]+(1LL*dp[node][i]*dp[x][j])%MOD)%MOD;
}
}
dist[node]=max(dist[node],dist[x]+1);
for(int j=0;j<=dist[node];j++)
{
dp[node][j]=aux[j];
}
}
}
int main()
{
cin.tie ( 0 )->sync_with_stdio ( 0 );
cin.tie(0);
cout.tie(0);
cin>>n>>k;
for(int i=1;i<n;i++)
{
int x,y;
cin>>x>>y;
G[x].pb(y);
G[y].pb(x);
}
dfs(1,0);
long long ans=0;
for(int i=0;i<n;i++)
{
ans=ans+dp[1][i];
ans%=MOD;
}
cout<<ans<<'\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long power(long x, long n) {
if (n == 0) return 1;
if (n == 1) return x;
long n2 = n / 2;
long long po = power(x, n2);
if (n % 2) return po * po * x;
return po * po;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
class CSoldierAndCards {
queue<int> v1, v2;
int n, win;
map<string, set<string>> M;
public:
int dfs() {
if (v1.size() == 0) {
win = 2;
return 0;
}
if (v2.size() == 0) {
win = 1;
return 0;
}
string s1 = "", s2 = "";
queue<int> q;
q = v1;
while (!q.empty()) {
s1 += ('0' + q.front());
q.pop();
}
q = v2;
while (!q.empty()) {
s2 += +('0' + q.front());
q.pop();
}
if (M[s1].find(s2) != M[s1].end()) {
win = -1;
return 0;
}
M[s1].insert(s2);
int x = v1.front(), y = v2.front();
v1.pop();
v2.pop();
if (x > y) {
v1.push(y);
v1.push(x);
} else {
v2.push(x);
v2.push(y);
}
return 1 + dfs();
}
void solve(std::istream &cin, std::ostream &cout) {
cin >> n;
int k, i, x;
cin >> k;
for (i = 0; i < k; i++) cin >> x, v1.push(x);
cin >> k;
for (i = 0; i < k; i++) cin >> x, v2.push(x);
int moves = dfs();
if (win > 0)
cout << moves << " " << win << '\n';
else
cout << win << '\n';
}
};
int main() {
CSoldierAndCards solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353, R = 3;
const int BRUTE_N2_LIMIT = 50;
int mpow(int x, int k, int p = P) {
int ret = 1;
while (k) {
if (k & 1) ret = ret * (long long)x % p;
x = x * (long long)x % p;
k >>= 1;
}
return ret;
}
int norm(int x) { return x >= P ? x - P : x; }
void add(int &x, int y) {
if ((x += y) >= P) x -= P;
}
void sub(int &x, int y) {
if ((x -= y) < 0) x += P;
}
struct NumberTheory {
mt19937 rng;
NumberTheory()
: rng(chrono::steady_clock::now().time_since_epoch().count()) {}
void _exGcd(int a, int b, int &x, int &y) {
if (!b) {
x = 1;
y = 0;
return;
}
_exGcd(b, a % b, y, x);
y -= a / b * x;
}
int inv(int a, int p = P) {
int x, y;
_exGcd(a, p, x, y);
if (x < 0) x += p;
return x;
}
template <class Integer>
bool quadRes(Integer a, Integer b) {
if (a <= 1) return true;
while (a % 4 == 0) a /= 4;
if (a % 2 == 0) return (b % 8 == 1 || b % 8 == 7) == quadRes(a / 2, b);
return ((a - 1) % 4 == 0 || (b - 1) % 4 == 0) == quadRes(b % a, a);
}
int sqrt(int x, int p = P) {
if (p == 2 || x <= 1) return x;
int w, v, k = (p + 1) / 2;
do {
w = rng() % p;
} while (quadRes(v = int((w * (long long)w - x + p) % p), p));
pair<int, int> res(1, 0), a(w, 1);
while (k) {
if (k & 1)
res = pair<int, int>((res.first * (long long)a.first +
res.second * (long long)a.second % p * v) %
p,
(res.first * (long long)a.second +
res.second * (long long)a.first) %
p);
if (k >>= 1)
a = pair<int, int>((a.first * (long long)a.first +
a.second * (long long)a.second % p * v) %
p,
(a.first * (long long)a.second << 1) % p);
}
return min(res.first, p - res.first);
}
} nt;
template <class T, class Comp>
struct AdditionChain {
int k;
vector<T> prepare;
T t, unit;
Comp comp;
AdditionChain(const T &t, const Comp &comp, int k, const T &unit = 1)
: comp(comp), t(t), unit(unit), k(k), prepare(1U << k) {
prepare[0] = unit;
for (int i = 1; i < 1 << k; ++i) prepare[i] = comp(prepare[i - 1], t);
}
static AdditionChain fourRussians(const T &t, const Comp &comp, int lgn,
const T &unit = 1) {
lgn = max(lgn, 1);
int k = 1, lglgn = 1;
while (2 << lglgn <= lgn) ++lglgn;
int w = lglgn / lgn;
while (1 << k < w) ++k;
return AdditionChain(t, comp, k, unit);
}
T pow(int n) const {
if (n < 1 << k) return prepare[n];
int r = n & ((1 << k) - 1);
T step = pow(n >> k);
for (int rep = 0; rep < k; ++rep) step = comp(step, step);
return comp(step, prepare[r]);
}
};
struct Simple {
int n;
vector<int> fac, ifac, inv;
void build(int n) {
this->n = n;
fac.resize(n + 1);
ifac.resize(n + 1);
inv.resize(n + 1);
fac[0] = 1;
for (int x = 1; x <= n; ++x) fac[x] = fac[x - 1] * (long long)x % P;
inv[1] = 1;
for (int x = 2; x <= n; ++x)
inv[x] = -(P / x) * (long long)inv[P % x] % P + P;
ifac[0] = 1;
for (int x = 1; x <= n; ++x) ifac[x] = ifac[x - 1] * (long long)inv[x] % P;
}
Simple() { build(1); }
void check(int k) {
int nn = n;
if (k > nn) {
while (k > nn) nn <<= 1;
build(nn);
}
}
int gfac(int k) {
check(k);
return fac[k];
}
int gifac(int k) {
check(k);
return ifac[k];
}
int ginv(int k) {
check(k);
return inv[k];
}
int binom(int n, int m) {
if (m < 0 || m > n) return 0;
return gfac(n) * (long long)gifac(m) % P * gifac(n - m) % P;
}
} simp;
const int L2 = 11;
struct NTT {
int L;
int brev[1 << L2];
vector<int> root;
NTT() : L(-1) {
for (int i = 1; i < (1 << L2); ++i)
brev[i] = brev[i >> 1] >> 1 | ((i & 1) << (L2 - 1));
}
void prepRoot(int l) {
L = l;
root.resize(2 << L);
for (int i = 0; i <= L; ++i) {
int *w = root.data() + (1 << i);
w[0] = 1;
int omega = mpow(R, (P - 1) >> i);
for (int j = 1; j < 1 << i; ++j) w[j] = w[j - 1] * (long long)omega % P;
}
}
void fft(int *a, int lgn, int d = 1) {
if (L < lgn) prepRoot(lgn);
int n = 1 << lgn;
for (int i = 0; i < n; ++i) {
int rev = (brev[i >> L2] | (brev[i & ((1 << L2) - 1)] << L2)) >>
((L2 << 1) - lgn);
if (i < rev) swap(a[i], a[rev]);
}
for (int i = 1; i < n; i <<= 1) {
int *w = root.data() + (i << 1);
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; ++k) {
int aa = w[k] * (long long)a[i + j + k] % P;
a[i + j + k] = norm(a[j + k] + P - aa);
add(a[j + k], aa);
}
}
}
if (d == -1) {
reverse(a + 1, a + n);
int nv = mpow(n, P - 2);
for (int i = 0; i < n; ++i) a[i] = a[i] * (long long)nv % P;
}
}
} ntt;
struct Poly {
vector<int> a;
Poly(int v = 0) : a(1) {
if ((v %= P) < 0) v += P;
a[0] = v;
}
Poly(const vector<int> &a) : a(a) {}
Poly(initializer_list<int> init) : a(init) {}
int operator[](int k) const { return k < a.size() ? a[k] : 0; }
int &operator[](int k) {
if (k >= a.size()) a.resize(k + 1);
return a[k];
}
int deg() const { return a.size() - 1; }
void redeg(int d) { a.resize(d + 1); }
Poly monic() const;
Poly sunic() const;
Poly slice(int d) const {
if (d < a.size()) return vector<int>(a.begin(), a.begin() + d + 1);
vector<int> res(a);
res.resize(d + 1);
return res;
}
int *base() { return a.data(); }
const int *base() const { return a.data(); }
Poly println(FILE *fp) const {
fprintf(fp, "%d", a[0]);
for (int i = 1; i < a.size(); ++i) fprintf(fp, " %d", a[i]);
fputc('\n', fp);
return *this;
}
Poly operator+(const Poly &rhs) const {
vector<int> res(max(a.size(), rhs.a.size()));
for (int i = 0; i < res.size(); ++i)
if ((res[i] = operator[](i) + rhs[i]) >= P) res[i] -= P;
return res;
}
Poly operator-() const {
Poly ret(a);
for (int i = 0; i < a.size(); ++i)
if (ret[i]) ret[i] = P - ret[i];
return ret;
}
Poly operator-(const Poly &rhs) const { return operator+(-rhs); }
Poly operator*(const Poly &rhs) const;
Poly operator/(const Poly &rhs) const;
Poly operator%(const Poly &rhs) const;
Poly der() const;
Poly integ() const;
Poly inv() const;
Poly sqrt() const;
Poly ln() const;
Poly exp() const;
pair<Poly, Poly> sqrti() const;
pair<Poly, Poly> expi() const;
Poly quo(const Poly &rhs) const;
pair<Poly, Poly> iquo(const Poly &rhs) const;
pair<Poly, Poly> div(const Poly &rhs) const;
Poly taylor(int k) const;
Poly pow(int k) const;
Poly exp(int k) const;
};
Poly zeroes(int deg) { return vector<int>(deg + 1); }
struct Newton {
void inv(const Poly &f, const Poly &nttf, Poly &g, const Poly &nttg, int t) {
int n = 1 << t;
Poly prod = nttf;
for (int i = 0; i < (n << 1); ++i)
prod[i] = prod[i] * (long long)nttg[i] % P;
ntt.fft(prod.base(), t + 1, -1);
for (int i = 0; i < n; ++i) prod[i] = 0;
ntt.fft(prod.base(), t + 1, 1);
for (int i = 0; i < (n << 1); ++i)
prod[i] = prod[i] * (long long)nttg[i] % P;
ntt.fft(prod.base(), t + 1, -1);
for (int i = 0; i < n; ++i) prod[i] = 0;
g = g - prod;
}
void inv(const Poly &f, const Poly &nttf, Poly &g, int t) {
Poly nttg = g;
nttg.redeg((2 << t) - 1);
ntt.fft(nttg.base(), t + 1, 1);
inv(f, nttf, g, nttg, t);
}
void inv(const Poly &f, Poly &g, int t) {
Poly nttg = g;
nttg.redeg((2 << t) - 1);
ntt.fft(nttg.base(), t + 1, 1);
Poly nttf = f;
nttf.redeg((2 << t) - 1);
ntt.fft(nttf.base(), t + 1, 1);
inv(f, nttf, g, nttg, t);
}
void sqrt(const Poly &f, Poly &g, Poly &nttg, Poly &h, int t) {
for (int i = 0; i < (1 << t); ++i) nttg[i] = mpow(nttg[i], 2);
ntt.fft(nttg.base(), t, -1);
nttg = nttg - f;
for (int i = 0; i < (1 << t); ++i)
if ((nttg[i + (1 << t)] += nttg[i]) >= P) nttg[i + (1 << t)] -= P;
memset(nttg.base(), 0, sizeof(int) << t);
ntt.fft(nttg.base(), t + 1, 1);
Poly tmp = h;
tmp.redeg((2 << t) - 1);
ntt.fft(tmp.base(), t + 1, 1);
for (int i = 0; i < (2 << t); ++i) tmp[i] = tmp[i] * (long long)nttg[i] % P;
ntt.fft(tmp.base(), t + 1, -1);
memset(tmp.base(), 0, sizeof(int) << t);
g = g - tmp * nt.inv(2);
}
void exp(const Poly &f, Poly &g, Poly &nttg, Poly &h, int t) {
Poly ntth(h);
ntt.fft(ntth.base(), t, 1);
Poly dg = g.der().slice((1 << t) - 1);
ntt.fft(dg.base(), t, 1);
Poly tmp = zeroes((1 << t) - 1);
for (int i = 0; i < (1 << t); ++i) {
tmp[i] = nttg[i << 1] * (long long)ntth[i] % P;
dg[i] = dg[i] * (long long)ntth[i] % P;
}
ntt.fft(tmp.base(), t, -1);
ntt.fft(dg.base(), t, -1);
if (--tmp[0] < 0) tmp[0] = P - 1;
dg.redeg((2 << t) - 1);
Poly df0 = f.der().slice((1 << t) - 1);
df0[(1 << t) - 1] = 0;
for (int i = 0; i < (1 << t); ++i) {
if ((dg[i | 1 << t] = dg[i] - df0[i]) < 0) dg[i | 1 << t] += P;
}
memcpy(dg.base(), df0.base(), sizeof(int) * ((1 << t) - 1));
tmp.redeg((2 << t) - 1);
ntt.fft(tmp.base(), t + 1, 1);
df0.redeg((2 << t) - 1);
ntt.fft(df0.base(), t + 1, 1);
for (int i = 0; i < (2 << t); ++i) df0[i] = df0[i] * (long long)tmp[i] % P;
ntt.fft(df0.base(), t + 1, -1);
memcpy(df0.base() + (1 << t), df0.base(), sizeof(int) << t);
memset(df0.base(), 0, sizeof(int) << t);
dg = (dg - df0).integ().slice((2 << t) - 1) - f;
ntt.fft(dg.base(), t + 1, 1);
for (int i = 0; i < (2 << t); ++i) tmp[i] = dg[i] * (long long)nttg[i] % P;
ntt.fft(tmp.base(), t + 1, -1);
g.redeg((2 << t) - 1);
for (int i = 1 << t; i < (2 << t); ++i)
if (tmp[i]) g[i] = P - tmp[i];
}
} nit;
struct SemiRelaxedConvolution {
template <class Function>
void run(const vector<int> &a, vector<int> &b, const Function &relax) {
int n = a.size() - 1;
function<void(int, int)> divideConquer = [&](int l, int r) {
if (r - l <= BRUTE_N2_LIMIT) {
for (int i = l; i <= r; ++i) {
for (int j = l; j < i; ++j)
b[i] = (b[i] + b[j] * (long long)a[i - j]) % P;
relax(i);
}
return;
}
int lg = 31 - __builtin_clz(r - l) + 1;
int d = (r - l) / lg + 1;
int lgd = 0;
while ((1 << lgd) < d) ++lgd;
++lgd;
vector<int> top((lg << (lgd + 1)));
for (int i = 0; i < lg; ++i) {
copy(a.begin() + i * d, a.begin() + min((i + 2) * d, n + 1),
top.begin() + (i << lgd));
ntt.fft(top.data() + (i << lgd), lgd, 1);
}
for (int i = 0; i < lg; ++i) {
if (i) ntt.fft(top.data() + ((lg + i) << lgd), lgd, -1);
for (int j = 0; j < min(d, r - l - i * d + 1); ++j)
b[l + i * d + j] =
norm(b[l + i * d + j] + top[((lg + i) << lgd) + d + j]);
divideConquer(l + i * d, min(l + (i + 1) * d - 1, r));
if (i + 1 < lg) {
copy(b.begin() + l + i * d, b.begin() + min(l + (i + 1) * d, n + 1),
top.begin() + ((lg + i) << lgd));
fill(top.data() + ((lg + i) << lgd) + d,
top.data() + ((lg + i + 1) << lgd), 0);
ntt.fft(top.data() + ((lg + i) << lgd), lgd, 1);
}
for (int j = i + 1; j < lg; ++j) {
for (int k = 0; k < (1 << lgd); ++k)
top[((lg + j) << lgd) + k] =
(top[((lg + j) << lgd) + k] +
top[((j - i - 1) << lgd) + k] *
(long long)top[((lg + i) << lgd) + k]) %
P;
}
}
};
divideConquer(0, n);
}
} src;
struct Transposition {
vector<int> _mul(int l, vector<int> res, const Poly &b) {
vector<int> tmp(1 << l);
memcpy(tmp.data(), b.a.data(), sizeof(int) * (b.deg() + 1));
reverse(tmp.begin() + 1, tmp.end());
ntt.fft(tmp.data(), l, 1);
for (int i = 0; i < (1 << l); ++i) res[i] = res[i] * (long long)tmp[i] % P;
ntt.fft(res.data(), l, -1);
return res;
}
Poly bfMul(const Poly &a, const Poly &b) {
int n = a.deg(), m = b.deg();
Poly ret = zeroes(n - m);
for (int i = 0; i <= n - m; ++i)
for (int j = 0; j <= m; ++j)
ret[i] = (ret[i] + a[i + j] * (long long)b[j]) % P;
return ret;
}
Poly mul(const Poly &a, const Poly &b) {
if (a.deg() < b.deg()) return 0;
if (a.deg() <= BRUTE_N2_LIMIT) return bfMul(a, b);
int l = 0;
while ((1 << l) <= a.deg()) ++l;
vector<int> res(1 << l);
memcpy(res.data(), a.a.data(), sizeof(int) * (a.deg() + 1));
ntt.fft(res.data(), l, 1);
res = _mul(l, res, b);
res.resize(a.deg() - b.deg() + 1);
return res;
}
pair<Poly, Poly> mul2(const Poly &a, const Poly &b1, const Poly &b2) {
if (a.deg() <= BRUTE_N2_LIMIT) return make_pair(bfMul(a, b1), bfMul(a, b2));
int l = 0;
while ((1 << l) <= a.deg()) ++l;
vector<int> fa(1 << l);
memcpy(fa.data(), a.a.data(), sizeof(int) * (a.deg() + 1));
ntt.fft(fa.data(), l, 1);
vector<int> res1 = _mul(l, fa, b1), res2 = _mul(l, fa, b2);
res1.resize(a.deg() - b1.deg() + 1);
res2.resize(a.deg() - b2.deg() + 1);
return make_pair(res1, res2);
}
vector<int> ls, rs, pos;
vector<Poly> p, q;
void _build(int n) {
ls.assign(n * 2 - 1, 0);
rs.assign(n * 2 - 1, 0);
p.assign(n * 2 - 1, 0);
q.assign(n * 2 - 1, 0);
pos.resize(n);
int cnt = 0;
function<int(int, int)> dfs = [&](int l, int r) {
if (l == r) {
pos[l] = cnt;
return cnt++;
}
int ret = cnt++;
int mid = (l + r) >> 1;
ls[ret] = dfs(l, mid);
rs[ret] = dfs(mid + 1, r);
return ret;
};
dfs(0, n - 1);
}
vector<int> _eval(vector<int> f, const vector<int> &x) {
int n = f.size();
_build(n);
for (int i = 0; i < n; ++i) q[pos[i]] = {1, norm(P - x[i])};
for (int i = n * 2 - 2; i >= 0; --i)
if (ls[i]) q[i] = q[ls[i]] * q[rs[i]];
f.resize(n * 2);
p[0] = mul(f, q[0].inv());
for (int i = 0; i < n * 2 - 1; ++i)
if (ls[i]) tie(p[ls[i]], p[rs[i]]) = mul2(p[i], q[rs[i]], q[ls[i]]);
vector<int> ret(n);
for (int i = 0; i < n; ++i) ret[i] = p[pos[i]][0];
return ret;
}
vector<int> eval(const Poly &f, const vector<int> &x) {
int n = f.deg() + 1, m = x.size();
vector<int> tmpf = f.a, tmpx = x;
tmpf.resize(max(n, m));
tmpx.resize(max(n, m));
vector<int> ret = _eval(tmpf, tmpx);
ret.resize(m);
return ret;
}
Poly inter(const vector<int> &x, const vector<int> &y) {
int n = x.size();
_build(n);
for (int i = 0; i < n; ++i) q[pos[i]] = {1, norm(P - x[i])};
for (int i = n * 2 - 2; i >= 0; --i)
if (ls[i]) q[i] = q[ls[i]] * q[rs[i]];
Poly tmp = q[0];
reverse(tmp.a.begin(), tmp.a.end());
vector<int> f = tmp.der().a;
f.resize(n * 2);
p[0] = mul(f, q[0].inv());
for (int i = 0; i < n * 2 - 1; ++i)
if (ls[i]) tie(p[ls[i]], p[rs[i]]) = mul2(p[i], q[rs[i]], q[ls[i]]);
for (int i = 0; i < n; ++i)
p[pos[i]] = nt.inv(p[pos[i]][0]) * (long long)y[i] % P;
for (int i = 0; i < n * 2 - 1; ++i) reverse(q[i].a.begin(), q[i].a.end());
for (int i = n * 2 - 2; i >= 0; --i)
if (ls[i]) p[i] = p[ls[i]] * q[rs[i]] + p[rs[i]] * q[ls[i]];
return p[0];
}
} tp;
Poly operator"" _z(unsigned long long a) { return {0, (int)a}; }
Poly operator+(int v, const Poly &rhs) { return Poly(v) + rhs; }
Poly Poly::operator*(const Poly &rhs) const {
int n = deg(), m = rhs.deg();
if (n <= 10 || m <= 10 || n + m <= BRUTE_N2_LIMIT) {
Poly ret = zeroes(n + m);
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j)
ret[i + j] = (ret[i + j] + a[i] * (long long)rhs[j]) % P;
return ret;
}
n += m;
int l = 0;
while ((1 << l) <= n) ++l;
vector<int> res(1 << l), tmp(1 << l);
memcpy(res.data(), base(), a.size() * sizeof(int));
ntt.fft(res.data(), l, 1);
memcpy(tmp.data(), rhs.base(), rhs.a.size() * sizeof(int));
ntt.fft(tmp.data(), l, 1);
for (int i = 0; i < (1 << l); ++i) res[i] = res[i] * (long long)tmp[i] % P;
ntt.fft(res.data(), l, -1);
res.resize(n + 1);
return res;
}
Poly Poly::inv() const {
Poly g = nt.inv(a[0]);
for (int t = 0; (1 << t) <= deg(); ++t) nit.inv(slice((2 << t) - 1), g, t);
g.redeg(deg());
return g;
}
Poly Poly::taylor(int k) const {
int n = deg();
Poly t = zeroes(n);
simp.check(n);
for (int i = 0; i <= n; ++i) t[n - i] = a[i] * (long long)simp.fac[i] % P;
int pw = 1;
Poly help = vector<int>(simp.ifac.begin(), simp.ifac.begin() + n + 1);
for (int i = 0; i <= n; ++i) {
help[i] = help[i] * (long long)pw % P;
pw = pw * (long long)k % P;
}
t = t * help;
for (int i = 0; i <= n; ++i) help[i] = t[n - i] * (long long)simp.ifac[i] % P;
return help;
}
Poly Poly::pow(int k) const {
if (k == 0) return 1;
if (k == 1) return *this;
int n = deg() * k;
int lgn = 0;
while ((1 << lgn) <= n) ++lgn;
vector<int> val = a;
val.resize(1 << lgn);
ntt.fft(val.data(), lgn, 1);
for (int i = 0; i < (1 << lgn); ++i) val[i] = mpow(val[i], k);
ntt.fft(val.data(), lgn, -1);
return val;
}
Poly Poly::der() const {
if (deg() == 0) return 0;
vector<int> res(deg());
for (int i = 0; i < deg(); ++i) res[i] = a[i + 1] * (long long)(i + 1) % P;
return res;
}
Poly Poly::integ() const {
vector<int> res(deg() + 2);
simp.check(deg() + 1);
for (int i = 0; i <= deg(); ++i)
res[i + 1] = a[i] * (long long)simp.inv[i + 1] % P;
return res;
}
Poly Poly::quo(const Poly &rhs) const {
if (rhs.deg() == 0) return a[0] * (long long)nt.inv(rhs[0]) % P;
Poly g = nt.inv(rhs[0]);
int t = 0, n;
for (n = 1; (n << 1) <= rhs.deg(); ++t, n <<= 1)
nit.inv(rhs.slice((n << 1) - 1), g, t);
Poly nttg = g;
nttg.redeg((n << 1) - 1);
ntt.fft(nttg.base(), t + 1, 1);
Poly eps1 = rhs.slice((n << 1) - 1);
ntt.fft(eps1.base(), t + 1, 1);
for (int i = 0; i < (n << 1); ++i) eps1[i] = eps1[i] * (long long)nttg[i] % P;
ntt.fft(eps1.base(), t + 1, -1);
memcpy(eps1.base(), eps1.base() + n, sizeof(int) << t);
memset(eps1.base() + n, 0, sizeof(int) << t);
ntt.fft(eps1.base(), t + 1, 1);
Poly h0 = slice(n - 1);
h0.redeg((n << 1) - 1);
ntt.fft(h0.base(), t + 1);
Poly h0g0 = zeroes((n << 1) - 1);
for (int i = 0; i < (n << 1); ++i) h0g0[i] = h0[i] * (long long)nttg[i] % P;
ntt.fft(h0g0.base(), t + 1, -1);
Poly h0eps1 = zeroes((n << 1) - 1);
for (int i = 0; i < (n << 1); ++i) h0eps1[i] = h0[i] * (long long)eps1[i] % P;
ntt.fft(h0eps1.base(), t + 1, -1);
for (int i = 0; i < n; ++i) {
h0eps1[i] = operator[](i + n) - h0eps1[i];
if (h0eps1[i] < 0) h0eps1[i] += P;
}
memset(h0eps1.base() + n, 0, sizeof(int) << t);
ntt.fft(h0eps1.base(), t + 1);
for (int i = 0; i < (n << 1); ++i)
h0eps1[i] = h0eps1[i] * (long long)nttg[i] % P;
ntt.fft(h0eps1.base(), t + 1, -1);
memcpy(h0eps1.base() + n, h0eps1.base(), sizeof(int) << t);
memset(h0eps1.base(), 0, sizeof(int) << t);
return (h0g0 + h0eps1).slice(rhs.deg());
}
Poly Poly::ln() const {
if (deg() == 0) return 0;
return der().quo(slice(deg() - 1)).integ();
}
pair<Poly, Poly> Poly::sqrti() const {
Poly g = nt.sqrt(a[0]), h = nt.inv(g[0]), nttg = g;
for (int t = 0; (1 << t) <= deg(); ++t) {
nit.sqrt(slice((2 << t) - 1), g, nttg, h, t);
nttg = g;
ntt.fft(nttg.base(), t + 1, 1);
nit.inv(g, nttg, h, t);
}
return make_pair(g.slice(deg()), h.slice(deg()));
}
Poly Poly::sqrt() const {
Poly g = nt.sqrt(a[0]), h = nt.inv(g[0]), nttg = g;
for (int t = 0; (1 << t) <= deg(); ++t) {
nit.sqrt(slice((2 << t) - 1), g, nttg, h, t);
if ((2 << t) <= deg()) {
nttg = g;
ntt.fft(nttg.base(), t + 1, 1);
nit.inv(g, nttg, h, t);
}
}
return g.slice(deg());
}
Poly Poly::exp() const {
vector<int> der(a), ret(a.size());
for (int i = 0; i < a.size(); ++i) der[i] = der[i] * (long long)i % P;
src.run(der, ret, [&](int i) {
if (i == 0)
ret[0] = 1;
else
ret[i] = ret[i] * (long long)simp.ginv(i) % P;
});
return ret;
}
pair<Poly, Poly> Poly::expi() const {
Poly g = 1, h = 1, nttg = {1, 1};
for (int t = 0; (1 << t) <= deg(); ++t) {
nit.exp(slice((2 << t) - 1), g, nttg, h, t);
nttg = g;
nttg.redeg((4 << t) - 1);
ntt.fft(nttg.base(), t + 2);
Poly f2n = zeroes((2 << t) - 1);
for (int i = 0; i < (2 << t); ++i) f2n[i] = nttg[i << 1];
nit.inv(g, f2n, h, t);
}
return make_pair(g.slice(deg()), h.slice(deg()));
}
Poly Poly::exp(int k) const {
int lead, lz = 0;
while (lz < deg() && !a[lz]) ++lz;
if (lz == deg() && !a[lz]) return *this;
lead = a[lz];
if (lz * (long long)k > deg()) return zeroes(deg());
Poly part =
Poly(vector<int>(a.begin() + lz, a.begin() + deg() - lz * (k - 1) + 1)) *
nt.inv(lead);
part = (part.ln() * k).exp() * mpow(lead, k);
vector<int> ret(deg() + 1);
memcpy(ret.data() + lz * k, part.base(), sizeof(int) * (deg() - lz * k + 1));
return ret;
}
Poly Poly::operator/(const Poly &rhs) const {
int n = deg(), m = rhs.deg();
if (n < m) return 0;
Poly ta(vector<int>(a.rbegin(), a.rend())),
tb(vector<int>(rhs.a.rbegin(), rhs.a.rend()));
ta.redeg(n - m);
tb.redeg(n - m);
Poly q = ta.quo(tb);
reverse(q.a.begin(), q.a.end());
return q;
}
pair<Poly, Poly> Poly::div(const Poly &rhs) const {
if (deg() < rhs.deg()) return make_pair(0, *this);
int n = deg(), m = rhs.deg();
Poly q = operator/(rhs), r;
int lgn = 0;
while ((1 << lgn) < rhs.deg()) ++lgn;
int t = (1 << lgn) - 1;
r = zeroes(t);
Poly tmp = zeroes(t);
for (int i = 0; i <= m; ++i)
if ((r[i & t] += rhs[i]) >= P) r[i & t] -= P;
for (int i = 0; i <= n - m; ++i)
if ((tmp[i & t] += q[i]) >= P) tmp[i & t] -= P;
ntt.fft(r.base(), lgn, 1);
ntt.fft(tmp.base(), lgn, 1);
for (int i = 0; i <= t; ++i) tmp[i] = tmp[i] * (long long)r[i] % P;
ntt.fft(tmp.base(), lgn, -1);
memset(r.base(), 0, sizeof(int) << lgn);
for (int i = 0; i <= n; ++i)
if ((r[i & t] += a[i]) >= P) r[i & t] -= P;
for (int i = 0; i < m; ++i)
if ((r[i] -= tmp[i]) < 0) r[i] += P;
return make_pair(q, r.slice(m - 1));
}
Poly Poly::operator%(const Poly &rhs) const {
if (deg() < rhs.deg()) return *this;
return div(rhs).second;
}
using namespace std;
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];
}
return os;
}
const int N = 100010;
int a[N], b[N];
void GG() {
cout << "0\n";
exit(0);
}
vector<vector<Poly>> solve(int l, int r) {
if (l == r) {
if (b[l] == 1)
return {{Poly(nt.inv(2)), Poly(1)}, {1_z, 1_z}};
else
return {{Poly(1), Poly(1)}, {1_z, 1_z}};
}
int mid = (l + r) / 2;
auto X = solve(l, mid), Y = solve(mid + 1, r);
vector<vector<Poly>> ret(2, vector<Poly>(2, Poly(0)));
for (int i = 0; i != 2; ++i)
for (int j = 0; j != 2; ++j)
for (int k = 0; k != 2; ++k) ret[i][k] = ret[i][k] + X[i][j] * Y[j][k];
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int m = 0, m1 = 0;
for (int i = 1; i <= n; ++i) cin >> a[i];
{
int p = n;
while (p) {
int x = a[p];
if (x == 1)
b[++m] = 1;
else
b[++m] = 2;
for (int rep = 0; rep != x; ++rep) {
if (p == 0) GG();
if (a[p] != x) GG();
--p;
}
}
}
auto res = solve(1, m)[0][0];
int ans = 0;
for (int i = 0; i <= res.deg(); ++i) {
int v =
res[i] * (unsigned long long)mpow(2, m - i) % P * simp.gfac(m - i) % P;
if (i & 1)
sub(ans, v);
else
add(ans, v);
}
cout << ans << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
string r;
r.push_back(s[i]);
int nr = atoi(r.c_str());
if (nr % 8 == 0) {
cout << "YES" << endl << r;
return 0;
}
}
for (int i = 0; i < s.size(); i++)
for (int j = i + 1; j < s.size(); j++) {
string r;
r.push_back(s[i]);
r.push_back(s[j]);
int nr = atoi(r.c_str());
if (nr % 8 == 0) {
cout << "YES" << endl << r;
return 0;
}
}
for (int i = 0; i < s.size(); i++)
for (int j = i + 1; j < s.size(); j++)
for (int k = j + 1; k < s.size(); k++) {
string r;
r.push_back(s[i]);
r.push_back(s[j]);
r.push_back(s[k]);
int nr = atoi(r.c_str());
if (nr % 8 == 0) {
cout << "YES" << endl << r;
return 0;
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool base3(long long n) {
bool check = true;
while (n > 0) {
if (n % 3 == 2) {
check = false;
break;
}
n /= 3;
}
if (check)
return true;
else
return false;
}
int main() {
long long T, n, k;
cin >> T;
for (int i = 1; i <= T; i++) {
cin >> n;
if (n >= 1000000000000000000) {
cout << "1350851717672992089" << endl;
continue;
}
long long m = n;
while (1) {
long long k = 1, h = m;
bool check = true;
while (h > 0) {
if (h % 3 == 2) {
check = false;
break;
}
h /= 3;
k++;
}
if (check)
break;
else {
long long r = 1;
for (int i = 1; i <= k - 2; i++) r *= 3;
m += r;
}
}
cout << m << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int a, b, c, r;
cin >> a >> b >> c >> r;
int x = c - r;
int y = c + r;
if (a > b) {
swap(a, b);
}
int intersection = max(min(b, y) - max(a, x), 0);
cout << b - a - intersection << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
long long a[N], b[N], ccount;
vector<long long> Qs, Ps[N];
map<long long, long long> f;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, p;
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i], f[b[i]]++, ccount += f[b[i]] == 1;
for (int i = 1; i <= n; i++) {
Ps[i % p].push_back(i);
}
for (int i = 0; i < p; i++) {
if (Ps[i].size() < m) continue;
long long cur_count = ccount;
for (int j = 0; j < Ps[i].size(); j++) {
f[a[Ps[i][j]]]--;
if (f[a[Ps[i][j]]] == -1) cur_count++;
if (f[a[Ps[i][j]]] == 0) cur_count--;
if (j >= m - 1) {
if (!cur_count) {
if (!i) {
Qs.push_back((j + 1 - m + 1) * p);
} else {
Qs.push_back((j - m + 1) * p + i);
}
}
f[a[Ps[i][j - m + 1]]]++;
if (f[a[Ps[i][j - m + 1]]] == 0) cur_count--;
if (f[a[Ps[i][j - m + 1]]] == 1) cur_count++;
}
}
for (int j = 0; j < Ps[i].size(); j++) {
f[a[Ps[i][j]]]++;
if (j >= m - 1) f[a[Ps[i][j - m + 1]]]--;
}
}
sort(Qs.begin(), Qs.end());
cout << Qs.size() << '\n';
for (int i = 0; i < Qs.size(); i++) {
cout << Qs[i] << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int ar[1000];
int dp[20001];
int dp2[20001];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &ar[i]);
for (int i = 0; i < n; i++) {
memset(dp2, 0, sizeof(dp2));
for (int j = 0; j < 20001; j++) {
if (j >= ar[i]) dp2[j - ar[i]] = (dp2[j - ar[i]] + dp[j]) % 1000000007;
if (j + ar[i] < 20001)
dp2[j + ar[i]] = (dp2[j + ar[i]] + dp[j]) % 1000000007;
}
dp2[10000 - ar[i]] = (dp2[10000 - ar[i]] + 1) % 1000000007;
dp2[10000 + ar[i]] = (dp2[10000 + ar[i]] + 1) % 1000000007;
for (int j = 0; j < 20001; j++) dp[j] = dp2[j];
ans = (ans + dp[10000]) % 1000000007;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int main() {
long long i, j, n;
cin >> n;
vector<long long> a(n);
for (i = 0; i < n; i++) cin >> a[i];
set<long long> st;
for (auto in : a) st.insert(in);
vector<long long> v1;
for (auto in : st) v1.push_back(in);
map<long long, long long> m;
for (auto in : st) m[in] = 1;
vector<long long> v2;
for (i = 0; i <= 1000000; i++)
if (m[i] == 0) v2.push_back(i);
long long p1 = 0, p2 = 0;
vector<long long> ans;
for (i = 0; i < n; i++) {
if (i == 0 || a[i] == a[i - 1])
ans.push_back(v2[p2]), p2++;
else
ans.push_back(v1[p1]), p1++;
}
for (auto in : ans) cout << in << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ind = 0, n;
int used[101];
int g[101][101];
void dfs(int v) {
used[v] = 1;
for (int k = 1; k <= n; k++)
if (g[v][k] == 1)
if (used[k] == 0)
dfs(k);
else if (used[k] == 2)
ind++;
used[v] = 2;
}
int main() {
int m;
cin >> n >> m;
for (int k = 1; k <= m; k++) {
int a, b;
cin >> a >> b;
g[a][b] = g[b][a] = 1;
}
dfs(1);
if (n != m) {
cout << "NO";
return 0;
}
for (int j = 1; j <= n; j++)
if (used[j] == 0) {
cout << "NO";
return 0;
}
cout << "FHTAGN!";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, minimo = 10001;
int ind1, ind2;
vector<int> v;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b;
v.push_back(b);
}
for (int i = 1; i < v.size(); i++) {
if (abs(v[i] - v[i - 1]) < minimo) {
minimo = abs(v[i] - v[i - 1]);
ind1 = i + 1;
ind2 = i;
}
}
if (abs(v[v.size() - 1] - v[0]) < minimo) {
ind1 = v.size();
ind2 = 1;
}
cout << ind1 << " " << ind2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int num[30][100];
int rp[30];
int T;
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 0; i < m; i++) {
getchar();
for (int j = 0; j < n; j++) {
char c;
scanf("%c", &c);
num[i][j] = c - '0';
}
scanf("%d", &rp[i]);
}
map<vector<int>, int> mp;
int p = n / 2;
for (int i = 0; i < (1 << p); i++) {
vector<int> v1;
for (int j = 0; j < m; j++) {
int tmp = 0;
for (int k = 0; k < p; k++) {
tmp += ((i >> k) & 1) ^ num[j][k];
}
v1.push_back(tmp);
}
mp[v1]++;
}
int q = n - p;
int ans = 0;
for (int i = 0; i < (1 << q); i++) {
vector<int> v1;
for (int j = 0; j < m; j++) {
int tmp = 0;
for (int k = 0; k < q; k++) {
tmp += ((i >> k) & 1) ^ num[j][p + k];
}
v1.push_back(rp[j] - tmp);
}
ans += mp[v1];
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
struct Point {
long long x, y;
bool operator<(const Point &p) const {
if (x != p.x)
return x > p.x;
else
return y > p.y;
}
bool operator==(const Point &p) const { return x == p.x && y == p.y; }
} pt[maxn];
int stk[maxn], stnum;
set<pair<long long, long long> > has;
bool check(Point a, Point b, Point c) {
return c.x * b.y * (b.x - a.x) * (a.y - c.y) <
b.x * c.y * (a.x - c.x) * (b.y - a.y);
}
bool check2(Point a, Point b, Point c) {
cout << a.x << " " << a.y << " " << b.x << " " << b.y << " " << c.x << " "
<< c.y << endl;
cout << c.x * b.y * (b.x - a.x) * (a.y - c.y) << " "
<< b.x * c.y * (a.x - c.x) * (b.y - a.y) << endl;
cout << c.x * b.y * (b.x - a.x) * (a.y - c.y) -
b.x * c.y * (a.x - c.x) * (b.y - a.y)
<< endl;
return c.x * b.y * (b.x - a.x) * (a.y - c.y) <
b.x * c.y * (a.x - c.x) * (b.y - a.y);
}
void convex(int n) {
int i, j;
stnum = 0;
for (i = 0; i < n; i++) {
while (stnum > 1 && check(pt[stk[stnum - 1]], pt[stk[stnum - 2]], pt[i]))
stnum--;
stk[stnum++] = i;
}
while (stnum > 1 && pt[stk[stnum - 1]].y <= pt[stk[stnum - 2]].y) stnum--;
for (i = 0; i < stnum - 1; i++)
if (pt[stk[i]].x != pt[stk[i + 1]].x) break;
for (i = 0; i < stnum; i++) {
has.insert(make_pair(pt[stk[i]].x, pt[stk[i]].y));
}
}
long long a[maxn], b[maxn];
int main() {
int n, tn, i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d %I64d", &a[i], &b[i]);
pt[i].x = a[i];
pt[i].y = b[i];
}
sort(pt, pt + n);
tn = unique(pt, pt + n) - pt;
convex(tn);
for (i = 0; i < n; i++) {
if (has.find(make_pair(a[i], b[i])) != has.end()) {
printf("%d ", i + 1);
}
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long getmod(int n, int t) {
int ret = n / 5;
ret += t <= n % 5;
if (t == 0) ret--;
return ret;
}
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = 0; i < 5; i++) {
ans += getmod(n, i) * getmod(m, 5 - i);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
unsigned int n, d, mod, C[N][N], f[N][N], s[N];
int main() {
cin >> n >> d >> mod;
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
f[1][0] = s[1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j < d; j++)
for (int k = 1; k < i; k++)
f[i][j + 1] =
(f[i][j + 1] + 1ll * s[k] * f[i - k][j] % mod * C[i - 2][k - 1]) %
mod;
for (int j = 0; j < d; j++) s[i] = (s[i] + f[i][j]) % mod;
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= d; j++)
for (int k = 0; j + k <= d; k++)
if (k ^ 1) ans = (ans + 1ll * f[i + 1][j] * f[n - i][k]) % mod;
cout << 2ll * n * (n - 1) % mod * ans % mod;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 3e3 + 1;
int a[N], nxt[N], prv[N], lst[N];
int16_t dp[N][N];
int main() {
cin.tie(0), ios::sync_with_stdio(0);
int t, n;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i], --a[i];
}
memset(lst, -1, n * sizeof *lst);
n = unique(a, a + n) - a;
memset(prv, -1, n * sizeof *prv);
memset(nxt, 127, n * sizeof *nxt);
for (int i = 0; i < n; ++i) {
if (lst[a[i]] != -1) {
prv[i] = lst[a[i]];
nxt[lst[a[i]]] = i;
}
lst[a[i]] = i;
}
for (int i = n - 1; i > -1; --i)
for (int j = i + 1; j < n; ++j) {
dp[i][j] = dp[i + 1][j] - 1;
for (int z = nxt[i]; z <= j; z = nxt[z]) {
dp[i][j] = max(dp[i][j], int16_t(dp[i + 1][z - 1] + dp[z][j]));
}
++dp[i][j];
}
cout << n - dp[0][n - 1] - 1 << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num, a, b;
cin >> num;
if (num % 2 == 0) {
cout << (num - 4) << ' ' << 4 << endl;
} else {
cout << (num - 9) << ' ' << 9 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, v[100009], sum = 0, i, j = 0, c = 0;
cin >> n >> t;
for (i = 0; i < n; ++i) {
cin >> v[i];
sum += v[i];
while (sum > t) sum -= v[j++];
if (i - j + 1 > c) c = i - j + 1;
}
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool dfs(int cur, int edge, vector<vector<pair<int, int> > > &g,
set<int> &edges, vector<int> &p, vector<bool> &visited) {
visited[cur] = true;
int cur_p = p[cur];
for (int i = 0; i < g[cur].size(); i++) {
int next = g[cur][i].first, next_p = g[cur][i].second;
if (!visited[next]) {
cur_p = cur_p ^ dfs(next, next_p, g, edges, p, visited);
}
}
if (cur_p == 1) {
edges.insert(edge);
}
return cur_p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int n_cnt = 0, p_cnt = 0;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
n_cnt += p[i] < 0 ? 1 : 0;
p_cnt += p[i] > 0 ? 1 : 0;
}
if (n_cnt == 0 && p_cnt % 2 == 1) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < n; i++) {
if (p_cnt % 2 == 1 && p[i] == -1) {
p[i] = 1;
n_cnt--;
p_cnt++;
} else if (p[i] == -1) {
p[i] = 0;
n_cnt--;
}
}
vector<vector<pair<int, int> > > g(n, vector<pair<int, int> >());
int from, to;
for (int i = 1; i <= m; i++) {
cin >> from >> to;
from--, to--;
g[from].push_back(make_pair(to, i));
g[to].push_back(make_pair(from, i));
}
set<int> edges;
vector<bool> visited(n, false);
dfs(0, -1, g, edges, p, visited);
cout << edges.size() << "\n";
for (set<int>::iterator it = edges.begin(); it != edges.end(); it++) {
cout << *it << " ";
}
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mxS = 1e5;
char s[mxS + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int64_t n;
int q;
cin >> n >> q;
int tree_height = __builtin_popcountll(n);
for (int64_t u; q--;) {
cin >> u >> s;
int h = __builtin_ctzll(u) + 1;
for (int i = 0; s[i]; ++i) {
if (s[i] == 'U') {
if (h != tree_height) {
u = (u + ((u ^ (1ll << h)))) >> 1;
++h;
}
} else {
if (h == 1) continue;
--h;
u += s[i] == 'L' ? -(1ll << (h - 1)) : (1ll << (h - 1));
}
}
cout << u << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
long double pi = 2 * acosl(0.0);
int test_case_number, test_case = 1;
struct edge_structure {
int vertex_1, vertex_2, weight;
};
std::vector<edge_structure> edges;
std::vector<std::vector<int>> weight_id(5e5 + 10, std::vector<int>());
std::vector<int> parent;
int parent_finder(int vertex) {
if (parent[vertex] == vertex) {
return vertex;
} else {
return parent[vertex] = parent_finder(parent[vertex]);
}
}
void merger(int vertex1, int vertex2) {
vertex1 = parent_finder(vertex1);
vertex2 = parent_finder(vertex2);
if (vertex1 != vertex2) {
parent[vertex1] = vertex2;
}
}
void function_name() {
int vertex_number, edge_number;
scanf("%d %d", &vertex_number, &edge_number);
edges = std::vector<edge_structure>(edge_number);
parent = std::vector<int>(vertex_number);
for (int i = 0; i < edge_number; i++) {
int vertex1, vertex2, weight;
scanf("%d %d %d", &vertex1, &vertex2, &weight);
edges[i] = {--vertex1, --vertex2, weight};
weight_id[weight].push_back(i);
}
for (int i = 0; i < vertex_number; i++) {
parent[i] = i;
}
for (std::vector<int> &ids : weight_id) {
for (int &id : ids) {
edges[id].vertex_1 = parent_finder(edges[id].vertex_1);
edges[id].vertex_2 = parent_finder(edges[id].vertex_2);
}
for (int &id : ids) {
merger(edges[id].vertex_1, edges[id].vertex_2);
}
}
for (int i = 0; i < vertex_number; i++) {
parent[i] = i;
}
int query_number;
scanf("%d", &query_number);
std::vector<int> parent_changes;
for (int i = 0; i < query_number; i++) {
bool possible = true;
int query_edge_number;
scanf("%d", &query_edge_number);
for (int i = 0; i < query_edge_number; i++) {
int id;
scanf("%d", &id);
--id;
parent_changes.push_back(edges[id].vertex_1);
parent_changes.push_back(edges[id].vertex_2);
if (parent_finder(edges[id].vertex_1) ==
parent_finder(edges[id].vertex_2)) {
possible = false;
}
merger(edges[id].vertex_1, edges[id].vertex_2);
}
if (possible) {
printf("YES\n");
} else {
printf("NO\n");
}
for (int &vertex : parent_changes) {
parent[vertex] = vertex;
}
parent_changes.clear();
}
}
void function_name(int v1, int v2, int v3) {}
void function_name(std::string line) {}
class initial_works {
public:
void with_test_case_number() {
scanf("%d", &test_case_number);
while (test_case <= test_case_number) {
function_name();
test_case++;
}
}
void single_iteration() { function_name(); }
void without_test_case_number() {
int v1, v2, v3;
while (scanf("%d %d %d", &v1, &v2, &v3) == 3 && v1 != 0) {
function_name(v1, v2, v3);
test_case++;
}
}
void eoof() {
char dummy_char_array[100] = {0};
while (scanf("%[^\n]", &dummy_char_array) != EOF) {
getchar();
std::string line = dummy_char_array;
function_name(line);
test_case++;
}
}
};
int main() {
initial_works a;
a.single_iteration();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> sus(5);
bool found = false;
bool used[49];
bool edge[49][49];
int n, m;
void solve() {
if (found) return;
found = true;
for (int i = 0; i < 5; i++) cout << sus[i] << " ";
}
void bt1(int x) {
if (found) return;
if (x == 5)
solve();
else {
for (int i = 1; i <= min(n, 48); i++) {
if (!used[i]) {
bool good = true;
for (int j = 0; j < x; j++)
if (!edge[i][sus[j]]) good = false;
if (good) {
used[i] = true;
sus[x] = i;
bt1(x + 1);
used[i] = false;
}
}
}
}
}
void bt2(int x) {
if (found) return;
if (x == 5)
solve();
else {
for (int i = 1; i <= min(n, 48); i++) {
if (!used[i]) {
bool good = true;
for (int j = 0; j < x; j++)
if (edge[i][sus[j]]) good = false;
if (good) {
used[i] = true;
sus[x] = i;
bt2(x + 1);
used[i] = false;
}
}
}
}
}
int main() {
memset(used, false, sizeof(used));
memset(edge, false, sizeof(edge));
for (int i = 0; i < 49; i++) {
edge[i][i] = true;
}
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (a <= 48 && b <= 48) {
edge[a][b] = true;
edge[b][a] = true;
}
}
bt1(0);
if (!found) bt2(0);
if (!found) cout << -1;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[300010], pre[300010];
int n, b[300010], pre0[300010], pre1[300010];
int main() {
scanf("%d", &n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
b[i] = __builtin_popcountll(a[i]);
pre[i] = pre[i - 1] + b[i];
pre0[i] = pre0[i - 1] + (pre[i] & 1 ^ 1);
pre1[i] = pre1[i - 1] + (pre[i] & 1);
}
for (int i = 1; i <= n; ++i) {
if (pre[i - 1] & 1)
ans += pre1[n] - pre1[i];
else
ans += pre0[n] - pre0[i];
int range = min(i + 64, n), maxn = b[i];
for (int j = i + 1; j <= range; ++j) {
maxn = max(maxn, b[j]);
if ((maxn << 1) <= pre[j] - pre[i - 1]) continue;
if (pre[j] - pre[i - 1] & 1) continue;
--ans;
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
bool solve() {
int w, m;
scanf("%d %d", &w, &m);
int t = 0;
while (m > 0) {
m += t;
if (m % w != 0 && m % w != 1 && m % w != w - 1) {
return false;
}
if (m % w == w - 1)
t = 1;
else
t = 0;
m /= w;
}
return true;
}
int main(void) { printf("%s\n", solve() ? "YES" : "NO"); }
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
bool a[500];
int cc[500];
int c[500][3];
bool b[500];
int fc[500];
int n, k, t;
int now;
int cnt;
int num;
int x, y, z, xx;
int cx, cy;
int dep;
int ntop;
long long s, ans;
bool v = true;
bool v1, v2;
bool fin;
int itr;
ans = 0;
scanf("%d", &t);
for (int tt = 0; tt < int(t); tt++) {
scanf("%d", &n);
for (int i = 0; i < int(500); i++) a[i] = false;
a[0] = true;
fin = false;
now = 0;
dep = -1;
printf("? 1\n");
fflush(stdout);
scanf("%d", &num);
for (int i = 0; i < int(num); i++) {
scanf("%d", &c[now][i]);
c[now][i]--;
}
if (num == 2) {
fin = true;
printf("! 1\n");
fflush(stdout);
continue;
}
if (num == 1) {
now = c[0][0];
dep = n - 2;
} else {
v1 = false;
v2 = false;
x = c[now][0];
y = c[now][1];
for (int i = 0; i < int(4); i++) {
printf("? %d\n", x + 1);
a[x] = true;
fflush(stdout);
scanf("%d", &num);
for (int j = 0; j < int(num); j++) {
scanf("%d", &c[x][j]);
c[x][j]--;
}
if (num == 2) {
fin = true;
printf("! %d\n", x + 1);
fflush(stdout);
break;
}
if (num == 1)
v1 = true;
else {
for (int j = 0; j < int(num); j++) {
z = c[x][j];
if (!a[z]) xx = z;
}
x = xx;
}
printf("? %d\n", y + 1);
a[y] = true;
fflush(stdout);
scanf("%d", &num);
for (int j = 0; j < int(num); j++) {
scanf("%d", &c[y][j]);
c[y][j]--;
}
if (num == 2) {
fin = true;
printf("! %d\n", y + 1);
fflush(stdout);
break;
}
if (num == 1)
v2 = true;
else {
for (int j = 0; j < int(num); j++) {
z = c[y][j];
if (!a[z]) xx = z;
}
y = xx;
}
if (v1 || v2) {
dep = n - 3 - i;
if (v1 && v2)
now = c[0][2];
else if (v2)
now = c[0][0];
else
now = c[0][1];
break;
}
}
if (fin) continue;
}
if (fin) continue;
if (dep == -1) {
printf("! %d\n", c[0][2] + 1);
fflush(stdout);
continue;
}
for (int i = 0; i < int(500); i++) a[i] = false;
a[0] = true;
a[now] = true;
ntop = now;
while (dep > 2) {
for (int i = 0; i < int(500); i++) {
if (a[i])
b[i] = true;
else
b[i] = false;
}
for (int i = 0; i < int(n - dep - 1); i++) {
printf("? %d\n", now + 1);
b[now] = true;
fflush(stdout);
scanf("%d", &num);
for (int j = 0; j < int(num); j++) {
scanf("%d", &c[now][j]);
c[now][j]--;
}
if (num == 2) {
fin = true;
printf("! %d\n", now + 1);
fflush(stdout);
break;
}
if (i == 0) {
cx = -1;
cy = -1;
}
for (int j = 0; j < int(num); j++) {
z = c[now][j];
if (!b[z]) xx = z;
if (i == 0) {
if ((!b[z]) && (cx < 0))
cx = z;
else if (!b[z])
cy = z;
}
}
now = xx;
}
if (fin) break;
printf("? %d\n", now + 1);
b[now] = true;
fflush(stdout);
scanf("%d", &num);
for (int j = 0; j < int(num); j++) {
scanf("%d", &c[now][j]);
c[now][j]--;
}
if (num == 2) {
fin = true;
printf("! %d\n", now + 1);
fflush(stdout);
break;
}
if (num == 1) {
now = cx;
ntop = cx;
dep--;
} else {
now = cy;
ntop = cy;
dep--;
}
a[now] = true;
}
if (fin) continue;
for (int i = 0; i < int(500); i++) fc[i] = -1;
fc[0] = now;
itr = 1;
for (int i = 0; i < int(6); i++) {
printf("? %d\n", fc[i] + 1);
a[fc[i]] = true;
fflush(stdout);
scanf("%d", &num);
for (int j = 0; j < int(num); j++) {
scanf("%d", &c[fc[i]][j]);
c[fc[i]][j]--;
}
if (num == 2) {
fin = true;
printf("! %d\n", fc[i] + 1);
fflush(stdout);
break;
}
if (num == 3) {
for (int j = 0; j < int(num); j++) {
if (!a[c[fc[i]][j]]) {
fc[itr] = c[fc[i]][j];
itr++;
}
}
}
}
if (fin) continue;
printf("! %d\n", fc[6] + 1);
fflush(stdout);
}
printf("Finish\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
int n, q, xx, yy, ty, tx, nty, ntx, s, p[110000], plo, v[110000], m[1020],
e[1020][10], vis[1020][2520], f[1020][2520], clo;
void dfs(int x, int y) {
int ny = (y + v[x]) % 2520;
if (ny < 0) ny += 2520;
int z = e[x][ny % m[x]];
if (vis[z][ny] && vis[z][ny] < clo) {
f[x][y] = f[z][ny];
return;
}
if (vis[z][ny] == clo) {
ty = ny;
tx = z;
s = 1;
p[tx] = ++plo;
while (1) {
nty = (ty + v[tx]) % 2520;
if (nty < 0) nty += 2520;
ntx = e[tx][nty % m[tx]];
if ((ntx == z) && (nty == ny)) break;
tx = ntx;
if (p[tx] < plo) {
p[tx] = plo;
s++;
}
ty = nty;
}
f[x][y] = s;
return;
}
vis[z][ny] = clo;
dfs(z, ny);
f[x][y] = f[z][ny];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i]);
for (int j = 0; j <= m[i] - 1; j++) scanf("%d", &e[i][j]);
}
scanf("%d", &q);
while (q--) {
scanf("%d%d", &xx, &yy);
yy %= 2520;
if (yy < 0) yy += 2520;
if (vis[xx][yy])
printf("%d\n", f[xx][yy]);
else {
vis[xx][yy] = ++clo;
dfs(xx, yy);
printf("%d\n", f[xx][yy]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct Matrix {
int a[55][55];
Matrix operator*(const Matrix& b) const {
Matrix ret;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
ret.a[i][j] = 0;
for (int k = 0; k < n; ++k) ret.a[i][j] ^= a[i][k] & b.a[k][j];
}
return ret;
}
Matrix operator+(const Matrix& b) const {
Matrix ret;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
ret.a[i][j] = a[i][j] ^ b.a[i][j];
}
return ret;
}
void create(int* b = 0) {
if (b == 0) {
for (int j = 0; j < n; ++j) a[0][j] = rand() & 1;
a[0][n - 1] = 1;
} else {
for (int j = 0; j < n; ++j) a[0][j] = b[j];
}
for (int i = 1; i < n; ++i)
for (int j = 0; j < n; ++j) a[i][j] = (int)(j == i - 1);
}
Matrix() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) a[i][j] = (int)(i == j);
}
Matrix(const Matrix& b) { memcpy(a, b.a, sizeof(a)); }
Matrix& operator=(const Matrix& b) {
memcpy(a, b.a, sizeof(a));
return *this;
}
void print() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%d", a[i][j]);
printf("\n");
}
printf("\n");
}
Matrix pow(long long k) {
Matrix ret;
Matrix b = *this;
while (k > 0) {
if (k & 1) ret = ret * b;
b = b * b;
k /= 2;
}
return ret;
}
bool is1() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (a[i][j] != (int)(i == j)) return false;
return true;
}
};
bool test(Matrix a) {
long long k = (1LL << n) - 1;
if (!a.pow(k).is1()) return false;
for (long long d = 1; d * d <= k; ++d) {
if (k % d == 0) {
if (a.pow(d).is1()) return false;
if (k / d != k && k / d != d) {
if (a.pow(k / d).is1()) return false;
}
}
}
return true;
}
string res[] = {"11",
"011",
"1001",
"00101",
"101101",
"1111101",
"01100011",
"010010101",
"1011000001",
"10110010011",
"111000010101",
"0010101100011",
"01101111101011",
"111011101101111",
"1100001101111101",
"01101100001110001",
"100001101100110001",
"1010101001110000111",
"10110000101000010011",
"111000011011011010101",
"1001110011000010000111",
"10001110110110111111101",
"010011110000010010001101",
"1011001001000011011001011",
"10100111101010001001100111",
"001001101101110010111111001",
"1111011111010101001101000111",
"11100010000100010110101111001",
"010100110011010110101010010111",
"1010001100011010110101111101101",
"10111011110110101001101001111111",
"010101110001111010111110011000111",
"0000000110001010000001101111110011",
"01001100011110111110111000110101001",
"011111101011101000100010001101001111",
"1111101000011100101010101111111100001",
"10010101010000000101010011100000011001",
"110110010111011101100001001111111001101",
"1010010011010000010000100011110101001001",
"00001011111110000100101101111101001001101",
"111111000001011100010000001101001100001111",
"0010011100011101000101101101101111010011011",
"10110011011100001000000111111110111001100011",
"011111000111100011101011011001001110010111001",
"1110101000110101110000010101011000001110101111",
"10101110001110100110000010100101011100011101011",
"100010111110101010011000110001011010001011011001",
"1000001101010101110100110000100100100000110011001",
"00010101101110001001001001111010100011100100101101"};
int main() {
n = 50;
cin >> n;
string ans = res[n - 2];
for (int i = 0; i < n; ++i) printf("%c ", ans[i]);
printf("\n");
for (int i = 0; i < n; ++i) printf("1 ");
return 0;
}
| 9 |
#include <bits/stdc++.h>
struct arr {
int x;
int z;
char s[100];
};
void merge(struct arr a[], int s, int mid, int e);
void mergesort(struct arr a[], int s, int e);
void mergesort(struct arr a[], int s, int e) {
int mid;
if (s < e) {
mid = (s + e) / 2;
mergesort(a, s, mid);
mergesort(a, mid + 1, e);
merge(a, s, mid, e);
}
}
void merge(struct arr a[], int s, int mid, int e) {
struct arr b[e - s + 1];
int l = s, h = mid + 1, k = 0, i, j;
while (l <= mid && h <= e) {
if (a[l].x < a[h].x) {
b[k].x = a[l].x;
b[k].z = a[l].z;
j = 0;
while (a[l].s[j] != '\0') {
b[k].s[j] = a[l].s[j];
j++;
}
b[k].s[j] = '\0';
k++;
l++;
} else if (a[h].x < a[l].x) {
b[k].x = a[h].x;
b[k].z = a[h].z;
j = 0;
while (a[h].s[j] != '\0') {
b[k].s[j] = a[h].s[j];
j++;
}
b[k].s[j] = '\0';
k++;
h++;
} else if (a[l].x == a[h].x) {
if (a[l].z < a[h].z) {
b[k].x = a[l].x;
b[k].z = a[l].z;
j = 0;
while (a[l].s[j] != '\0') {
b[k].s[j] = a[l].s[j];
j++;
}
b[k].s[j] = '\0';
k++;
l++;
} else {
b[k].x = a[h].x;
b[k].z = a[h].z;
j = 0;
while (a[h].s[j] != '\0') {
b[k].s[j] = a[h].s[j];
j++;
}
b[k].s[j] = '\0';
k++;
h++;
}
}
}
while (l <= mid) {
b[k].x = a[l].x;
b[k].z = a[l].z;
j = 0;
while (a[l].s[j] != '\0') {
b[k].s[j] = a[l].s[j];
j++;
}
b[k].s[j] = '\0';
k++;
l++;
}
while (h <= e) {
b[k].x = a[h].x;
b[k].z = a[h].z;
j = 0;
while (a[h].s[j] != '\0') {
b[k].s[j] = a[h].s[j];
j++;
}
b[k].s[j] = '\0';
k++;
h++;
}
k = 0;
for (i = s; i <= e; i++) {
a[i].x = b[k].x;
a[i].z = b[k].z;
j = 0;
while (b[k].s[j] != '\0') {
a[i].s[j] = b[k].s[j];
j++;
}
a[i].s[j] = '\0';
k++;
}
}
int main() {
int n, i = 0, j = 0, m, r, p = 200;
scanf("%d\n", &n);
m = n;
struct arr a[n];
char c, b[100];
while (n--) {
j = 0;
while (1) {
c = getchar();
if (c == ' ') {
r = 0;
while (1) {
c = getchar();
if (c == '\n')
break;
else
b[r++] = c;
}
b[r] = '\0';
break;
} else
a[i].s[j++] = c;
}
a[i].s[j] = '\0';
if (b[0] == 'c' && b[1] == 'a') {
a[i].x = 4;
a[i].z = p++;
} else if (b[0] == 'w') {
a[i].x = 2;
a[i].z = p++;
} else if (b[0] == 'c' && b[1] == 'h') {
a[i].x = 2;
a[i].z = p++;
} else if (b[0] == 'm') {
a[i].x = 3;
a[i].z = p++;
} else if (b[0] == 'r') {
a[i].x = 1;
a[i].z = p++;
}
i++;
}
mergesort(a, 0, m - 1);
for (i = 0; i < m; i++) {
j = 0;
while (a[i].s[j] != '\0') {
printf("%c", a[i].s[j]);
j++;
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 102, M = 102 * 102;
int n, m;
vector<pair<int, int> > g[N];
char ans[N][N];
char dp[N][N][28] = {0};
void input() {
cin >> n >> m;
for (int i = (0); i < (m); ++i) {
int u, v;
char ch;
cin >> u >> v >> ch;
u--, v--;
g[u].push_back(make_pair(v, ch - 'a'));
}
}
int dfs(int u, int v, char c) {
if (dp[u][v][c] != 0) return dp[u][v][c];
for (auto x : g[u]) {
int h = x.first;
char k = x.second;
int win = 0;
if (k >= c) {
win = dfs(v, h, k);
if (win == 2) {
dp[u][v][c] = 1;
return 1;
}
}
}
dp[u][v][c] = 2;
return 2;
}
void solve() {
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (n); ++j) {
ans[i][j] = ((dfs(i, j, 0) == 1) ? 'A' : 'B');
}
}
}
void output() {
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (n); ++j) {
cout << ans[i][j];
}
cout << "\n";
}
}
int main() {
input();
solve();
output();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int pow(int a, int b) {
if (b == 0)
return 1;
else
return a * pow(a, b - 1);
}
int main() {
ios_base::sync_with_stdio(0);
;
long long precision = numeric_limits<double>::digits10;
;
long long n;
cin >> n;
long long a[n], b[n], c[n];
bool d[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
for (long long i = 0; i < n; i++) c[i] = 0;
for (long long i = 0; i < n; i++) d[i] = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == b[i]) {
c[i] = a[i];
d[a[i] - 1] = 1;
}
}
long long x = 0, y = 0;
for (long long i = 0; i < n; i++) {
if (d[i] == 0 && x == 0)
x = i + 1;
else if (d[i] == 0 && x != 0 && y == 0)
y = i + 1;
}
if (y == 0) {
for (long long i = 0; i < n; i++) {
if (c[i] == 0) {
c[i] = x;
break;
}
}
} else {
long long g = -1, h = -1;
for (long long i = 0; i < n; i++) {
if (c[i] == 0 && g == -1) {
g = i;
} else if (c[i] == 0 && g != -1 and h == -1) {
h = i;
}
}
if ((a[g] == x || b[g] == x) && (a[h] == y || b[h] == y)) {
c[g] = x;
c[h] = y;
} else {
c[h] = x;
c[g] = y;
}
}
for (long long i = 0; i < n; i++) cout << c[i] << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[(int)(2e5 + 10)], b[(int)(2e5 + 10)], bas, H[(int)(2e5 + 10)], bas2;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
H[a[i]] = i;
}
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
if (b[1])
bas = H[b[1]];
else
bas = H[b[2]];
bas2 = 1;
for (int i = 1; i <= n; i++) {
if (!a[bas]) {
bas = bas == n ? 1 : bas + 1;
continue;
}
if (!b[bas2]) {
bas2++;
continue;
}
if (a[bas] != b[bas2]) return puts("NO"), 0;
bas = bas == n ? 1 : bas + 1;
bas2++;
}
puts("YES");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> w_sum(n);
vector<int> power(n);
for (int i = 0; i < n - 1; ++i) {
for (int j = i + 1; j < n; ++j) {
long long t;
cin >> t;
if (t != -1) {
power[i]++;
power[j]++;
w_sum[i] += t;
w_sum[j] += t;
}
}
}
long long up = 0, down = 0;
if (k < 5) {
vector<vector<long long> > Cnk(n + 1, vector<long long>(k + 1));
for (int i = 0; i <= n; ++i) {
Cnk[i][0] = 1;
}
for (int i = 1; i <= k; ++i) {
Cnk[0][i] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
Cnk[i][j] = Cnk[i - 1][j] + Cnk[i - 1][j - 1];
}
}
for (int i = 0; i < n; ++i) {
if (power[i] >= k) {
up += Cnk[power[i] - 1][k - 1] * w_sum[i];
down += Cnk[power[i]][k];
}
}
} else {
down = n;
for (int i = 0; i < n; ++i) {
if (power[i] >= k) {
up += w_sum[i];
}
}
}
cout << up / down << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
void umin(T& a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
void umax(T& a, U b) {
if (a < b) a = b;
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return make_pair(a.first - b.first, a.second - b.second);
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
template <typename T>
int g_sz(const T& a) {
return static_cast<int>(a.size());
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
set<char> st;
for (auto e : s) {
st.insert(e);
}
if (st.count('<') + st.count('>') <= 1) {
cout << n << '\n';
} else {
int ans = 0;
for (int i = 0; i < n; ++i) {
int ni = (i + 1) % n;
if ((s[i] == '-') || (s[ni] == '-')) {
ans++;
}
}
cout << ans << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i, p = 0, l, q = 0, r, t = 0;
long long int k = 0, j = 0;
map<long long int, string> m;
map<long long int, string> a;
map<long long int, string> b;
cin >> l;
vector<pair<long long int, string>> v;
for (i = 0; i < l; i++) {
string s, s1;
cin >> s >> s1;
m[i] = s;
v.push_back(make_pair(i, s1));
}
for (i = 0; i < l; i++) {
string s = v[i].second;
if (m[i] == ".") continue;
for (j = i + 1; j < l; j++) {
if (m[j] != ".") {
if (m[j] == s) {
s = v[j].second;
m[j] = '.';
}
}
}
a[k] = m[i];
b[k] = s;
k++;
}
cout << k << endl;
for (i = 0; i < k; i++) cout << a[i] << " " << b[i] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[55];
for (int i = 0; i < m; i++) cin >> a[i];
sort(a, a + m);
int diff = INT_MAX;
for (int i = 0; i <= m - n; i++) {
int k = i + n - 1;
int mini = INT_MAX;
int maxi = INT_MIN;
for (int j = i; j <= k; j++) {
if (a[j] < mini)
mini = a[j];
else if (a[j] > maxi)
maxi = a[j];
}
if ((maxi - mini) < diff) diff = maxi - mini;
}
cout << diff << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string t;
cin >> t;
int num = 0;
for (int i = 0; i < (int)t.size(); i++) {
if (t[i] == 'a') {
num++;
}
}
int len;
len = (int)t.size() - num;
if (len % 2 != 0) {
cout << ":(";
} else {
if (num == (int)t.size()) {
cout << t;
} else {
len = len / 2;
int i = 0;
int j = len + num;
bool p = true;
while (i < (len + num) && j < (int)t.size()) {
if (t[i] == 'a') {
i++;
continue;
}
if (t[i] != t[j]) {
cout << ":(";
p = false;
break;
}
i++;
j++;
}
if (p) {
t.resize(len + num);
cout << t;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void read(vector<long long> &v) {
for (auto &i : v) cin >> i;
}
const long long INF = 1e9;
const int64_t INFF = 1e18;
const long long N = 1e7 + 69;
void solve() {
long long x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << (x2 - x1) * (y2 - y1) + 1 << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
for (long long i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool vis1[1005][1005], vis2[1005][1005];
int a[1005][1005];
int n;
inline void read(int &x) {
int f = 1;
char c;
for (x = 0, c = getchar(); c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
x *= f;
}
inline int mx(int _x, int _y) { return _x > _y ? _x : _y; }
inline int mn(int _x, int _y) { return _x < _y ? _x : _y; }
int main() {
read(n);
n--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) a[i][j] = (i + j) % n + 1;
}
for (int i = 0; i < n; i++) {
a[n][i] = a[i][n] = a[i][i];
a[i][i] = 0;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) printf("%d ", a[i][j]);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[112345];
long long int s[112345];
int n;
long long int A;
int ans[112345];
long long int minp(long long int m, int mr) {
if (m <= 0) {
return a[0].first;
}
long long int l = 0, r = mr;
long long int mid;
while (l < r) {
mid = (l + r) / 2 + 1;
if (a[mid].first * (mid + 1) - s[mid] <= m) {
l = mid;
} else {
r = mid - 1;
}
}
long long int rem = m - (a[l].first * (l + 1) - s[l]);
return min(A, a[l].first + rem / (l + 1));
}
int main() {
long long int cf, cm, m;
cin >> n >> A >> cf >> cm >> m;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
s[0] = a[0].first;
for (int i = 1; i < n; ++i) {
s[i] = s[i - 1] + a[i].first;
}
long long int curv, ansv = minp(m, n - 1) * cm;
int j = n;
long long int tmp = m;
long long int mip;
for (int i = n - 1; i >= 0; --i) {
m -= (A - a[i].first);
if (m < 0) {
break;
}
mip = (i > 0 ? minp(m, i - 1) : A);
curv = mip * cm + cf * (n - i);
if (curv > ansv) {
ansv = curv;
j = i;
}
}
cout << ansv << endl;
m = tmp;
for (int i = n - 1; i >= j; --i) {
m -= (A - a[i].first);
a[i].first = A;
}
if (j > 0) {
mip = minp(m, j - 1);
} else {
mip = A;
}
for (int i = 0; i < n; ++i) {
if (a[i].first < mip) {
a[i].first = mip;
}
}
for (int i = 0; i < n; ++i) {
ans[a[i].second] = a[i].first;
}
for (int i = 0; i < n; ++i) {
printf("%d", ans[i]);
printf(i < n - 1 ? " " : "\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 10;
int n, B, K, x;
int a[N];
int cnt[1000];
long long ways[1000];
struct matrix {
long long mat[101][101];
};
matrix mul(matrix A, matrix B) {
matrix ret;
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++) {
ret.mat[i][j] = 0;
for (int k = 0; k < K; k++) {
ret.mat[i][j] += (A.mat[i][k] * B.mat[k][j]) % 1000000007;
if (ret.mat[i][j] >= 1000000007) ret.mat[i][j] -= 1000000007;
}
}
}
return ret;
}
matrix pow(matrix A, long long p) {
if (p == 1) return A;
matrix ret = pow(A, p / 2);
ret = mul(ret, ret);
if (p & 1) ret = mul(ret, A);
return ret;
}
matrix Transition;
inline void createTransform(void) {
for (int j = 0; j < K; j++) {
for (int i = 0; i < K; i++) {
Transition.mat[i][j] = 0;
for (int k = 0; k < K; k++) {
if ((10 * i + k) % K == j) Transition.mat[i][j] = cnt[k];
}
}
}
return;
}
int main() {
cin >> n >> B >> x >> K;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i] % K]++;
}
createTransform();
matrix x1;
x1 = pow(Transition, B);
long long ans = x1.mat[0][x];
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const double PI = 3.14159265358979323846264338f;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const long long mod = 100000007;
const int MAXN = 50005;
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
inline int read() {
int c = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
c = c * 10 + ch - '0';
ch = getchar();
}
return c * f;
}
int a[1001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) a[i] = i;
for (int i = n; i >= 2; i--) {
swap(a[i], a[i - 1]);
}
int f = 1;
for (int i = 1; i <= n; i++) {
if (f)
f = 0;
else
cout << " ";
cout << a[i];
}
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
string smaller(string a) {
int len = a.length();
if (len % 2 == 1) return a;
len = len / 2;
string a1, a2;
a1 = smaller(a.substr(0, len));
a2 = smaller(a.substr(len, len));
if (a1 < a2)
return a1 + a2;
else
return a2 + a1;
}
int main() {
cin >> a;
cin >> b;
if (smaller(a) == smaller(b))
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
pair<int, int> d[100005];
int cnt[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> d[i].first;
d[i].second = i;
}
sort(d + 1, d + n + 1);
if (d[1].first) return cout << -1, 0;
int cur = 1;
for (int i = 2; i <= n; i++) {
if (!d[i].first) return cout << -1, 0;
while (d[i].first - 1 > d[cur].first) cur++;
if (d[i].first - 1 != d[cur].first) return cout << -1, 0;
if (cnt[cur] == k) cur++;
if (d[i].first - 1 != d[cur].first) return cout << -1, 0;
cnt[cur]++;
cnt[i]++;
ans.push_back({d[cur].second, d[i].second});
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int t,x,n;
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
n*=2;
int j=0,o=0;
for(int i=0;i<n;++i)
{
scanf("%d",&x);
if(x%2==1)++j;
else ++o;
}
if(j==o)puts("Yes");
else puts("No");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int x, i, flag, flag2, a, sayac, b;
int main() {
scanf("%d", &x);
a = 5;
while (1) {
b = a;
while (b) {
if (b % 5 != 0)
break;
else {
sayac++;
b = b / 5;
}
}
if (sayac == x) {
printf("5\n");
for (int i = a; i < a + 5; i++) {
printf("%d ", i);
}
return 0;
}
if (sayac > x) {
printf("0");
return 0;
}
a = a + 5;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[1005][1005][15][2];
int n, m, k;
string s, t;
int lcs(int i, int j, int rem, bool subst) {
if (i == n || j == m) {
if (rem != k) return INT_MIN;
return 0;
}
int &res = dp[i][j][rem][subst];
if (res != -1) return res;
res = 0;
res = max(res, max(lcs(i + 1, j, rem, false), lcs(i, j + 1, rem, false)));
if (s[i] == t[j]) {
if (subst) res = max(res, 1 + lcs(i + 1, j + 1, rem, true));
if (rem < k) res = max(res, 1 + lcs(i + 1, j + 1, rem + 1, true));
}
return res;
}
int main() {
ios::sync_with_stdio(false);
memset(dp, -1, sizeof(dp));
cin >> n >> m >> k;
cin >> s >> t;
cout << lcs(0, 0, 0, false);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define M 1000000007
void solve()
{
int n;
cin>>n;
multiset<int>st;
for(int i=0;i<2*n;i++)
{
int x;
cin>>x;
st.insert(x);
}
int ce=0,co=0;
for(auto i:st)
{
if(i%2==0)
ce++;
else
co++;
}
if(ce==co)
cout<<"Yes";
else
cout<<"No";
cout<<endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
char walls[1005][1005];
scanf("%d%d", &n, &m);
int rows[1005] = {0};
int cols[1005] = {0};
int i, j, total_walls = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> walls[i][j];
if (walls[i][j] == '*') {
rows[i]++;
cols[j]++;
total_walls++;
}
}
}
int flag = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
if ((rows[i] + cols[j] - (walls[i][j] == '*' ? 1 : 0)) == total_walls) {
flag = 1;
break;
}
if (flag) break;
}
if (flag) {
printf("YES\n");
printf("%d %d", i + 1, j + 1);
printf("\n");
} else
printf("NO\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int mod = 1000000007;
bool visit[N];
vector<int> v[N];
void bfs() {
priority_queue<int, vector<int>, greater<int>> pq;
pq.push(1);
visit[1] = 1;
while (!pq.empty()) {
int u = pq.top();
cout << u << ' ';
pq.pop();
for (int i : v[u]) {
if (visit[i]) continue;
pq.push(i);
visit[i] = 1;
}
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
bfs();
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> st;
int pot = 1;
vector<pair<long long, int> > v_aux;
void st_change(int idx, long long dp_val) {
int node = pot + idx;
st[node] = dp_val;
node /= 2;
while (node != 0) {
st[node] = max(st[2 * node], st[2 * node + 1]);
node /= 2;
}
}
long long st_query(int node, int l, int r, int L, int R) {
if (r < L || l > R)
return 0ll;
else if (L <= l && r <= R)
return st[node];
else {
long long q1 = st_query(2 * node, l, (l + r) / 2, L, R);
long long q2 = st_query(2 * node + 1, (l + r) / 2 + 1, r, L, R);
return max(q1, q2);
}
}
long long query(int i) {
if (v_aux[0].first == v_aux[i].first)
return 0ll;
else {
int l = 0, m, r = i;
while (l != r) {
m = (l + r + 1) / 2;
if (v_aux[m].first < v_aux[i].first)
l = m;
else
r = m - 1;
}
return st_query(1, 0, pot - 1, 0, l);
}
}
int main() {
int n;
scanf("%d", &n);
long long r, h;
vector<long long> v(n);
vector<int> sigma(n);
v_aux.resize(n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &r, &h);
v[i] = r * r * h;
v_aux[i] = pair<long long, int>(v[i], i);
}
sort(v_aux.begin(), v_aux.end());
for (int i = 0; i < n; i++) sigma[v_aux[i].second] = i;
while (pot < n) pot *= 2;
st = vector<long long>(2 * pot + 1, 0ll);
for (int i = 0; i < n; i++) {
st_change(sigma[i], v[i] + query(sigma[i]));
}
printf("%.13f\n", ((double)st_query(1, 0, pot - 1, 0, pot - 1)) *
3.141592653589793238462643383279502884197169399375);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cntN[2][400010], cntM[2][400010];
char op[5], le[100010], ri[100010], up[100010], dn[100010];
bool revN[2][400010], revM[2][400010], revmarkN[2][400010], revmarkM[2][400010];
struct Matrix {
int a[2][2];
Matrix(int t = 0) { a[0][0] = a[0][1] = a[1][0] = a[1][1] = t; }
void operator+=(int t) {
a[0][0] += t;
a[0][1] += t;
a[1][0] += t;
a[1][1] += t;
}
Matrix operator*(Matrix t) const {
Matrix ans(1e9);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
ans.a[i][j] = min(ans.a[i][j], a[i][k] + t.a[k][j]);
return ans;
}
} sN[2][2][400010], sM[2][2][400010];
namespace Seg1 {
void pushupN(int rt) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
sN[i][j][rt] = sN[i][j][rt * 2 + 1] * sN[i][j][rt * 2];
}
void pushupM(int rt) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
sM[i][j][rt] = sM[i][j][rt * 2 + 1] * sM[i][j][rt * 2];
}
void pushdownN(int rt) {
if (revN[0][rt]) {
revN[0][rt * 2] ^= 1;
revN[0][rt * 2 + 1] ^= 1;
for (int i = 0; i < 2; i++) {
swap(sN[0][i][rt * 2], sN[1][i][rt * 2]);
swap(sN[0][i][rt * 2 + 1], sN[1][i][rt * 2 + 1]);
}
revN[0][rt] = 0;
}
if (revN[1][rt]) {
revN[1][rt * 2] ^= 1;
revN[1][rt * 2 + 1] ^= 1;
for (int i = 0; i < 2; i++) {
swap(sN[i][0][rt * 2], sN[i][1][rt * 2]);
swap(sN[i][0][rt * 2 + 1], sN[i][1][rt * 2 + 1]);
}
revN[1][rt] = 0;
}
}
void pushdownM(int rt) {
if (revM[0][rt]) {
revM[0][rt * 2] ^= 1;
revM[0][rt * 2 + 1] ^= 1;
for (int i = 0; i < 2; i++) {
swap(sM[0][i][rt * 2], sM[1][i][rt * 2]);
swap(sM[0][i][rt * 2 + 1], sM[1][i][rt * 2 + 1]);
}
revM[0][rt] = 0;
}
if (revM[1][rt]) {
revM[1][rt * 2] ^= 1;
revM[1][rt * 2 + 1] ^= 1;
for (int i = 0; i < 2; i++) {
swap(sM[i][0][rt * 2], sM[i][1][rt * 2]);
swap(sM[i][0][rt * 2 + 1], sM[i][1][rt * 2 + 1]);
}
revM[1][rt] = 0;
}
}
void buildN(int rt, int l, int r) {
if (l > r) return;
if (l == r) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
sN[i][j][rt].a[0][1] = sN[i][j][rt].a[1][0] = m;
for (int k = 0; k < 2; k++) {
sN[i][j][rt].a[k][0] += (i ^ k ? le[l] == 'B' : le[l] == 'R') +
(j ^ k ? ri[l] == 'B' : ri[l] == 'R');
sN[i][j][rt].a[k][1] += (i ^ k ? le[l] == 'B' : le[l] == 'R') +
(j ^ k ? ri[l] == 'B' : ri[l] == 'R');
}
}
return;
}
int mid = (l + r) / 2;
buildN(rt * 2, l, mid);
buildN(rt * 2 + 1, mid + 1, r);
pushupN(rt);
}
void buildM(int rt, int l, int r) {
if (l > r) return;
if (l == r) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
sM[i][j][rt].a[0][1] = sM[i][j][rt].a[1][0] = n;
for (int k = 0; k < 2; k++) {
sM[i][j][rt].a[k][0] += (i ^ k ? up[l] == 'B' : up[l] == 'R') +
(j ^ k ? dn[l] == 'B' : dn[l] == 'R');
sM[i][j][rt].a[k][1] += (i ^ k ? up[l] == 'B' : up[l] == 'R') +
(j ^ k ? dn[l] == 'B' : dn[l] == 'R');
}
}
return;
}
int mid = (l + r) / 2;
buildM(rt * 2, l, mid);
buildM(rt * 2 + 1, mid + 1, r);
pushupM(rt);
}
void updateN(int rt, int l, int r, int x, int y, int z) {
if (l > r || l > y || r < x) return;
if (l >= x && r <= y) {
revN[z][rt] ^= 1;
for (int i = 0; i < 2; i++)
if (z)
swap(sN[i][0][rt], sN[i][1][rt]);
else
swap(sN[0][i][rt], sN[1][i][rt]);
return;
}
pushdownN(rt);
int mid = (l + r) / 2;
updateN(rt * 2, l, mid, x, y, z);
updateN(rt * 2 + 1, mid + 1, r, x, y, z);
pushupN(rt);
}
void updateM(int rt, int l, int r, int x, int y, int z) {
if (l > r || l > y || r < x) return;
if (l >= x && r <= y) {
revM[z][rt] ^= 1;
for (int i = 0; i < 2; i++)
if (z)
swap(sM[i][0][rt], sM[i][1][rt]);
else
swap(sM[0][i][rt], sM[1][i][rt]);
return;
}
pushdownM(rt);
int mid = (l + r) / 2;
updateM(rt * 2, l, mid, x, y, z);
updateM(rt * 2 + 1, mid + 1, r, x, y, z);
pushupM(rt);
}
} // namespace Seg1
namespace Seg2 {
void pushupN(int rt) {
cntN[0][rt] = cntN[0][rt * 2] + cntN[0][rt * 2 + 1];
cntN[1][rt] = cntN[1][rt * 2] + cntN[1][rt * 2 + 1];
}
void pushupM(int rt) {
cntM[0][rt] = cntM[0][rt * 2] + cntM[0][rt * 2 + 1];
cntM[1][rt] = cntM[1][rt * 2] + cntM[1][rt * 2 + 1];
}
void pushdownN(int rt, int l, int r) {
int mid = (l + r) / 2;
if (revmarkN[0][rt]) {
revmarkN[0][rt * 2] ^= 1;
revmarkN[0][rt * 2 + 1] ^= 1;
cntN[0][rt * 2] = mid - l + 1 - cntN[0][rt * 2];
cntN[0][rt * 2 + 1] = r - mid - cntN[0][rt * 2 + 1];
revmarkN[0][rt] = 0;
}
if (revmarkN[1][rt]) {
revmarkN[1][rt * 2] ^= 1;
revmarkN[1][rt * 2 + 1] ^= 1;
cntN[1][rt * 2] = mid - l + 1 - cntN[1][rt * 2];
cntN[1][rt * 2 + 1] = r - mid - cntN[1][rt * 2 + 1];
revmarkN[1][rt] = 0;
}
}
void pushdownM(int rt, int l, int r) {
int mid = (l + r) / 2;
if (revmarkM[0][rt]) {
revmarkM[0][rt * 2] ^= 1;
revmarkM[0][rt * 2 + 1] ^= 1;
cntM[0][rt * 2] = mid - l + 1 - cntM[0][rt * 2];
cntM[0][rt * 2 + 1] = r - mid - cntM[0][rt * 2 + 1];
revmarkM[0][rt] = 0;
}
if (revmarkM[1][rt]) {
revmarkM[1][rt * 2] ^= 1;
revmarkM[1][rt * 2 + 1] ^= 1;
cntM[1][rt * 2] = mid - l + 1 - cntM[1][rt * 2];
cntM[1][rt * 2 + 1] = r - mid - cntM[1][rt * 2 + 1];
revmarkM[1][rt] = 0;
}
}
void buildN(int rt, int l, int r) {
if (l == r)
return cntN[0][rt] = (le[l] == 'B'), cntN[1][rt] = (ri[l] == 'B'), void();
int mid = (l + r) / 2;
buildN(rt * 2, l, mid);
buildN(rt * 2 + 1, mid + 1, r);
pushupN(rt);
}
void buildM(int rt, int l, int r) {
if (l == r)
return cntM[0][rt] = (up[l] == 'B'), cntM[1][rt] = (dn[l] == 'B'), void();
int mid = (l + r) / 2;
buildM(rt * 2, l, mid);
buildM(rt * 2 + 1, mid + 1, r);
pushupM(rt);
}
void updateN(int rt, int l, int r, int x, int y, int z) {
if (l > y || r < x) return;
if (l >= x && r <= y)
return revmarkN[z][rt] ^= 1, cntN[z][rt] = r - l + 1 - cntN[z][rt], void();
pushdownN(rt, l, r);
int mid = (l + r) / 2;
updateN(rt * 2, l, mid, x, y, z);
updateN(rt * 2 + 1, mid + 1, r, x, y, z);
pushupN(rt);
}
void updateM(int rt, int l, int r, int x, int y, int z) {
if (l > y || r < x) return;
if (l >= x && r <= y)
return revmarkM[z][rt] ^= 1, cntM[z][rt] = r - l + 1 - cntM[z][rt], void();
pushdownM(rt, l, r);
int mid = (l + r) / 2;
updateM(rt * 2, l, mid, x, y, z);
updateM(rt * 2 + 1, mid + 1, r, x, y, z);
pushupM(rt);
}
int queryN(int rt, int l, int r, int x, int y) {
if (l == r) return cntN[y][rt];
pushdownN(rt, l, r);
int mid = (l + r) / 2;
if (x <= mid)
return queryN(rt * 2, l, mid, x, y);
else
return queryN(rt * 2 + 1, mid + 1, r, x, y);
}
int queryM(int rt, int l, int r, int x, int y) {
if (l == r) return cntM[y][rt];
pushdownM(rt, l, r);
int mid = (l + r) / 2;
if (x <= mid)
return queryM(rt * 2, l, mid, x, y);
else
return queryM(rt * 2 + 1, mid + 1, r, x, y);
}
} // namespace Seg2
int solve() {
int l1 = Seg2::queryN(1, 1, n, 1, 0), r1 = Seg2::queryN(1, 1, n, 1, 1),
u1 = Seg2::queryM(1, 1, m, 1, 0), d1 = Seg2::queryM(1, 1, m, 1, 1),
f0 = m - cntM[0][1] + !l1 + !r1, f1 = cntM[0][1] + l1 + r1,
g0 = n - cntN[0][1] + !u1 + !d1, g1 = cntN[0][1] + u1 + d1, ans = 1e9;
Matrix sn = sN[0][0][1], sm = sM[0][0][1];
if (n == 1)
ans = min(ans, min(f0 + m - cntM[1][1], f1 + cntM[1][1]));
else {
int tf0 = min(f0 + sn.a[0][0], f1 + sn.a[0][1]),
tf1 = min(f0 + sn.a[1][0], f1 + sn.a[1][1]);
ans = min(ans, min(tf0 + m - cntM[1][1], tf1 + cntM[1][1]));
}
if (m == 1)
ans = min(ans, min(g0 + n - cntN[1][1], g1 + cntN[1][1]));
else {
int tg0 = min(g0 + sm.a[0][0], g1 + sm.a[0][1]),
tg1 = min(g0 + sm.a[1][0], g1 + sm.a[1][1]);
ans = min(ans, min(tg0 + n - cntN[1][1], tg1 + cntN[1][1]));
}
return ans;
}
int main() {
int x, y;
scanf("%d%d%*d%s%s%s%s", &n, &m, le + 1, ri + 1, up + 1, dn + 1);
Seg1::buildN(1, 2, n);
Seg1::buildM(1, 2, m);
Seg2::buildN(1, 1, n);
Seg2::buildM(1, 1, m);
cout << solve() << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll c[5], a[10];
ll cc[5];
int main(){
int T; scanf("%d", &T);
while (T--){
for (int i = 1; i <= 3; i++) scanf("%lld", &c[i]);
for (int i = 1; i <= 5; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= 3; i++) cc[i] = c[i];
for (int i = 1; i <= 3; i++) cc[i] -= a[i];
if (cc[1]<0 || cc[2]<0 || cc[3]<0){
puts("NO");
continue;
}
ll tmp = min(a[4], cc[1]);
cc[1] -= tmp;
a[4] -= tmp;
cc[3] -= a[4];
tmp = min(a[5], cc[2]);
cc[2] -= tmp;
a[5] -= tmp;
cc[3] -= a[5];
if (cc[1]<0 || cc[2]<0 || cc[3]<0){
puts("NO");
continue;
}
puts("YES");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[202000];
int b[202000];
deque<pair<int, int> > q;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int type, pos;
cin >> type >> pos;
while (!q.empty() && pos >= q.back().second) {
q.pop_back();
}
q.push_back(make_pair(type, pos));
}
sort(a, a + q.front().second);
for (int i = q.back().second - 1; i < n; i++) b[i] = a[i];
int l = 0, r = q.front().second - 1;
while (!q.empty()) {
pair<int, int> pi = q.front();
q.pop_front();
int type = pi.first;
int pos = pi.second;
if (!q.empty()) {
pair<int, int> nx = q.front();
if (type == 1) {
for (int i = pos - 1; i >= nx.second; --i) {
b[i] = a[r];
r--;
}
} else {
for (int i = pos - 1; i >= nx.second; --i) {
b[i] = a[l];
l++;
}
}
} else {
if (type == 1) {
for (int i = 0; i < pos; i++) {
b[i] = a[l++];
}
} else {
for (int i = 0; i < pos; i++) {
b[i] = a[r--];
}
}
}
}
for (int i = 0; i < n - 1; i++) cout << b[i] << " ";
cout << b[n - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, ans, co, fr;
vector<long long int> v;
int main() {
cin >> n >> m;
for (long long int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
co += a;
v.push_back(a - b);
}
sort((v).begin(), (v).end(), greater<long long int>());
while (co > m && fr < v.size()) {
co -= v[fr++];
++ans;
}
if (co > m) {
cout << -1 << "\n";
return 0;
}
cout << ans << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int lps[45];
long long dp[45][45];
string s;
void LPS() {
int i = 1, len = 0;
while (i < (int)s.size())
if (s[i] == s[len])
lps[i++] = ++len;
else if (len)
len = lps[len - 1];
else
i++;
}
int advance(int st, char c) {
while (1) {
if (st < (int)s.size() and s[st] == c) {
st++;
break;
}
if (st)
st = lps[st - 1];
else
break;
}
return st;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, i, j, st, last, l;
long long res = 0;
cin >> n >> s;
LPS();
for (last = 0; last < n; last++) {
l = n - 1 - last - max(0, (int)s.size() - last - 1);
memset(dp, 0, sizeof dp);
dp[0][(int)s.size()] = 1;
for (i = 0; i < l; i++)
for (j = 0; j <= (int)s.size(); j++) {
st = advance(j, '0');
if (st < (int)s.size()) dp[i + 1][st] += dp[i][j];
st = advance(j, '1');
if (st < (int)s.size()) dp[i + 1][st] += dp[i][j];
}
if (last + 1 < (int)s.size()) {
for (i = 0; i <= (int)s.size(); i++) {
for (j = 0, st = i; j < (int)s.size() - last - 1; j++) {
st = advance(st, s[j]);
if (st == (int)s.size()) break;
}
if (j == (int)s.size() - last - 1) res += dp[l][i];
}
} else
for (i = 0; i <= (int)s.size(); i++)
res += (1LL << (last + 1 - (int)s.size())) * dp[l][i];
}
cout << res;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < 1e3; i++) {
cout << 5;
}
cout << " ";
for (int i = 0; i < 1e3 - 1; i++) {
cout << 4;
}
cout << 5 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int modu = 1e9 + 7;
int n, m;
long long _pow[505], f[2][505][505];
inline void update(long long &x, long long y) { x = (x + y) % modu; }
int main() {
scanf("%d %d", &n, &m);
_pow[0] = 1;
for (int i = 1; i <= n; ++i) _pow[i] = _pow[i - 1] * 2ll % modu;
f[0][0][0] = 1;
for (int i = 0; i < n; ++i) {
int now = i & 1, succ = now ^ 1;
memset(f[succ], 0, sizeof f[succ]);
for (int j = 0; j <= min(m, i); ++j)
for (int k = 0; k <= i; ++k) {
long long v = f[now][j][k];
update(f[succ][j][k], v);
update(f[succ][j][k], v * (_pow[k] - 1 + modu));
if (j < m)
update(f[succ][j + 1][i + 1], v * (_pow[i + 1] - _pow[k] + modu));
}
}
int now = n & 1;
long long ans(0);
for (int k = 0; k <= n; ++k) update(ans, f[now][m][k]);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<pair<int, int> > graph[100010];
int color[100010];
void dfs(int x, int c) {
if (color[x] != -1) return;
color[x] = c;
int i;
for ((i) = 0; (i) < (int)(graph[x].size()); (i)++)
dfs(graph[x][i].first, (c + graph[x][i].second) % 2);
}
void query(int a, int b, int val) {
int x = a - b;
int y = a + b;
if (x < 0) x = -x;
if (y > N - 1) y = 2 * (N - 1) - y;
int p, q;
if (x % 2 == 0) {
p = N / 2 + x / 2;
q = N / 2 + y / 2 + 1;
} else {
p = N / 2 - x / 2;
q = N / 2 - y / 2 - 1;
}
graph[p].push_back(make_pair(q, val));
graph[q].push_back(make_pair(p, val));
}
int main(void) {
int K, a, b, c, i, j;
scanf(" %d %d ", &N, &K);
for ((i) = 0; (i) < (int)(K); (i)++) {
char ch;
scanf(" %d %d %c ", &a, &b, &ch);
c = ((ch == 'o') ? 1 : 0);
query(a - 1, b - 1, c);
}
int comp = -1;
for ((i) = 0; (i) < (int)(N + 1); (i)++) color[i] = -1;
for ((i) = 0; (i) < (int)(N + 1); (i)++)
if (color[i] == -1) {
dfs(i, 0);
comp++;
}
bool bad = false;
for ((i) = 0; (i) < (int)(N + 1); (i)++)
for ((j) = 0; (j) < (int)(graph[i].size()); (j)++)
if (color[graph[i][j].first] != (color[i] + graph[i][j].second) % 2)
bad = true;
if (bad) {
cout << 0 << endl;
} else {
int ans = 1;
for ((i) = 0; (i) < (int)(comp); (i)++) ans = 2 * ans % 1000000007;
cout << ans << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, k, a[N], d2, d1, t[N];
void input() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
d2 = n - k;
d2 >= 0 ? d1 = k - d2 : d1 = n;
}
void solve() {
sort(a + 1, a + n + 1);
if (d2 >= 0) {
for (int i = 1, j = 2 * d2; i < j; i++, j--) t[i] = a[i] + a[j];
for (int i = d2 * 2 + 1; i <= n; i++) t[i - d2] = a[i];
sort(t + 1, t + k + 1);
cout << t[k];
} else
cout << a[n];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
input();
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 200005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int n, x, k, a[N];
long long ans = 0;
long long work(int pos) {
int t = a[pos] / x;
while ((long long)t * x < a[pos]) t++;
int xx = t;
t += k - 1;
int l, r;
if (k)
l = lower_bound(a + 1, a + n + 1, (long long)t * x) - a,
r = lower_bound(a + 1, a + n + 1, (long long)(t + 1) * x) - a - 1;
else
l = lower_bound(a + 1, a + n + 1, a[pos]) - a,
r = lower_bound(a + 1, a + n + 1, (long long)xx * x) - a - 1;
return ((r - l + 1) > (0) ? (r - l + 1) : (0));
}
int main() {
scanf("%d%d%d", &n, &x, &k);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = (1); i <= (n); ++i) ans += work(i);
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 3e5 + 10;
int n, m, u, v, lst, d[N], hed[N], s[M], ed, tp, cnt;
bool vis[M], ban[N];
struct edge {
int to, nex;
edge(int _ = 0, int __ = 0) : to(_), nex(__) {}
} e[M << 1];
inline void add(int u, int v) {
e[++ed] = edge(v, hed[u]);
hed[u] = ed;
}
void dfs(int u) {
ban[u] = 1;
for (int &i = hed[u], v = e[i].to; i; i = e[i].nex, v = e[i].to)
if (!vis[i + 1 >> 1]) vis[i + 1 >> 1] = 1, dfs(v);
s[tp++] = u;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); ++i)
scanf("%d%d", &u, &v), add(u, v), add(v, u), ++d[u], ++d[v];
for (int i = (1); i <= (n); ++i)
if (d[i] & 1) lst ? (add(lst, i), add(i, lst), ++cnt, lst = 0) : (lst = i);
m += cnt;
if (m & 1) add(1, 1), add(1, 1), ++m;
printf("%d\n", m);
for (int i = (1); i <= (n); ++i)
if (!ban[i]) {
tp = 0;
dfs(i);
for (int j = (0); j <= (tp - 2); ++j)
if (j & 1)
printf("%d %d\n", s[j + 1], s[j]);
else
printf("%d %d\n", s[j], s[j + 1]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const int N = 2005;
int n, m, d;
string p, q;
int a[N], b[N];
int dp[N][N][2][2];
int calc(int id, int rem, int aflag, int bflag) {
if (id == n) {
return (rem == 0);
}
int& ans = dp[id][rem][aflag][bflag];
if (ans != -1) {
return ans;
}
ans = 0;
if (aflag && bflag) {
for (int x = 0; x < 10; x++) {
if ((id % 2 && x != d) || (id % 2 == 0 && x == d)) {
continue;
}
ans = (ans + calc(id + 1, (10 * rem + x) % m, 1, 1)) % M;
}
} else if (aflag && bflag == 0) {
for (int x = 0; x < b[id] + 1; x++) {
if ((id % 2 && x != d) || (id % 2 == 0 && x == d)) {
continue;
}
ans = (ans + calc(id + 1, (10 * rem + x) % m, 1, x != b[id])) % M;
}
} else if (aflag == 0 && bflag) {
for (int x = a[id]; x < 10; x++) {
if ((id % 2 && x != d) || (id % 2 == 0 && x == d)) {
continue;
}
ans = (ans + calc(id + 1, (10 * rem + x) % m, x != a[id], 1)) % M;
}
} else {
for (int x = a[id]; x < b[id] + 1; x++) {
if ((id % 2 && x != d) || (id % 2 == 0 && x == d)) {
continue;
}
ans =
(ans + calc(id + 1, (10 * rem + x) % m, x != a[id], x != b[id])) % M;
}
}
return ans;
}
void solve() {
memset(dp, -1, sizeof(dp));
cin >> m >> d >> p >> q;
n = (int)((p).size());
for (int i = 0; i < n; i++) {
a[i] = p[i] - '0';
b[i] = q[i] - '0';
}
cout << calc(0, 0, 0, 0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int nr, timp, z, tine[1005], lung, i, total, cat, minim, maxim;
char cuvant[1005];
int main() {
cin >> nr >> timp;
cin.get();
for (z = 1; z <= nr; z++) {
cin.getline(cuvant + 1, 1000);
tine[strlen(cuvant + 1)]++;
}
cin.getline(cuvant + 1, 1000);
lung = strlen(cuvant + 1);
for (i = 1; i < lung; i++) {
total += tine[i];
}
cat = total / timp;
minim = total + 1 + cat * 5;
total += tine[lung] - 1;
cat = total / timp;
maxim = total + 1 + cat * 5;
cout << minim << ' ' << maxim;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MaxN = 1e5 + 5;
using namespace std;
long long int t, n, m, k, ans = 0;
string a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> t;
while (t--) {
cin >> n;
cin >> a >> b;
set<char> st[20];
int flag = 0;
for (int i = 0; i < n; i++) {
if (b[i] > a[i]) {
st[a[i] - 'a'].insert(b[i]);
}
if (b[i] < a[i]) {
flag = 1;
break;
}
}
if (flag) {
cout << -1 << "\n";
continue;
}
ans = 0;
for (int i = 0; i < 20; i++) {
char firstchr;
if (st[i].size() == 0) {
continue;
}
firstchr = *st[i].begin();
st[i].erase(firstchr);
ans++;
for (auto x : st[i]) {
st[firstchr - 'a'].insert(x);
}
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long w;
cin >> w;
pair<long long, int> A[n];
for (int i = 0; i < n; ++i) {
cin >> A[i].first;
A[i].second = i;
}
sort(A, A + n);
long long l = ceil(w / 2.00);
long long s = 0;
int j = 0;
int ans1 = -1, ans2 = -1;
for (int i = 0; i < n; ++i) {
s += A[i].first;
if (s >= l && s <= w) {
ans1 = i;
ans2 = j;
break;
}
while (s > w) {
s -= A[j].first;
j++;
}
if (s >= l && s <= w) {
ans1 = i;
ans2 = j;
break;
}
}
if (ans1 != -1) {
cout << (ans1 - ans2 + 1) << endl;
for (int i = ans2; i <= ans1; ++i) {
cout << A[i].second + 1 << " ";
}
cout << endl;
} else
cout << -1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
if (b == 0) return 1;
long long int p = (power(a, b / 2)) % 1000000007;
if (b % 2 == 0)
return (p * p) % 1000000007;
else
return ((a % 1000000007) * (p * p) % 1000000007) % 1000000007;
}
long int gcd(long int a, long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
std::ios_base::sync_with_stdio(false);
long int n, i, a, j, t = 3;
cin >> n;
vector<string> s(n);
string s0 = "0", s1 = "1", s2 = "2", s3 = "3";
vector<pair<long int, long int> > v;
for (i = 0; i < n; i++) {
cin >> a;
if (a) {
v.push_back(make_pair(a, i));
} else {
if (v.size() < 3)
t = v.size();
else
t = 3;
if (t == 0) s[i] = s0;
if (t == 1) s[i] = s1;
if (t == 2) s[i] = s2;
if (t == 3) s[i] = s3;
if (v.size()) {
sort(v.begin(), v.end());
s[v[v.size() - 1].second] = "pushFront";
if (v.size() > 1) s[v[v.size() - 2].second] = "pushQueue";
if (v.size() > 2) s[v[v.size() - 3].second] = "pushStack";
j = v.size() - 4;
for (j = j; j >= 0; j--) s[v[j].second] = "pushBack";
v.clear();
}
}
}
if (v.size()) {
sort(v.begin(), v.end());
s[v[v.size() - 1].second] = "pushFront";
if (v.size() > 1) s[v[v.size() - 2].second] = "pushQueue";
if (v.size() > 2) s[v[v.size() - 3].second] = "pushStack";
j = v.size() - 4;
for (j = j; j >= 0; j--) {
s[v[j].second] = "pushBack";
}
v.clear();
}
for (i = 0; i < n; i++) {
cout << s[i];
if (s[i] == "1") cout << " popFront";
if (s[i] == "2") cout << " popFront popQueue";
if (s[i] == "3") cout << " popFront popQueue popStack";
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
const int inf = 0x3f3f3f3f;
int n, m;
int w[MAXN][10];
char s[MAXN];
int ans;
bool vis[MAXN];
void dfs(int j, int sum) {
if (j == 3) {
ans = min(ans, sum);
return;
}
if (sum > ans) return;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
vis[i] = 1;
dfs(j + 1, sum + w[i][j]);
vis[i] = 0;
}
}
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
memset(w, inf, sizeof(w));
for (i = 0; i < n; ++i) {
scanf("%s", s);
for (j = 0; j < m; ++j) {
if (isdigit(s[j]))
w[i][0] = min(w[i][0], min(j, m - j));
else if (islower(s[j]))
w[i][1] = min(w[i][1], min(j, m - j));
else
w[i][2] = min(w[i][2], min(j, m - j));
}
}
ans = inf;
dfs(0, 0);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
int n, m, s, a, b, sol, cnt;
int bio[MAXN], _bio[MAXN];
vector<int> vi;
vector<vector<int> > graf;
vector<pair<int, int> > vp;
void dfs(int x) {
if (bio[x]) return;
bio[x] = 1;
for (int i = 0; i < graf[x].size(); i++) {
dfs(graf[x][i]);
}
}
void _dfs(int x) {
if (_bio[x]) return;
_bio[x] = 1;
cnt++;
for (int i = 0; i < graf[x].size(); i++) {
_dfs(graf[x][i]);
}
}
int main() {
cin >> n >> m >> s;
graf.insert(graf.begin(), n + 5, vi);
for (int i = 0; i < m; i++) {
cin >> a >> b;
graf[a].push_back(b);
}
dfs(s);
for (int i = 1; i <= n; i++) {
if (!bio[i]) {
cnt = 0;
memset(_bio, 0, sizeof _bio);
_dfs(i);
vp.push_back(make_pair(cnt, i));
}
}
sort(vp.begin(), vp.end());
for (int i = vp.size() - 1; i >= 0; i--) {
if (!bio[vp[i].second]) {
sol++;
dfs(vp[i].second);
}
}
cout << sol << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool do_i_win(long long int a, long long int b) {
if (a == 0) return 0;
if (a == 1) return 1;
if (b % a == 0) return 1;
bool next_turn = do_i_win(b % a, a);
if (next_turn == 0)
return 1;
else {
long long int x = (b / a) % (a + 1);
if (x & 0x1)
return 0;
else
return 1;
}
}
int main(void) {
int n;
long long int a, b;
bool result;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (a < b)
result = do_i_win(a, b);
else
result = do_i_win(b, a);
if (result == 1)
cout << "First" << endl;
else
cout << "Second" << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char C[1047];
int n;
scanf("%s %d", C, &n);
string s = C;
vector<int> P, V;
P.resize(300, 0);
V.resize(300, 0);
for (int i = 0; i < (s.length()); i++) P[s[i]]++;
int poc = 0;
for (int i = 0; i < (300); i++) {
if (P[i] == 0) continue;
V[i]++;
poc++;
}
if (poc > n) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n - poc; i++) {
int naj = -1, maxi = -1;
for (int j = 0; j < (300); j++) {
if (P[j] == 0) continue;
int pot = (P[j] + V[j] - 1) / V[j];
if (pot > maxi) {
maxi = pot;
naj = j;
}
}
V[naj]++;
}
int maxi = -1;
for (int i = 0; i < (300); i++) {
if (P[i] == 0) continue;
maxi = max(maxi, (P[i] + V[i] - 1) / V[i]);
}
printf("%d\n", maxi);
for (int i = 0; i < (300); i++) {
for (int j = 0; j < (V[i]); j++) printf("%c", i);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, k, p;
int h[N], a[N];
long long val[N];
int cnt[N];
bool Judge(long long x) {
int tot = 0;
for (int i = 1; i <= n; i++) val[i] = x;
for (int i = 0; i <= m; i++) cnt[i] = 0;
for (int i = 1; i <= n; i++) {
int j = 0;
while (j + val[i] / a[i] < m) {
j += val[i] / a[i];
val[i] %= a[i];
val[i] += p;
cnt[j]++;
tot++;
if (tot > m * k) return false;
}
val[i] -= (long long)(m - j) * a[i];
while (val[i] < h[i]) {
val[i] += p;
cnt[m]++;
tot++;
if (tot > m * k) return false;
}
}
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i <= m; i++)
if (cnt[i] > i * k) return false;
return true;
}
int main() {
cin >> n >> m >> k >> p;
for (int i = 1; i <= n; i++) scanf("%d%d", h + i, a + i);
long long l = 0, r = 1LL << 43;
while (l != r - 1) {
long long mid = (l + r) >> 1;
if (Judge(mid))
r = mid;
else
l = mid;
}
cout << r << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
long long val(long long *a, long long *b, long long *c, long long k,
long long d1, long long d2) {
*c = k - (d1 + 2 * d2);
if (*c % 3 != 0) return 0;
*c /= 3;
*b = *c + d2;
*a = *c + d1 + d2;
}
int main() {
long long t, a, b, c, n, k, d1, d2, i, j;
scanf("%lld", &t);
for (i = 1; i <= t; i++) {
scanf("%lld %lld %lld %lld", &n, &k, &d1, &d2);
if (n % 3 != 0) {
printf("no\n");
continue;
}
a = -1;
b = -1;
c = -1;
val(&a, &b, &c, k, d1, d2);
if (!(a < 0 || b < 0 || c < 0 || a > n / 3 || b > n / 3 || c > n / 3 ||
a + b + c != k)) {
printf("yes\n");
continue;
}
val(&a, &b, &c, k, d1, -d2);
if (!(a < 0 || b < 0 || c < 0 || a > n / 3 || b > n / 3 || c > n / 3 ||
a + b + c != k)) {
printf("yes\n");
continue;
}
val(&a, &b, &c, k, -d1, d2);
if (!(a < 0 || b < 0 || c < 0 || a > n / 3 || b > n / 3 || c > n / 3 ||
a + b + c != k)) {
printf("yes\n");
continue;
}
val(&a, &b, &c, k, -d1, -d2);
if (!(a < 0 || b < 0 || c < 0 || a > n / 3 || b > n / 3 || c > n / 3 ||
a + b + c != k)) {
printf("yes\n");
continue;
}
printf("no\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N, M;
scanf("%d%d", &N, &M);
int X = N - M;
long long R = X / (M + 1);
int S = X % (M + 1);
int T = (M + 1) - S;
long long ans = (long long)N * (N + 1) / 2;
;
;
ans -= R * (R + 1) / 2 * T;
ans -= (R + 1) * (R + 2) / 2 * S;
printf("%lld\n", ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
if (m == 1) {
if (n == 1)
printf("YES\n1");
else if (n < 4)
printf("NO\n");
else {
printf("YES\n");
for (i = 2; i <= n; i += 2) printf("%d\n", i);
for (i = 1; i <= n; i += 2) printf("%d\n", i);
}
} else if (m == 2) {
if (n < 4)
printf("NO\n");
else {
printf("YES\n");
if (n & 1) {
for (i = 2; i <= n; i += 2) printf("%d %d\n", i * 2 - 3, i * 2);
printf("%d %d\n", 2 * n - 1, 2);
for (i = 2; i <= n; i += 2) printf("%d %d\n", i * 2 - 1, i * 2 + 2);
} else {
for (i = 2; i <= n; i += 2)
printf("%d %d\n", i * 2 - 1, (n + 1 - i) * 2);
for (i = 1; i <= n; i += 2)
printf("%d %d\n", i * 2 - 1, (n + 1 - i) * 2);
}
}
} else if (m == 3) {
if (n < 3)
printf("NO\n");
else if (n == 3) {
printf("YES\n5 3 7\n1 8 6\n9 4 2\n");
} else {
printf("YES\n");
if (n & 1) {
for (i = 2; i <= n; i += 2)
printf("%d %d %d\n", i * 3 - 5, i * 3 - 1, i * 3 - 3);
printf("%d %d %d\n", 3 * n - 2, 2, 3 * n);
for (i = 2; i <= n; i += 2)
printf("%d %d %d\n", i * 3 - 2, i * 3 + 2, i * 3);
} else {
for (i = 2; i <= n; i += 2)
printf("%d %d %d\n", i * 3 - 2, (n + 1 - i) * 3 - 1, i * 3);
for (i = 1; i <= n; i += 2)
printf("%d %d %d\n", i * 3 - 2, (n + 1 - i) * 3 - 1, i * 3);
}
}
} else {
printf("YES\n");
if (m & 1) {
for (i = 0; i < n; i++) {
if (i & 1) {
for (j = 1; j <= m; j += 2) printf("%d ", j + i * m);
for (j = 2; j <= m; j += 2) printf("%d ", j + i * m);
} else {
for (j = 2; j <= m; j += 2) printf("%d ", j + i * m);
for (j = 1; j <= m; j += 2) printf("%d ", j + i * m);
}
printf("\n");
}
} else {
for (i = 0; i < n; i++) {
if (i & 1) {
for (j = 2; j <= m; j += 2) printf("%d ", j + i * m);
for (j = 1; j <= m; j += 2) printf("%d ", j + i * m);
} else {
for (j = m - 1; j > 0; j -= 2) printf("%d ", j + i * m);
for (j = m; j > 0; j -= 2) printf("%d ", j + i * m);
}
printf("\n");
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
void solve() {
int n;
cin >> n;
vector<int> a(n);
multiset<int> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
vector<int> ans;
for (int i = 0; i < n; i++) {
int x = ((i % 2) ? (*s.begin()) : (*s.rbegin()));
ans.push_back(x);
s.erase(s.find(x));
}
reverse(ans.begin(), ans.end());
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int tc;
cin >> tc;
while (tc--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[10] = "BWBWBWBW", c[10], *p;
for (int i = 1; i <= 8; i++) {
cin >> c;
p = c;
if (c[0] == 'W') {
c[8] = 'W';
p++;
}
if (strcmp(a, p)) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.