solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <vector>
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string>
#include <utility>
using namespace std;
int prom(int n, const vector<vector<int>> & inv, int mod) {
int res = 0;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
int sum = 0;
for (int k = j - i + 1; k <= (n * (n - 1)) / 2; k++) {
sum = (sum + inv[n - 1][k - j + i - 1]) % mod;
res = (res + (int)( ((long long)sum * inv[n - 1][k]) % mod)) % mod;
}
//cout << res << endl;
}
}
return res;
}
int main() {
int n, mod;
cin >> n >> mod;
vector<vector<int>> inv(52, vector<int>(52 * 26, 0));
inv[1][0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
for (int k = j - 1; k <= (i * (i - 1)) / 2; k++) {
inv[i][k] = (inv[i][k] + inv[i - 1][k - j + 1]) % mod;
}
}
}
/*for (int i = 1; i <= 4; i++) {
for (int j = 0; j <= 6; j++) {
cout << i << ' ' << j << " " << inv[i][j] << endl;
}
}*/
long long fac = 1;
long long ans = 0;
for (int k = 0; k <= n - 2; k++) {
ans = (ans + ((fac * prom(n - k, inv, mod)) % mod)) % mod;
fac = (fac * (n - k)) % mod;
}
printf("%lld\n", ans);
} | 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using db = double;
bool prime(ll x) {
for (ll i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
ll cal(ll n) {
if (n == 2) return 1;
if (n % 2 == 0) return 2;
if (prime(n)) return 1;
if (prime(n - 2)) return 2;
return 3;
}
int main() {
ll n;
cin >> n;
cout << cal(n) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (b) {
int temp = b;
b = a % b;
a = temp;
}
return a;
}
int main() {
int a, b, n, counting = 0, GCD;
scanf("%d %d %d", &a, &b, &n);
while (1) {
counting++;
GCD = gcd(a, n);
if (n < GCD) break;
n = n - GCD;
counting++;
GCD = gcd(b, n);
if (n < GCD) break;
n = n - GCD;
}
if (counting % 2 == 0)
printf("0\n");
else
printf("1");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j;
char s[1001][1001], t1, t2;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%s", s[i] + 1);
t1 = s[1][1];
t2 = s[1][2];
int t = 1;
if (t1 == t2) t = 0;
for (i = 1; i <= n; i++)
if (s[i][i] != t1 || s[i][n - i + 1] != t1) {
t = 0;
break;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (j != i && j != n - i + 1 && s[i][j] != t2) {
t = 0;
break;
}
if (!t)
printf("NO\n");
else
printf("YES\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n <= 2) {
cout << -1 << endl;
return 0;
}
if (n & 1) {
cout << (n * n + 1) / 2 << " " << (n * n - 1) / 2 << endl;
} else {
cout << ((n * n) / 4 + 1) << " " << ((n * n) / 4 - 1) << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
first = first * 10 + ch - 48;
}
return first * f;
}
const int mxN = 1e5;
int n, m, d, q;
vector<int> adj[mxN + 3];
struct SgTNode {
int l, r, cnt;
vector<int> s, id;
} sgt[mxN * 4 + 3];
int uf[mxN + 3], idi[mxN + 3];
int findfa(int u) { return u == uf[u] ? u : uf[u] = findfa(uf[u]); }
int unionfa(int u, int v) {
if (idi[u] > idi[v]) swap(u, v);
u = findfa(u), v = findfa(v);
if (u != v) {
uf[u] = v;
return 1;
} else {
return 0;
}
}
SgTNode operator+(SgTNode ls, SgTNode rs) {
SgTNode ret;
ret.l = ls.l, ret.r = rs.r, ret.cnt = ls.cnt + rs.cnt;
ret.s.resize(min(ret.r - ret.l + 1, 2 * d)), ret.id.resize(ret.s.size());
for (int i = 0; i < ret.id.size() && i < d; i++) {
ret.id[i] = ret.l + i;
}
for (int i = 0; i < ret.id.size() && i < d; i++) {
ret.id[ret.id.size() - 1 - i] = ret.r - i;
}
for (int i = 0; i < ret.id.size(); i++) {
idi[ret.id[i]] = i;
}
for (int i = 0; i < ls.s.size(); i++) {
uf[ls.id[i]] = ls.id[ls.s[i]];
}
for (int i = 0; i < rs.s.size(); i++) {
uf[rs.id[i]] = rs.id[rs.s[i]];
}
for (int i = 0; i < ls.s.size() && i < d; i++) {
int u = ls.id[ls.s.size() - 1 - i];
for (int o = 0; o < adj[u].size(); o++) {
int v = adj[u][o];
if (v >= rs.l && v <= rs.r) {
ret.cnt -= unionfa(u, v);
}
}
}
for (int i = 0; i < ret.id.size(); i++) {
int u = ret.id[i], p = findfa(u);
if (idi[p] == -1) {
uf[p] = uf[u] = u;
}
ret.s[i] = idi[findfa(ret.id[i])];
}
for (int i = 0; i < ret.id.size(); i++) {
idi[ret.id[i]] = -1;
}
return ret;
}
void build(int u, int le, int ri) {
if (le == ri) {
sgt[u].s.resize(1), sgt[u].id.resize(1), sgt[u].id[0] = le, sgt[u].cnt = 1,
sgt[u].l = sgt[u].r = le;
return;
}
int mid = (le + ri) >> 1;
if (le <= mid) {
build(u << 1, le, mid);
}
if (ri > mid) {
build(u << 1 | 1, mid + 1, ri);
}
sgt[u] = sgt[u << 1] + sgt[u << 1 | 1];
}
SgTNode query(int u, int le, int ri, int l, int r) {
if (le >= l && ri <= r) {
return sgt[u];
}
int mid = (le + ri) >> 1;
if (r <= mid) {
return query(u << 1, le, mid, l, r);
} else if (l > mid) {
return query(u << 1 | 1, mid + 1, ri, l, r);
} else {
return query(u << 1, le, mid, l, r) + query(u << 1 | 1, mid + 1, ri, l, r);
}
}
int main() {
n = read(), d = read(), m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
adj[u].push_back(v), adj[v].push_back(u);
}
memset(idi, -1, sizeof(idi));
build(1, 1, n);
q = read();
while (q--) {
int l = read(), r = read();
printf("%d\n", query(1, 1, n, l, r).cnt);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n, m, i, c = 0;
scanf("%d %d", &n, &m);
char s[3], t[4], u[5], v[3];
int le = 1, re = n, p;
for (i = 0; i < m; i++) {
scanf("%s %s %s %s %d", s, t, u, v, &p);
if (u[0] == 'l') {
if (p - 1 < re && p - 1 >= le)
re = p - 1;
else if (p - 1 < le) {
c++;
break;
}
} else if (u[0] == 'r') {
if (p + 1 > le && p + 1 <= re)
le = p + 1;
else if (p + 1 > re) {
c++;
break;
}
}
}
if (c == 1)
printf("-1");
else
printf("%d", re - le + 1);
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-9;
int bit_count(int first) {
return first == 0 ? 0 : 1 + bit_count(first & (first - 1));
}
inline int low_bit(int first) { return first & -first; }
inline int sign(double first) {
return first < -EPS ? -1 : first > EPS ? 1 : 0;
}
inline int sign(int first) { return (first > 0) - (first < 0); }
inline int getint() {
int a;
return scanf("%d", &a) ? a : (fprintf(stderr, "trying to read\n"), -1);
}
inline double getdouble() {
double a;
return scanf("%lf", &a) ? a : (fprintf(stderr, "trying to read\n"), -1.0);
}
inline double myrand() {
return ((double)rand() / RAND_MAX) + ((double)rand() / RAND_MAX / RAND_MAX);
}
void myCode() {
int n = getint();
long long l = getint(), c = getint(), v = getint();
l *= 2 * (v + c);
long long lSeg = l / (v + c) * v / 2;
vector<long long> stars(n);
for (int i = (int)0; i < (int)n; ++i) stars[i] = getint() * (v + c);
for (int i = (int)0; i < (int)n; ++i)
if (stars[i] > l) stars[i] -= l;
vector<pair<long long, int> > events;
for (int i = (int)0; i < (int)n; ++i) {
events.push_back(make_pair(stars[i], 1));
events.push_back(make_pair(stars[i] + (lSeg), -1));
}
for (int i = (int)0; i < (int)((int)(events).size()); ++i)
if (events[i].first > l) events[i].first -= l;
sort((events).begin(), (events).end());
events.insert(events.begin(), make_pair(0, 0));
events.push_back(make_pair(l, 0));
int num = 0;
for (int i = (int)0; i < (int)n; ++i)
if (stars[i] > l - lSeg) ++num;
vector<long long> p(n + 1, 0);
int j = 1;
for (int i = 1; i < ((int)(events).size()); i = j) {
p[num] += events[i].first - events[i - 1].first;
while (j < ((int)(events).size()) && events[j].first == events[i].first)
++j;
for (int k = (int)i; k < (int)j; ++k) num += events[k].second;
}
for (int i = (int)0; i < (int)n + 1; ++i)
printf("%.20lf\n", p[i] / (double)l);
}
int main() {
srand(time(NULL));
myCode();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, apple, money, i;
string s[51];
int main() {
cin >> n >> m;
m /= 2;
for (i = 1; i <= n; i++) cin >> s[i];
for (i = n; i >= 1; i--) {
apple *= 2;
if (s[i] == "halfplus") apple += 1;
money += apple;
}
money *= m;
cout << money;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60000000")
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
int n, m;
int V;
int a[500], b[500];
int l[500];
vector<int> g[500];
bool live[500];
bool u[500];
int leader(int v) {
if (l[v] != v) l[v] = leader(l[v]);
return l[v];
}
void unite(int v1, int v2) {
v1 = leader(v1);
v2 = leader(v2);
l[v1] = v2;
}
vector<pair<pair<int, int>, int> > ans;
void push_from(int v, int x) {
u[v] = 1;
for (int i = 0; i < (int)(g[v].size()); i++) {
if (x == 0) break;
int w = g[v][i];
if (live[w] && !u[w]) {
push_from(w, a[w]);
int t = min(x, V - a[w]);
if (t > 0) {
x -= t;
a[w] += t;
a[v] -= t;
ans.push_back(make_pair(make_pair(v, w), t));
}
}
}
}
void push_to(int v, int x) {
u[v] = 1;
for (int i = 0; i < (int)(g[v].size()); i++) {
if (x == 0) break;
int w = g[v][i];
if (live[w] && !u[w]) {
push_to(w, V - a[w]);
int t = min(x, a[w]);
if (t > 0) {
x -= t;
a[w] -= t;
a[v] += t;
ans.push_back(make_pair(make_pair(w, v), t));
}
}
}
}
void erase(int v) {
g[v].resize(0);
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(g[i].size()); j++)
if (g[i][j] == v) {
swap(g[i][j], g[i].back());
g[i].pop_back();
j--;
}
}
int main() {
cin >> n >> V >> m;
for (int i = 0; i < (int)(n); i++) cin >> a[i];
for (int i = 0; i < (int)(n); i++) cin >> b[i];
for (int i = 0; i < (int)(n); i++) l[i] = i;
for (int i = 0; i < (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
if (leader(x) != leader(y)) {
unite(x, y);
g[x].push_back(y);
g[y].push_back(x);
}
}
memset(live, 1, sizeof(live));
for (int ii = 0; ii < (int)(n); ii++) {
for (int j = 0; j < (int)(n); j++)
if (live[j] && g[j].size() == 0) {
if (a[j] != b[j]) {
cout << "NO" << endl;
return 0;
}
live[j] = 0;
erase(j);
} else if (live[j] && g[j].size() == 1) {
memset(u, 0, sizeof(u));
push_from(j, a[j]);
if (a[j] > b[j]) {
cout << "NO" << endl;
return 0;
}
memset(u, 0, sizeof(u));
push_to(j, b[j] - a[j]);
if (a[j] != b[j]) {
cout << "NO" << endl;
return 0;
}
live[j] = 0;
erase(j);
}
}
cout << ans.size() << endl;
for (int i = 0; i < (int)(ans.size()); i++)
printf("%d %d %d\n", ans[i].first.first + 1, ans[i].first.second + 1,
ans[i].second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k, l;
cin >> n >> k >> l;
vector<long long> depth(n);
int flag = 0;
for (long long i = 0; i < n; i++) {
cin >> depth[i];
if (depth[i] > l) flag = 1;
}
if (flag) {
cout << "No\n";
continue;
}
vector<pair<long long, long long>> range(n);
for (long long i = 0; i < n; i++)
range[i] = {-min(l - depth[i], k), min(l - depth[i], k)};
for (long long i = 1; i < n; i++) {
if (range[i].first == -k) continue;
range[i].first = max(range[i - 1].first + 1, range[i].first);
if (range[i].first > range[i].second) {
flag = 1;
break;
}
}
if (flag) {
cout << "No\n";
continue;
}
cout << "Yes\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int(i) = (0); (i) < (n); (i)++) cin >> arr[i];
vector<int> ans(n, 0);
int ptr = 0;
int last = -1;
for (int(i) = (0); (i) < (n); (i)++) {
if (arr[i] == 0 && last == 1) {
ptr++;
} else if (arr[i] == 1) {
ans[ptr]++;
}
last = arr[i];
}
int a = 0;
for (int(i) = (0); (i) < (int((ans).size())); (i)++) {
if (ans[i] == 0) continue;
a += ans[i] + 1;
}
cout << ((a == 0) ? a : a - 1) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[100005], b[100005], za[100005], zb[100005];
long long num, den, z;
const long long pri = 1e9 + 7;
long long myPow(long long a, long long b) {
long long ret = 1;
while (b != 0) {
if (b % 2 != 0) {
ret = (ret * a) % pri;
}
b /= 2;
a = (a * a) % pri;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
long long precision = numeric_limits<long double>::digits10;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
z++;
za[i] = 1;
}
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] == 0) {
z++;
zb[i] = 1;
}
}
for (long long i = 1; i <= n; i++) {
za[i] += za[i - 1];
zb[i] += zb[i - 1];
}
long long numWays = 1;
for (long long i = 1; i <= n; i++) {
if (a[i] == 0 && b[i] == 0) {
long long tem = (m * (m - 1ll)) / 2ll;
tem %= pri;
tem *= numWays;
tem %= pri;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
numWays *= m;
numWays %= pri;
} else if (a[i] != 0 && b[i] == 0) {
long long tem = a[i] - 1;
tem *= numWays;
tem %= pri;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
} else if (a[i] == 0 && b[i] != 0) {
long long tem = m - b[i];
tem *= numWays;
tem %= pri;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
} else if (a[i] != 0 && b[i] != 0) {
if (a[i] == b[i]) {
} else if (a[i] < b[i]) {
break;
} else {
long long tem = numWays;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
break;
}
}
}
den = myPow(m, z);
long long temp = myPow(den, pri - 2);
cout << (num * temp) % pri;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
char s[2000 + 10][2000 + 10];
int degree[2000 + 10][2000 + 10];
struct Node {
int x, y;
Node() {}
Node(int a, int b) {
x = a;
y = b;
}
};
queue<Node> que;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int Count(int x, int y) {
int cnt = 0;
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && s[xx][yy] == '.') cnt++;
}
return cnt;
}
void update(int x, int y) {
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && s[xx][yy] == '.') {
degree[xx][yy] = Count(xx, yy);
if (degree[xx][yy] == 1) que.push(Node(xx, yy));
}
}
}
void solve() {
Node node;
memset(degree, 0, sizeof(degree));
while (!que.empty()) que.pop();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '*') continue;
degree[i][j] = Count(i, j);
if (degree[i][j] == 1) {
node.x = i, node.y = j;
que.push(node);
}
}
}
int x, y;
while (!que.empty()) {
node = que.front();
que.pop();
x = node.x, y = node.y;
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && s[xx][yy] == '.') {
if (i == 0)
s[x][y] = '<', s[xx][yy] = '>';
else if (i == 1)
s[xx][yy] = '<', s[x][y] = '>';
else if (i == 2)
s[x][y] = '^', s[xx][yy] = 'v';
else if (i == 3)
s[xx][yy] = '^', s[x][y] = 'v';
update(x, y);
update(xx, yy);
break;
}
}
}
}
void print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", s[i][j]);
}
printf("\n");
}
}
bool check() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') return false;
}
}
return true;
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 0; i < n; i++) {
gets(s[i]);
}
solve();
if (check())
print();
else
printf("Not unique\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
long long int binpow(long long int a, long long int b) {
long long int r = 1;
while (b) {
if (b & 1) r = (r % MOD * a % MOD) % MOD;
a = (a % MOD * a % MOD) % MOD;
b /= 2;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1, testcases = 1;
cin >> t;
while (t >= testcases) {
long long int n, k;
cin >> n >> k;
long long int ans = 0;
if (n % 2) {
ans = (binpow(2, n - 1) + 1) % MOD;
ans = binpow(ans, k);
} else {
long long int dp[k + 1];
dp[0] = 1;
long long int c = (binpow(2, n - 1) - 1 + MOD) % MOD;
for (long long int i = 1; i <= k; i++) {
long long int p = n * (i - 1);
long long int o = binpow(2, p);
dp[i] = (o % MOD + (c % MOD * dp[i - 1] % MOD) % MOD) % MOD;
}
ans = dp[k];
}
cout << ans << "\n";
testcases++;
}
cerr << "Time Taken:" << (float)clock() / CLOCKS_PER_SEC * 1000 << "ms"
<< "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF(0x3f3f3f3f3f3f3f3fll);
const long long inf(0x3f3f3f3f);
template <typename T>
void read(T &res) {
bool flag = false;
char ch;
while (!isdigit(ch = getchar())) (ch == '-') && (flag = true);
for (res = ch - 48; isdigit(ch = getchar());
res = (res << 1) + (res << 3) + ch - 48)
;
flag && (res = -res);
}
template <typename T>
void Out(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) Out(x / 10);
putchar(x % 10 + '0');
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long pow_mod(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long fact_pow(long long n, long long p) {
long long res = 0;
while (n) {
n /= p;
res += n;
}
return res;
}
long long mult(long long a, long long b, long long p) {
a %= p;
b %= p;
long long r = 0, v = a;
while (b) {
if (b & 1) {
r += v;
if (r > p) r -= p;
}
v <<= 1;
if (v > p) v -= p;
b >>= 1;
}
return r;
}
long long quick_pow(long long a, long long b, long long p) {
long long r = 1, v = a % p;
while (b) {
if (b & 1) r = mult(r, v, p);
v = mult(v, v, p);
b >>= 1;
}
return r;
}
bool CH(long long a, long long n, long long x, long long t) {
long long r = quick_pow(a, x, n);
long long z = r;
for (long long i = 1; i <= t; i++) {
r = mult(r, r, n);
if (r == 1 && z != 1 && z != n - 1) return true;
z = r;
}
return r != 1;
}
bool Miller_Rabin(long long n) {
if (n < 2) return false;
if (n == 2) return true;
if (!(n & 1)) return false;
long long x = n - 1, t = 0;
while (!(x & 1)) {
x >>= 1;
t++;
}
srand(time(NULL));
long long o = 8;
for (long long i = 0; i < o; i++) {
long long a = rand() % (n - 1) + 1;
if (CH(a, n, x, t)) return false;
}
return true;
}
long long exgcd1(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long t = exgcd1(b, a % b, y, x);
y -= a / b * x;
return t;
}
long long get_inv(long long a, long long mod) {
long long x, y;
long long d = exgcd1(a, mod, x, y);
return d == 1 ? (x % mod + mod) % mod : -1;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - (a / b) * y;
}
long long INV(long long a, long long b) {
long long x, y;
return exgcd(a, b, x, y), (x % b + b) % b;
}
long long crt(long long x, long long p, long long mod) {
return INV(p / mod, mod) * (p / mod) * x;
}
long long FAC(long long x, long long a, long long b) {
if (!x) return 1;
long long ans = 1;
for (long long i = 1; i <= b; i++)
if (i % a) ans *= i, ans %= b;
ans = pow_mod(ans, x / b, b);
for (long long i = 1; i <= x % b; i++)
if (i % a) ans *= i, ans %= b;
return ans * FAC(x / a, a, b) % b;
}
long long C(long long n, long long m, long long a, long long b) {
long long N = FAC(n, a, b), M = FAC(m, a, b), Z = FAC(n - m, a, b), sum = 0,
i;
for (i = n; i; i = i / a) sum += i / a;
for (i = m; i; i = i / a) sum -= i / a;
for (i = n - m; i; i = i / a) sum -= i / a;
return N * pow_mod(a, sum, b) % b * INV(M, b) % b * INV(Z, b) % b;
}
long long exlucas(long long n, long long m, long long p) {
long long t = p, ans = 0, i;
for (i = 2; i * i <= p; i++) {
long long k = 1;
while (t % i == 0) {
k *= i, t /= i;
}
ans += crt(C(n, m, i, k), p, k), ans %= p;
}
if (t > 1) ans += crt(C(n, m, t, t), p, t), ans %= p;
return ans % p;
}
const long long N = 5e5 + 10;
struct Edge {
long long nex, to;
} edge[N << 1];
long long head[N], TOT;
void add_edge(long long u, long long v) {
edge[++TOT].nex = head[u];
edge[TOT].to = v;
head[u] = TOT;
}
long long n, a[N], cnt[N], vis[N];
long long s, c, ma, ans, pre[N], num[N];
void solve1(long long x) {
long long sum = n;
for (long long i = 1; i <= n; i++) pre[i] = pre[i + n] = inf;
pre[n] = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] == ma)
sum++;
else if (a[i] == x)
sum--;
ans = max(ans, i - pre[sum]);
pre[sum] = min(pre[sum], i);
}
}
void solve2(long long x) {
for (long long i = 1; i <= n; i++) num[i] = 0;
long long l = 1, res = 0;
num[a[l]]++;
if (num[a[l]] == x) res++;
for (long long i = 2; i <= n; i++) {
num[a[i]]++;
if (num[a[i]] == x)
res++;
else if (num[a[i]] > x) {
while (num[a[i]] > x && l <= i) {
num[a[l]]--;
if (num[a[l]] == x - 1) res--;
l++;
}
}
if (res >= 2) ans = max(ans, i - l + 1);
}
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
s = sqrt(n), c = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i], cnt[a[i]]++;
if (cnt[a[i]] > c) c = cnt[a[i]], ma = a[i];
}
for (long long i = 1; i <= n; i++)
if (cnt[a[i]] >= s && a[i] != ma && !vis[a[i]]) {
solve1(a[i]);
vis[a[i]] = 1;
}
for (long long i = 1; i <= s; i++) solve2(i);
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int coord[(int)2e5 + 5];
int c[(int)4e5 + 5];
int main() {
int n, m, s, d;
cin >> n >> m >> s >> d;
for (long long i = 0; i < n; ++i) scanf("%d", &coord[i]);
sort(coord, coord + n);
int curx = 0;
int cur_pos = 0;
int shift = 0;
int anspos = 0;
while (cur_pos < n) {
if (coord[cur_pos] - 1 - curx < s) {
cout << "IMPOSSIBLE";
return 0;
};
c[anspos++] = coord[cur_pos] - curx - 1;
curx = coord[cur_pos++] - 1;
while (cur_pos < n && coord[cur_pos] - coord[cur_pos - 1] - 2 < s)
++cur_pos;
--cur_pos;
if (coord[cur_pos] + 1 - curx > d) {
cout << "IMPOSSIBLE";
return 0;
};
c[anspos++] = coord[cur_pos] + 1 - curx;
curx = coord[cur_pos++] + 1;
}
if (curx < m) c[anspos++] = m - curx;
for (long long i = 0; i < anspos; ++i)
if (i % 2)
printf("JUMP %d\n", c[i]);
else
printf("RUN %d\n", c[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1010101];
int main() {
int i, j, k;
long long N;
long long D;
cin >> N >> D;
for (i = 0; i < N; ++i) cin >> arr[i];
int ind = 0;
int ind2 = 0;
long long res = 0;
for (i = 0; i < N; ++i) {
while (ind < N && arr[ind] - arr[i] <= D) ind++;
if (ind - i > 2) {
long long a = ind - i - 1;
res += (a * (a - 1)) / 2LL;
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int shift = 1 << 18;
int n, m;
long long t[2 * shift + 500];
long long add[2 * shift + 500];
long long pl(int l) {
if (l == 1) return add[1];
return add[l] + pl(l / 2);
}
void check(int q) {
if (q > 0) {
t[q] = min(t[2 * q] + add[2 * q], t[2 * q + 1] + add[2 * q + 1]);
check(q / 2);
}
}
long long minf(int l, int r) {
if (l > r) return 1LL << 60;
if (l % 2 == 1) return min(t[l] + pl(l), minf(l + 1, r));
if (r % 2 == 0) return min(t[r] + pl(r), minf(l, r - 1));
return minf(l / 2, r / 2);
}
void ad(int l, int r, long long sum) {
if (l > r) return;
if (l % 2 == 1) {
add[l] += sum;
check(l / 2);
l++;
ad(l, r, sum);
return;
}
if (r % 2 == 0) {
add[r] += sum;
check(r / 2);
r--;
ad(l, r, sum);
return;
}
ad(l / 2, r / 2, sum);
}
int main() {
cin >> n;
int i;
for (i = shift; i < n + shift; i++) cin >> t[i];
i = shift - 1;
while (i > 0) {
t[i] = min(t[2 * i], t[2 * i + 1]);
i--;
}
cin >> m;
for (i = 0; i < m; i++) {
int q, w;
long long e;
cin >> q >> w;
if (getchar() == ' ') {
cin >> e;
if (w >= q)
ad(q + shift, w + shift, e);
else {
ad(q + shift, shift + n - 1, e);
ad(shift, shift + w, e);
}
} else {
if (q <= w)
cout << minf(q + shift, w + shift) << endl;
else
cout << min(minf(q + shift, shift + n - 1), minf(shift, shift + w))
<< endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int block[maxn];
pair<int, int> G[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int cnt = 0, ans = 0;
for (int i = 0; i < k; i++) {
int t, a, begpos;
cin >> t >> a;
t--;
begpos = a;
if (!t) G[cnt++] = make_pair(begpos, a);
while (t--) {
int b;
scanf("%d", &b);
if (!t) {
if (a != b - 1) {
G[cnt++] = make_pair(begpos, a);
G[cnt++] = make_pair(b, b);
ans++;
} else
G[cnt++] = make_pair(begpos, b);
} else if (a != b - 1) {
G[cnt++] = make_pair(begpos, a);
begpos = b;
ans++;
}
a = b;
}
}
sort(G, G + cnt);
for (int i = 0; i < cnt - 1; i++) {
if (G[i].second + 1 != G[i + 1].second)
ans += (G[i + 1].second - G[i + 1].first) * 2 + 1;
else
ans++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int Power(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) {
res = (res * a) % 998244353ll;
}
a = (a * a) % 998244353ll;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int p[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> p[i];
}
long long int num = 1;
long long int cur = 1;
long long int cur10 = 1;
for (long long int i = 1; i <= n - 1; i++) {
cur = (cur * p[i]) % 998244353ll;
cur10 = (cur10 * (long long int)100) % 998244353ll;
long long int x = cur * Power(cur10, 998244353ll - 2);
num = (num + x) % 998244353ll;
}
long long int den = (cur * p[n]) % 998244353ll;
cur10 = (cur10 * (long long int)100) % 998244353ll;
den = Power(den, 998244353ll - 2);
num = (num * den) % 998244353ll;
num = (num * cur10) % 998244353ll;
cout << num << "\n";
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n = 0, k = 0, i = 0, j = 0, min = 1000000, t, sum = 0, max = -1, s = 0;
int arr[10000] = {0}, arr2[10000] = {0}, ans[10000] = {0}, arr3[10000] = {0};
scanf("%d %d", &n, &k);
for (i = 0; i <= n - 1; i++) {
scanf("%d", &arr[i]);
}
for (i = 0; i <= n - 1; i++) {
arr2[i] = arr[i];
}
for (i = 0; i <= n - 1; i++) {
for (j = 0; j <= n - 1; j++) {
if (arr[j] < min) min = arr[j], t = j;
}
ans[i] = min;
arr[t] = 100000;
min = 10000;
}
sum = 0;
for (i = 0; i <= n - 1; i++) {
if (sum + ans[i] > k) {
break;
}
sum += ans[i];
s++;
for (j = 0; j <= n - 1; j++) {
if (ans[i] == arr2[j]) {
arr3[s] = j + 1;
arr2[j] = max--;
break;
}
}
}
printf("%d\n", s);
for (i = 1; i <= s; i++) {
printf("%d ", arr3[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int f[100005] = {0};
int a[100005];
int store[100005];
int cnt[100005] = {0};
int n, i, j, nn;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &nn);
a[i] = nn;
f[nn]++;
}
j = 1;
int k;
for (i = 1; i <= n; i++) {
if (f[i] == 0) store[j++] = i;
}
for (i = 1; i <= n; i++) {
if (cnt[a[i]] == 1) {
a[i] = 0;
} else if (a[i] > n)
a[i] = 0;
else
cnt[a[i]]++;
}
j = 1;
for (i = 1; i <= n; i++) {
if (a[i] == 0) {
a[i] = store[j++];
}
}
for (i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d", a[n]);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x = -1e18, y = 1e18;
cin >> n;
while (n--) {
string a, b;
long long f;
cin >> a >> f >> b;
if (b == "N") {
if (a == ">")
a = "<=";
else {
if (a == "<")
a = ">=";
else {
if (a == ">=")
a = "<";
else if (a == "<=")
a = ">";
}
}
}
if (a == ">=") x = max(x, f);
if (a == ">") x = max(x, f + 1);
if (a == "<") y = min(y, f - 1);
if (a == "<=") y = min(y, f);
}
if (y < x)
cout << "Impossible";
else {
if (x > 0 && y > 0)
cout << x;
else {
if (y < 0 && x < 0)
cout << y;
else
cout << 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
const long long inf = 1000000000ll;
const long long inf64 = inf * inf;
const long long base = inf + 7;
const long long MOD = inf + 9;
const double pi = acos(-1.0);
using namespace std;
template <typename T, typename P>
const ostream& operator<<(ostream& os, const pair<T, P>& a) {
os.precision(10);
os << fixed;
os << a.first;
os << ' ';
os << a.second;
os << ' ';
return os;
}
bool solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i(0); i < n; i++) {
scanf("%d", &a[i]);
}
int all = 0;
for (int i(0); i < n; i++) {
for (int j(i + 1); j < n; j++) {
if (a[i] > a[j]) {
all++;
}
}
}
vector<vector<int> > dp(n, vector<int>(n, 0)), dp2 = dp;
for (int i(1); i < n; i++) {
for (int j(0); j < n; j++) {
dp[i][j] = dp[i - 1][j] + (a[i] > j);
}
}
for (int i(n - 2); i >= 0; i--) {
for (int j(0); j < n; j++) {
dp2[i][j] = dp2[i + 1][j] + (j > a[i]);
}
}
int ans = inf, ans2 = 0;
for (int i(0); i < n; i++) {
for (int j(i + 1); j < n; j++) {
int until, after, x = a[i], y = a[j];
until = after = 0;
if (i + 1 <= j - 1) {
until = dp2[i + 1][x] - dp2[j][x] + dp[j - 1][y] - dp[i][y];
after = dp2[i + 1][y] - dp2[j][y] + dp[j - 1][x] - dp[i][x];
}
until += (a[i] > a[j]);
after += (a[i] < a[j]);
int tmp = all - until + after;
if (tmp < ans) {
ans = tmp;
ans2 = 1;
} else if (tmp == ans) {
ans2++;
}
}
}
cout << ans << ' ' << ans2 << '\n';
return true;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
long long mod = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
vector<long long> arr(n);
long long low = 0, high = 10;
long long ans = -1;
long long t = 240 - m;
while (low <= high) {
long long mid = low + (high - low) / 2;
long long time = 5 * mid * (mid + 1) / 2;
if (time <= t) {
low = mid + 1;
ans = mid;
} else
high = mid - 1;
}
cout << min(n, ans) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int readInt() {
char c;
int tmp = 0, x = 1;
c = getchar();
while (c > '9' || c < '0') {
if (c == '-') x = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp * x;
}
const int maxn = (int)1e5 + 5;
int n, m, seed, vmax, a[maxn], ret;
int rnd() {
ret = seed;
seed = ((long long)seed * 7 + 13) % 1000000007;
return ret;
}
struct node {
int l, r;
mutable long long val;
bool operator<(const node& oth) const { return l < oth.l; }
node(int l = 0, int r = 0, long long val = 0) : l(l), r(r), val(val) {}
};
set<node> intev;
void split(int pos) {
set<node>::iterator ite = intev.lower_bound(node(pos, -1, -1));
if (ite == intev.end() || ite->l > pos) {
--ite;
int L = ite->l, R = ite->r;
long long val = ite->val;
intev.erase(ite);
intev.insert(node(L, pos - 1, val));
intev.insert(node(pos, R, val));
}
}
long long quickpow(long long x, int k, long long mo) {
long long ret = 1;
while (k > 0) {
if (k & 1) ret = (ret * x) % mo;
x = x * x % mo;
k >>= 1;
}
return ret;
}
vector<pair<long long, int> > par;
int main() {
n = readInt(), m = readInt(), seed = readInt(), vmax = readInt();
for (int i = 1; i <= n; i++) {
a[i] = rnd() % vmax + 1;
intev.insert(node(i, i, 1ll * a[i]));
}
int op, l, r, x, y;
for (int i = 1; i <= m; i++) {
op = (rnd() % 4) + 1, l = rnd() % n + 1, r = rnd() % n + 1;
if (l > r) swap(l, r);
if (op == 3)
x = rnd() % (r - l + 1) + 1;
else
x = rnd() % vmax + 1;
if (op == 4) y = (rnd() % vmax) + 1;
split(l);
if (r <= n - 1) split(r + 1);
set<node>::iterator iteL = intev.lower_bound(node(l, -1, -1));
set<node>::iterator iteR = intev.upper_bound(node(r, -1, -1));
if (op == 1) {
for (set<node>::iterator ite = iteL; ite != iteR; ++ite) ite->val += x;
} else if (op == 2) {
set<node>::iterator iteRp = iteR;
iteRp--;
int ALLl = iteL->l, ALLr = iteRp->r;
intev.erase(iteL, iteR);
intev.insert(node(ALLl, ALLr, x));
} else if (op == 3) {
par.clear();
for (set<node>::iterator ite = iteL; ite != iteR; ++ite)
par.push_back(make_pair(ite->val, ite->r - ite->l + 1));
sort(par.begin(), par.end());
for (int i = 0; i < (int)par.size(); i++) {
x -= par[i].second;
if (x <= 0) {
printf("%lld\n", par[i].first);
break;
}
}
assert(x <= 0);
} else if (op == 4) {
long long ans = 0;
for (set<node>::iterator ite = iteL; ite != iteR; ++ite) {
long long valu = quickpow(ite->val % (1ll * y), x, y) % y;
valu = valu * (ite->r - ite->l + 1) % y;
ans = (ans + valu) % y;
}
printf("%lld\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
long long int n, arr[101];
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
}
long long int count = 0, ans = 0;
while (count < n) {
long long int j;
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (arr[i] >= 0) {
j = i;
break;
}
}
long long int temp = 0;
while (j < n) {
if (arr[j] >= temp) {
arr[j] = -1;
temp++;
count++;
}
j++;
}
ans++;
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a[105];
int i = 0;
a[1] = 1;
a[2] = 2;
a[3] = 4;
for (i = 4; i <= 100; i++) {
a[i] = i + a[i - 2];
}
int n;
scanf("%d", &n);
printf("%d", a[n]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
int n, k, c[N], s, id[N], ss;
bool cp[N];
long long ans = 0, w;
int main() {
int i, x;
long long q;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; ++i) scanf("%d", &c[i]), s += c[i];
for (i = 2; i <= n; ++i) ans += c[i] * c[i - 1];
ans += c[1] * c[n];
for (i = 1; i <= k; ++i)
scanf("%d", &id[i]), ss += c[id[i]], cp[id[i]] = true;
s -= ss;
for (i = 1; i <= k; ++i) {
q = (long long)s;
if (!cp[(id[i] + 1 == n + 1 ? 1 : id[i] + 1)])
q -= c[(id[i] + 1 == n + 1 ? 1 : id[i] + 1)];
if (!cp[(id[i] - 1 == 0 ? n : id[i] - 1)])
q -= c[(id[i] - 1 == 0 ? n : id[i] - 1)];
ans += q * c[id[i]];
}
for (i = 1; i <= k; ++i) {
q = (long long)ss;
if (cp[(id[i] + 1 == n + 1 ? 1 : id[i] + 1)])
q -= c[(id[i] + 1 == n + 1 ? 1 : id[i] + 1)];
if (cp[(id[i] - 1 == 0 ? n : id[i] - 1)])
q -= c[(id[i] - 1 == 0 ? n : id[i] - 1)];
w += (q - c[id[i]]) * c[id[i]];
}
cout << ans + w / 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[10000001];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int max = -99999;
int k;
for (int j = 1; j <= n; j++) {
int x;
cin >> x;
if (x > max) {
max = x;
k = j;
}
}
a[k]++;
}
int ans;
int max = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > max) {
max = a[i];
ans = i;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[200010];
long long func(int N, int two, long long M) {
int i;
long long ans = 1;
two = -two;
for (i = 1; i <= N; i++) {
int x = i;
while (x % 2 == 0) {
x /= 2;
two++;
}
ans = ans * x % M;
}
for ((i) = 0; (i) < (int)(two); (i)++) ans = ans * 2 % M;
return ans;
}
int main(void) {
int N, x, i, j, k;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) {
scanf("%d", &x);
p[i] = make_pair(x, i);
}
for ((i) = 0; (i) < (int)(N); (i)++) {
scanf("%d", &x);
p[N + i] = make_pair(x, i);
}
N *= 2;
sort(p, p + N);
long long M;
cin >> M;
long long ans = 1;
i = 0;
while (i < N) {
for (j = i; j < N; j++)
if (p[j].first != p[i].first) break;
int two = 0;
for (k = i + 1; k < j; k++)
if (p[k].second == p[k - 1].second) two++;
long long tmp = func(j - i, two, M);
ans = ans * tmp % M;
i = j;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, a = "hello";
int cur = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (a[cur] == s[i]) cur++;
}
cout << (cur == a.length() ? "YES" : "NO") << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
return y == 0 ? x : gcd(y, x % y);
}
int main() {
long long int a;
cin >> a;
if (a > 2) {
if (a * a % 2)
cout << (a * a - 1) / 2 << ' ' << (a * a + 1) / 2;
else
cout << (a * a / 2 - 2) / 2 << ' ' << (a * a / 2 + 2) / 2;
} else {
cout << -1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
int main(void) {
int T, S, q, ans;
scanf("%d%d%d", &T, &S, &q);
ans = 0;
while (S < T) {
S *= q;
ans = ans + 1;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e18;
int main() {
long long sum = 0, x = 1, a;
scanf("%lld", &a);
for (int i = 0; i < 18; i++) {
sum = ((sum % a * 10 % a) % a + (45 % a * x % a) % a) % a;
x = (x % a * 10 % a) % a;
}
printf("%lld %lld\n", a - sum, maxn + a - sum - 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,tune=native")
#pragma GCC target("avx,avx2")
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> cntmi(n + 10, 0), cntma(n + 10, 0), cnt(n + 10, 0);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
cnt[x]++;
}
int ansmi = 1e9, ansma = 0;
for (int len = 0; len <= 2; ++len) {
cntmi.assign(n + 10, 0);
int ansex = 0;
for (int i = 1; i <= len; ++i) {
cntmi[2] += cnt[i];
}
for (int i = len + 1; i <= n; i++) {
if (cnt[i] == 0) continue;
cntmi[i + 1] = cnt[i] + cnt[i + 1] + cnt[i + 2];
i += 2;
}
for (auto x : cntmi) {
if (x > 0) ansex++;
}
ansmi = min(ansex, ansmi);
}
for (int i = 0; i <= n + 1; ++i) {
if (i > 0 && cnt[i - 1] > 0) {
cnt[i - 1]--;
cntma[i]++;
} else if (cnt[i] > 0) {
cnt[i]--;
cntma[i]++;
} else if (i < n + 1 && cnt[i + 1] > 0) {
cnt[i + 1]--;
cntma[i]++;
}
}
for (auto x : cntma)
if (x > 0) ansma++;
cout << ansmi << ' ' << ansma;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long l, cnt, num, val;
node *go[26], *link;
} sa[400005], *root, *last;
long long sz = 0, k;
bool vis[400005];
vector<vector<long long>> states_with_len(100005);
void extend(long long x) {
sz++;
node *cur = &sa[sz];
cur->l = (last->l + 1);
cur->cnt = 1;
cur->num = sz;
cur->val = 0;
node *p = last;
while (p && !p->go[x]) {
p->go[x] = cur;
p = p->link;
}
if (!p) {
cur->link = root;
} else {
node *q = p->go[x];
if (q->l == (p->l + 1)) {
cur->link = q;
} else {
sz++;
node *clone = &sa[sz];
for (long long i = 0; i < 26; i++) {
if (q->go[i]) clone->go[i] = q->go[i];
}
clone->link = q->link;
clone->l = (p->l + 1);
clone->cnt = 0;
clone->val = 0;
clone->num = sz;
cur->link = clone;
q->link = clone;
while (p && p->go[x] == q) {
p->go[x] = clone;
p = p->link;
}
}
}
last = cur;
}
void dfs(node *x) {
if (vis[x->num]) return;
vis[x->num] = true;
x->val = x->cnt;
for (long long i = 0; i < 26; i++) {
if (x->go[i]) {
dfs(x->go[i]);
x->val += x->go[i]->val;
}
}
}
void compute(node *x) {
if (k <= x->cnt) return;
k -= x->cnt;
for (long long i = 0; i < 26; i++) {
if (x->go[i]) {
if (k <= x->go[i]->val) {
printf("%c", char(i + 'a'));
compute(x->go[i]);
break;
}
k -= x->go[i]->val;
}
}
}
signed main() {
memset(vis, false, sizeof(false));
last = root = &sa[0];
char st[100005];
scanf("%s", st);
scanf("%lld", &k);
long long len = strlen(st);
if (k > len * (len + 1) / 2) {
printf("No such line.\n");
return 0;
}
k = k + len;
for (long long i = 0; i < len; i++) extend(st[i] - 'a');
for (long long i = 0; i <= sz; i++)
states_with_len[sa[i].l].push_back(sa[i].num);
for (long long i = len; i > 0; i--) {
for (auto it : states_with_len[i]) sa[sa[it].link->num].cnt += sa[it].cnt;
}
dfs(root);
compute(root);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
while (~scanf("%d %d", &n, &m)) {
int ae = 0, ao = 0, be = 0, bo = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (a & 1)
ao++;
else
ae++;
}
for (int i = 0; i < m; i++) {
scanf("%d", &b);
if (b & 1)
bo++;
else
be++;
}
printf("%d\n", min(ae, bo) + min(ao, be));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, K, y, x = -1;
char str[10];
int f(int lo, int hi) {
if (lo > hi) return -1;
if (lo == hi) {
if (lo > 1) {
printf("1 %d %d\n", lo, lo - 1);
fflush(stdout);
scanf("%s", str);
if (str[0] == 'N') return -1;
}
if (lo < N) {
printf("1 %d %d\n", lo, lo + 1);
fflush(stdout);
scanf("%s", str);
if (str[0] == 'N') return -1;
}
return lo;
}
int med1 = (lo + hi) / 2;
int med2 = (lo + hi) / 2 + 1;
printf("1 %d %d\n", med1, med2);
fflush(stdout);
scanf("%s", str);
if (str[0] == 'T')
return f(lo, med1);
else
return f(med2, hi);
}
int main() {
scanf("%d", &N), scanf("%d", &K);
x = f(1, N);
y = max(f(1, x - 1), f(x + 1, N));
printf("2 %d %d\n", x, y);
fflush(stdout);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using vi = vector<int>;
mt19937 mrand(time(0));
ll get(ll r) { return ((ll)mrand() * mrand() % r + r) % r; }
ll get(ll l, ll r) { return get(r - l + 1) + l; }
const ll P = 1e9 + 7;
ll n, m, t, B, ans, dis[100100], vis[100100], st[100100], head[100100], tot,
d[70];
struct Edge {
ll to, nxt, w;
} e[400100];
void addEdge(ll x, ll y, ll w) {
e[++tot] = (Edge){y, head[x], w}, head[x] = tot;
e[++tot] = (Edge){x, head[y], w}, head[y] = tot;
}
void ins(ll x) {
for (ll i = 59; ~i; i--)
if (x >> i & 1) {
if (d[i])
x ^= d[i];
else {
d[i] = x, B++;
break;
}
}
}
void dfs(ll x, ll nw) {
dis[x] = nw, vis[x] = 1, st[++t] = x;
for (ll i = head[x]; i; i = e[i].nxt)
if (!vis[e[i].to])
dfs(e[i].to, nw ^ e[i].w);
else
ins(nw ^ e[i].w ^ dis[e[i].to]);
}
signed main() {
scanf("%lld %lld", &n, &m);
for (ll i = 1, x, y, w; i <= m; i++)
scanf("%lld %lld %lld", &x, &y, &w), addEdge(x, y, w);
for (ll i = 1; i <= n; i++)
if (!vis[i]) {
memset(d, 0, sizeof(d)), B = t = 0, dfs(i, 0);
for (ll j = 0; j < 60; j++) {
ll bo = 0, tmp = (1ll << j) % P;
for (ll k = 0; k < 60; k++) bo |= d[k] >> j & 1;
if (bo)
(ans += t * (t - 1) / 2 % P * ((1ll << B - 1) % P) % P * tmp) %= P;
else {
ll x = 0;
for (ll k = 1; k <= t; k++) x += dis[st[k]] >> j & 1;
(ans += x * (t - x) % P * ((1ll << B) % P) % P * tmp) %= P;
}
}
}
printf("%lld\n", ans);
fprintf(stderr, "time=%.4f\n", (db)clock() / CLOCKS_PER_SEC);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
bool isPrime(long long int x) {
for (long long int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
int main() {
int x;
scanf("%d", &x);
if (x % 2 == 0 and x >= 4)
cout << 2 << endl;
else if (x % 2 == 0 and x < 4)
cout << 1 << endl;
else {
if (isPrime(x))
cout << 1 << endl;
else if (isPrime(x - 2))
cout << 2 << endl;
else
cout << 3 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int arr[105][105];
int pos[105][105];
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
pos[i][j] = 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 0) {
for (int k = 0; k < n; k++) {
pos[k][j] = 0;
}
for (int k = 0; k < m; k++) {
pos[i][k] = 0;
}
}
}
}
bool result = true;
bool able = false;
;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
able = false;
if (arr[i][j] == 1) {
bool ableH = false;
for (int k = 0; k < n; k++) {
if (pos[k][j] == 1) {
ableH = true;
break;
}
}
bool ableV = false;
for (int k = 0; k < m; k++) {
if (pos[i][k] == 1) {
ableV = true;
break;
}
}
able = ableH || ableV;
if (!able) {
result = false;
break;
}
}
}
}
if (result) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << pos[i][j];
if (j != m - 1) {
cout << " ";
}
}
cout << endl;
}
} else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int modExp(long long int b, long long int p) {
long long int res = 1;
while (p > 0) {
if (p & 1) {
res = (res * b) % 1000000007;
}
b = (b * b) % 1000000007;
p >>= 1;
}
return res;
}
long long int properdiv(long long int x, long long int y) {
if (x % y == 0)
return x / y;
else
return x / y + 1;
}
long long int mdls(long long int x) { return max(x, -x); }
int main() {
long long int i;
int flag = 1;
string s;
cin >> s;
long long int l = s.length();
if (s[l - 1] != 'a' && s[l - 1] != 'u' && s[l - 1] != 'o' &&
s[l - 1] != 'i' && s[l - 1] != 'e' && s[l - 1] != 'n')
flag = 0;
for (i = 0; i < l - 1; i++) {
if (s[i] != 'a' && s[i] != 'u' && s[i] != 'o' && s[i] != 'i' &&
s[i] != 'e' && s[i] != 'n') {
if (s[i + 1] != 'a' && s[i + 1] != 'u' && s[i + 1] != 'o' &&
s[i + 1] != 'i' && s[i + 1] != 'e') {
flag = 0;
break;
}
}
}
if (flag == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x[3000], y[3000], cnt;
char s[50][50];
bool check(int x, int a1, int b1, int y, int a2, int b2) {
for (int i = min(a1, b1); i <= max(a1, b1); i++)
if (s[x][i] != 'B') return 0;
for (int i = min(a2, b2); i <= max(a2, b2); i++)
if (s[i][y] != 'B') return 0;
return 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++)
if (s[i][j] == 'B') x[++cnt] = i, y[cnt] = j;
}
for (int i = 1; i < cnt; i++)
for (int j = i + 1; j <= cnt; j++) {
if (check(x[i], y[i], y[j], y[j], x[i], x[j])) continue;
if (check(x[j], y[i], y[j], y[i], x[i], x[j])) continue;
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%d", &n);
getchar();
char paper[n][n];
for (int i = 0; i < n; i++) {
scanf("%s", &paper[i]);
getchar();
}
char ch = paper[0][0], other = paper[0][1];
int flag = 1;
if (ch != other) {
flag = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if ((i == j) || ((i + j) == (n - 1))) {
if (paper[i][j] != ch) {
flag++;
break;
}
} else {
if (paper[i][j] != other) {
flag++;
break;
}
}
}
}
if (flag != 0)
printf("NO");
else
printf("YES");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int ar[300000], cum[300000], suf[300000];
int pos[300000];
int main() {
int n, i, k, a, b;
long long int ans = -1;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> ar[i];
for (i = 1; i <= n; i++) suf[i] = -1;
for (i = n; i >= 1; i--) {
cum[i] = cum[i + 1] + ar[i];
}
for (i = n; i >= 1; i--) {
if (i + k - 1 > n) {
} else {
if (cum[i] - cum[i + k] >= suf[i + 1]) {
pos[i] = i;
suf[i] = max(cum[i] - cum[i + k], suf[i + 1]);
} else {
pos[i] = pos[i + 1];
suf[i] = max(cum[i] - cum[i + k], suf[i + 1]);
}
}
}
for (i = 1; i <= n; i++) {
if (i + k - 1 > n) break;
if (cum[i] - cum[i + k] + suf[i + k] > ans) {
ans = max(ans, cum[i] - cum[i + k] + suf[i + k]);
a = i;
b = pos[i + k];
}
}
cout << a << " " << b << endl;
}
| 3 |
#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 <int N_MAX>
struct gaussian_binary {
int n;
vector<bitset<N_MAX>> coefficients;
vector<bool> values;
bool solve_called = false;
gaussian_binary(int _n = 0) { init(_n); }
void init(int _n) {
n = _n;
coefficients = {};
values = {};
}
void print() const {
cerr << n << " vars, " << coefficients.size() << " equations" << '\n';
for (int i = 0; i < (int)coefficients.size(); i++) {
string coefs = coefficients[i].to_string().substr(N_MAX - n);
reverse(coefs.begin(), coefs.end());
cerr << coefs << ": " << values[i] << '\n';
}
}
template <typename T_coefs>
void add_equation(const T_coefs &coefs, bool value) {
assert((int)coefs.size() >= n);
bitset<N_MAX> b_coefs;
for (int i = 0; i < n; i++) b_coefs[i] = coefs[i];
coefficients.push_back(b_coefs);
values.push_back(value);
}
void swap_rows(int a, int b) {
swap(coefficients[a], coefficients[b]);
swap(values[a], values[b]);
}
void eliminate(int target, int source, int col) {
if (coefficients[target][col] == 0) return;
assert(coefficients[source][col] != 0);
coefficients[target] ^= coefficients[source];
values[target] = values[target] ^ values[source];
}
bitset<N_MAX> solve() {
solve_called = true;
int rows = coefficients.size();
for (int i = 0, cur_row = 0; i < n; i++) {
int on_row = -1;
for (int row = cur_row; row < rows; row++)
if (coefficients[row][i] != 0) {
on_row = row;
break;
}
if (on_row >= 0) {
swap_rows(on_row, cur_row);
for (int row = cur_row + 1; row < rows; row++)
eliminate(row, cur_row, i);
cur_row++;
}
}
bitset<N_MAX> answers;
for (int row = rows - 1; row >= 0; row--) {
int col = -1;
for (int i = 0; i < n; i++)
if (coefficients[row][i]) {
col = i;
break;
}
if (col < 0) {
if (values[row]) return {};
continue;
}
answers[col] = values[row] ^ ((coefficients[row] & answers).count() % 2);
}
for (int row = 0; row < rows; row++) {
bool value = (coefficients[row] & answers).count() % 2;
assert(value == values[row]);
}
return answers;
}
int rank() const {
assert(solve_called);
int count = 0;
for (int i = 0; i < (int)coefficients.size(); i++) {
if (values[i] && coefficients[i].none()) return -1;
count += coefficients[i].any();
}
return count;
}
bool invalid() const { return rank() < 0; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
static const int VAR_MAX = 2005;
auto &&color_to_index = [](char color) {
switch (color) {
case 'W':
return 0;
case 'R':
return 1;
case 'Y':
return 2;
case 'B':
return 3;
default:
assert(false);
}
};
auto &&index_to_color = [](int index) {
switch (index) {
case 0:
return '.';
case 1:
return 'R';
case 2:
return 'Y';
case 3:
return 'B';
default:
assert(false);
}
};
int N, K;
cin >> N >> K;
gaussian_binary<VAR_MAX> solver(2 * N);
vector<array<bitset<2>, 2>> vars(N);
for (int i = 0; i < N; i++) vars[i][0][0] = vars[i][1][1] = 1;
for (int t = 0; t < K; t++) {
string op;
int m;
vector<int> indices;
cin >> op >> m;
for (int i = 0; i < m; i++) {
int index;
cin >> index;
index--;
indices.push_back(index);
}
if (op == "mix") {
char result;
cin >> result;
int result_index = color_to_index(result);
for (int x = 0; x < 2; x++) {
bitset<VAR_MAX> coefs;
for (int index : indices) {
coefs[2 * index] = vars[index][x][0];
coefs[2 * index + 1] = vars[index][x][1];
}
solver.add_equation(coefs, result_index >> x & 1);
}
} else {
if (op == "RB") {
for (int x : indices) vars[x][1] ^= vars[x][0];
} else if (op == "YB") {
for (int x : indices) vars[x][0] ^= vars[x][1];
} else if (op == "RY") {
for (int x : indices) swap(vars[x][0], vars[x][1]);
} else {
assert(false);
}
}
}
bitset<VAR_MAX> answers = solver.solve();
if (solver.invalid()) {
cout << "NO" << '\n';
return 0;
}
cout << "YES" << '\n';
for (int i = 0; i < N; i++) {
int value = answers[2 * i] + 2 * answers[2 * i + 1];
cout << index_to_color(value);
}
cout << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, a[105];
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
for (int k = 1; k <= n; ++k) {
int ok = true;
for (int i = 0; i < n; ++i)
if (a[i] < i / k) ok = false;
if (ok) {
cout << k;
return 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1010][1010];
bool got[1010][1010];
bool ok(int x) {
memset(got, 0, sizeof(got));
for (int j = 0; j < m; j++) {
vector<int> vt;
for (int i = 0; i < n; i++)
if (a[i][j] >= x) vt.push_back(i);
for (int o = 0; o < vt.size(); o++)
for (int p = o + 1; p < vt.size(); p++)
if (got[vt[o]][vt[p]])
return true;
else
got[vt[o]][vt[p]] = true;
}
return false;
}
int t[1000010];
int main() {
int cnt = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
t[cnt++] = a[i][j];
}
sort(t, t + n * m);
int l = 0, r = unique(t, t + n * m) - t - 1;
while (l < r) {
int m = (l + r + 1) >> 1;
if (ok(t[m]))
l = m;
else
r = m - 1;
}
printf("%d\n", t[l]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int a = 0;
int ans = 0;
bool car = 0;
for (int i = s.size() - 1; i >= 0; --i) {
int x = s[i] - '0';
if (x == 9 and !car)
ans += 9, car = 0;
else
ans += (x + 10 - int(car)), car = 1;
}
if (car) ans -= 10;
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, fl, idx;
string s;
cin >> n >> t;
cin >> s;
idx = s.size() - 1, fl = 0;
for (int i = int(0); i <= int(s.size() - 1); i++) {
if (s[i] == '.') {
fl = 1;
continue;
}
if (fl && s[i] >= '5') {
idx = i;
break;
}
}
int mrk = s.size() - 1;
fl = 0;
while (t-- && s[idx] >= '5') {
if (s[idx - 1] == '.') {
fl = 2;
if (s[idx - 2] == '9')
s[idx - 2] = '0';
else
s[idx - 2]++;
int j = idx - 2;
mrk = idx - 2;
while (s[j] == '0') {
if (!j) {
fl = 1;
break;
} else
s[j - 1] = (s[j - 1] == '9' ? '0' : s[j - 1] + 1);
--j;
}
break;
}
s[idx - 1]++;
idx--;
mrk = idx;
}
if (fl == 1) cout << 1;
for (int i = int(0); i <= int(mrk); i++) cout << s[i];
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || a.first == b.first && a.second <= b.second);
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
const long long int maxN = 400000L;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<long long int> a, e[maxN + 5], b;
long long int tin[maxN + 5], tout[maxN + 5];
long long int f[4 * maxN + 5], lazy[4 * maxN + 5];
void dfs(long long int u, long long int p) {
tin[u] = ++T;
b.push_back(1LL << a[u]);
for (auto x : e[u]) {
if (x == p) continue;
dfs(x, u);
}
tout[u] = T;
}
void build(long long int id, long long int l, long long int r) {
long long int i;
for (i = (l); i <= (r); ++i) f[id] |= b[i];
if (l == r) return;
long long int m = (l + r) / 2;
build(2 * id, l, m);
build(2 * id + 1, m + 1, r);
}
void shift(long long int id) {
if (!lazy[id]) return;
f[2 * id] = f[2 * id + 1] = lazy[2 * id] = lazy[2 * id + 1] = lazy[id];
lazy[id] = 0;
}
void update(long long int id, long long int l, long long int r, long long int L,
long long int R, long long int x) {
if (r < L || R < l) return;
if (L <= l && r <= R) {
f[id] = x;
lazy[id] = x;
return;
}
long long int m = (l + r) / 2;
shift(id);
update(2 * id, l, m, L, R, x);
update(2 * id + 1, m + 1, r, L, R, x);
f[id] = f[2 * id] | f[2 * id + 1];
}
long long int query(long long int id, long long int l, long long int r,
long long int L, long long int R) {
if (r < L || R < l) return 0;
if (L <= l && r <= R) return f[id];
long long int m = (l + r) / 2;
shift(id);
return query(2 * id, l, m, L, R) | query(2 * id + 1, m + 1, r, L, R);
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> n >> m;
a.clear();
a.reserve(n + 1);
a.push_back(0);
b.push_back(0);
for (i = 0; i < (n); ++i) {
cin >> in;
a.push_back(in);
}
for (i = 0; i < (n - 1); ++i) {
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 1);
build(1, 1, n);
while (m--) {
cin >> T >> u;
if (T == 1) {
cin >> x;
x = (1LL << x);
update(1, 1, n, tin[u], tout[u], x);
} else {
cout << __builtin_popcountll(query(1, 1, n, tin[u], tout[u])) << "\n";
}
}
}
aryanc403();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int MAXN = 1000000 + 100;
const int INF = 0x6fffffff;
const int inf = 522133279;
const long long LLinf = 1e30;
int person[1000];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
person[a] += w;
person[b] -= w;
}
long long cnt = 0;
for (int i = 0; i <= n; i++)
if (person[i] < 0) cnt += -person[i];
cout << cnt << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-9;
const int maxn = 3e5 + 5;
int fa[maxn];
int findfa(int x) {
int y = x;
while (fa[x] != x) x = fa[x];
while (fa[y] != x) {
int z = fa[y];
fa[y] = x;
y = z;
}
return x;
}
vector<int> a, b, c, d;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n + 1; i++) fa[i] = i;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
int fu = findfa(u), fv = findfa(v);
if (fu == fv) {
a.push_back(u);
b.push_back(v);
} else {
int f = min(fu, fv);
fa[fu] = f, fa[fv] = f;
}
}
int cnt = 0;
for (int i = 1; i < n + 1; i++) {
int first = findfa(i);
if (first == 1) continue;
c.push_back(1), d.push_back(i);
fa[first] = 1;
++cnt;
}
printf("%d\n", (cnt));
for (int i = 0; i < cnt; i++) printf("%d %d %d %d\n", a[i], b[i], c[i], d[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s[6];
string v[3], g[3];
int i[6];
vector<string> ans;
bool ok() {
bool d = true;
for (int j = 0; j < 6; j++)
for (int l = j + 1; l < 6; l++)
if (i[l] == i[j]) d = false;
return d;
}
void print() {
for (int i = 0; i < v[1].length(); ans[ans.size() - 1] += ("\n"), i++) {
if (i == 0) {
ans[ans.size() - 1] += g[0];
for (int j = 0; j < g[1].length() - g[0].length(); j++)
ans[ans.size() - 1] += (".");
continue;
}
if (i == v[1].length() - 1) {
for (int j = 0; j < g[1].length() - g[2].length(); j++)
ans[ans.size() - 1] += (".");
ans[ans.size() - 1] += g[2];
continue;
}
if (i == v[0].length() - 1) {
ans[ans.size() - 1] += g[1];
continue;
}
if (i < v[0].length()) {
ans[ans.size() - 1] += (v[0][i]);
for (int j = 1; j < g[1].length(); j++)
if (j == g[0].length() - 1)
ans[ans.size() - 1] += (v[1][i]);
else
ans[ans.size() - 1] += (".");
} else {
for (int j = 0; j < g[1].length() - 1; j++)
if (j == g[0].length() - 1)
ans[ans.size() - 1] += (v[1][i]);
else
ans[ans.size() - 1] += (".");
ans[ans.size() - 1] += (v[2][i - v[0].length() + 1]);
}
}
}
int main() {
for (int i = 0; i < 6; i++) cin >> s[i];
sort(s, s + 6);
for (i[3] = 0; i[3] < 6; i[3]++)
for (i[4] = 0; i[4] < 6; i[4]++)
for (i[5] = 0; i[5] < 6; i[5]++)
for (i[0] = 0; i[0] < 6; i[0]++)
for (i[1] = 0; i[1] < 6; i[1]++)
for (i[2] = 0; i[2] < 6; i[2]++)
if (ok()) {
for (int j = 0; j < 3; j++) v[j] = s[i[j]];
for (int j = 0; j < 3; j++) g[j] = s[i[j + 3]];
bool d = true;
if (v[0].length() + v[2].length() - 1 != v[1].length())
d = false;
if (g[0].length() + g[2].length() - 1 != g[1].length())
d = false;
if (v[0][0] != g[0][0] ||
v[2][v[2].length() - 1] != g[2][g[2].length() - 1])
d = false;
if (v[0][v[0].length() - 1] != g[1][0] ||
g[0][g[0].length() - 1] != v[1][0])
d = false;
if (v[1][v[1].length() - 1] != g[2][0] ||
g[1][g[1].length() - 1] != v[2][0])
d = false;
if (d && g[1][g[0].length() - 1] != v[1][v[0].length() - 1])
d = false;
if (d) {
ans.push_back("");
print();
}
}
if (!ans.empty()) {
sort(ans.begin(), ans.end());
cout << ans[0];
} else
cout << "Impossible";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 0; i <= 100; ++i)
for (int j = 0; j <= 100; ++j) {
if (i * i + j == n && i + j * j == m) cnt++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const int MAXN = 1e5 + 5;
int N, M;
int A[MAXN];
int C[MAXN];
int nxt[MAXN];
bool IsLucky(int n) {
while (n > 0) {
if (n % 10 != 4 && n % 10 != 7) {
return false;
}
n /= 10;
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> A[i];
if (IsLucky(A[i])) {
C[++M] = i;
}
}
C[M + 1] = N + 1;
for (int i = 1; i <= M; i++) {
nxt[i] = M + 1;
for (int j = i + 1; j <= M; j++) {
if (A[C[i]] == A[C[j]]) {
nxt[i] = j;
break;
}
}
}
lint ans = 1ull * (N + 2) * (N + 1) / 2 * N / 3 * (N - 1) / 4;
for (int i = M; i >= 1; i--) {
set<int> s;
s.emplace(C[i]);
s.emplace(N + 1);
lint val = 0;
for (int j = i; j >= 1; j--) {
if (nxt[j] > i) {
for (int k = nxt[j]; k <= M; k = nxt[k]) {
s.emplace(C[k]);
auto l = s.lower_bound(C[k]);
auto r = l;
l--, r++;
if (*l == C[i]) {
val += 1ll * (C[i + 1] - C[i]) * (C[i + 1] - C[i] + 1) / 2 *
(*r - C[k]);
val += 1ll * (C[i + 1] - C[i]) * (C[k] - C[i + 1]) * (*r - C[k]);
} else {
val += 1ll * (C[i + 1] - C[i]) * (C[k] - *l) * (*r - C[k]);
}
}
}
ans -= 1ll * val * (C[j] - C[j - 1]);
}
}
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long NLINF = 0xf7f7f7f7f7f7f7f7;
const int INF = 0x3f3f3f3f, NINF = 0xf7f7f7f7;
const int MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
const int N = 2e5 + 10;
int n, m, a[N];
long long s = 0LL;
bool cmp(int a, int b) { return a > b; }
bool f(int d) {
int qd[N];
memset(qd, 0, sizeof qd);
int x = 1;
long long s = 0LL;
for (int i = 1; i <= n + 1; i++) {
;
if (s >= m) return 1;
if (x == d + 1) x = 1;
;
if (a[i] > qd[x])
s += a[i] - (qd[x++]++);
else
break;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s += a[i];
if (s < m) return puts("-1"), 0;
sort(a + 1, a + n + 1, cmp);
int lo = 1, hi = n, mid;
while (lo < hi) {
mid = (lo + hi) >> 1;
if (f(mid))
hi = mid;
else
lo = mid + 1;
}
printf("%d\n", hi);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long S;
vector<pair<int, pair<long long, long long> > > adj[101010];
int sz[101010];
long long w[101010];
int c[101010];
priority_queue<pair<long long, long long> > pq[3];
bool lf(int v) { return adj[v].size() == 1 && v != 1; }
void dfs(int v, int p) {
if (lf(v))
sz[v] = 1;
else
sz[v] = 0;
for (auto i : adj[v]) {
if (i.first == p) continue;
w[i.first] = i.second.first;
c[i.first] = (int)i.second.second;
dfs(i.first, v);
sz[v] += sz[i.first];
}
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
scanf("%d%lld", &N, &S);
for (int i = 1; i <= N; i++) adj[i].clear();
for (int i = 1; i < N; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
adj[a].push_back({b, {c, d}});
adj[b].push_back({a, {c, d}});
}
dfs(1, 0);
for (int i = 1; i <= 2; i++) {
while (pq[i].size()) pq[i].pop();
}
long long sum = 0;
for (int i = 2; i <= N; i++) {
sum += (long long)w[i] * sz[i];
pq[c[i]].emplace((w[i] + 1) / 2 * sz[i], i);
}
int ans = 0;
while (sum > S) {
long long s1 = 0, s2 = 0, s3 = 0, s4 = 0;
if (pq[1].size()) {
pair<long long, long long> tmp = pq[1].top();
pq[1].pop();
s4 = tmp.first;
if (pq[1].size()) {
s3 = tmp.first + pq[1].top().first;
}
s1 = tmp.first + (w[tmp.second] / 2 + 1) / 2 * sz[tmp.second];
pq[1].push(tmp);
}
if (pq[2].size()) {
s2 = pq[2].top().first;
}
if (sum - s4 <= S) {
ans++;
break;
}
int c = (max(s1, s3) >= s2 ? 1 : 2);
pair<long long, long long> t = pq[c].top();
pq[c].pop();
sum -= t.first;
w[t.second] /= 2;
pq[c].emplace((w[t.second] + 1) / 2 * sz[t.second], t.second);
ans += c;
}
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cnt[28];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
string str;
cin >> n >> k;
;
cin >> str;
for (int i = 0; i < n; i++) {
cnt[str[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (cnt[i] > k) {
printf("NO");
return 0;
}
}
printf("YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c;
cin >> a >> b >> c;
long long x = (a + b + c) / 3;
long long y = min(a + b, a + c);
long long z = min(y, b + c);
cout << min(x, z) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << 4 + (3 * n) << "\n";
cout << 0 << " " << 0 << "\n";
cout << 0 << " " << 1 << "\n";
cout << 1 << " " << 0 << "\n";
cout << 1 << " " << 1 << "\n";
for (int i = 1; i <= n; i++) {
cout << i << " " << i + 1 << "\n";
cout << i + 1 << " " << i << "\n";
cout << i + 1 << " " << i + 1 << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i;
long long int t;
while (~scanf("%d", &n)) {
t = n / 2 * 3 + n % 2;
printf("%lld\n", t);
for (i = 2; i <= n; i += 2) {
printf("%d ", i);
}
for (i = 1; i <= n; i += 2) {
printf("%d ", i);
}
for (i = 2; i <= n; i += 2) {
printf("%d ", i);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, d, h;
cin >> n;
int sum = 0;
for (i = 0; i < n; i++) {
int a;
cin >> a;
sum += 4 * a * i;
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int ret = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
for (; ch >= '0' && ch <= '9'; ch = getchar()) ret = ret * 10 + ch - '0';
return ret * f;
}
int n, a[200020], f[513];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
memset(f, 0x3f, sizeof f);
f[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 512; j++) {
if (f[j] < a[i]) f[j ^ a[i]] = min(f[j ^ a[i]], a[i]);
}
}
vector<int> ans;
for (int i = 0; i <= 512; i++) {
if (f[i] != 0x3f3f3f3f) ans.push_back(i);
}
cout << ans.size() << endl;
for (int i : ans) cout << i << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
// #define ll long long
#define pi pair<int, int>
#define pf pair<float, int>
#define ps pair<string, int>
#define pii pair<pi, int>
#define mi map<int, int>
#define ml map<long long, int>
#define ms map<string, int>
#define mc map<char, int>
#define mpi map<pi, int>
#define F first
#define S second
#define vt vector
#define vi vector<int>
#define vd vector<double>
#define vf vector<float>
#define vl vector<long long>
#define vpi vector<pi>
#define vpf vector<pf>
#define vpii vector<pii>
#define st set
#define si set<int>
#define sd set<double>
#define sf set<float>
#define sl set<long long>
#define FOR(t, q) for(int q = 0; q < t; q++)
#define FORN(t, q, v) for(int q = v; q < t; q++)
#define sz(v) (int)(v.size())
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define B(v) v.begin()
#define RB(v) v.rbegin()
#define E(v) v.end()
#define RE(v) v.rend()
#define LOWER(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
#define UPPER(s) transform(s.begin(), s.end(), s.begin(), ::toupper)
#define pb(s) push_back(s);
#define TC int _t; cin >> _t; FOR(_t, _q)
using namespace std;
void solve() {
int n; cin >> n;
vi l(n), r(n), ll(n), rr(n);
FOR(n, i) {
cin >> l[i] >> r[i];
ll[i] = l[i]; rr[i] = r[i];
}
sort(all(l)), sort(all(r));
int ans = n-1;
FOR(n, i) {
int x = lower_bound(all(r), ll[i]) - B(r);
int y = upper_bound(all(l), rr[i]) - B(l);
ans = min(ans, n - y + x);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
TC
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> jumps;
int count, test, total, steps, pos;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> total;
pos = steps = 0;
count = 1;
jumps.clear();
jumps.assign(total, 0);
jumps[0] = 1;
for (int i = 0; i < 2 * total; i++) {
steps = (steps + 1) % total;
pos = (pos + steps) % total;
if (!jumps[pos]) {
jumps[pos] = 1;
count++;
}
}
(count == total) ? cout << "YES\n" : cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, mod, ans;
cin >> n >> a >> b;
if (n == 1)
cout << a << endl;
else {
mod = abs(b) % n;
if (mod == 0)
ans = a;
else {
if (b < 0)
ans = a + (n - mod);
else
ans = a + mod;
if (ans > n) {
ans = ans % n;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
vector<int> getBorder(const string str) {
int n = str.size();
vector<int> border(n, -1);
for (int i = 1, j = -1; i < n; i++) {
while (j >= 0 && str[i] != str[j + 1]) {
j = border[j];
}
if (str[i] == str[j + 1]) j++;
border[i] = j;
}
return border;
}
int matchPattern(string txt, string pat, const vector<int> border) {
int freq = 0;
for (int i = 0, j = -1; i < (int)txt.size(); i++) {
while (j >= 0 && txt[i] != pat[j + 1]) {
j = border[j];
}
if (txt[i] == pat[j + 1]) {
j++;
}
if (j + 1 == (int)pat.size()) {
freq++;
j = border[j];
}
}
return freq;
}
string cut(string s, int p, bool pref = true) {
if (!pref) {
reverse(s.begin(), s.end());
}
while ((int)s.size() >= p) s.pop_back();
if (!pref) {
reverse(s.begin(), s.end());
}
return s;
}
const int ms = 210;
string pref[ms], suf[ms];
long long trans[ms];
int bk = 0;
long long getFreq(int n, string pat, long long k) {
std::vector<long long> f(n + 1, 0);
if (pat == "0") f[0]++;
if (pat == "1") f[1]++;
auto border = getBorder(pat);
for (int i = 2; i <= n; i++) {
long long cur = trans[i - 2];
if (i < bk + 2) {
string curString = cut(suf[i - 2], (int)pat.size(), false) +
cut(pref[i - 1], (int)pat.size());
cur = matchPattern(curString, pat, border);
}
f[i] = f[i - 1] + f[i - 2] + cur;
if (f[i] > k) return k + 1;
trans[i] = cur;
}
return min(f[n], k + 1);
}
int main() {
pref[0] = suf[0] = "0";
pref[1] = suf[1] = "1";
for (int i = 2; i < ms; i++) {
pref[i] = cut(pref[i - 2] + pref[i - 1], ms);
suf[i] = cut(suf[i - 2] + suf[i - 1], ms, false);
if (pref[i] == pref[i - 2] && suf[i] == suf[i - 1] && bk == 0) bk = i;
}
int n, m;
long long k;
cin >> n >> k >> m;
n = min(n, 100);
if (n == 0) {
cout << "0\n";
return 0;
}
if (n == 1) {
cout << "1\n";
return 0;
}
string ans;
k--;
while (k >= 0 && (int)ans.size() < m) {
if (ans.size() > 0 &&
suf[n].substr(suf[n].size() - ans.size(), ans.size()) == ans) {
k--;
}
if (k < 0) break;
ans += '0';
long long got = getFreq(n, ans, k);
if (got <= k) {
ans.back() = '1';
k -= got;
}
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
std::map<long long int, bool> map;
std::vector<long long int> v;
for (long long int i = 1; (i * (i + 1) / 2) <= n; i++) {
map[i * (i + 1) / 2] = true;
v.push_back(i * (i + 1) / 2);
}
for (long long int i : v) {
if (map[n - i] && map[i]) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int aces[5100][5100];
int bits[5100][5100];
int insq(int i, int j, int k) {
return aces[i + k - 1][j + k - 1] - aces[i + k - 1][j - 1] -
aces[i - 1][j + k - 1] + aces[i - 1][j - 1];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%1d", &bits[i][j]);
}
}
for (int i = 1; i <= 5050; i++) {
for (int j = 1; j <= 5050; j++) {
aces[i][j] =
aces[i - 1][j] + aces[i][j - 1] - aces[i - 1][j - 1] + bits[i][j];
}
}
int res = n * m;
for (int k = 2; k <= max(m, n); k++) {
int changesneeded = 0;
for (int iy = 1; iy <= n; iy += k) {
for (int ix = 1; ix <= m; ix += k) {
int acesthis = insq(iy, ix, k);
changesneeded += min(acesthis, k * k - acesthis);
}
}
res = min(res, changesneeded);
}
printf("%d", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1111111;
char s[N];
pair<int, int> operator+=(pair<int, int>& a, const pair<int, int>& b) {
return a = make_pair(a.first + b.first, a.second + b.second);
}
inline pair<int, int> get(char ch) {
switch (ch) {
case 'U':
return make_pair(0, 1);
case 'D':
return make_pair(0, -1);
case 'R':
return make_pair(1, 0);
case 'L':
return make_pair(-1, 0);
}
}
int main() {
int x, y;
scanf("%d%d\n", &x, &y);
scanf("%s", s);
vector<pair<int, int> > v;
int n = strlen(s);
pair<int, int> d = make_pair(0, 0);
v.push_back(d);
for (int i = 0; i < n; ++i) {
d += get(s[i]);
v.push_back(d);
}
int dx = d.first;
int dy = d.second;
bool flag = 0;
for (size_t i = 0; i < v.size(); ++i) {
if (dx == 0 && dy == 0) {
if (x == v[i].first && y == v[i].second) {
flag = 1;
}
continue;
}
int X = (x - v[i].first);
int Y = (y - v[i].second);
if (dx == 0) {
if (x == v[i].first && Y % dy == 0 && Y / dy >= 0) {
flag = 1;
}
continue;
}
if (dy == 0) {
if (y == v[i].second && X % dx == 0 && X / dx >= 0) {
flag = 1;
}
continue;
}
if (X % dx == 0 && Y % dy == 0 && X / dx == Y / dy && X / dx >= 0) {
flag = 1;
}
}
puts(flag ? "Yes" : "No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct sjx {
int b[3];
sjx(int x) {
for (int i = 0; i < 3; i++) b[i] = x;
}
bool ok(int x) {
for (int i = 0; i < 3; i++)
if (b[i] != x) return false;
return true;
}
void change(int x) {
sort(b, b + 3);
int MAX = b[1] + b[2] - 1;
b[0] = min(x, MAX);
}
};
int main() {
int x, y;
scanf("%d %d", &x, &y);
sjx s(y);
int cnt = 0;
while (1) {
if (s.ok(x)) break;
s.change(x);
cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<pll> xs, ys;
for (int i = 0; i < n; ++i) {
ll a, b, c, d;
cin >> a >> b >> c >> d;
xs.emplace_back(a + c, i);
ys.emplace_back(b + d, i);
}
sort((xs).begin(), (xs).end());
sort((ys).begin(), (ys).end());
long long ans = -1;
for (int a = 0; a <= k; ++a) {
for (int b = 0; b <= k; ++b) {
for (int c = 0; c <= k; ++c) {
for (int d = 0; d <= k; ++d) {
set<int> rem;
for (int i = 0; i < a; ++i) rem.insert(xs[i].second);
for (int i = 0; i < b; ++i) rem.insert(xs[n - 1 - i].second);
for (int i = 0; i < c; ++i) rem.insert(ys[i].second);
for (int i = 0; i < d; ++i) rem.insert(ys[n - 1 - i].second);
if ((int)rem.size() > k) continue;
ll w = (xs[n - 1 - b].first - xs[a].first + 1LL) / 2LL;
ll h = (ys[n - 1 - d].first - ys[c].first + 1LL) / 2LL;
ans = min(ans, max(1ll, w) * max(1ll, h));
if (ans == -1) ans = max(1ll, w) * max(1ll, h);
}
}
}
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ar[100005], fr[100005];
vector<vector<int>> adj(100005);
int OO = INT32_MAX;
int odd = 0, even = 0;
vector<int> res;
int cnt = 0;
int vis[100005];
void dfs(int s, int lvl, int odd, int even) {
int od = 0, ev = 0;
if (lvl % 2 == 0) {
if (even) {
ar[s - 1]++;
ar[s - 1] %= 2;
}
} else {
if (odd) {
ar[s - 1]++;
ar[s - 1] %= 2;
}
}
if (ar[s - 1] != fr[s - 1]) {
res.push_back(s);
cnt++;
if (lvl % 2 == 0) {
ev++;
} else {
od++;
}
}
vis[s] = 1;
for (int i = 0; i < adj[s].size(); i++) {
int child = adj[s][i];
if (!vis[child]) dfs(child, lvl + 1, (odd + od) % 2, (even + ev) % 2);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n; i++) {
cin >> fr[i];
}
dfs(1, 1, 0, 0);
cout << cnt << endl;
for (int i = 0; i < cnt; i++) {
cout << res[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fa[100005];
const int maxn = 100005;
int n, m, tot;
int find(int x) {
if (fa[x] != x) {
fa[x] = find(fa[x]);
}
return fa[x];
}
struct edge {
int u, v, w, id;
} E[1000005], E2[1000005];
bool operator<(const struct edge &a, const struct edge &b) { return a.w < b.w; }
vector<pair<int, int> > e[maxn];
void kruscal() {
sort(E, E + m);
int s = 0;
for (int i = 0; i < m; i++) {
int fx = find(E[i].u);
int fy = find(E[i].v);
if (fx != fy && s <= n - 1) {
s++;
fa[fx] = fy;
e[E[i].u].push_back(make_pair(E[i].v, E[i].w));
e[E[i].v].push_back(make_pair(E[i].u, E[i].w));
} else {
E2[tot++] = E[i];
}
}
}
int f[100005][20];
int mx[100005][20];
int dep[100005];
void dfs(int u, int fa) {
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
if (v == fa) continue;
f[v][0] = u;
mx[v][0] = e[u][i].second;
dep[v] = dep[u] + 1;
dfs(v, u);
}
}
void init() {
for (int i = 1; i < 18; i++) {
for (int u = 1; u <= n; u++) f[u][i] = f[f[u][i - 1]][i - 1];
}
for (int i = 1; i < 18; i++) {
for (int u = 1; u <= n; u++)
mx[u][i] = max(mx[u][i - 1], mx[f[u][i - 1]][i - 1]);
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) {
swap(u, v);
}
int d = dep[u] - dep[v];
int maxn = 0;
for (int i = 0; i < 18; i++) {
if (d & (1 << i)) {
maxn = max(maxn, mx[u][i]);
u = f[u][i];
d ^= (1 << i);
}
}
while (u != v) {
for (int i = 17; i >= 0; i--) {
if (f[u][i] != f[v][i] || i == 0)
maxn = max(maxn, max(mx[u][i], mx[v][i])), u = f[u][i], v = f[v][i];
}
}
return maxn;
}
int ans[1000005];
int main(int argc, char **argv) {
scanf("%d%d", &n, &m);
tot = 0;
for (int i = 0; i <= 100000; i++) fa[i] = i;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
E[i].id = i;
}
kruscal();
f[1][0] = 1;
dfs(1, -1);
init();
for (int i = 0; i < tot; i++) {
int u = E2[i].u;
int v = E2[i].v;
ans[E2[i].id] = lca(u, v);
}
for (int i = 0; i < m; i++) {
if (ans[i]) printf("%d\n", ans[i]);
}
return 0;
}
| 6 |
#include<iostream>
#include<vector>
#include<set>
#include<map>
#include<math.h>
#include<algorithm>
#include<stack>
#define desync() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define ll long long
#define check() cout << "OK" << '\n'
ll mod = 1e9 + 7;
ll lim = 1e6 + 1;
using namespace std;
int main() {
desync();
int n; cin >> n;
vector<vector<int>> vec(n, vector<int>(n, -1));
for (int i = 0; i < n; i++) {
cin >> vec[i][i];
int num = vec[i][i]; --num;
int vert = i, horiz = i;
while (num--) {
if (horiz - 1 >= 0) {
--horiz;
if (vec[vert][horiz] == -1) {
vec[vert][horiz] = vec[i][i];
}
else {
++horiz;
++vert;
vec[vert][horiz] = vec[i][i];
}
}
else {
++vert;
vec[vert][horiz] = vec[i][i];
}
}
}
/*for (int i = n - 1; i >= 0; i--) {
int k = vec[i][i]; --k;
int vert = i;
int horiz{};
if(i != 0){ horiz = i - 1; }
else { horiz = i; }
check();
while (k--) {
if ((vert + 1) < n && vec[vert + 1][horiz] == -1) {
vec[vert + 1][horiz] = vec[i][i];
++vert;
}
else {
vec[vert][horiz] = vec[i][i];
}
horiz--;
}
}*/
for (int i = 0; i < n; i++) {
int k = i + 1;
int j = 0;
while (k--) {
cout << vec[i][j] << ' '; j++;
}
cout << '\n';
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int MAXM = 10005;
int N, M;
int sz[MAXN];
int val[MAXN][MAXN];
int pre[MAXN][MAXN];
int dp[MAXN][MAXM];
int A[MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
cin >> N >> M;
for (int i = 1; i <= N; i++) {
cin >> sz[i];
for (int j = 1; j <= sz[i]; j++) {
cin >> val[i][j];
pre[i][j] = pre[i][j - 1] + val[i][j];
}
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= sz[i]; j++)
for (int k = 0; k <= j; k++)
A[i][j] =
max(A[i][j], pre[i][k] + pre[i][sz[i]] - pre[i][sz[i] - j + k]);
for (int i = 1; i <= N; i++)
for (int j = 0; j <= M; j++)
for (int k = 0; k <= sz[i]; k++)
if (j >= k) dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + A[i][k]);
cout << dp[N][M] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 100;
const int CASE_SIZE = 26;
char str[MAXN];
struct Trie {
int child[MAXN][CASE_SIZE], value[MAXN], trieN, root;
void init() {
trieN = root = 0;
value[root] = 0;
memset(child[root], -1, sizeof(child[root]));
}
int newnode() {
trieN++;
value[trieN] = 0;
memset(child[trieN], -1, sizeof(child[trieN]));
return trieN;
}
void insert(char *s, int val) {
int x = root;
for (int i = 0; s[i]; i++) {
int d = s[i] - 'a';
if (child[x][d] == -1) child[x][d] = newnode();
x = child[x][d];
}
value[x] += val;
}
int search(char *s) {
int sum = 0, x = root;
for (int i = 0; s[i]; i++) {
int d = s[i] - 'a';
if (child[x][d] == -1) break;
x = child[x][d];
sum += value[x];
}
return sum;
}
} trie;
struct KMP {
int Next[MAXN];
void getNext(string s, int len) {
memset(Next, 0, sizeof(Next));
int i = 0, j = -1;
Next[0] = -1;
while (i < len) {
if (j == -1 || s[i] == s[j]) {
++i;
++j;
Next[i] = j;
} else
j = Next[j];
}
}
int search(string s, char *str) {
int sum = 0, j = 0, lens = s.length(), lenstr = strlen(str);
getNext(s, s.length());
for (int i = 0; i < lenstr; i++) {
while (j > 0 && s[j] != str[i]) {
j = Next[j];
}
if (s[j] == str[i]) j++;
if (j == lens) {
sum++;
j = Next[j];
}
}
return sum;
}
} kmp;
string cun[MAXN];
int flag[MAXN];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int cnt = 0;
memset(flag, 0, sizeof(flag));
trie.init();
for (int i = 1; i <= n; i++) {
int d;
scanf("%d %s", &d, str);
int len = strlen(str);
if (d == 1) {
if (len <= 1000)
trie.insert(str, 1);
else
cun[++cnt] = string(str), flag[cnt] = 1;
}
if (d == 2) {
if (len <= 1000)
trie.insert(str, -1);
else
cun[++cnt] = string(str), flag[cnt] = -1;
}
if (d == 3) {
long long ans = 0;
for (int i = 0; i < len; i++) ans += trie.search(str + i);
for (int i = 1; i <= cnt; i++) {
if (len < cun[i].length()) continue;
ans += kmp.search(cun[i], str) * flag[i];
}
printf("%I64d\n", ans);
fflush(stdout);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, k, flag = 0;
string str;
cin >> n >> k >> str;
for (int i = 0; i < n; i++) {
if (i + k >= n) break;
if (str[i] == '.' && str[i + k] == '.') {
str[i] = '0', str[i + k] = '1';
flag = 1;
break;
}
if (str[i] != str[i + k]) {
flag = 1;
if (str[i] != '.' && str[i + k] != '.') break;
if (str[i] == '0')
str[i + k] = '1';
else if (str[i] == '1')
str[i + k] = '0';
else if (str[i] == '.') {
if (str[i + k] == '1')
str[i] = '0';
else if (str[i + k] == '0')
str[i] = '1';
}
break;
}
}
if (flag) {
for (int i = 0; i < str.size(); i++)
if (str[i] != '.')
cout << str[i];
else
cout << "0";
} else
cout << "No";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
string str;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n;
cin >> str;
int maxnum = 0, ans = 0;
int arr[26] = {0};
for (int i = 0; i < n; i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
arr[str[i] - 'a']++;
} else {
for (int i = 0; i < 26; i++) {
if (arr[i] > 0) ans++;
}
maxnum = max(maxnum, ans);
ans = 0;
memset(arr, 0, sizeof(arr));
}
}
for (int i = 0; i < 26; i++) {
if (arr[i] > 0) ans++;
}
maxnum = max(ans, maxnum);
cout << maxnum << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int vis[maxn][maxn];
int A, B, N, M;
vector<vector<int> > adj;
void init() { memset(vis, 0, sizeof vis); }
bool check(int a, int b) {
for (int i = 0; i < ((int)(adj[a]).size()); i++) {
if (adj[a][i] == b) return false;
}
return true;
}
int perm[110000];
int main() {
int n, m, a, b;
scanf("%d%d", &n, &m);
adj.resize(n + 1);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
int cycle = 110;
bool ok = true;
while (cycle--) {
for (int i = 1; i <= n; i++) perm[i] = i;
random_shuffle(perm + 1, perm + n + 1);
perm[n + 1] = perm[1];
ok = true;
for (int i = 1; i <= m; i++) {
if (!check(perm[i], perm[i + 1])) {
ok = false;
break;
}
}
if (ok) {
for (int i = 1; i <= m; i++) {
cout << perm[i] << " " << perm[i + 1] << endl;
}
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[1007];
long long ans = 0;
long long dp[2][1007];
long long pref[1007];
long long prv_ans;
long long calc(int sr) {
int curr = 0, prv = 1;
for (int i = 1; i <= n; i++) {
dp[prv][i] = 1;
}
for (int j = 2; j <= k; ++j) {
for (int i = 1; i <= n; ++i) {
pref[i] = pref[i - 1] + dp[prv][i];
pref[i] = (pref[i] >= 998244353) ? pref[i] - 998244353 : pref[i];
}
int init = 0;
for (int i = 1; i <= n; ++i) {
while (init < n && a[i] - sr >= a[init + 1]) {
++init;
}
dp[curr][i] = pref[init];
}
prv ^= 1;
curr ^= 1;
}
long long sm = 0;
for (int i = 1; i <= n; ++i) {
sm = (sm + dp[prv][i]);
sm = (sm >= 998244353) ? sm - 998244353 : sm;
}
long long ret = (sm - prv_ans);
ret = (ret >= 0) ? ret : ret + 998244353;
prv_ans = sm;
return ret;
}
void input() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
}
void solve() {
int mxval = (a[n] - a[1] + k - 2) / (k - 1);
for (int i = mxval; i >= 1; --i) {
ans = (ans + (calc(i) * i) % 998244353);
ans = (ans >= 998244353) ? ans - 998244353 : ans;
}
printf("%I64d\n", ans);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-11;
double a[544][544], cp;
bool Gauss(int len) {
for (int i = 1; i <= len; ++i) {
int k = i;
while (k <= len && fabs(a[k][i]) < eps) k++;
if (k > len) continue;
if (k != i) swap(a[k], a[i]);
for (int k = 1; k <= len; ++k)
if (k != i) {
cp = a[k][i] / a[i][i];
for (int j = i; j <= len + 1; ++j) a[k][j] -= cp * a[i][j];
}
}
return 0;
}
int n, m, x, y;
int T[55][505], cnt[55];
double stay[55];
int getid(int a, int b) { return (a - 1) * n + b; }
void Build_Tree(int aa, int b) {
if (x == aa && y == b) a[getid(aa, b)][n * n + 1] = -1;
a[getid(aa, b)][getid(aa, b)] = -1;
for (int i = 1; i <= cnt[aa]; ++i)
for (int j = 1; j <= cnt[b]; ++j) {
int u = T[aa][i], v = T[b][j];
if (u == v) continue;
double p1, p2;
if (u == aa)
p1 = stay[u];
else
p1 = (1 - stay[u]) / (cnt[u] - 1);
if (v == b)
p2 = stay[v];
else
p2 = (1 - stay[v]) / (cnt[v] - 1);
a[getid(aa, b)][getid(u, v)] += p1 * p2;
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &x, &y);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
T[x][++cnt[x]] = y;
T[y][++cnt[y]] = x;
}
for (int i = 1; i <= n; ++i) scanf("%lf", &stay[i]), T[i][++cnt[i]] = i;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) Build_Tree(i, j);
Gauss(n * n);
for (int i = 1; i <= n; ++i)
printf("%.6lf ", a[getid(i, i)][n * n + 1] / a[getid(i, i)][getid(i, i)]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
int N, a[2209], b[2209];
int ned, prv[2209], first[2209];
long long int cap[20009], cost[20009], to[20009], nxt[20009], dist[2209],
pot[2209], K;
void init() {
memset(first, -1, sizeof first);
ned = 0;
}
void add(int u, int v, long long int f, long long int c) {
to[ned] = v, cap[ned] = f;
cost[ned] = c, nxt[ned] = first[u];
first[u] = ned++;
to[ned] = u, cap[ned] = 0;
cost[ned] = -c, nxt[ned] = first[v];
first[v] = ned++;
}
bool dijkstra(int s, int t) {
memset(prv, -1, sizeof prv);
for (int i = 0; i < N; i++) dist[i] = 1000000000000000000LL;
set<pair<long long int, int> > q;
q.insert(make_pair(0LL, s));
dist[s] = prv[s] = 0;
int u, v;
while (!q.empty()) {
u = q.begin()->second;
q.erase(q.begin());
for (int e = first[u]; e != -1; e = nxt[e]) {
if (cap[e] <= 0) continue;
v = to[e];
long long int new_dist = dist[u] + cost[e] + pot[u] - pot[v];
if (new_dist < dist[v]) {
q.erase(make_pair(dist[v], v));
dist[v] = new_dist;
prv[v] = e;
q.insert(make_pair(new_dist, v));
}
}
}
assert(prv[t] != -1);
return prv[t] != -1;
}
inline long long int augment(int s, int t) {
for (int i = t; i != s; i = to[prv[i] ^ 1]) {
cap[prv[i]]--;
cap[prv[i] ^ 1]++;
}
--K;
long long int flowCost = dist[t] - pot[s] + pot[t];
for (int i = 0; i < N; i++)
if (prv[i] != -1) pot[i] += dist[i];
return flowCost;
}
long long int mincostmaxflow(int s, int t) {
long long int flowCost = 0;
memset(pot, 0, sizeof(pot));
while (K > 0 && dijkstra(s, t)) {
flowCost += augment(s, t);
}
return flowCost;
}
int main() {
scanf("%d%lld", &N, &K);
for (int i = 0; i < N; ++i) scanf("%d", &a[i]);
for (int i = 0; i < N; ++i) scanf("%d", &b[i]);
init();
int s = 0, t = N + 1;
for (int i = 0; i < N; ++i) {
if (i != N - 1) add(i + 1, i + 2, K, 0);
add(s, i + 1, 1, a[i]);
add(i + 1, t, 1, b[i]);
}
N += 2;
printf("%lld\n", mincostmaxflow(s, t));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 444444;
int p[N], ss[N], ff[N], r[N];
bool imp[N];
int findset(int x) {
if (x != p[x]) p[x] = findset(p[x]);
return p[x];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", ss + i, ff + i);
imp[i] = false;
}
int kr = 0;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
int x = findset(ss[i]);
int y = findset(ff[i]);
if (x != y) {
r[kr++] = i;
imp[i] = true;
p[x] = y;
}
}
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = m; i >= 1; i--) {
int x = findset(ss[i]);
int y = findset(ff[i]);
if (x != y) {
if (!imp[i]) {
r[kr++] = i;
imp[i] = true;
}
p[x] = y;
}
}
int tt;
scanf("%d", &tt);
while (tt--) {
int from, to;
scanf("%d %d", &from, &to);
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 0; i < kr; i++)
if (r[i] < from || r[i] > to) {
int x = findset(ss[r[i]]);
int y = findset(ff[r[i]]);
if (x != y) p[x] = y;
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (p[i] == i) ans++;
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int main() {
int n;
long long k;
cin >> n >> k;
vector<long long> a(MAXN);
for (int i = 0; i <= n; i++) cin >> a[i];
long long t = 0;
bool flag = false;
vector<bool> b(MAXN);
vector<long long> c(MAXN);
for (int i = 0; i < n; i++) {
long long tmp = a[i] + t;
if (tmp % 2 == 0) {
c[i] = 0;
} else {
c[i] = 1;
flag = true;
}
b[i] = flag;
t = (tmp - c[i]) / 2;
}
int i;
c[n] = a[n] + t;
b[n] = true;
long long A = 0;
for (i = n; i >= 0; i--) {
A = A * 2 + c[i];
if (abs(A) > 2 * k) {
if (b[i]) {
cout << 0 << endl;
return 0;
}
break;
}
}
if (i < 0) i = 0;
int answ = 0;
for (; i <= n; i++) {
if (i == n && a[i] == A) break;
if (abs(a[i] - A) <= k) answ++;
if (A % 2 != 0) break;
A /= 2;
}
cout << answ;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
inline int letterToNum(char ch) {
if (ch == 'A')
return 0;
else if (ch == 'C')
return 1;
else if (ch == 'G')
return 2;
else
return 3;
}
int a, b, c, d, i, j, n, m, k;
int sm[102][4], nx[102][4];
bool en[102];
string cs[102];
int pr[102], len[102], ms[102];
char str[12];
int dp[1001][11][102];
int main() {
scanf("%d%d", &n, &m);
k = 1;
memset(sm, -1, sizeof(sm));
for (int _n((m)-1), i(0); i <= _n; i++) {
scanf("%s", str);
c = (int)strlen(str);
for (int _n((c)-1), j(0); j <= _n; j++) str[j] = letterToNum(str[j]);
a = 0;
for (int _n((c)-1), j(0); j <= _n; j++) {
if (sm[a][str[j]] != -1)
a = sm[a][str[j]];
else {
sm[a][str[j]] = k++;
if (j == c - 1) en[k - 1] = 1;
cs[k - 1] = cs[a];
cs[k - 1] += (char)(str[j] + 'A');
a = k - 1;
}
if (j == c - 1) en[a] = 1;
}
}
pr[0] = 0;
for (int _n((k - 1)), i(1); i <= _n; i++) {
if (en[i]) ms[i] = (int)((cs[i]).size());
if ((int)((cs[i]).size()) == 1)
pr[i] = 0;
else {
for (int _n((k)-1), j(0); j <= _n; j++) {
if (en[j] && (int)((cs[j]).size()) < (int)((cs[i]).size())) {
a = (int)((cs[j]).size());
if (cs[i].substr((int)((cs[i]).size()) - a, a) == cs[j]) {
ms[i] = max(ms[i], (int)((cs[j]).size()));
}
}
if ((int)((cs[j]).size()) >= (int)((cs[i]).size()) ||
(int)((cs[j]).size()) <= (int)((cs[pr[i]]).size()))
continue;
a = (int)((cs[j]).size());
if (cs[i].substr((int)((cs[i]).size()) - a, a) == cs[j]) pr[i] = j;
}
}
}
memset(nx, -1, sizeof(nx));
for (int _n((k)-1), i(0); i <= _n; i++) {
for (int _n((4) - 1), j(0); j <= _n; j++) {
a = i;
while (a > 0 && sm[a][j] == -1) a = pr[a];
nx[i][j] = sm[a][j];
}
}
for (int _n((k)-1), i(0); i <= _n; i++) len[i] = (int)((cs[i]).size());
dp[0][0][0] = 1;
for (int _n((n)-1), i(0); i <= _n; i++) {
for (int _n((10) - 1), j(0); j <= _n; j++) {
for (int _n((k)-1), z(0); z <= _n; z++) {
if (!dp[i][j][z]) continue;
for (int _n((4) - 1), o(0); o <= _n; o++) {
a = nx[z][o];
if (a == -1) continue;
b = j + 1;
if (ms[a] >= b) b = 0;
if (b == 10) continue;
if (len[a] < b) continue;
dp[i + 1][b][a] += dp[i][j][z];
if (dp[i + 1][b][a] >= 1000000009) dp[i + 1][b][a] -= 1000000009;
}
}
}
}
a = 0;
for (int _n((k)-1), i(0); i <= _n; i++) {
a += dp[n][0][i];
if (a >= 1000000009) a -= 1000000009;
}
printf("%d\n", a);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
#define rep(i, a, n) for (ll i = a; i <= n; i++)
#define per(i, n, a) for (ll i = n; i >= a; i--)
#define pb push_back
// #define mp make_pair
#define endl "\n"
#define cty cout << "YES" << endl
#define ctn cout << "NO" << endl
#define ff first
#define ss second
#define vli vector<long long int>
#define vi vector<int>
#define pll pair<ll, ll>
#define all(c) (c).begin(), (c).end()
#define csp(x) cout << (x) << " "
#define c1(x) cout << (x) << endl
#define c2(x, y) cout << (x) << " " << (y) << endl
#define c3(x, y, z) cout << (x) << " " << (y) << " " << (z) << endl
#define c4(a, b, c, d) cout << (a) << " " << (b) << " " << (c) << " " << (d) << endl
#define c5(a, b, c, d, e) cout << (a) << " " << (b) << " " << (c) << " " << (d) << " " << (e) << endl
#define c6(a, b, c, d, e, f) cout << (a) << " " << (b) << " " << (c) << " " << (d) << " " << (e) << " " << (f) << endl
ll gcd(ll a, ll b)
{
return b ? gcd(b, a % b) : a;
}
const int mod = 1e9 + 7;
const long double pi = 3.14159265358979323846264338327950288419716939937510582097494459230;
/*
██╗░░░██╗███████╗███╗░░██╗░█████╗░███╗░░░███╗
██║░░░██║██╔════╝████╗░██║██╔══██╗████╗░████║
╚██╗░██╔╝█████╗░░██╔██╗██║██║░░██║██╔████╔██║
░╚████╔╝░██╔══╝░░██║╚████║██║░░██║██║╚██╔╝██║
░░╚██╔╝░░███████╗██║░╚███║╚█████╔╝██║░╚═╝░██║
░░░╚═╝░░░╚══════╝╚═╝░░╚══╝░╚════╝░╚═╝░░░░░╚═╝
*/
ll binpow(ll a, ll b)
{
ll res = 1;
while (b > 0)
{
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll pow_mod(ll base, ll power, ll md)
{
// binary expo
ll res = 1;
while (power)
{
if (power & 1)
res = (res % md * base % md) % md;
base = (base % md * base % md) % md;
power = power >> 1;
}
return res % md;
}
ll mod_add(ll a, ll b)
{
return ((a % mod + b % mod) % mod);
}
ll mod_mul(ll a, ll b)
{
return ((a % mod * b % mod) % mod);
}
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
void WE_ARE_VENOM()
{
ll n;
cin>>n;
string t;
cin>>t;
ll freq[26]={0};
rep(i,0,n-1) freq[t[i]-'a']++;
rep(i,0,25)
{
if(freq[i]==0)
{
c1(char(i+'a'));
return;
}
}
unordered_map<string, ll> mp;
for(ll len=1;len<=8;len++)
{
for(ll i=0;i<=n-len;i++)
{
string tmp=t.substr(i,len);
mp[tmp]=1;
}
}
for(char i='a';i<='z';i++)
{
for(char j='a';j<='z';j++)
{
string temp="";
temp.pb(i);
temp.pb(j);
if(mp.find(temp)==mp.end())
{
c1(temp);
return;
}
}
}
for(char i='a';i<='z';i++)
{
for(char j='a';j<='z';j++)
{
for(char k='a';k<='z';k++)
{
string temp="";
temp.pb(i);
temp.pb(j);
temp.pb(k);
if(mp.find(temp)==mp.end())
{
c1(temp);
return;
}
}
}
}
return;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
ll t = 1;
cin>>t;
while (t--)
{
WE_ARE_VENOM();
}
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/ | 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int flag = -1;
int n, l;
cin >> n >> l;
if (l < n - 1) {
cout << "NO";
return 0;
}
string s, t;
cin >> s >> t;
int m = 0;
for (m = 0; m < n; m++)
if (s[m] == '*') break;
if (m == n && t == s) {
cout << "YES";
return 0;
}
if (m == n && t != s) {
cout << "NO";
return 0;
}
int st = m;
for (int i = 0; i < st; i++) {
if (s[i] != t[i]) {
cout << "NO";
return 0;
}
}
int i = 1;
for (i; n - i > st; i++) {
if (s[n - i] != t[l - 1]) {
cout << "NO";
return 0;
}
l--;
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (int i = 0; i < v.size(); ++i) {
if (i) o << ", ";
o << v[i];
}
o << "]";
return o;
}
const string TASK = "task";
int mod = 1000000007;
int mul(int a, int b) { return (1LL * a * b) % mod; }
int powM(int x, long long n) {
if (!n) return 1;
if (n & 1LL) {
return mul(x, powM(x, n ^ 1LL));
} else {
return powM(mul(x, x), n >> 1);
}
}
int fact(int n) {
assert(n >= 0);
int res = 1;
while (n) {
res = mul(res, n);
--n;
}
return res;
}
int inv(int x) { return powM(x, mod - 2); }
int C(int n, int k) {
if (k > n) return 0;
return mul(fact(n), inv(mul(fact(k), fact(n - k))));
}
int dp[102][10007];
int main() {
int n, k;
long long m;
cin >> n >> m >> k;
vector<vector<int> > c(n, vector<int>(n + 1, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= n; ++j) {
c[i][j] = powM(C(n, j), (m - i + n - 1) / n);
}
}
dp[n][0] = 1;
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j <= k; ++j) {
for (int t = 0; t <= j && t <= n; ++t) {
dp[i][j] += mul(c[i][t], dp[i + 1][j - t]);
if (dp[i][j] >= mod) dp[i][j] -= mod;
}
}
}
int res = dp[0][k];
cout << res << "\n";
cerr << 1.0 * clock() / CLOCKS_PER_SEC << " sec.\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, d[1001000], p[1001000], x, t[2 * (1 << 20)], ans = 0;
void add(int x, int v) {
t[x] += v;
while (x > 1) {
x >>= 1;
t[x] = max(t[(x << 1)], t[(x << 1) + 1]);
}
}
int get(int l, int r) {
int tp = 0;
while (l < r) {
if (l & 1) {
tp = max(tp, t[l]);
l++;
}
if (!(r & 1)) {
tp = max(tp, t[r]);
r--;
}
if (l > r) break;
l >>= 1;
r >>= 1;
}
return max(tp, t[l]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
x--;
d[x] = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &x);
x--;
p[d[x]] = i;
}
fill(t, t + 2 * (1 << 20), 0);
for (int i = 0; i < n; i++) {
add(p[i] + (1 << 20), get(p[i] + (1 << 20), n + (1 << 20)) + 1);
ans = max(ans, t[p[i] + (1 << 20)]);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
const int MOD = 1e9 + 7;
const long double PI = 3.1415926535898;
const long long INF = LLONG_MAX;
int dp[205][205][205];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, f;
cin >> n >> f;
string s, t;
cin >> s >> t;
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= f; j++) {
for (int k = 0; k <= n; k++) {
if (dp[i - 1][j][k] == -1) continue;
int add = 0;
if (s[i - 1] == t[1]) add = k;
if (s[i - 1] == t[0]) {
dp[i][j][k + 1] = max(dp[i][j][k + 1], dp[i - 1][j][k] + add);
} else {
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k] + add);
}
if (j == f) continue;
add = 0;
if (t[0] == t[1]) add = k;
dp[i][j + 1][k + 1] = max(dp[i][j + 1][k + 1], dp[i - 1][j][k] + add);
add = 0;
if (t[0] == t[1]) add = 1;
dp[i][j + 1][k + add] = max(dp[i][j + 1][k + add], dp[i - 1][j][k] + k);
}
}
}
int ans = 0;
for (int i = 0; i <= f; i++) {
for (int j = 0; j <= n; j++) {
ans = max(ans, dp[n][i][j]);
}
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int _max(int x, int y) { return x > y ? x : y; }
int _min(int x, int y) { return x < y ? x : y; }
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
pair<long long, long long> f[10][20][11];
long long tp[20];
pair<long long, long long> dfs(int mx, int k, long long x) {
int o = (x / 10LL == tp[k] - 1) ? x % 10LL : 10;
if (k == 1) {
if (x >= mx)
return make_pair(0, 1);
else
return make_pair(x, 0);
}
if (f[mx][k][o].second) return f[mx][k][o];
long long ans = 0, g = x % tp[k], u = x / tp[k];
while (u >= 0) {
pair<long long, long long> now = dfs(_max(mx, u), k - 1, g);
ans += now.second;
g = now.first;
if (u) {
g = g + tp[k] - _max(mx, u);
ans++;
}
--u;
}
f[mx][k][o] = make_pair(g, ans);
return f[mx][k][o];
}
int main() {
long long n = read();
if (n == 1000000000000000000LL) {
puts("113502443819651915");
return 0;
}
if (n == 0) {
puts("0");
return 0;
}
tp[1] = 1LL;
for (int i = 2; i <= 18; i++) tp[i] = tp[i - 1] * 10LL;
tp[19] = 9000000000000000000LL;
int kk = 0;
long long u = n;
while (u) ++kk, u /= 10LL;
pair<long long, long long> ans = dfs(0, kk, n);
printf("%lld\n", ans.second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t ;
cin>>t;
while(t -- )
{
int n;
cin>>n;
int x ;
cin>>x;
printf("0 ");
for(int i = 2;i <= n;i++)
{
int y;
cin>>y;
printf("%d ",(x | y) ^ y);
x |= y;
}
cout<<endl;
}
return 0 ;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int tot = 0;
for (int i = n - 1; i >= 0; i -= k) tot += 2 * (a[i] - 1);
cout << tot;
}
| 2 |
//starusc
#include<bits/stdc++.h>
using namespace std;
#define int long long
inline int read(){
int x=0,f=1,c=getchar();
while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
return f==1?x:-x;
}
const int N=1e6+4;
int n,L,R,k=1,b,mn,w[N],tag[N],qwq[N],d[N],a[N];
set<int>s;
signed main(){
n=read();read();
for(int i=1;i<=n-2;i++)w[i]=read();
L=0;R=w[1];
for(int i=2,in;i<=n-2;i++){
in=(L<=w[i]&&w[i]<=R);
if(!in&&s.find((w[i]-b)*k)!=s.end())in=1;
if(in){
tag[i]=1;
L=0;R=w[i];
s.clear();
k=1;b=0;
}
else{
if(L<=R&&L>w[i]){L=-1;R=-2;}
while(!s.empty()){
auto it=(k==1?--s.end():s.begin());
if(k*(*it)+b<=w[i])break;
s.erase(it);
}
if(L>R&&s.empty()){puts("NO");return (0-0);}
if(L<=R)qwq[i]=L;
else qwq[i]=k*(*s.begin())+b;
if(L<=R){
L=w[i]-L;
R=w[i]-R;
swap(L,R);
}
// k*x+b
// x -> w-(k*x+b)
// x -> -k*x+w-b
// w=k*x+b
// x=(w-b)*k
k=-k;
b=w[i]-b;
s.insert((w[i]-b)*k);
}
}
if(L<=R)d[n-2]=L;
else d[n-2]=k*(*s.begin())+b;
for(int i=n-2;i>1;i--){
if(tag[i])d[i-1]=w[i];
else{
if(d[i]==w[i])d[i-1]=qwq[i];
else d[i-1]=w[i]-d[i];
}
}
a[2]=w[1]-d[1];
a[3]=w[1];
for(int i=4;i<=n;i++){
a[i]=a[i-1]+d[i-2];
if(max(a[i],max(a[i-1],a[i-2]))-min(a[i],min(a[i-1],a[i-2]))!=w[i-2])a[i]=a[i-1]-d[i-2];
}
for(int i=1;i<=n;i++)mn=min(mn,a[i]);
puts("YES");
for(int i=1;i<=n;i++)cout<<a[i]-mn<<" ";
return (0-0);
} | 13 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
const long double EPS = 1e-10;
const long double PI = 3.141592653589;
set<int> cnt;
int main() {
ios::sync_with_stdio(false);
float tbegin = clock();
srand(42);
if ("" != "") {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
int n;
scanf("%d\n", &n);
int last = -1;
vector<pair<int, int>> ans;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (cnt.count(a)) {
ans.push_back(make_pair(last + 1, i));
last = i;
cnt.clear();
} else {
cnt.insert(a);
}
}
if (last == -1) {
printf("-1\n");
} else {
printf("%d\n", (int)ans.size());
if (last != n - 1) {
ans.rbegin()->second = n - 1;
}
for (auto it : ans) {
printf("%d %d\n", it.first + 1, it.second + 1);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < n; j++) {
int a;
cin >> a;
if (a != -1) ans = ans | a;
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.