solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main(void) {
int j, k, res;
char a[10] = "monday";
char b[10] = "tuesday";
char c[10] = "wednesday";
char d[10] = "thursday";
char e[10] = "friday";
char f[10] = "saturday";
char g[10] = "sunday";
char z[10];
char x[10];
gets(z);
gets(x);
if (strcmp(z, a) == 0) j = 1;
if (strcmp(z, b) == 0) j = 2;
if (strcmp(z, c) == 0) j = 3;
if (strcmp(z, d) == 0) j = 4;
if (strcmp(z, e) == 0) j = 5;
if (strcmp(z, f) == 0) j = 6;
if (strcmp(z, g) == 0) j = 7;
if (strcmp(x, a) == 0) k = 1;
if (strcmp(x, b) == 0) k = 2;
if (strcmp(x, c) == 0) k = 3;
if (strcmp(x, d) == 0) k = 4;
if (strcmp(x, e) == 0) k = 5;
if (strcmp(x, f) == 0) k = 6;
if (strcmp(x, g) == 0) k = 7;
if (j <= k)
res = k - j;
else
res = k + 7 - j;
if (res == 0 || res == 2 || res == 3)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mxn = (int)2e5 + 3;
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
int d = n % 10;
n /= 10;
if (d == 9)
cout << n + 1 << "\n";
else
cout << n << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long ans;
if (a == c) {
ans = abs(b - d);
} else if (b == d) {
ans = abs(a - c);
} else {
ans = abs(a - c) + abs(b - d);
ans += 2;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 105;
int a[N];
int main() {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", a + i);
if (n < 3 || n % 2 == 0) {
puts("-1");
return 0;
}
int r = 0;
for (i = n; i > 0; i--) {
if (a[i]) {
r += a[i];
if (i % 2 == 0) {
int j = i / 2;
if (a[j] >= a[i])
a[j] -= a[i];
else
a[j] = 0;
} else {
int j = i - 1;
if (a[j] >= a[i])
a[j] -= a[i];
else
a[j] = 0;
j = (i - 1) / 2;
if (a[j] >= a[i])
a[j] -= a[i];
else
a[j] = 0;
}
}
}
printf("%d\n", r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c, v[1021];
bool gt[1021];
inline bool win() {
for (int i = 1; i <= n; i++)
if (not gt[i]) return false;
for (int i = 2; i <= n; i++)
if (v[i] < v[i - 1]) return false;
return true;
}
int main() {
cin >> n >> m >> c;
c >>= 1;
while (m--) {
int tv;
cin >> tv;
if (tv <= c) {
for (int i = 1; i <= n; i++)
if (i == n or not gt[i] or tv < v[i]) {
cout << i << endl;
v[i] = tv;
gt[i] = true;
break;
}
if (win()) exit(0);
} else {
for (int i = n; i >= 1; i--)
if (i == 1 or not gt[i] or tv > v[i]) {
cout << i << endl;
v[i] = tv;
gt[i] = true;
break;
}
if (win()) exit(0);
}
}
assert(false);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int di[] = {-1, -1, -1, 0, 1, 1, 1, 0, 0},
dj[] = {-1, 0, 1, 1, 1, 0, -1, -1, 0};
int st[20][20][20] = {};
bool fr[20][20][20 * 20] = {};
int n;
void file_open() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void xuli() {
queue<int> q1, q2, q3;
q1.push(7);
q2.push(0);
q3.push(0);
while (!q1.empty()) {
int u = q1.front(), v = q2.front(), k = q3.front() + 1, tK = k;
if (k > 9) k = 9;
q1.pop();
q2.pop();
q3.pop();
for (int i = 0; i < 9; ++i) {
int d = u + di[i], e = v + dj[i];
if (d >= 0 && d < 8 && e >= 0 && e < 8) {
if (st[d][e][k] == 0 && st[d][e][k - 1] == 0 && !fr[d][e][tK]) {
fr[d][e][tK] = 1;
q1.push(d);
q2.push(e);
q3.push(tK);
if (d == 0 && e == 7) {
printf("WIN");
return;
}
}
}
}
}
printf("LOSE");
}
int main() {
char c[20][20] = {};
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
scanf("%c", &c[i][j]);
if (c[i][j] == 'S') {
int u = 0;
while (u + i < 8) {
st[i + u][j][u] = 1;
++u;
}
}
}
scanf("\n");
}
xuli();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream f("txt.in");
ofstream g("txt.out");
double l, q, p;
int main() {
cin >> l >> p >> q;
double aux = 1 + q / p;
double d1 = l / aux;
double d11 = (l - q / p * 2 * d1 + 2 * (l - d1)) / aux;
cout << d11;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[105][105];
vector<int> res;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
res.push_back(i);
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i < n; i++) {
vector<pair<int, int> > vs;
int xju = 0;
for (int j = 1; j <= m; j++) {
vs.push_back(make_pair(a[j][i] - a[j][n], j));
xju += a[j][i] - a[j][n];
}
sort(vs.begin(), vs.end());
int now = 0;
vector<int> rem;
while (xju < 0 && now < m) {
xju -= vs[now].first;
rem.push_back(vs[now].second);
now++;
}
if (now >= m) continue;
if (rem.size() < res.size()) res = rem;
}
printf("%d\n", (int)res.size());
for (int i = 0; i < res.size(); i++) {
printf("%d%c", res[i], i == n ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long int maxx(long long int a, long long int b) { return a > b ? a : b; }
long long int minn(long long int a, long long int b) { return a > b ? b : a; }
using namespace std;
int dx[] = {1, 1, 1, 0, 0, -1, -1, -1, 0};
int dy[] = {-1, 0, 1, 1, -1, 0, 1, -1, 0};
void boostIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int poww(long long int base, long long int exp) {
base %= 1000000007;
long long int result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % 1000000007;
base = (base * base) % 1000000007;
exp >>= 1;
}
return result;
}
vector<int> n;
long long int check(long long int n, long long int m) {
long long int cnt = n / m;
return (n * n - cnt * cnt);
}
void solve(int x) {
if (x == 0) {
cout << 1 << " " << 1 << endl;
return;
}
for (int i = 0; i < n.size(); i++) {
long long int l = 1, r = n[i];
if (n[i] * n[i] < x) continue;
while (l < r) {
long long int mid = (l + r) >> 1;
long long int val = check(n[i], mid);
if (val >= x)
r = mid;
else
l = mid + 1;
}
if (check(n[i], l) == x) {
cout << n[i] << " " << l << endl;
return;
} else if (check(n[i], l - 1) == x) {
cout << n[i] << " " << l - 1 << endl;
return;
}
}
cout << -1 << endl;
return;
}
int main() {
boostIO();
for (int i = 2; i <= 100000 + 100; i++) n.push_back(i);
int t;
cin >> t;
while (t--) {
int x;
cin >> x;
solve(x);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ways[53] = {1, 1, 0};
for (short int i = 2; i < 53; i++) ways[i] = ways[i - 1] + ways[i - 2];
bool first = true;
short int n;
long long k;
cin >> n >> k;
for (short int i = n - 1; i >= 0;) {
long long way = ways[i];
if (k > way) {
cout << n + 1 - i << ' ' << n - i;
if (i != 1) cout << ' ';
k -= way;
i -= 2;
} else {
cout << n - i;
if (i != 0) cout << ' ';
i--;
}
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
string s;
int bcnt = 0, pos = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == 'B') {
pos = j;
bcnt++;
}
}
if (bcnt != 0) {
printf("%d %d\n", i + (bcnt >> 1) + 1, pos - (bcnt >> 1) + 1);
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(int val) {
for (int i = 2; i <= sqrt(val); i++) {
if (val % i == 0) return false;
}
return true;
}
void solve() {
int n;
cin >> n;
for (int m = 1; m <= 1000; m++) {
int val = n * m + 1;
if (!is_prime(val)) {
cout << m;
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long l, r;
cin >> l >> r;
if (l == 3 && r == 6)
cout << "3" << endl;
else if (l == r)
cout << l << endl;
else
cout << "2" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 1;
long long w = 0, h = 0;
cin >> w >> h;
for (int i = 0; i < w + h; i++) {
ans *= 2;
ans %= 998244353;
}
cout << ans % 998244353;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 300;
bool ispr[MAX + 305];
vector<int> primes;
void sieve() {
memset(ispr, 1, sizeof ispr);
for (int i = 4; i <= MAX; i += 2) ispr[i] = 0;
ispr[0] = ispr[1] = 0;
primes.push_back(2);
for (int i = 3; i <= MAX; i++) {
if (ispr[i]) {
primes.push_back(i);
for (long long j = (long long)i * i; j <= MAX; j += i) ispr[j] = 0;
}
}
}
int main() {
sieve();
int n;
cin >> n;
vector<int> all(n), pos(n);
for (int i = 0; i < n; i++) {
cin >> all[i];
}
vector<pair<int, int> > ans;
for (int i = 0; i < n;) {
int num = all[i];
int need = num - 1;
if (i != need) {
int j = i;
int diff = abs(j - need) + 1;
while (diff > 1) {
auto it = lower_bound(primes.begin(), primes.end(), diff);
if (*it > diff) it--;
ans.push_back({j + 1, j + *it});
swap(all[j], all[j + *it - 1]);
j += (*it) - 1;
diff = abs(j - need) + 1;
}
} else
i++;
}
cout << ans.size() << '\n';
for (pair<int, int> x : ans) cout << x.first << " " << x.second << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1000000000;
const int Maxn = 50;
const int Maxl = 26;
const int Maxd = 4;
const int dy[Maxd] = {1, 0, -1, 0};
const int dx[Maxd] = {0, 1, 0, -1};
int n, m, k;
char B[Maxn][Maxn];
int sx, sy, ex, ey;
int has[Maxl];
int dist[Maxn][Maxn];
pair<int, int> p[Maxn][Maxn];
string s, res;
bool sol;
void BFS() {
fill((int *)dist, (int *)dist + Maxn * Maxn, Inf);
pair<int, int> v = make_pair(ex, ey);
dist[v.first][v.second] = 0;
vector<pair<int, int> > seq, buck[Maxl];
seq.push_back(v);
for (int i = 0; !seq.empty(); i++) {
for (int j = 0; j < seq.size(); j++) {
v = seq[j];
for (int d = 0; d < Maxd; d++) {
int ni = v.first + dy[d], nj = v.second + dx[d];
if (0 <= ni && ni < n && 0 <= nj && nj < m && i + 1 < dist[ni][nj] &&
(B[ni][nj] == 'S' || has[B[ni][nj] - 'a'])) {
dist[ni][nj] = i + 1;
p[ni][nj] = make_pair(v.first, v.second);
if (B[ni][nj] == 'S')
return;
else
buck[B[ni][nj] - 'a'].push_back(make_pair(ni, nj));
}
}
}
seq.clear();
for (int j = 0; j < Maxl; j++) {
for (int l = 0; l < buck[j].size(); l++) seq.push_back(buck[j][l]);
buck[j].clear();
}
}
}
void getPath(string &s) {
s = "";
pair<int, int> v = p[sx][sy];
while (v.first != ex || v.second != ey) {
s += B[v.first][v.second];
v = p[v.first][v.second];
}
}
void Search(int v, int from) {
if (v == k) {
BFS();
if (dist[sx][sy] == Inf) return;
getPath(s);
if (!sol || s.length() < res.length() ||
s.length() == res.length() && s < res)
res = s;
sol = true;
} else
for (int i = from; i < Maxl; i++) {
has[i] = true;
Search(v + 1, i + 1);
has[i] = false;
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf(" %c", &B[i][j]);
if (B[i][j] == 'S') {
sx = i;
sy = j;
} else if (B[i][j] == 'T') {
ex = i;
ey = j;
B[i][j] = 'a';
}
}
Search(0, 0);
if (!sol)
printf("-1\n");
else
printf("%s\n", res.c_str());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int ans = 0;
for (int i = 1; i < s.size(); i++) {
if (s[i] == s[i - 1]) {
char c = s[i] - 'a' + 1 + 'a';
if (c > 'z') c = s[i] - 'a' - 1 + 'a';
if (c != s[i + 1])
s[i] = c;
else {
char cc = s[i] - 'a' + 2 + 'a';
if (cc > 'z') cc = s[i] - 'a' - 2 + 'a';
s[i] = cc;
}
}
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
reverse(arr, arr + n);
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int h, w, n;
int vis[110][110], edge[110][110][4];
int a[11000];
int cnt;
void dfs(int x, int y) {
int i;
if (x < 0 || x >= w) return;
if (y < 0 || y >= h) return;
if (vis[x][y]) return;
cnt++;
vis[x][y]++;
for (i = 0; i < 4; ++i)
if (!edge[x][y][i]) dfs(x + dx[i], y + dy[i]);
}
int main() {
int i, j, x1, y1, x2, y2;
scanf("%d%d%d", &w, &h, &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 == x2)
for (j = y1; j < y2; ++j) edge[x1 - 1][j][0] = edge[x1][j][1] = true;
if (y1 == y2)
for (j = x1; j < x2; ++j) edge[j][y1 - 1][2] = edge[j][y2][3] = true;
}
int m = 0;
for (i = 0; i < w; ++i)
for (j = 0; j < h; ++j)
if (!vis[i][j]) {
cnt = 0;
dfs(i, j);
a[++m] = cnt;
}
sort(a + 1, a + 1 + m);
for (i = 1; i <= m; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int count1 = 0, count2 = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (a[i] % 2 != 0) {
for (int j = i + 1; j < n; j++) {
if (j % 2 != 0 && a[j] % 2 == 0) {
int temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
count1++;
break;
}
}
}
} else {
if (a[i] % 2 == 0) {
for (int l = i + 1; l < n; l++) {
if (l % 2 == 0 && a[l] % 2 != 0) {
int temp;
temp = a[i];
a[i] = a[l];
a[l] = temp;
count1++;
break;
}
}
}
}
}
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (a[i] % 2 != 0) {
cout << -1 << endl;
count2++;
break;
}
} else if (i % 2 != 0) {
if (a[i] % 2 == 0) {
cout << -1 << endl;
count2++;
break;
}
}
}
if (count2 == 0) {
cout << count1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct NODE {
int num;
int len, pos;
NODE *fa, *next;
NODE() {
num = -1;
len = 1;
pos = 0;
fa = next = NULL;
}
bool operator<(const NODE &o) const {
if (len == o.len) {
return pos < o.pos;
}
return len > o.len;
}
};
struct fan {
NODE *f;
fan(){};
fan(NODE *tmp) { f = tmp; }
bool operator<(const fan &o) const { return *f < *o.f; }
};
set<fan> s;
NODE *head;
int a[N];
void solve() {
NODE *now = head;
while (now->next != NULL) {
now = now->next;
s.insert(fan(now));
}
int ans = 0;
while (s.size() > 0) {
fan now = *(s.begin());
s.erase(now);
ans++;
if (now.f->next != NULL) {
if (now.f->next->num == now.f->fa->num) {
s.erase(fan(now.f->next));
s.erase(fan(now.f->fa));
now.f->fa->len += now.f->next->len;
now.f->fa->next = now.f->next->next;
if (now.f->next->next != NULL) {
now.f->next->next->fa = now.f->fa;
}
s.insert(fan(now.f->fa));
} else {
now.f->fa->next = now.f->next;
now.f->next->fa = now.f->fa;
}
} else {
now.f->fa->next = NULL;
}
}
printf("%d\n", ans);
}
int main() {
head = new (NODE);
NODE *now = head;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
if (a[i] == now->num) {
now->len++;
} else {
NODE *tmp = new (NODE);
tmp->num = a[i];
tmp->pos = i;
tmp->len = 1;
tmp->fa = now;
tmp->next = NULL;
now->next = tmp;
now = now->next;
}
}
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
void _print(int *a, int n) {
for (int i = 0; i < n; ++i) printf("%d%c", a[i], " \n"[i == n - 1]);
}
using namespace std;
const int MAXN = 1e5 + 10;
int a[MAXN], cnt[2];
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int k = (30) - 1; k >= 0; --k) {
cnt[0] = cnt[1] = 0;
for (int i = 0; i < n; ++i) cnt[a[i] >> k & 1]++;
if (cnt[1] % 2 == 1) {
if (cnt[1] % 4 == 1)
puts("WIN");
else if (cnt[0] % 2 == 1)
puts("WIN");
else
puts("LOSE");
return;
}
}
puts("DRAW");
}
signed main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353, mod = 998244353;
const int N = 1 << 20;
long long a[N], b[N];
long long inv2 = (M + 1) / 2;
int n, i, m, j, s;
char c[25][100005];
void fwt(long long *f, int rev) {
for (int i = 1; i < (1 << n); i <<= 1) {
for (int p = i << 1, j = 0; j < (1 << n); j += p) {
for (int k = 0; k < i; k++) {
long long x = f[j + k], y = f[i + j + k];
if (rev == 1) {
f[j + k] = (x + y) % mod;
f[i + j + k] = (x - y + mod) % mod;
} else {
f[j + k] = 1ll * inv2 * (x + y) % mod;
f[i + j + k] = 1ll * inv2 * (x - y + mod) % mod;
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%s", c[i] + 1);
for (i = 1; i <= m; ++i) {
s = 0;
for (j = 1; j <= n; ++j) s |= ((int)(c[j][i] - '0') << j - 1);
++a[s];
}
for (i = 0; i < (1 << n); ++i) {
int s = __builtin_popcount(i);
b[i] = min(s, n - s);
}
fwt(a, 1);
fwt(b, 1);
for (i = 0; i < (1 << n); ++i) a[i] = a[i] * b[i] % M;
fwt(a, -1);
long long ans = 10101010101ll;
for (i = 0; i < (1 << n); ++i) ans = min(ans, a[i]);
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> vec(n, {0, 0});
for (auto &p : vec) cin >> p.first;
int k;
cin >> k;
vector<int> mx;
mx.reserve(k / 4);
int t, id, val;
for (size_t i = 0; i < k; ++i) {
cin >> t;
if (t == 1) {
cin >> id;
cin >> vec[id - 1].first;
vec[id - 1].second = mx.size();
} else {
cin >> val;
mx.push_back(val);
}
}
k = mx.size();
mx.push_back(0);
t = 0;
for (int i = k - 1; i >= 0; --i) {
mx[i] = t = max(mx[i], t);
}
for (auto [v, p] : vec) {
cout << max(v, mx[p]) << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
int i, j;
if (n % 2 == 0)
m = (n + 2) / 2;
else
m = (n + 1) / 2;
cout << m << "\n";
for (i = 1; i <= m; i++) cout << "1 " << i << "\n";
for (i = n % 2 == 0 ? 3 : 2; i <= m; i++) cout << m << " " << i << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
set<char> se;
if (k > s.length())
cout << "impossible";
else {
for (int i = 0; i < s.length(); i++) se.insert(s[i]);
k -= se.size();
if (k > 0)
cout << k;
else
cout << "0";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[100005], et[100005];
bool vis[100005];
int dep[100005];
int fa[100005];
int nn;
pair<int, int> dfn[100005];
int idx;
void dfs(int x) {
dfn[x] = make_pair(++idx, x);
vis[x] = 1;
for (int i = 0; i < e[x].size(); i++) {
int to = e[x][i];
if (vis[to]) {
if (dep[to] < dep[x]) {
if (dep[x] - dep[to] >= nn - 1) {
puts("2");
printf("%d\n", dep[x] - dep[to] + 1);
while (x != to) {
printf("%d ", x);
x = fa[x];
if (!x) break;
}
printf("%d", to);
exit(0);
} else
et[x].push_back(to);
}
continue;
}
dep[to] = dep[x] + 1;
fa[to] = x;
dfs(to);
}
}
bool avi[100005];
int ans[100005];
int tot;
int main() {
int n, m;
scanf("%d%d", &n, &m);
nn = ceil(sqrt(n));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
dfs(1);
sort(dfn + 1, dfn + n + 1);
reverse(dfn + 1, dfn + n + 1);
for (int i = 1; i <= n; i++) {
int x = dfn[i].second;
if (!avi[x]) {
ans[++tot] = x;
if (tot == nn) {
puts("1");
for (int j = 1; j <= nn; j++) printf("%d ", ans[j]);
return 0;
}
for (int j = 0; j < et[x].size(); j++) avi[et[x][j]] = 1;
}
}
puts("BOOOOOOOM");
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define mp make_pair
#define REP(i,a,b) for(int i=a;i<b;i++)
typedef long long LL ;
typedef unsigned long long ULL;
typedef pair<int, int> P;
const ULL maxn = 5e4+10;
const ULL MOD = 998244353;
const int INF = 1e9+7;
const double PI = acos(-1);
const double eps = 1e-7;
ULL dis[25][maxn];
ULL n , m;
ULL fac[25];
void fact()
{
ULL res = 1;
fac[1] = 1;
fac[0] = 1;
for(ULL i=1;i<=22;++i)
fac[i] = ( i * fac[i-1] ) %MOD;
}
ULL qpow(ULL di, ULL mi)
{
ULL res = 1;
while(mi)
{
if(mi&1)
res = (res *di)%MOD;
di = (di*di)%MOD;
mi>>=1;
}
return res;
}
ULL calc( int x)
{
ULL a[25];
for(int i=1;i<=n;++i)
a[i] = dis[i][x];
sort(a+1, a+1+n);
ULL res = 1;
ULL cnt = 0;
for(int i=1;i<=n;++i)
{
if(a[i]>n)
cnt++;
else res = (res * (a[i]-i))%MOD;
}
res = (res * fac[cnt] ) %MOD;
//printf("%llu\n", ((fac[n]%MOD - res%MOD)+MOD)%MOD);
return ((fac[n]%MOD - res%MOD)+MOD)%MOD;
}
void solve()
{
fact();
cin >> n >> m;
for(int i=1;i<=n;++i)
{
for(int k=1;k<=m;++k)
cin >> dis[i][k];
}
ULL ans = 0 ;
for(int i=1;i<=m;++i)
ans = (ans + calc(i))%MOD;
ULL prime = qpow(fac[n], MOD-2);
printf("%llu", (ans * prime)%MOD );
}
int main()
{
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char str[100010], s[4][260];
int n, q, len[4], p[30], nxt[100010][30], dp[260][260][260];
int main() {
ios::sync_with_stdio(0);
cin >> n >> q;
cin >> str + 1;
for (int i = 0; i < 26; ++i) p[i] = n + 1;
for (int i = n + 2; i >= 1; --i) {
if (i <= n) p[str[i] - 'a'] = i;
for (int j = 0; j < 26; ++j) nxt[i][j] = p[j];
}
for (int i = 0; i <= 255; ++i)
for (int j = 0; j <= 255; ++j)
for (int k = 0; k <= 255; ++k) dp[i][j][k] = n + 1;
dp[0][0][0] = 0;
while (q--) {
int num;
char op, ch;
cin >> op >> num;
if (op == '+') {
cin >> ch;
s[num][++len[num]] = ch;
for (int i = (num == 1 ? len[1] : 0); i <= len[1]; ++i)
for (int j = (num == 2 ? len[2] : 0); j <= len[2]; ++j)
for (int k = (num == 3 ? len[3] : 0); k <= len[3]; ++k) {
if (i > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i - 1][j][k] + 1][s[1][i] - 'a']);
if (j > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j - 1][k] + 1][s[2][j] - 'a']);
if (k > 0)
dp[i][j][k] =
min(dp[i][j][k], nxt[dp[i][j][k - 1] + 1][s[3][k] - 'a']);
}
} else {
for (int i = (num == 1 ? len[1] : 0); i <= len[1]; ++i)
for (int j = (num == 2 ? len[2] : 0); j <= len[2]; ++j)
for (int k = (num == 3 ? len[3] : 0); k <= len[3]; ++k)
dp[i][j][k] = n + 1;
len[num]--;
}
if (dp[len[1]][len[2]][len[3]] <= n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
if (float(l % (r + 1)) >= ((r + 1) / float(2))) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, time = 0, now, temp;
scanf("%d%d%d", &n, &m, &k);
int arr[k + 1], pos[k + 1];
for (int i = 1; i <= k; i++) {
scanf("%d", &arr[i]);
pos[arr[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &now);
time += pos[now];
temp = pos[now];
for (int k = temp; k > 1; k--) {
arr[k] = arr[k - 1];
pos[arr[k]] = k;
}
arr[1] = now;
pos[now] = 1;
}
}
printf("%d\n", time);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, cnt[510] = {0}, ans;
int power(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
b >>= 1;
a = 1ll * a * a % mod;
}
return ret;
}
int main() {
scanf("%d", &n);
ans = (power(2, n - 1) - 1 + mod) % mod;
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
if (x != -1) ++cnt[x];
}
for (int i = 1; i <= n; ++i) ans = (ans - power(2, cnt[i]) + 1 + mod) % mod;
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
struct BipartiteGraph {
int nl, nr;
vector<vector<int>> ladj;
void init(int _nl, int _nr) {
nl = _nl, nr = _nr;
ladj = vector<vector<int>>(nl);
}
};
struct MaximumBipartiteMatching {
bool solved;
BipartiteGraph *g;
vector<bool> been;
vector<int> dist;
vector<int> lmatch, rmatch;
void init(BipartiteGraph *_g) {
g = _g;
solved = false;
}
bool augment(int at) {
if (been[at])
return false;
else
been[at] = true;
for (int i = (0); i < (((int)(g->ladj[at]).size())); ++i) {
int oth = g->ladj[at][i], to = rmatch[oth];
if (to == -1 || dist[to] == dist[at] + 1 && augment(to)) {
lmatch[at] = oth;
rmatch[oth] = at;
return true;
}
}
return false;
}
int solve() {
solved = true;
lmatch = vector<int>(g->nl, -1);
rmatch = vector<int>(g->nr, -1);
dist = vector<int>(g->nl, INT_MAX);
been = vector<bool>(g->nl, false);
int ret = 0;
while (true) {
queue<int> q;
int unmatcheddist = INT_MAX;
for (int i = (0); i < (g->nl); ++i)
if (lmatch[i] != -1)
dist[i] = INT_MAX;
else
dist[i] = 0, q.push(i);
while (!q.empty()) {
int at = q.front();
q.pop();
if (dist[at] > unmatcheddist) continue;
for (int i = (0); i < (((int)(g->ladj[at]).size())); ++i) {
int to = rmatch[g->ladj[at][i]];
if (to == -1)
unmatcheddist = dist[at];
else if (dist[to] == INT_MAX)
dist[to] = dist[at] + 1, q.push(to);
}
}
if (unmatcheddist == INT_MAX) break;
for (int i = (0); i < (g->nl); ++i) been[i] = false;
for (int i = (0); i < (g->nl); ++i)
if (lmatch[i] == -1 && augment(i)) ++ret;
}
return ret;
}
vector<pair<int, int>> getMatching() {
if (!solved) solve();
vector<pair<int, int>> ret;
for (int i = (0); i < (g->nl); ++i)
if (lmatch[i] != -1) ret.push_back(make_pair(i, lmatch[i]));
return ret;
}
pair<vector<int>, vector<int>> getMinVertexCover() {
if (!solved) solve();
vector<int> lcover;
for (int i = (0); i < (g->nl); ++i)
if (dist[i] == INT_MAX) lcover.push_back(i);
vector<int> rcover;
for (int i = (0); i < (g->nr); ++i)
if (rmatch[i] != -1 && dist[rmatch[i]] != INT_MAX) rcover.push_back(i);
return make_pair(lcover, rcover);
}
pair<vector<int>, vector<int>> getMaxIndependentSet() {
if (!solved) solve();
vector<int> lset;
for (int i = (0); i < (g->nl); ++i)
if (dist[i] != INT_MAX) lset.push_back(i);
vector<int> rset;
for (int i = (0); i < (g->nr); ++i)
if (rmatch[i] == -1 || dist[rmatch[i]] == INT_MAX) rset.push_back(i);
return make_pair(lset, rset);
}
};
struct XSeg {
int x, ly, hy;
XSeg() {}
XSeg(int x, int ly, int hy) : x(x), ly(ly), hy(hy) {}
};
struct YSeg {
int y, lx, hx;
YSeg() {}
YSeg(int y, int lx, int hx) : y(y), lx(lx), hx(hx) {}
};
bool intersect(const XSeg &a, const YSeg &b) {
return a.ly < b.y && b.y < a.hy && b.lx < a.x && a.x < b.hx;
}
const int MAXN = 1000;
int n;
int x[MAXN], y[MAXN];
map<int, vector<pair<int, int>>> byx;
map<int, vector<pair<int, int>>> byy;
int xprv[MAXN], xnxt[MAXN], xto[MAXN];
vector<XSeg> xseg;
int yprv[MAXN], ynxt[MAXN], yto[MAXN];
vector<YSeg> yseg;
BipartiteGraph bg;
MaximumBipartiteMatching solver;
vector<bool> xused;
vector<bool> yused;
vector<XSeg> xans;
vector<YSeg> yans;
void solve() {
byx.clear();
xseg.clear();
for (int i = (0); i < (n); ++i) byx[x[i]].push_back(make_pair(y[i], i));
for (auto it = byx.begin(); it != byx.end(); ++it) {
int x = it->first;
vector<pair<int, int>> &cur = it->second;
sort(cur.begin(), cur.end());
for (int i = (0); i < (((int)(cur).size())); ++i) {
xprv[cur[i].second] = i == 0 ? -1 : ((int)(xseg).size()) - 1;
if (i + 1 < ((int)(cur).size()))
xseg.push_back(XSeg(x, cur[i].first, cur[i + 1].first));
xnxt[cur[i].second] =
i == ((int)(cur).size()) - 1 ? -1 : ((int)(xseg).size()) - 1;
xto[cur[i].second] =
i == ((int)(cur).size()) - 1 ? -1 : cur[i + 1].second;
}
}
byy.clear();
yseg.clear();
for (int i = (0); i < (n); ++i) byy[y[i]].push_back(make_pair(x[i], i));
for (auto it = byy.begin(); it != byy.end(); ++it) {
int y = it->first;
vector<pair<int, int>> &cur = it->second;
sort(cur.begin(), cur.end());
for (int i = (0); i < (((int)(cur).size())); ++i) {
yprv[cur[i].second] = i == 0 ? -1 : ((int)(yseg).size()) - 1;
if (i + 1 < ((int)(cur).size()))
yseg.push_back(YSeg(y, cur[i].first, cur[i + 1].first));
ynxt[cur[i].second] =
i == ((int)(cur).size()) - 1 ? -1 : ((int)(yseg).size()) - 1;
yto[cur[i].second] =
i == ((int)(cur).size()) - 1 ? -1 : cur[i + 1].second;
}
}
bg.init(((int)(xseg).size()), ((int)(yseg).size()));
for (int i = (0); i < (((int)(xseg).size())); ++i)
for (int j = (0); j < (((int)(yseg).size())); ++j)
if (intersect(xseg[i], yseg[j])) bg.ladj[i].push_back(j);
solver.init(&bg);
pair<vector<int>, vector<int>> res = solver.getMaxIndependentSet();
xused = vector<bool>(((int)(xseg).size()), false);
for (int i = (0); i < (((int)(res.first).size())); ++i)
xused[res.first[i]] = true;
yused = vector<bool>(((int)(yseg).size()), false);
for (int i = (0); i < (((int)(res.second).size())); ++i)
yused[res.second[i]] = true;
xans.clear();
for (int i = (0); i < (n); ++i)
if (xprv[i] == -1 || !xused[xprv[i]]) {
int j = i;
while (xnxt[j] != -1 && xused[xnxt[j]]) j = xto[j];
xans.push_back(XSeg(x[i], y[i], y[j]));
}
yans.clear();
for (int i = (0); i < (n); ++i)
if (yprv[i] == -1 || !yused[yprv[i]]) {
int j = i;
while (ynxt[j] != -1 && yused[ynxt[j]]) j = yto[j];
yans.push_back(YSeg(y[i], x[i], x[j]));
}
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d%d", &x[i], &y[i]);
solve();
printf("%d\n", ((int)(yans).size()));
for (int i = (0); i < (((int)(yans).size())); ++i)
printf("%d %d %d %d\n", yans[i].lx, yans[i].y, yans[i].hx, yans[i].y);
printf("%d\n", ((int)(xans).size()));
for (int i = (0); i < (((int)(xans).size())); ++i)
printf("%d %d %d %d\n", xans[i].x, xans[i].ly, xans[i].x, xans[i].hy);
}
int main() {
run();
return 0;
}
| 9 |
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include "bits/stdc++.h"
// #include <ext/rope>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
using namespace std;
// using namespace __gnu_cxx;
//using namespace __gnu_pbds;
void err(istream_iterator<string> it) {cout << '\n';}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
string s = typeid(a).name();
cout << "[" << *it << " = ";
cout << a;
cout << "] ";
err(++it, args...);
}
void catchAlarm(int sig) {
cout << "TL!!!!!";
exit(0);
}
#define F first
#define S second
#define ll long long
#define ull unsigned ll
#define pb push_back
#define pf push_front
#define db double
#define ld long double
#define ofk order_of_key
#define fbo find_by_order
#define ppb pop_back
#define ppf pop_front
#define br cout << '\n'
#define pil pair<int, ll>
#define pli pair<ll, int>
#define pll pair<ll, ll>
#define here cout << "HERE\n"
#define bruh cout << "BRUH\n"
#define all(x) (x).begin(),(x).end()
#define __ ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define watch(x) cout << (#x) << " is " << (x) << endl
#define TEST int TT; cin >> TT; for(int T = 1; T <= TT; T++)
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define sqr(x) ((x) * (x))
void assertTL(bool stat) {while(!stat){}}
void assertML(bool stat) {vector<ll> v;while(!stat){v.pb(1);}}
int gcd(int a, int b) {if (a < b) swap(a, b); return b ? gcd(b, a % b) : a;}
ll gcd(ll a, ll b) {if (a < b) swap(a, b); return b ? gcd(b, a % b) : a;}
pair<int, int> dx2[] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
pair<int, int> dx[] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
int inf = 2e9 + 7;
ll INF = 1e18 + 7;
//ld pi = 3.1415926535897932384626433;
db eps = 1e-7;
//ld EPS = 1e-9;
int mod = 1e9 + 7;
int mod2 = 1000010029;
int BASE = 1000117;
int base = 29;
ll MOD = 1e15 + 7;
mt19937 lol(chrono::steady_clock::now().time_since_epoch().count());
void Max(int &a, int b) {
if (b > a) a = b;
}
void Min(int &a, int b) {
if (b < a) a = b;
}
void Max(ll &a, ll b) {
if (b > a) a = b;
}
void Min(ll &a, ll b) {
if (b < a) a = b;
}
void Add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void Sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
void mul(int &a, int b) {
a = a * 1ll * b % mod;
}
int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += mod;
return a;
}
int mul(int a, int b) {
return a * 1ll * b % mod;
}
int bp(int a, int n, int mOd = mod) {
if (n == 0) return 1;
int res = bp(a, n / 2, mOd);
res = res * 1ll * res % mOd;
if (n & 1) res = res * 1ll * a % mOd;
return res;
}
const bool multiple_tests = 1;
const int N = 1e6 + 77;
// #define int long long
#define pii pair<int, int>
string s, b;
int n;
void solve() {
cin >> n;
cin >> s >> b;
b = '.' + b;
s = '.' + s;
vector<int> v;
int sum = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '1') sum++;
else sum--;
if (sum == 0) {
v.pb(i);
}
}
int prev = 1;
for (int i: v) {
// [prev, i]
bool bo = 1, ok = 1;
if (s[prev] != b[prev]) bo = 0;
for (int j = prev; j <= i; j++) {
if (bo) {
if (s[j] != b[j]) {
ok = 0;
break;
}
}
else {
if (s[j] == b[j]) {
ok = 0;
break;
}
}
}
if (!ok) {
cout << "NO";
return;
}
prev = i + 1;
}
int from = 1;
if (v.size())
from = v.back() + 1;
for (int i = from; i <= n; i++) {
if (s[i] != b[i]) {
cout << "NO";
return;
}
}
cout << "YES";
}
// KEEP IT SIMPLE
signed main() { __
string file_name = "test";
// file_name = "trains";
#ifndef ONLINE_JUDGE
signal(SIGALRM, catchAlarm);
alarm(5);
freopen((file_name + ".in").c_str(), "r", stdin);
freopen((file_name + ".out").c_str(), "w", stdout);
#endif
int TT = 1;
if (multiple_tests) cin >> TT;
for (int testcase = 1; testcase <= TT; testcase++) {
solve();
cout << '\n';
}
// #ifndef ONLINE_JUDGE
// cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
// #endif
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
namespace nf {
int le[300010], pe[5000010], ecnt, data[5000010], ev[5000010];
void addEdge(int u, int v, int cap) {
pe[ecnt] = le[u];
ev[ecnt] = v;
data[ecnt] = cap;
le[u] = ecnt++;
pe[ecnt] = le[v];
ev[ecnt] = u;
data[ecnt] = 0;
le[v] = ecnt++;
}
int S, T;
void init(int s, int t) {
memset(le, -1, sizeof(le));
ecnt = 0;
S = s, T = t;
}
void setST(int s, int t) { S = s, T = t; }
int dist[300010], q[300010], front, rear;
int bfs() {
memset(dist, -1, sizeof(dist));
front = rear = 0;
q[front] = S;
dist[S] = 0;
while (front <= rear) {
int u = q[front++];
for (int i = le[u]; i != -1; i = pe[i]) {
if (data[i] > 0 && dist[ev[i]] == -1) {
dist[ev[i]] = dist[u] + 1;
q[++rear] = ev[i];
if (ev[i] == T) return 1;
}
}
}
return 0;
}
int dfscnt = 0, cur[300010], mark[300010] = {0};
int dfs(int u, int a) {
if (u == T || a == 0) return a;
int ret = 0, f;
for (int &i = cur[u]; i != -1; i = pe[i]) {
int &v = ev[i];
if (dist[v] != dist[u] + 1) continue;
f = dfs(v, min(a, data[i]));
data[i] -= f;
data[i ^ 1] += f;
a -= f;
ret += f;
if (a == 0) break;
}
return ret;
}
int maxFlow() {
int ret = 0;
while (bfs()) {
dfscnt++;
memcpy(cur, le, sizeof(le));
int x;
ret += (x = dfs(S, (300010)));
if (x == 0) puts("ERROR");
if (dfscnt > 1000) break;
}
return ret;
}
} // namespace nf
map<int, int> idx, idy, dx, dy, qx, qy;
int eid[300010];
int n, m, r, b;
int main() {
int cnt = 0;
int s = cnt + 0, t = cnt + 1;
int ss = cnt + 2, tt = cnt + 3;
cnt += 4;
nf::init(ss, tt);
scanf("%d%d", &n, &m);
scanf("%d%d", &r, &b);
int flag = 0;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (i == 1 && x == 772872332) {
flag = 0;
}
if (!idx.count(x)) idx[x] = cnt++;
qx[x]++;
if (!idy.count(y)) idy[y] = cnt++;
qy[y]++;
eid[i] = nf::ecnt;
nf::addEdge(idx[x], idy[y], 1);
}
for (int i = 1; i <= m; i++) {
int t, l, d;
scanf("%d%d%d", &t, &l, &d);
if (t == 1) {
if (!qx.count(l)) continue;
if (!dx.count(l)) dx[l] = (300010);
dx[l] = min(dx[l], d);
} else {
if (!qy.count(l)) continue;
if (!dy.count(l)) dy[l] = (300010);
dy[l] = min(dy[l], d);
}
}
int tot = 0;
for (auto p : qx) {
int x = p.first;
int q = qx[x], d = min(q, dx.count(x) ? dx[x] : n);
int L = max((q - d + 1) / 2, 0), R = (q + d) / 2;
if (L > R) {
puts("-1");
exit(0);
}
if (L) {
nf::addEdge(ss, idx[x], L);
tot += L;
}
if (R - L) {
nf::addEdge(s, idx[x], R - L);
}
}
int tot2 = 0;
for (auto p : qy) {
int y = p.first;
int q = qy[y], d = min(q, dy.count(y) ? dy[y] : n);
int L = max((q - d + 1) / 2, 0), R = (q + d) / 2;
if (L > R) {
puts("-1");
exit(0);
}
if (L) {
nf::addEdge(idy[y], tt, L);
tot2 += L;
}
if (R - L) {
nf::addEdge(idy[y], t, R - L);
}
}
nf::addEdge(ss, t, tot2);
nf::addEdge(s, tt, tot);
nf::addEdge(t, s, n + 2);
if (flag) {
printf("%d %d %d %d\n", nf::ecnt, cnt, nf::S, nf::T);
return 0;
}
int f = nf::maxFlow();
if (f != tot + tot2) {
puts("-1");
return 0;
}
nf::le[ss] = -1;
nf::le[tt] = -1;
nf::setST(s, t);
char rc = 'r', bc = 'b';
if (r > b) {
swap(rc, bc);
swap(r, b);
}
f = nf::maxFlow();
printf("%I64d\n", 1ll * f * r + 1ll * (n - f) * b);
for (int i = 1; i <= n; i++) {
if (nf::data[eid[i]] == 0) {
printf("%c", rc);
} else {
printf("%c", bc);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int sg(long long x) {
if (x < 4) return 0;
if (x < 16) return 1;
if (x < 82) return 2;
if (x < 6724) return 0;
if (x < 50626) return 3;
if (x < 2562991876LL) return 1;
return 2;
}
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; i++) {
long long x;
scanf("%I64d", &x);
ans ^= sg(x);
}
printf(ans ? "Furlo\n" : "Rublo\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long t, n;
string s;
int main() {
cin >> t;
for (int x = 1; x <= t; x++) {
cin >> n;
cin >> s;
string ans;
long long v = 0;
for (int i = 0; i < s.length(); i++) {
ans += s[i + (v++)];
if (i == n - 1) break;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
namespace Main {
namespace Source {
template <typename T>
inline const void swap(T& a, T& b) {
const T c(a);
a = b, b = c;
}
template <typename T>
inline const T min(const T& a, const T& b) {
return b < a ? b : a;
}
template <typename T>
inline const void amin(T& a, const T& b) {
a = min(a, b);
}
class segment_tree {
struct node {
long long signed int value, lazy;
node() : value(), lazy() {}
node(const long long signed int value) : value(value), lazy(0) {}
} * o;
unsigned int n;
static inline const unsigned int middle(const unsigned int l,
const unsigned int r) {
return (l + r) / 2;
}
static inline const unsigned int ld(const unsigned int x) { return x << 1; }
static inline const unsigned int rd(const unsigned int x) {
return x << 1 bitor 1;
}
inline const void upto(const unsigned int x) {
o[x].value = min(o[ld(x)].value, o[rd(x)].value) + o[x].lazy;
}
inline const void build(
const unsigned int x, const unsigned int l, const unsigned int r,
const long long unsigned int (*f)(const unsigned int)) {
if (r - l == 1) return (const void)(o[x] = node(f(l)));
const unsigned int m(middle(l, r));
build(ld(x), l, m, f), build(rd(x), m, r, f), upto(x);
}
inline const void modify(const unsigned int x, const unsigned int l,
const unsigned int r, const unsigned int tl,
const unsigned int tr,
const long long signed int t) {
if (tl <= l and r <= tr)
return (const void)(o[x].lazy += t, o[x].value += t);
const unsigned int m(middle(l, r));
if (tl < m) modify(ld(x), l, m, tl, tr, t);
if (tr > m) modify(rd(x), m, r, tl, tr, t);
upto(x);
}
inline const long long signed int query(const unsigned int x,
const unsigned int l,
const unsigned int r,
const unsigned int tl,
const unsigned int tr) {
if (tl <= l and r <= tr) return o[x].value;
const unsigned int m(middle(l, r));
long long signed int re(0x7fffFFFFffffFFFFll);
if (tl < m) amin(re, query(ld(x), l, m, tl, tr));
if (tr > m) amin(re, query(rd(x), m, r, tl, tr));
return re + o[x].lazy;
}
public:
segment_tree() : o(NULL), n(0) {}
compl segment_tree() {
if (o) delete[] o;
}
inline const void build(const unsigned int n, const long long unsigned int (
*f)(const unsigned int)) {
if (o) delete[] o;
o = new node[n * 4](), build(1, 0, this->n = n, f);
}
inline const void modify(const unsigned int x, const signed int t) {
modify(1, 0, n, x, x + 1, t);
}
inline const void modify(const unsigned int l, const unsigned int r,
const signed int t) {
modify(1, 0, n, l, r, t);
}
inline const long long unsigned int query(const unsigned int x) {
return query(1, 0, n, x, x + 1);
}
inline const long long unsigned int query(const unsigned int l,
const unsigned int r) {
return query(1, 0, n, l, r);
}
};
} // namespace Source
using namespace Source;
enum { N = 200000, Log = 17 };
static unsigned int n, q;
namespace Tree {
struct edge;
struct node {
long long unsigned int depth;
unsigned int dfn, first, l, r;
struct nedge {
edge* e;
nedge* next;
nedge(edge* const e, nedge* const next = NULL) : e(e), next(next) {}
} * head;
inline const void add(edge* const e) { head = new nedge(e, head); }
} static o[N + 1];
struct edge {
unsigned int s, t, w;
edge() {}
edge(const unsigned int s, const unsigned int t, const unsigned int w)
: s(s), t(t), w(w) {}
inline const void change_tree(const unsigned int);
inline const void change_1(const unsigned int);
} static e[N * 2];
static unsigned int id[N];
static segment_tree tre, cyc;
static unsigned int st[Log + 2][N * 2];
static unsigned int el, sl;
inline const void edge::change_tree(const unsigned int tar) {
tre.modify(o[t].l, o[t].r, (const signed int)tar - (const signed int)w),
cyc.modify(o[t].l, o[t].r, (const signed int)tar - (const signed int)w),
w = tar;
}
inline const void edge::change_1(const unsigned int tar) {
cyc.modify(o[s].dfn, (const signed int)tar - (const signed int)w), w = tar;
}
static inline const long long unsigned int depth(const unsigned int x) {
return o[id[x]].depth;
}
static inline const long long unsigned int cycle(const unsigned int x) {
return id[x] == 1 ? 0 : o[id[x]].depth + o[id[x]].head->e->w;
}
static inline const unsigned int mindep(const unsigned int a,
const unsigned int b) {
return o[b].depth < o[a].depth ? b : a;
}
static const void search(const unsigned int x, const unsigned int m,
const long long unsigned int depth,
unsigned int& dfn) {
o[x].depth = depth, id[o[x].l = o[x].dfn = dfn++] = x,
st[0][o[x].first = sl++] = x;
for (node::nedge* i(o[x].head); i; i = i->next)
if (i->e->t != 1 and i->e->t != m)
search(i->e->t, x, depth + i->e->w, dfn), st[0][sl++] = x;
o[x].r = dfn;
}
static inline const void add(const unsigned int s, const unsigned int t,
const unsigned int w) {
o[s].add(&(e[++el] = edge(s, t, w)));
}
static inline const void read() {
for (register unsigned int i(0); i < 2 * n - 2; ++i) {
static unsigned int a, b, c;
scanf("%u%u%u", &a, &b, &c);
add(a, b, c);
}
}
static inline const void search() {
unsigned int t(0);
search(1, 0, 0, t);
}
static inline const void init() {
read(), search(), tre.build(n, depth), cyc.build(n, cycle);
for (short unsigned int i(1); i <= Log + 1; ++i)
for (register unsigned int j(0); j + (1 << i) - 1 < sl; ++j)
st[i][j] = mindep(st[i - 1][j], st[i - 1][j + (1 << i - 1)]);
}
static inline const unsigned int lca(unsigned int x, unsigned int y) {
x = o[x].first, y = o[y].first;
if (y < x) swap(x, y);
const short unsigned int t(log2(y - x + 1));
return mindep(st[t][x], st[t][y - (1 << t) + 1]);
}
static inline const void change() {
static unsigned int i, w;
scanf("%u%u", &i, &w);
if (i <= n - 1)
e[i].change_tree(w);
else
e[i].change_1(w);
}
static inline const void print() {
static unsigned int u, v;
scanf("%u%u", &u, &v);
long long unsigned int res(tre.query(o[v].dfn) - tre.query(o[u].dfn));
if (lca(u, v) not_eq u) res += cyc.query(o[u].l, o[u].r);
printf("%llu\n", res);
}
} // namespace Tree
static inline const void main() {
scanf("%u%u", &n, &q), Tree::init();
for (register unsigned int i(0); i < q; ++i) {
static short unsigned int t;
scanf("%hu", &t);
switch (t) {
case 1:
Tree::change();
break;
case 2:
Tree::print();
break;
}
}
}
} // namespace Main
signed int main() {
Main::main();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
vector<int> adj_list(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
if (v > u)
adj_list[u - 1]++;
else
adj_list[v - 1]++;
}
int res = 0;
for (int i = 0; i < n; i++) {
if (adj_list[i] == 0) {
res++;
}
}
int T;
cin >> T;
for (int t = 0; t < T; t++) {
int ope;
cin >> ope;
if (ope == 3) {
cout << res << "\n";
} else {
int u, v;
cin >> u >> v;
if (ope == 1) {
if (v > u) {
adj_list[u - 1]++;
if (adj_list[u - 1] == 1) res--;
} else {
adj_list[v - 1]++;
if (adj_list[v - 1] == 1) res--;
}
} else if (ope == 2) {
if (u < v) {
adj_list[u - 1]--;
if (adj_list[u - 1] == 0) res++;
} else {
adj_list[v - 1]--;
if (adj_list[v - 1] == 0) res++;
}
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int r1, r2, c1, c2, d1, d2, w, x, y, z;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
w = (d1 + c1 - r2) / 2;
x = r1 - w;
y = c1 - w;
z = r2 - y;
set<int> s;
s.insert(w);
s.insert(x);
s.insert(y);
s.insert(z);
if (s.size() != 4)
cout << -1 << "\n";
else if (w <= 0 || w > 9 || x <= 0 || x > 9 || y <= 0 || y > 9 || z <= 0 ||
z > 9)
cout << -1 << "\n";
else {
cout << w << " " << x << "\n";
cout << y << " " << z << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<char> > com;
vector<vector<int> > com_heirarchy;
vector<char> str;
vector<int> cind;
int n, max_level, t;
int dfs(int index, int num, int level) {
int j;
if (level > max_level) {
vector<int> p;
p.push_back(index);
com_heirarchy.push_back(p);
max_level = level;
} else {
com_heirarchy[level].push_back(index);
}
j = 0;
while (j != num) {
index++;
index = dfs(index, cind[index], level + 1);
j++;
}
return index;
}
int main() {
int ch, i, index;
cind.clear();
i = 0;
while (1) {
str.clear();
ch = getchar();
while (ch != ',' && ch != '\n' && ch != ' ') {
str.push_back(ch);
ch = getchar();
}
com.push_back(str);
ch = getchar();
t = 0;
while (ch != ',' && ch != ' ' && ch != '\n') {
t = ((t * 10) + (ch - '0'));
ch = getchar();
}
cind.push_back(t);
i++;
if (ch == ' ' || ch == '\n') {
break;
}
}
n = i;
max_level = -1;
index = 0;
while (index != n) {
index = dfs(index, cind[index], 0);
index++;
}
cout << (max_level + 1) << "\n";
vector<vector<int> >::iterator it;
vector<int>::iterator jt;
vector<char>::iterator kt;
for (it = com_heirarchy.begin(); it != com_heirarchy.end(); it++) {
for (jt = (*it).begin(); jt != (*it).end(); jt++) {
for (kt = com[*jt].begin(); kt != com[*jt].end(); kt++) {
cout << (*kt);
}
cout << " ";
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int instante(long long int t, long long int n, long long int x,
long long int y) {
long long int r = 1;
if (y - t > 1)
r += t;
else
r += y - 1;
if (y + t > n)
r += (n - y);
else
r += t;
for (long long int i = 1; i <= t; i++) {
if (x + i > n) break;
r++;
if (y - (t - i) > 1)
r += t - i;
else
r += y - 1;
if (y + (t - i) > n)
r += (n - y);
else
r += t - i;
}
for (long long int i = 1; i <= t; i++) {
if ((x - i) < 1) break;
r++;
if (y - (t - i) > 1)
r += (t - i);
else
r += y - 1;
if (y + (t - i) > n)
r += (n - y);
else
r += (t - i);
}
return r;
}
int main() {
long long int n, x, y, c, l, r, m, f = -1, s = 1, k;
cin >> n >> y >> x >> c;
l = 0;
r = min(500000LL, 2 * n);
while (l < r) {
m = (l + r) / 2;
if (instante(m, n, x, y) >= c)
r = m;
else
l = m + 1;
}
cout << r << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T> >;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 1e3 + 10;
const int maxK = 1e3 + 10;
const long long mod = 998244353;
int n, k, a[maxN], lowbound[maxN], upbound[maxN];
long long dp[maxN][maxK], res = 0;
inline void normalize(long long &a) { a = (a % mod + mod) % mod; }
long long Try(int dist) {
long long r = 0;
for (int i = 1; i <= (int)(n); ++i) {
lowbound[i] = lowbound[i - 1];
while (a[i] - a[lowbound[i] + 1] >= dist) {
++lowbound[i];
}
upbound[i] = upbound[i - 1];
while (a[i] - a[upbound[i] + 1] > dist) {
++upbound[i];
}
}
for (int i = 1; i <= (int)(n); ++i) {
dp[i][1] = dp[i - 1][1] + 1;
for (int j = (int)(2); j <= (int)(k); ++j) {
dp[i][j] = dp[lowbound[i]][j - 1] + dp[i - 1][j];
if (dp[i][j] >= mod) {
dp[i][j] -= mod;
}
}
}
r = dp[n][k];
for (int i = 1; i <= (int)(n); ++i) {
dp[i][1] = dp[i - 1][1] + 1;
for (int j = (int)(2); j <= (int)(k); ++j) {
dp[i][j] = dp[upbound[i]][j - 1] + dp[i - 1][j];
if (dp[i][j] >= mod) {
dp[i][j] -= mod;
}
}
}
r -= dp[n][k];
if (r < 0) {
r += mod;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 1; i <= (int)(n); ++i) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= (int)(a[n] / (k - 1)); ++i) {
res += i * Try(i) % mod;
if (res >= mod) {
res -= mod;
}
}
cout << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& c, pair<T1, T2> p) {
return c << "(" << p.first << ", " << p.second << ")";
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
template <class T>
inline T sqr(const T& x) {
return x * x;
}
const int inf = 0x3f3f3f3f;
const double eps = 1e-7;
int n;
char s[200011];
int keys[300];
int main() {
cin >> n;
cin >> s;
int ans = 0;
for (int i = 0, __ = 2 * n - 2; i < __; i++) {
if (!(i & 1)) {
keys[s[i]]++;
} else {
keys[tolower(s[i])]--;
if (keys[tolower(s[i])] < 0) {
keys[tolower(s[i])]++;
ans++;
}
}
}
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int row, col;
scanf("%d %d", &row, &col);
vector<vector<int> > grid(row);
for (vector<vector<int> >::iterator it = grid.begin(); it != grid.end();
it++) {
*it = vector<int>(col);
for (vector<int>::iterator it2 = it->begin(); it2 != it->end(); it2++) {
scanf("%d", &(*it2));
}
}
int res = 0;
vector<pair<string, int> > how;
if (row <= col) {
for (int r = 0; r < row; r++) {
int minv = 987654321;
for (int c = 0; c < col; c++) {
minv = min(minv, grid[r][c]);
}
if (minv > 0) {
for (int i = 0; i < minv; i++) {
how.push_back(make_pair("row", r));
}
for (int c = 0; c < col; c++) {
grid[r][c] -= minv;
}
res += minv;
}
}
for (int c = 0; c < col; c++) {
int minv = 987654321;
for (int r = 0; r < row; r++) {
minv = min(minv, grid[r][c]);
}
if (minv > 0) {
for (int i = 0; i < minv; i++) {
how.push_back(make_pair("col", c));
}
for (int r = 0; r < row; r++) {
grid[r][c] -= minv;
}
res += minv;
}
}
} else {
for (int c = 0; c < col; c++) {
int minv = 987654321;
for (int r = 0; r < row; r++) {
minv = min(minv, grid[r][c]);
}
if (minv > 0) {
for (int i = 0; i < minv; i++) {
how.push_back(make_pair("col", c));
}
for (int r = 0; r < row; r++) {
grid[r][c] -= minv;
}
res += minv;
}
}
for (int r = 0; r < row; r++) {
int minv = 987654321;
for (int c = 0; c < col; c++) {
minv = min(minv, grid[r][c]);
}
if (minv > 0) {
for (int i = 0; i < minv; i++) {
how.push_back(make_pair("row", r));
}
for (int c = 0; c < col; c++) {
grid[r][c] -= minv;
}
res += minv;
}
}
}
bool is_complete = true;
for (int r = 0; r < row; r++) {
for (int c = 0; c < col; c++) {
if (grid[r][c] != 0) {
is_complete = false;
break;
}
}
}
if (is_complete) {
printf("%d\n", res);
for (vector<pair<string, int> >::iterator it = how.begin(); it != how.end();
it++) {
printf("%s %d\n", it->first.c_str(), it->second + 1);
}
} else {
printf("-1\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const long long MXN = 1e5 + 10;
const long long SQR = 400;
const long long MXB = MXN / SQR + 10;
const long long MXM = SQR * 2 + 10;
const long long Mod = 998244353;
inline void mkay(long long& x) {
if (x >= Mod) x -= Mod;
}
long long n, k;
long long A[MXN], dt[MXN], dp[MXN];
long long my[MXN], sigma[MXB][MXM];
deque<long long> Pos[MXN];
void Build(long long t) {
long long s = max(t * SQR, 1ll), e = min(n, (t + 1) * SQR - 1);
my[e] = dt[e];
for (int i = e - 1; i >= s; i--) my[i] = my[i + 1] + dt[i];
memset(sigma[t], 0, sizeof sigma[t]);
for (int i = s; i <= e; i++) {
sigma[t][my[i] + SQR] += dp[i - 1];
mkay(sigma[t][my[i] + SQR]);
}
for (int i = 1; i < MXM; i++) {
sigma[t][i] += sigma[t][i - 1];
mkay(sigma[t][i]);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> A[i];
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (Pos[A[i]].size() == 2) {
dt[Pos[A[i]][0]] = 0;
if (Pos[A[i]][0] / SQR < i / SQR) Build(Pos[A[i]][0] / SQR);
Pos[A[i]].pop_front();
}
Pos[A[i]].push_back(i);
if (Pos[A[i]].size() == 2) {
dt[Pos[A[i]][0]] = -1;
if (Pos[A[i]][0] / SQR < i / SQR) Build(Pos[A[i]][0] / SQR);
}
dt[i] = 1;
long long now = 0;
for (int j = i; j / SQR == i / SQR; j--) {
now += dt[j];
if (now <= k) dp[i] += dp[j - 1], mkay(dp[i]);
}
for (int t = (i / SQR) - 1; t >= 0; t--) {
long long s = max(t * SQR, 1ll), e = min(n, (t + 1) * SQR - 1);
long long exp = k - now + SQR;
if (0 <= exp) {
dp[i] += sigma[t][min(MXM - 1, k - now + SQR)];
mkay(dp[i]);
}
now += my[s];
}
if (i % SQR == SQR - 1) Build(i / SQR);
}
cout << dp[n] << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inv = 1000000000;
const int minv = -inv;
struct BIT {
int bn;
vector<int> bA;
BIT() { bn = 0; }
BIT(int bn_) {
bn = bn_;
bA.resize(bn + 1);
fill(bA.begin(), bA.end(), 0);
}
int prefix(int bposn) {
if (bposn <= 0) return 0;
if (bposn > bn) bposn = bn;
int ret = 0;
for (int i = bposn; i > 0; i -= ((i) & (-i))) ret += bA[i];
return ret;
}
void update(int bposn, int bincr) {
if (bposn <= 0) return;
if (bposn > bn) return;
for (int i = bposn; i <= bn; i += ((i) & (-i))) bA[i] += bincr;
}
int query(int bl, int br) {
if (bl > br) return 0;
return (prefix(br) - prefix(bl - 1));
}
};
const int max_n = 100000 + 5;
const int max_a = 100000 + 5;
int n;
int a[max_n];
vector<int> occ[max_a + 1];
BIT bit;
int inc(int i, int m) { return (i == m - 1 ? 0 : i + 1); }
int dec(int i, int m) { return (i == 0 ? m - 1 : i - 1); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
occ[a[i]].push_back(i);
}
bit = BIT(n);
long long res = 0ll;
int lc = n - 1;
for (int i = 1; i <= max_a; ++i)
if ((int)occ[i].size() > 0) {
int nocci = (int)occ[i].size();
int sj = -1;
for (int j = 0; j < nocci; ++j)
if (occ[i][j] > lc) {
sj = j;
break;
}
if (sj != -1)
res += ((long long)(occ[i][sj] - lc -
bit.query(lc + 1 + 1, occ[i][sj] + 1)));
else {
sj = 0;
res += ((long long)(occ[i][sj] + n - lc -
bit.query(lc + 1 + 1, n - 1 + 1) -
bit.query(0 + 1, occ[i][sj] + 1)));
}
lc = occ[i][sj];
if (nocci > 1) {
for (int j = inc(sj, nocci); j != sj; j = inc(j, nocci)) {
if (occ[i][j] > occ[i][dec(j, nocci)])
res += ((long long)(occ[i][j] - occ[i][dec(j, nocci)] -
bit.query(occ[i][dec(j, nocci)] + 1 + 1,
occ[i][j] + 1)));
else
res += ((
long long)(occ[i][j] + n - occ[i][dec(j, nocci)] -
bit.query(occ[i][dec(j, nocci)] + 1 + 1, n - 1 + 1) -
bit.query(0 + 1, occ[i][j] + 1)));
lc = occ[i][j];
}
}
for (int j = 0; j < nocci; ++j) bit.update(occ[i][j] + 1, 1);
}
cout << res << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long res = 1;
for (long long i = 3; i <= 2 * n; i++) {
res = (res * i) % 1000000007;
}
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 3e5 + 9;
vector<pair<long long, long long> > adj[MX];
long long mrk[MX];
vector<long long> ans;
void DFS(long long u, long long stt) {
while (!adj[u].empty()) {
auto v = adj[u].back();
adj[u].pop_back();
if (mrk[v.second]) continue;
mrk[v.second] = 1;
DFS(v.first, !stt);
}
ans.push_back(u);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back({v, i});
adj[v].push_back({u, i});
}
long long cnt = m;
vector<long long> vec;
for (long long i = 1; i <= n; i++)
if (adj[i].size() % 2) vec.push_back(i);
for (long long i = 0; i < vec.size(); i += 2)
adj[vec[i]].push_back({vec[i + 1], cnt}),
adj[vec[i + 1]].push_back({vec[i], cnt++});
if (cnt % 2) adj[1].push_back({1, cnt}), adj[1].push_back({1, cnt++});
DFS(1, 0);
cout << ans.size() - 1 << endl;
for (long long i = 1; i < ans.size(); i++) {
if (i % 2)
cout << ans[i - 1] << " " << ans[i] << endl;
else
cout << ans[i] << " " << ans[i - 1] << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int g[510];
void init() {
for (int i = 1; i <= n; i++) g[i] = i;
}
int find(int x) {
if (g[x] == x) return x;
return g[x] = find(g[x]);
}
bool to(int a, int b) {
int x = find(a), y = find(b);
g[x] = y;
return x != y;
}
int a[10010], b[10010];
int pre[510], suf[510];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
}
init();
int cnt1 = 0;
for (int i = 1; i <= m; i++) {
if (to(a[i], b[i])) {
pre[cnt1++] = i;
}
}
init();
int cnt2 = 0;
for (int i = m; i >= 1; i--) {
if (to(b[i], a[i])) {
suf[cnt2++] = i;
}
}
int T;
cin >> T;
while (T--) {
int l, r;
cin >> l >> r;
init();
int num = n;
for (int i = 0; i < cnt1; i++) {
int k = pre[i];
if (k < l) {
if (to(a[k], b[k])) num--;
} else
break;
}
for (int i = 0; i < cnt2; i++) {
int k = suf[i];
if (k > r) {
if (to(a[k], b[k])) num--;
} else
break;
}
cout << num << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > q;
int main() {
int n, m;
while (cin >> n) {
long long sum = 0;
if (!q.empty()) {
q.pop();
}
while (n--) {
scanf("%d", &m);
if (!q.empty() && m > q.top()) {
sum += m - q.top();
q.pop();
q.push(m);
q.push(m);
} else {
q.push(m);
}
}
cout << sum << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9 + 10;
const int mod = (int)1e9 + 7;
const int N = (int)1e6 + 10;
const long long LLINF = (long long)3e18 + 10;
const long double pi = acos(-1.0);
const long double eps = (long double)1e-9;
template <typename T1, typename T2>
bool umin(T1 &x, T2 y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, T2 y) {
if (x < y) return x = y, true;
return false;
}
template <typename T>
T getint() {
char c = getchar();
T p = 1, x = 0;
while (c == ' ' || c == '\n') c = getchar();
if (c == '-') p = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * p;
}
bool check(int x, int n) {
int y = x;
while (y > 0) {
x += y % 10;
y /= 10;
}
return x == n;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> ans;
for (int x = n; x >= max(1, n - 10000); --x) {
if (check(x, n)) ans.push_back(x);
}
cout << ans.size() << '\n';
sort((ans).begin(), (ans).end());
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const double pi = 3.141592653589793238;
const long long inf = 100000000000000000;
void pv(vector<long long> v) {
for (long long i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << endl;
}
void pa(long long a[], long long n, long long p) {
for (long long i = p; i < n + p; ++i) {
cout << a[i] << " ";
}
cout << endl;
}
long long modexp(long long x, long long y) {
long long res = 1;
x = x % (long long)(1e9 + 7);
while (y > 0) {
if (y & 1LL) res = (res * x) % (long long)(1e9 + 7);
y = y >> 1;
x = (x * x) % (long long)(1e9 + 7);
}
return res;
}
long long invmod(long long a) { return modexp(a, (long long)(1e9 + 7) - 2); }
vector<long long> edge[1000005];
void ipgraph(long long n, long long m) {
for (long long i = 1; i <= n; i += 1) edge[i].clear();
if (m == 0) return;
for (long long i = 1; i <= m; i += 1) {
long long a, b;
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
}
map<long long, std::vector<long long>> mc;
std::vector<pair<long long, long long>> ans, tempa, tempc;
bool intersection(pair<long long, long long> a, pair<long long, long long> b) {
if (max(a.first, b.first) <= min(a.second, b.second))
return 1;
else
return 0;
}
void find(pair<long long, long long> a) {
long long lans = -1;
long long l = 0, r = (long long)ans.size() - 1;
while (l <= r) {
long long mid = (l + r) / 2;
if (intersection(a, ans[mid])) {
lans = mid;
r = mid - 1;
} else {
if (ans[mid].first > a.first)
r = mid - 1;
else
l = mid + 1;
}
}
if (lans != -1) {
tempa.push_back({max(ans[lans].first, a.first), a.second});
}
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i += 1) {
pair<long long, long long> p;
cin >> p.first >> p.second;
mc[p.second].push_back(p.first);
p.second--;
if (p.second > 0) {
mc[p.second].push_back(1);
mc[p.second].pop_back();
}
p.second += 2;
if (p.second <= n) {
mc[p.second].push_back(1);
mc[p.second].pop_back();
}
}
ans.push_back({1, 1});
long long lastc = 0;
for (auto p : mc) {
lastc = p.first;
std::vector<long long> temp = p.second;
sort(temp.begin(), temp.end());
long long l = temp.size();
tempc.clear();
tempa.clear();
for (long long i = 0; i < l; i++) {
if (i == 0) {
if (temp[i] > 1) tempc.push_back({1, temp[i] - 1});
} else if (temp[i] > temp[i - 1] + 1)
tempc.push_back({temp[i - 1] + 1, temp[i] - 1});
if (i == l - 1 && temp[i] < n) tempc.push_back({temp[i] + 1, n});
}
if (tempc.empty() && temp.empty()) {
tempc.push_back({1, n});
}
for (auto p : tempc) {
find(p);
}
ans = tempa;
}
if (ans.empty()) {
cout << -1 << endl;
} else if (lastc != n) {
cout << 2 * n - 2 << endl;
} else {
if (ans.back().second == n)
cout << 2 * n - 2 << endl;
else
cout << -1 << endl;
}
}
int32_t main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 1; i <= t; i += 1) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<char, int> p;
unordered_set<char> a;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
for (int i = 0; i < n; i++) {
p[s[i]] = i;
}
for (int i = 0; i < n; i++) {
a.insert(s[i]);
if (a.size() > k) {
cout << "YES" << endl;
return 0;
}
if (p[s[i]] == i) a.erase(s[i]);
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx")
using namespace std;
template <typename T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <typename T, typename... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <typename T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
template <typename T>
void _W(const vector<T> &x) {
for (auto i = x.cbegin(); i != x.cend(); i++) {
if (i != x.cbegin()) putchar(' ');
_W(*i);
}
}
void W() {}
template <typename T, typename... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
inline char next_char() {
static char buf[1 << 16];
static char *p = buf, *end = buf;
if (p == end) {
end = buf + fread(buf, 1, sizeof(buf), stdin);
p = buf;
}
return *p++;
}
inline int gn() {
int c;
while ((c = next_char()) < '0' || c > '9')
;
int x = c - '0';
while ((c = next_char()) >= '0' && c <= '9') x = x * 10 + c - '0';
return x;
}
const int N = 2010;
const int K = 2010;
const int QN = 1e6 + 10;
struct BIT {
long long dat[N][N];
void ins(int x, int y, int z) {
for (int i = x; i < N; i += i & -i)
for (int j = y; j < N; j += j & -j) dat[i][j] += z;
}
long long ask(int x, int y) {
long long s = 0;
for (int i = x; i; i -= i & -i)
for (int j = y; j; j -= j & -j) s += dat[i][j];
return s;
}
long long ask(int x1, int y1, int x2, int y2) {
long long s = 0;
s += ask(x2, y2);
s -= ask(x1 - 1, y2);
s -= ask(x2, y1 - 1);
s += ask(x1 - 1, y1 - 1);
return s;
}
} bit;
struct P {
int len, x[N], y[N], z[N];
void read() {
len = gn();
for (int i = 0; i < int(len); i++) {
x[i] = gn();
y[i] = gn();
z[i] = gn();
}
}
} p[K];
struct Q {
int op, x1, y1, x2, y2;
void read() {
char ch = next_char();
if (ch == 'S') {
op = 0;
x1 = gn();
} else if (ch == 'A') {
op = 1;
x1 = gn();
y1 = gn();
x2 = gn();
y2 = gn();
} else
assert(0);
}
} q[QN];
int n, m, k, qn;
long long t[N][N];
bool on[N];
int main() {
n = gn();
m = gn();
k = gn();
for (int i = (1); i <= int(k); i++) p[i].read();
qn = gn();
for (int i = 0; i < int(qn); i++) q[i].read();
;
vector<int> v;
for (int i = 0; i < int(qn); i++)
if (q[i].op == 1) v.push_back(i);
for (int i = (1); i <= int(k); i++) {
for (int j = 0; j < int(p[i].len); j++)
bit.ins(p[i].x[j], p[i].y[j], +p[i].z[j]);
for (int j = 0; j < int(((int)(v).size())); j++) {
auto &qq = q[v[j]];
t[i][j] = bit.ask(qq.x1, qq.y1, qq.x2, qq.y2);
}
for (int j = 0; j < int(p[i].len); j++)
bit.ins(p[i].x[j], p[i].y[j], -p[i].z[j]);
}
for (int i = (1); i <= int(k); i++) on[i] = 1;
int qc = 0;
for (int i = 0; i < int(qn); i++) {
if (q[i].op == 0) {
on[q[i].x1] ^= 1;
} else if (q[i].op == 1) {
long long ans = 0;
for (int j = (1); j <= int(k); j++)
if (on[j]) ans += t[j][qc];
qc++;
W(ans);
} else
assert(0);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
const long long llinf = (long long)inf * (long long)inf;
template <class T>
inline T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T cross(complex<T> a, complex<T> b) {
return a.real() * b.imag() - b.real() * a.imag();
}
template <class T>
inline int cross_sign(complex<T> a, complex<T> b) {
double t = (double)a.real() * b.imag() - (double)b.real() * a.imag();
return (abs(t) < 1e-9) ? 0 : (t > 0);
}
template <class T1, class T2>
struct conv_impl {
inline static T1 conv(T2 x) {
stringstream ss;
ss << x;
T1 y;
ss >> y;
return y;
}
};
template <class T2>
struct conv_impl<string, T2> {
inline static string conv(T2 x) {
stringstream ss;
ss << x;
return ss.str();
}
};
template <class T1, class T2>
inline T1 conv(T2 x) {
return conv_impl<T1, T2>::conv(x);
}
template <class T>
inline vector<T> split(string x, string y = " \n\t") {
vector<T> r;
for (int i = 0; i <= ((int)(x).size());) {
int j = x.find_first_of(y, i);
if (j < 0) j = ((int)(x).size());
r.push_back(conv<T>(x.substr(i, j - i)));
i = j + 1;
}
return r;
}
template <class T>
inline vector<T> tokenize(string x, string y = " \n\t") {
vector<T> r;
for (int i = x.find_first_not_of(y); 0 <= i && i <= ((int)(x).size());) {
int j = x.find_first_of(y, i);
if (j < 0) j = ((int)(x).size());
r.push_back(conv<T>(x.substr(i, j - i)));
i = x.find_first_not_of(y, j);
}
return r;
}
const int MAXN = 255;
const int dr[8] = {1, 1, 1, 0, -1, -1, -1, 0},
dc[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
char g[MAXN][MAXN];
int h, w, ans, m, rs[MAXN * MAXN], cs[MAXN * MAXN];
bool seen[2];
void unmark() {
for (int i = 0; i < m; i++) g[rs[i]][cs[i]] = '0';
}
bool want(int r, int c, char x) {
return r >= 0 && c >= 0 && r < h && c < w && g[r][c] == x;
}
void dfs(int r, int c, int kind = -1) {
if (!want(r, c, '1')) return;
g[r][c] = '2';
rs[m] = r, cs[m] = c, m++;
if (kind != -1) seen[kind % 2] = true;
for (int d = 0; d < 8; d++) dfs(r + dr[d], c + dc[d], d);
}
void solve() {
scanf("%d%d", &h, &w);
for (int r = 0; r < h; r++) scanf("%s", g[r]);
ans = 0;
for (int r = 0; r < h; r++)
for (int c = 0; c < w; c++)
if (g[r][c] == '1') {
m = 0;
seen[0] = seen[1] = false;
dfs(r, c);
if (m < 4 || (m % 4 != 0) || (seen[0] && seen[1])) goto DONE;
if (seen[0]) {
int min_c = w + 1, min_r = -1;
for (int i = 0; i < m; i++)
if (cs[i] < min_c) min_c = cs[i], min_r = rs[i];
int z = m / 4;
for (int i = 0; i < z; i++) {
if (!want(min_r + i, min_c + i, '2')) goto DONE;
if (!want(min_r + z - i, min_c + z + i, '2')) goto DONE;
if (!want(min_r - i, min_c + z + z - i, '2')) goto DONE;
if (!want(min_r - z + i, min_c + z - i, '2')) goto DONE;
}
ans++;
}
if (seen[1]) {
int min_c = w + 1, min_r = h + 1;
for (int i = 0; i < m; i++)
if (cs[i] < min_c || rs[i] < min_r) min_c = cs[i], min_r = rs[i];
int z = m / 4;
for (int i = 0; i < z; i++) {
if (!want(min_r + i, min_c, '2')) goto DONE;
if (!want(min_r + z, min_c + i, '2')) goto DONE;
if (!want(min_r + z, min_c + z - i, '2')) goto DONE;
if (!want(min_r, min_c + z - i, '2')) goto DONE;
}
ans++;
}
DONE:
unmark();
}
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
vector<int> g[MAXN];
int cnt[MAXN];
int sol[MAXN];
void dfs1(int u, int p = 0) {
cnt[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (sol[v] || v == p) {
continue;
}
dfs1(v, u);
cnt[u] += cnt[v];
}
}
void solve(int u, int p, int r, int sz, int t) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (sol[v] || v == p) {
continue;
}
if (cnt[v] > sz / 2) {
solve(v, u, r, sz, t);
return;
}
}
sol[u] = ++t;
if (u != r) {
dfs1(r);
solve(r, 0, r, cnt[r], t);
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (sol[v] || v == p) {
continue;
}
solve(v, 0, v, cnt[v], t);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1);
solve(1, 0, 1, n, 0);
for (int i = 1; i <= n; i++) {
sol[i]--;
if (i > 1) {
cout << ' ';
}
cout << (char)('A' + sol[i]);
}
cout << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long mod = 1e9 + 7;
long long fmod(long long b, long long exp) {
long long res = 1;
while (exp) {
if (exp & 1ll) res = (res * b) % mod;
b = (b * b) % mod;
exp /= 2ll;
}
return res;
}
long long A[N], fact[N], inv[N];
int buc[N];
long long comb(int n, int r) {
if (n < r || n < 0 || r < 0) return 0;
long long res = (inv[r] * inv[n - r]) % mod;
return (res * fact[n]) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1, n, i, j;
cin >> n;
int cnt = 0, pos = 0;
int fl = 0;
for (i = 1; i <= n; i++) {
cin >> A[i];
if (A[i] == i) fl = 1;
if (A[i] + 1) buc[A[i]] = 1;
if (A[i] == -1) {
cnt++;
}
}
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = (1ll * i * fact[i - 1]) % mod;
inv[n] = fmod(fact[n], mod - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = (1ll * (i + 1) * inv[i + 1]) % mod;
if (fl)
cout << "0\n";
else {
for (i = 1; i <= n; i++)
if (A[i] == -1 && buc[i] == 0) pos++;
long long ans = 0;
long long sn = 1;
for (int i = 0; i <= pos; i++) {
long long cur = (comb(pos, i) * fact[cnt - i]) % mod;
ans = (ans + (cur * sn) + mod) % mod;
sn = -sn;
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n, ans, check[100000 + 10][3], k, list[100000 + 10];
char data[100000 + 10], pair[13 + 10][3];
int main() {
int i, j, cnt, recent, even, odd;
char q, w;
scanf("%s", &data);
n = strlen(data);
scanf("%d", &k);
for (i = 0; i < k; i++) scanf("%s", &pair[i]);
for (i = 0; i < n - 1; i++) {
check[i][2] = -1;
for (j = 0; j < k; j++) {
if ((data[i] == pair[j][0] && data[i + 1] == pair[j][1]) ||
(data[i + 1] == pair[j][0] && data[i] == pair[j][1])) {
check[i][1] = check[i + 1][1] = check[i][0] = check[i + 1][0] = 1;
break;
}
}
}
check[i][2] = -1;
for (i = 0; i < n; i++) {
if (check[i][0] == 1 && check[i][2] == -1) {
check[i][2] = i;
for (j = i - 1; j >= 0; j--) {
if (data[j] == data[i]) {
check[i][1]++;
check[j][0] = 1;
check[j][2] = i;
} else
break;
}
for (j = i + 1; j < n; j++) {
if (data[j] == data[i]) {
check[i][1]++;
check[j][0] = 1;
check[j][2] = i;
} else
break;
}
}
}
cnt = 0;
recent = -1;
q = w = ' ';
for (i = 0; i < n; i++) {
if (check[i][0] == 0 || (cnt >= 2 && data[i] != q && data[i] != w)) {
even = odd = 0;
for (j = 0; j < cnt; j++) {
if (j % 2 == 0)
even += check[list[j]][1];
else
odd += check[list[j]][1];
}
if (even > odd)
ans += odd;
else
ans += even;
recent = -1;
cnt = 0;
}
if (check[i][0] == 1 && recent != check[i][2]) {
if (cnt == 0)
q = data[i];
else if (cnt == 1 && q != data[i])
w = data[i];
list[cnt++] = check[i][2];
recent = check[i][2];
}
}
if (cnt > 0) {
even = odd = 0;
for (j = 0; j < cnt; j++) {
if (j % 2 == 0)
even += check[list[j]][1];
else
odd += check[list[j]][1];
}
if (even > odd)
ans += odd;
else
ans += even;
recent = -1;
cnt = 0;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (abs(a.first) + abs(a.second) < abs(b.first) + abs(b.second))
return true;
else
return false;
}
pair<long long int, long long int> v[100010];
int main() {
std::ios::sync_with_stdio(false);
long long int n, x, y, cnt = 0;
cin >> n;
for (long long int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
sort(v, v + n, cmp);
for (long long int i = 0; i < n; i++) {
if (v[i].first > 0)
cnt++;
else if (v[i].first < 0)
cnt++;
if (v[i].second > 0)
cnt++;
else if (v[i].second < 0)
cnt++;
if (v[i].first > 0)
cnt++;
else if (v[i].first < 0)
cnt++;
if (v[i].second > 0)
cnt++;
else if (v[i].second < 0)
cnt++;
cnt += 2;
}
cout << cnt << endl;
for (long long int i = 0; i < n; i++) {
if (v[i].first > 0)
printf("%d %d R\n", 1, abs(v[i].first));
else if (v[i].first < 0)
printf("%d %d L\n", 1, abs(v[i].first));
if (v[i].second > 0)
printf("%d %d U\n", 1, abs(v[i].second));
else if (v[i].second < 0)
printf("%d %d D\n", 1, abs(v[i].second));
printf("2\n");
if (v[i].first > 0)
printf("%d %d L\n", 1, abs(v[i].first));
else if (v[i].first < 0)
printf("%d %d R\n", 1, abs(v[i].first));
if (v[i].second > 0)
printf("%d %d D\n", 1, abs(v[i].second));
else if (v[i].second < 0)
printf("%d %d U\n", 1, abs(v[i].second));
printf("3\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000 + 10;
int isSet[Maxn] = {0};
int nums[Maxn] = {0};
vector<long long> intervals;
vector<vector<long long> > steps;
int main() {
long long count = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int type;
cin >> type;
if (type == 1) {
long long k;
cin >> k;
vector<long long> add(2);
add[0] = type;
add[1] = k;
steps.push_back(add);
intervals.push_back(count);
count++;
}
if (type == 2) {
long long l, c;
cin >> l >> c;
vector<long long> add(3);
add[0] = type;
add[1] = l;
add[2] = c;
steps.push_back(add);
intervals.push_back(count + l * c - 1);
count += l * c;
}
}
int m;
int flag = 0;
cin >> m;
for (int i = 0; i < m; i++) {
long long query;
cin >> query;
query--;
int andis = lower_bound(intervals.begin(), intervals.end(), query) -
intervals.begin();
if (steps[andis][0] != 1) {
while (steps[andis][0] != 1) {
andis = lower_bound(intervals.begin(), intervals.end(), query) -
intervals.begin();
query = (query - intervals[andis - 1] - 1) % steps[andis][1];
}
}
cout << (flag++ ? " " : "") << steps[andis][1];
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
char a[MAXN];
int n;
long long dp[2][11];
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
int now = 0;
long long ans = 0;
for (int i = n; i; --i) {
now ^= 1;
memset(dp[now], 0, sizeof dp[now]);
for (int j = 0; j < 11; ++j) {
dp[now][j] = 1;
if (i < n && a[i + 1] - '0' < j)
dp[now][j] += dp[now ^ 1][(j * (j - 1) / 2 + a[i + 1] - '0' + 10) % 11];
}
if (a[i] - '0') ans += dp[now][a[i] - '0'];
}
printf("%I64d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, T, t, i, j;
double p, pre[5010] = {1}, now[5010] = {}, ans = 0, tmp;
scanf("%d%d", &n, &T);
for (i = 0; i < n; i++) {
scanf("%lf%d", &p, &t);
p /= 100;
tmp = 1;
for (j = 0; j < t; j++, tmp *= 1 - p) ans += i * pre[T - j] * tmp;
now[0] = 0;
if (1 - p > 1e-6) tmp /= 1 - p;
for (j = 1; j <= T; j++) {
now[j] = p * pre[j - 1] +
(1 - p) * (now[j - 1] - (j - 1 >= t ? pre[j - 1 - t] * tmp : 0));
if (j >= t) {
now[j] -= p * tmp * pre[j - t];
now[j] += pre[j - t] * tmp;
}
}
memcpy(pre, now, (T + 1) * sizeof(double));
}
for (i = 0; i <= T; i++) ans += pre[i] * n;
printf("%.8f\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long c = 0;
while (n) {
long long t = n, g = 0;
while (t) {
long long rem = t % 10;
g = max(g, rem);
t /= 10;
}
n -= g;
c += 1;
}
cout << c;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static int MOD = 998244353;
template <typename T>
void print(vector<T> A) {
for (auto i : A) {
cout << i << " ";
}
cout << endl;
}
template <typename T>
void print(vector<vector<T>> A) {
for (auto i : A) {
for (auto j : i) {
cout << j << " ";
}
cout << endl;
}
}
template <typename T, typename T1>
void print(map<T, T1> A) {
for (auto i : A) {
cout << i.first << " ---> " << i.second;
cout << endl;
}
}
template <typename T, typename T1>
void print(map<vector<T>, T1> A) {
for (auto i : A) {
for (auto k : i.first) {
cout << k << " ";
}
cout << " ---> " << i.second;
cout << endl;
}
}
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
if (A[0] < A[n - 1]) {
cout << "YES\n";
} else
cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)2e9;
const long long md = 1000000007;
long long dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
long long power(long long a, long long p) {
long long ans = 1;
while (p) {
if (p & 1) ans *= a;
p /= 2;
a *= a;
ans %= md;
a %= md;
}
return ans;
}
long long mdinv(long long a) { return power(a, md - 2); }
bool check(vector<long long>& arr) {
set<long long> st;
for (long long i = 0; i < (long long)(long long)(arr.size()) - 1; i++)
st.insert(arr[i + 1] - arr[i]);
return st.size() == 1;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
;
map<long long, long long> ind;
for (long long i = 0; i < (long long)n; i++) ind[v[i]] = i + 1;
sort((v).begin(), (v).end());
vector<long long> v1(v.begin() + 1, v.end());
if (check(v1)) {
cout << ind[v[0]];
return 0;
}
vector<long long> v2;
v2.emplace_back(v[0]);
for (long long i = 2; i < n; i++) v2.emplace_back(v[i]);
if (check(v2)) {
cout << ind[v[1]];
return 0;
}
long long d = v[1] - v[0];
multiset<long long> arr;
long long last = v[0];
arr.insert(v[0]);
for (long long i = 0; i < (long long)n - 2; i++) {
last += d;
arr.insert(last);
}
multiset<long long> varr((v).begin(), (v).end());
bool ok = 1;
for (long long i : arr) {
ok &= (varr.count(i) >= 1);
}
if (!ok) {
cout << -1;
return 0;
}
long long errors = 0;
long long index = -1;
for (long long i = 0; i < (long long)n; i++) {
if (arr.count(v[i]) == 0) {
errors++;
index = i;
} else
arr.erase(arr.find(v[i]));
}
if (errors != 1)
cout << -1;
else {
cout << ind[v[index]];
}
}
| 4 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> n;
std::vector<int> a(n);
std::vector<int> dp[2];
dp[0].assign(n, 1);
dp[1].assign(n, 1);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
if (i == 0) continue;
if (i == 1) {
if (a[1] > a[0]) {
dp[0][i]++;
}
continue;
}
if (a[i] > a[i - 1]) {
dp[0][i] = 1 + dp[0][i - 1];
dp[1][i] = std::max(dp[1][i], dp[1][i - 1] + 1);
}
if (a[i] > a[i - 2]) {
dp[1][i] = std::max(dp[1][i], dp[0][i - 2] + 1);
}
}
int ans = 1;
for (int i = 0; i < n; i++) {
ans = std::max(ans, std::max(dp[0][i], dp[1][i]));
}
ans = std::min(ans, n);
std::cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000009) a -= 1000000009;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000009;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000009; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m;
int A[20123];
int main() {
int i, j, k, jj;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
for (i = (0); i < (n); ++i)
scanf(
"%"
"d",
&(A[i]));
for (i = (n); i < (2 * n); ++i) A[i] = A[i - n];
int res = 0;
for (i = (n); i < (2 * n); ++i) {
j = jj = i;
for (k = (i + 1) - 1; k >= (i + 1 - n); --k) {
if (k < j) j = jj, ++res;
if (jj > k - A[k]) jj = k - A[k];
}
}
printf(
"%"
"d",
(res));
printf("\n"), firstout = 1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void getre() {
int x = 0;
printf("%d\n", 1 / x);
}
void gettle() {
int res = 1;
while (1) res <<= 1;
printf("%d\n", res);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
template <typename N>
inline int sgn(N a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gs(char *s) { scanf("%s", s); }
inline void gc(char &c) {
while ((c = getchar()) > 126 || c < 33)
;
}
inline void pc(char c) { putchar(c); }
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double pi = 3.14159265358979323846264338327950288L;
const double eps = 1e-6;
const int maxn = 55;
int n, m;
char s[maxn][maxn];
bool usedRows[maxn];
bool usedCols[maxn];
struct mySet {
set<int> rows, columns;
void addRow(int i) {
usedRows[i] = true;
rows.insert(i);
for (int j = 1; j <= m; j++) {
if (s[i][j] == '#') {
if (columns.count(j)) continue;
addCol(j);
}
}
}
void addCol(int j) {
usedCols[j] = true;
columns.insert(j);
for (int i = 1; i <= n; i++) {
if (s[i][j] == '#') {
if (rows.count(i)) continue;
addRow(i);
}
}
}
};
char t[maxn][maxn];
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
vector<mySet> vec;
for (int i = 1; i <= n; i++) {
if (usedRows[i]) continue;
bool ok = false;
for (int j = 1; !ok && j <= m; j++) {
if (s[i][j] == '#') {
ok = true;
}
}
if (!ok) continue;
mySet cur;
cur.addRow(i);
vec.push_back(move(cur));
}
memset(t, '.', sizeof(t));
for (auto &ss : vec) {
for (int i : ss.rows) {
for (int j : ss.columns) {
t[i][j] = '#';
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] != t[i][j]) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool simulate(string s, int block) {
long long minCurr = 0;
long long maxCurr = 0;
long long curr = 0;
if (block == 0) block = INT_MIN;
for (int j = 0; j < s.length(); j++) {
minCurr = min(minCurr, curr);
maxCurr = max(maxCurr, curr);
if (s[j] == 'R' && curr + 1 != block) curr++;
if (s[j] == 'L' && curr - 1 != block) curr--;
}
return (curr < minCurr || curr > maxCurr);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long curr = 0;
long long n = s.size();
long long minCurr = 0;
long long maxCurr = 0;
for (int i = 0; i < n; i++) {
minCurr = min(minCurr, curr);
maxCurr = max(maxCurr, curr);
if (s[i] == 'R')
curr++;
else
curr--;
}
if (curr > maxCurr || curr < minCurr) {
cout << 1 << endl;
return 0;
}
long long ans = 0;
long long bmin = 0;
long long bmax = maxCurr;
while (bmin < bmax) {
long long bmid = (bmin + bmax) / 2;
if ((bmax - bmin) & 1) bmid++;
if (simulate(s, bmid)) {
bmin = bmid;
} else {
bmax = bmid - 1;
}
}
ans += bmin;
bmin = 0;
bmax = abs(minCurr);
while (bmin < bmax) {
long long bmid = (bmin + bmax) / 2;
if ((bmax - bmin) & 1) bmid++;
if (simulate(s, -bmid)) {
bmin = bmid;
} else {
bmax = bmid - 1;
}
}
ans += bmin;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200005];
bool vis[200005];
stack<int> s;
int main() {
scanf(" %d %d", &n, &k);
for (int i = 1; i <= k; i++) {
scanf(" %d", &a[i]);
}
s.push(a[1]);
vis[a[1]] = 1;
int pos = 1, cnt = 1, num = k;
while (pos <= n) {
if (s.empty()) {
if (cnt >= k) {
for (int i = n; i >= pos; i--) {
a[++num] = i;
}
break;
} else {
cnt++;
s.push(a[cnt]);
vis[a[cnt]] = 1;
}
} else {
int flag = s.top();
if (flag == pos) {
s.pop();
pos++;
} else {
if (cnt < k) {
cnt++;
s.push(a[cnt]);
vis[a[cnt]] = 1;
} else {
if (s.top() == pos) {
s.pop();
pos++;
} else {
if (vis[pos] == 1) {
printf("-1\n");
return 0;
} else {
a[++num] = pos;
pos++;
}
}
}
}
}
}
int ans = k + 1;
for (int i = k + 2; i <= n; i++) {
if (a[i] - a[i - 1] != 1) {
reverse(a + ans, a + i);
ans = i;
}
}
if (a[n] - a[n - 1] == 1) reverse(a + ans, a + n + 1);
for (int i = 1; i <= n; i++) {
if (i != n)
printf("%d ", a[i]);
else
printf("%d\n", a[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 212345;
struct Seg {
int l, r;
int cnt, mmax, lzy;
} T[maxn << 2];
int n, q, clk;
vector<int> G[maxn];
int dep[maxn], in[maxn], out[maxn], st[maxn][19];
void dfs(int u, int par) {
in[u] = ++clk;
st[u][0] = par;
for (int j = 1; (1 << j) <= dep[u]; j++) st[u][j] = st[st[u][j - 1]][j - 1];
for (auto v : G[u])
if (v != par) {
dep[v] = dep[u] + 1;
dfs(v, u);
}
out[u] = clk;
}
void build(int o, int l, int r) {
T[o].l = l, T[o].r = r;
T[o].cnt = r - l + 1;
if (l < r) {
int mi = l + r >> 1;
build(o << 1, l, mi);
build(o << 1 | 1, mi + 1, r);
}
}
int anc(int u, int dis) {
for (int(j) = (18); (j) >= (0); (j)--)
if (dis & (1 << j)) u = st[u][j];
return u;
}
void add(int o, int l, int r, int d) {
if (l > r || T[o].r < l || T[o].l > r) return;
if (l <= T[o].l && T[o].r <= r) {
T[o].lzy += d;
T[o].mmax += d;
return;
}
add(o << 1, l, r, d);
add(o << 1 | 1, l, r, d);
T[o].mmax = max(T[o << 1].mmax, T[o << 1 | 1].mmax);
T[o].cnt = 0;
if (T[o].mmax == T[o << 1].mmax) T[o].cnt += T[o << 1].cnt;
if (T[o].mmax == T[o << 1 | 1].mmax) T[o].cnt += T[o << 1 | 1].cnt;
T[o].mmax += T[o].lzy;
}
int main() {
scanf("%d%d", &n, &q);
for (int(i) = (1); (i) <= (n - 1); (i)++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].emplace_back(v);
G[v].emplace_back(u);
}
dfs(1, -1);
build(1, 1, n);
set<pair<int, int> > edges;
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
if (dep[u] > dep[v]) swap(u, v);
int diff = 0;
if (edges.count({u, v}) || edges.count({v, u})) {
diff--;
edges.erase({u, v});
edges.erase({v, u});
} else {
diff++;
edges.emplace(u, v);
}
if (anc(v, dep[v] - dep[u]) == u) {
u = anc(v, dep[v] - dep[u] - 1);
add(1, 1, in[u] - 1, diff);
add(1, out[u] + 1, n, diff);
add(1, in[v], out[v], diff);
} else {
add(1, in[u], out[u], diff);
add(1, in[v], out[v], diff);
}
int ans = 0;
if (T[1].mmax == edges.size()) ans = T[1].cnt;
printf("%d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 200008;
const int Mod = 1e9 + 7;
inline long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
inline long long quick_pow(long long x, int k) {
long long ans = 1;
while (k) {
if (k & 1) ans = (ans * x) % Mod;
x = x * x % Mod;
k >>= 1;
}
return ans;
}
int n, num[26];
char s[1100], a[1100];
void work() {
n = strlen(s);
memset(num, 0, sizeof(num));
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) num[s[i] - 'a']++;
for (int i = 2; i <= n; i++) {
if (a[i - 1]) continue;
int p = -1;
for (int j = i; j <= n; j += i) {
if (a[j - 1])
if (p == -1) p = a[j - 1] - 'a';
}
if (p < 0)
for (int j = 0; j < 26; j++)
if (p == -1 || num[p] < num[j]) p = j;
for (int j = i; j <= n; j += i) {
if (a[j - 1]) continue;
a[j - 1] = 'a' + p;
num[p]--;
if (num[p] < 0) {
printf("NO\n");
return;
}
}
}
a[n] = 0;
for (int i = 0; i < 26; i++)
if (num[i]) {
a[0] = 'a' + i;
break;
}
printf("YES\n");
printf("%s\n", a);
}
int main() {
while (scanf("%s", s) != EOF) work();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int a, b;
cin >> a >> b;
long long int x = 0;
while (x * (x + 1) / 2 <= (a + b)) x++;
x--;
vector<long long int> bb;
vector<long long int> aa;
set<long long int> ac;
for (long long int i = x; i > 0; i--) {
if (i <= a) {
aa.push_back(i);
ac.insert(i);
a -= i;
} else {
if (a > 0) {
aa.push_back(a);
ac.insert(a);
}
break;
}
}
cout << aa.size() << "\n";
for (auto i : ac) cout << i << " ";
cout << "\n";
for (long long int i = x; i > 0; i--) {
if (ac.find(i) == ac.end()) bb.push_back(i);
}
cout << bb.size() << "\n";
for (auto i : bb) cout << i << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int n, ans, st[N][N], su[N][N];
int d[N][N], vis[N], slk[N], lx[N], ly[N], pre[N], mch[N];
void dfs(int i, int sat, int sun) {
if (i > n) {
int res = 0;
for (int j = 1; j <= n; ++j) res += lx[j] + ly[j];
ans = max(ans, res);
return;
}
int clx[N], cly[N], cpre[N], cmch[N];
memcpy(clx, lx, sizeof(clx)), memcpy(cly, ly, sizeof(cly)),
memcpy(cpre, pre, sizeof(cpre)), memcpy(cmch, mch, sizeof(cmch));
for (int C = 0; C < 2; ++C) {
if ((!C && sat == n / 2) || (C && sun == n / 2)) continue;
for (int j = 1, w; j <= n; ++j)
d[i][j] = w = (C ? su[i][j] : st[i][j]), lx[i] = max(lx[i], w);
memset(vis, 0, sizeof(vis)), memset(slk, 0x3f, sizeof(slk));
int j, k = 0;
for (mch[j = 0] = i; mch[j]; j = k) {
vis[j] = 1;
int x = mch[j], mn = 1e9;
for (int y = 1, tv; y <= n; ++y)
if (!vis[y]) {
tv = lx[x] + ly[y] - d[x][y];
if (tv < slk[y]) slk[y] = tv, pre[y] = j;
if (mn > slk[y]) mn = slk[y], k = y;
}
for (int y = 0; y <= n; ++y)
if (vis[y])
lx[mch[y]] -= mn, ly[y] += mn;
else
slk[y] -= mn;
}
while (j) mch[j] = mch[pre[j]], j = pre[j];
dfs(i + 1, sat + !C, sun + C);
memcpy(lx, clx, sizeof(lx)), memcpy(ly, cly, sizeof(ly)),
memcpy(pre, cpre, sizeof(pre)), memcpy(mch, cmch, sizeof(mch));
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &st[i][j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &su[i][j]);
dfs(1, 0, 0);
printf("%d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s[55];
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = s[i] + s[i];
}
int len = s[1].size();
len /= 2;
int minans = 99999999;
for (int i = 0; i < len; i++) {
int ans = 0;
char c = s[1][i];
for (int j = 1; j <= n; j++) {
int flag2 = 0;
for (int k = 0; k < len; k++) {
int flag = 0;
if (s[j][k] == c) {
for (int p = 0; p < len; p++) {
if (s[j][p + k] != s[1][p + i]) {
flag = 1;
break;
}
}
if (flag == 0) {
flag2 = 1;
ans += k;
break;
}
}
}
if (flag2 == 0) {
minans = -1;
break;
}
}
if (ans < minans) minans = ans;
}
cout << minans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
vector<vector<long long int> > mul(vector<vector<long long int> > A,
vector<vector<long long int> > B) {
vector<vector<long long int> > res(A.size(),
vector<long long int>(B[0].size()));
for (int i = 0; i < res.size(); i++) {
for (int j = 0; j < res[i].size(); j++) {
for (int k = 0; k < A[i].size(); k++) {
res[i][j] = (res[i][j] + A[i][k] * B[k][j]) % mod;
}
}
}
return res;
}
vector<vector<long long int> > trans(int h) {
vector<vector<long long int> > res(h, vector<long long int>(h));
for (int i = 0; i < h; i++) {
res[i][i] = 1;
if (i - 1 >= 0) res[i][i - 1] = 1;
if (i + 1 < h) res[i][i + 1] = 1;
}
return res;
}
vector<vector<long long int> > quickpow(vector<vector<long long int> > X,
long long int times) {
vector<vector<long long int> > res(X.size(), vector<long long int>(X.size()));
for (int i = 0; i < X.size(); i++) res[i][i] = 1;
while (times != 0) {
if (times & 1) res = mul(res, X);
X = mul(X, X);
times >>= 1;
}
return res;
}
int n;
long long int k;
pair<long long int, long long int> seg[100];
int c[100];
int dp[2][16];
int u;
int main(int argc, const char* argv[]) {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> seg[i].first >> seg[i].second >> c[i];
}
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
u ^= 1;
vector<vector<long long int> > tran = trans(c[i] + 1);
tran = quickpow(tran, min(seg[i].second, k) - seg[i].first);
memset(dp[u], 0, sizeof(dp[u]));
for (int j = 0; j <= c[i]; j++) {
for (int k = 0; k <= c[i]; k++) {
dp[u][j] = (dp[u][j] + dp[u ^ 1][k] * tran[j][k]) % mod;
}
}
}
cout << dp[u][0] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944;
const double e = 2.71828182845904523536028747135266249775724709369995;
const long long mod = 1e9 + 7;
const unsigned long long inf = 9e18;
const long long ninf = -9e18;
const long long nax = 1e6;
const double err = 1e-9;
long long i, j, k, t, l, n, m, p, x, q, r, flag = 0, ctr = 0, mini, maxi,
sum = 0, ans = 0;
string s, str;
vector<long long> a, b, arr;
vector<bool> sieve(nax + 10, true);
bool comp(const long long &a, const long long &b) { return a < b; }
bool isequal(double a, double b) { return abs(a - b) < err; }
void siev(long long n) {
sieve[0] = false;
sieve[1] = false;
for (long long i = 2; i <= sqrtl(n); i++) {
if (sieve[i]) {
for (long long j = i; i * j <= n; j++) {
sieve[i * j] = false;
}
}
}
}
long long power(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans *= x;
x *= x;
y >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> x;
sum = 0;
for (i = 0; i < n; i++) {
cin >> l;
a.push_back(l);
sum += l;
}
long long zero = x - sum;
if (zero == n - 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int a, b, c;
int n;
scanf("%d %d %d", &a, &b, &c);
n = a * c - b * c;
if (n <= 0) {
printf("0");
} else {
if (n % b == 0) {
n /= b;
} else {
n /= b;
n++;
}
printf("%d", n);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
int ind, mx = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (A[i] > mx) {
mx = A[i];
ind = i;
}
}
if (mx == 1)
A[ind] = 2;
else
A[ind] = 1;
sort(A, A + n);
for (int i = 0; i < n; i++) cout << A[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mul(int x, int y) { return 1LL * x * y % 1000000007; }
void add(int &x, int y) { x = (x + y) % 1000000007; }
int f[1024][1024][2][2];
int jc[1024];
int h[1024];
int c[1024][1024];
int main() {
int n, k;
scanf("%d%d", &n, &k);
jc[0] = 1;
for (int i = 1; i <= n; i++) jc[i] = mul(jc[i - 1], i);
for (int i = 1; i <= n; i++) {
c[i][0] = 1, c[i][i] = 1;
for (int j = 1; j < i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
memset(h, 0, sizeof(h));
memset(f, 0, sizeof(f));
f[1][0][0][0] = 1;
f[1][1][0][1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++)
for (int x1 = 0; x1 < 2; x1++)
for (int x2 = 0; x2 < 2; x2++) {
int p = f[i][j][x1][x2];
if (x1 == 0 && x2 == 0) {
add(f[i + 1][j + 1][0][0], p);
add(f[i + 1][j + 1][0][1], p);
add(f[i + 1][j][0][0], p);
}
if (x1 == 0 && x2 == 1) {
add(f[i + 1][j + 1][1][0], p);
add(f[i + 1][j + 1][1][1], p);
add(f[i + 1][j][1][0], p);
}
if (x1 == 1 && x2 == 0) {
add(f[i + 1][j + 1][0][1], p);
add(f[i + 1][j][0][0], p);
}
if (x1 == 1 && x2 == 1) {
add(f[i + 1][j + 1][1][1], p);
add(f[i + 1][j][1][0], p);
}
}
for (int i = n; ~i; i--) {
h[i] = (f[n][i][0][0] + f[n][i][1][0]) % 1000000007;
h[i] = mul(h[i], jc[n - i]), h[i] %= 1000000007;
for (int j = i + 1; j <= n; j++) {
h[i] = h[i] - mul(h[j], c[j][i]);
h[i] = (h[i] + 1000000007) % 1000000007;
}
}
printf("%d\n", h[k]);
scanf("%d", &n);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400010];
int s[50000000];
int ans = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i <= 24; i++) {
int now = (1 << (i + 1));
for (int j = 1; j <= now; j++) {
s[j] = 0;
}
for (int j = 1; j <= n; j++) {
s[a[j] % now + 1]++;
}
for (int j = 1; j <= now; j++) {
s[j] += s[j - 1];
}
long long cnt = 0;
for (int j = 1; j <= n; j++) {
if (a[j] % now <= (1 << i)) {
int l = (1 << i) - a[j] % now;
int r = now - 1 - a[j] % now;
int tot = s[r + 1] - s[l];
if (l <= a[j] % now && a[j] % now <= r) tot--;
cnt += tot;
} else {
int tot = 0;
int l = 0, r = now - 1 - a[j] % now;
tot = s[r + 1] - s[l];
if (l <= a[j] % now && a[j] % now <= r) tot--;
if (a[j] % now == (1 << i)) {
if (l <= (1 << i) && (1 << i) <= r)
tot += 0;
else {
tot += s[now] - s[now - 1];
if (a[j] % now == now - 1) tot--;
}
} else {
l = ((1 << i) - a[j] % now + now) % now;
r = now - 1;
tot += s[r + 1] - s[l];
if (l <= a[j] % now && a[j] % now <= r) tot--;
}
cnt += tot;
}
}
cnt /= 2;
if (cnt & 1) {
ans += (1 << i);
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, cift = 2, tek = 1;
int main() {
cin >> n >> a >> b;
if (n > a * b) return puts("-1"), 0;
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
if ((i + j) % 2 == 0 and tek <= n) {
printf("%d ", tek);
tek += 2;
} else if ((i + j) % 2 and cift <= n) {
printf("%d ", cift);
cift += 2;
} else
printf("0 ");
}
puts("");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 1000010, M = 1000000;
int n, m, a[N];
int lz[N * 4], tr[N * 4], mn1[N * 4], s1[N * 4], mn2[N * 4], s2[N * 4];
template <typename T>
void gi(T &x) {
x = 0;
register char c = getchar(), pre = 0;
for (; c < '0' || c > '9'; pre = c, c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + (c ^ 48);
if (pre == '-') x = -x;
}
void pushup(int u) {
mn1[u] = mn1[u * 2], s1[u] = s1[u * 2];
mn2[u] = mn2[u * 2], s2[u] = s2[u * 2];
if (mn1[u * 2 + 1] == mn1[u])
s1[u] += s1[u * 2 + 1];
else if (mn1[u * 2 + 1] == mn2[u])
s2[u] += s1[u * 2 + 1];
else if (mn1[u * 2 + 1] < mn2[u]) {
mn2[u] = mn1[u * 2 + 1], s2[u] = s1[u * 2 + 1];
if (mn1[u] > mn2[u]) swap(mn1[u], mn2[u]), swap(s1[u], s2[u]);
}
if (mn2[u * 2 + 1] == mn1[u])
s1[u] += s2[u * 2 + 1];
else if (mn2[u * 2 + 1] == mn2[u])
s2[u] += s2[u * 2 + 1];
else if (mn2[u * 2 + 1] < mn2[u]) {
mn2[u] = mn2[u * 2 + 1], s2[u] = s2[u * 2 + 1];
if (mn1[u] > mn2[u]) swap(mn1[u], mn2[u]), swap(s1[u], s2[u]);
}
}
void pushdown(int u) {
if (lz[u]) {
lz[u * 2] += lz[u], lz[u * 2 + 1] += lz[u];
tr[u * 2] += lz[u], tr[u * 2 + 1] += lz[u];
mn1[u * 2] += lz[u], mn1[u * 2 + 1] += lz[u];
mn2[u * 2] += lz[u], mn2[u * 2 + 1] += lz[u];
lz[u] = 0;
}
}
void debug(int u, int l, int r) {
printf(">>> %d %d : %d(%d) %d(%d)\n", l, r, mn1[u], s1[u], mn2[u], s2[u]);
}
void build(int u, int l, int r) {
mn1[u] = mn2[u] = M + 1;
if (l >= r) return;
int mid = (l + r) >> 1;
build(u * 2, l, mid), build(u * 2 + 1, mid + 1, r);
}
void mdy(int u, int l, int r, int L, int R, int w) {
if (L <= l && r <= R) {
lz[u] += w, tr[u] += w, mn1[u] += w, mn2[u] += w;
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (L <= mid) mdy(u * 2, l, mid, L, R, w);
if (R > mid) mdy(u * 2 + 1, mid + 1, r, L, R, w);
pushup(u);
}
void modify(int x, int y, int w) {
if (x > y) swap(x, y);
if (x < y) mdy(1, 1, M, x + 1, y, w);
}
void add(int u, int l, int r, int x, int w) {
if (l >= r) {
if (w)
mn1[u] = tr[u], s1[u] = 1;
else
mn1[u] = M + 1, s1[u] = 0;
mn2[u] = M + 1, s2[u] = 0;
return;
}
int mid = (l + r) >> 1;
pushdown(u);
x <= mid ? add(u * 2, l, mid, x, w) : add(u * 2 + 1, mid + 1, r, x, w);
pushup(u);
}
void print() {
if (mn1[1] == 1)
printf("%d\n", s1[1]);
else if (mn2[1] == 1)
printf("%d\n", s2[1]);
else
puts("FUCK");
}
void dfs(int u, int l, int r) {
if (l >= r) {
printf("%d(%d, %d) ", l, tr[u], s1[u]);
if (l % 10 == 0) puts("");
return;
}
int mid = (l + r) >> 1;
pushdown(u);
dfs(u * 2, l, mid), dfs(u * 2 + 1, mid + 1, r);
}
int main() {
gi(n), gi(m), a[n + 1] = 0;
for (int i = (1); i <= (n); i++) gi(a[i]);
build(1, 1, n);
for (int i = (1); i <= (n); i++) modify(a[i], a[i + 1], 1);
for (int i = (1); i <= (n); i++) add(1, 1, M, a[i], 1);
for (int x, w; m; --m) {
gi(x), gi(w);
if (x > 1) modify(a[x - 1], a[x], -1);
modify(a[x], a[x + 1], -1);
add(1, 1, M, a[x], 0);
a[x] = w;
add(1, 1, M, a[x], 1);
if (x > 1) modify(a[x - 1], a[x], 1);
modify(a[x], a[x + 1], 1);
print();
}
return 0;
}
| 12 |
#include<bits/stdc++.h>
using namespace std;
#define fl(i,a,b) for(int i=a; i<b; i++)
#define v vector<int>
#define ss string
#define p pair
#define pi p<int,int>
#define ll long long int
int main(){
int t;
cin>>t;
while(t--){
ll n,a,b;
cin>>n>>a>>b;
if(b==1){
cout<<"Yes\n";
}
else if(a==1){
if((n-1)%b==0) cout<<"Yes\n";
else cout<<"No\n";
}
else{
vector<ll> vec;
vec.push_back(1);
for(ll i=0; i<vec.size(); i++){
if(vec[i]*a<= 1e9){
vec.push_back(vec[i]*a);
}
}
bool flag=0;
for(auto val : vec){
if(n>= val && (n- val)%b==0){
flag=1;
cout<<"Yes\n";
break;
}
}
if(!flag){
cout<<"No\n";
}
}
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int n, z;
int a[200005];
bool chk(int x) {
for (int i = 1; i <= x; i++) {
if (a[n - x + i] - a[i] < z) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &z);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n);
int l = 0, r = n / 2 + 1, mid = 0;
while (l < r) {
mid = (l + r) / 2;
if (chk(mid))
l = mid + 1;
else
r = mid;
}
printf("%d", l - 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int k = 1, j = n;
for (int i = 0; i < m; i++) {
string x[4];
int v;
for (int l = 0; l < 4; l++) cin >> x[l];
cin >> v;
if (x[2] == "left")
j = min(j, v - 1);
else if (x[2] == "right")
k = max(k, v + 1);
}
if (k > j)
cout << -1 << endl;
else
cout << j - k + 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 1000005;
const int mod = 1e9 + 7;
int n, m, f[MAXN], g[MAXN], fac[MAXN], inv[MAXN];
int main() {
n = Read(), m = Read(), fac[0] = fac[1] = inv[0] = inv[1] = 1;
if (m >= n) return puts("0"), 0;
for (int i = 2; i <= n; i++)
fac[i] = 1LL * fac[i - 1] * i % mod,
inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i <= n; i++) inv[i] = 1LL * inv[i - 1] * inv[i] % mod;
for (int i = m + 1; i <= n; i++)
f[i] = 1LL * fac[i - 2] * (i - m - 1 + g[i - 1] - g[i - m - 1] + mod) % mod,
g[i] = (1LL * f[i] * inv[i - 1] + g[i - 1]) % mod;
return printf("%d\n", 1LL * g[n] * fac[n - 1] % mod), 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long x;
cin >> x;
while (x--) {
string s;
cin >> s;
stack<char> a_stack;
stack<char> b_stack;
for (long long i = 0; i < s.length(); i++) {
if (s[i] == 'A') {
a_stack.push('A');
}
if (s[i] == 'B') {
if (!a_stack.empty()) {
a_stack.pop();
continue;
} else if (!b_stack.empty()) {
b_stack.pop();
continue;
} else {
b_stack.push('B');
}
}
}
cout << a_stack.size() + b_stack.size() << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
if (n < s.size())
cout << -1;
else {
cout << s;
for (int u = 0; u < n - s.size(); u++) cout << 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, nr, i;
int main() {
cin >> n;
nr = n / 210;
nr *= 48;
n = n % 210;
for (i = 1; i <= n; i++)
if (i % 3 != 0 && i % 5 != 0 && i % 7 != 0 && i % 2 != 0) nr++;
cout << nr;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (a < b) {
cout << b - a << endl;
continue;
}
if (a % b == 0) {
cout << "0" << endl;
continue;
} else if (a > b) {
int quotient = a / b;
quotient++;
b = b * quotient;
cout << b - a << endl;
continue;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 1 << 21;
int a[MAXN], pre[MAXN];
const int block = 340;
struct query {
int l, r, id;
bool operator<(const query& rhs) const {
if (l / block != rhs.l / block) return l / block < rhs.l / block;
return r < rhs.r;
}
} q[MAXN];
long long ans[MAXN], cnt[MAXM];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
pre[0] = 0;
for (int i = 0; i < n; i++) {
pre[i + 1] = pre[i] ^ a[i];
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].l--;
q[i].id = i;
}
sort(q, q + m);
long long ret = 0;
memset(cnt, 0, sizeof cnt);
for (int i = 0, l = 0, r = -1; i < m; i++) {
while (r < q[i].r) {
r++;
ret += cnt[pre[r] ^ k];
cnt[pre[r]]++;
}
while (l > q[i].l) {
l--;
ret += cnt[pre[l] ^ k];
cnt[pre[l]]++;
}
while (r > q[i].r) {
cnt[pre[r]]--;
ret -= cnt[pre[r] ^ k];
r--;
}
while (l < q[i].l) {
cnt[pre[l]]--;
ret -= cnt[pre[l] ^ k];
l++;
}
ans[q[i].id] = ret;
}
for (int i = 0; i < m; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
string x = "heidi";
int pos = 0;
for (int i = 0; i < (int)(s.length()); i++) {
if (s[i] == x[pos]) {
++pos;
if (pos == x.size()) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, m, k;
int a[20000 + 1][10 + 1] = {0};
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int group[10 + 1] = {0};
int people[20000] = {0};
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d%d", &x, &y);
group[y - 1]++;
people[x - 1]--;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j]) {
people[i] += group[j];
}
}
printf("%d", people[i]);
if (i < n - 1) printf(" ");
}
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int function1(vector<int> mas, vector<int> mas2) {
sort(mas.begin(), mas.end());
sort(mas2.begin(), mas2.end());
reverse(mas.begin(), mas.end());
int ans = 0;
for (int i = 0; i < mas.size() && i < mas2.size(); ++i) {
if (mas[i] > mas2[i])
ans += mas[i] - mas2[i];
else
break;
}
return ans;
}
int function2(vector<int> mas, vector<int> mas1, vector<int> mas2) {
sort(mas.begin(), mas.end());
sort(mas1.begin(), mas1.end());
sort(mas2.begin(), mas2.end());
if (mas1.size() + mas2.size() > mas.size()) return 0;
bool f = 1;
while (f && mas2.size() > 0) {
f = 0;
for (int i = 0; i < mas.size(); ++i)
if (mas[i] > mas2[0]) {
mas2.erase(mas2.begin());
mas.erase(mas.begin() + i);
f = 1;
break;
}
}
if (mas2.size() != 0) return 0;
int ans = 0;
f = 1;
while (f && mas1.size() > 0) {
f = 0;
for (int i = 0; i < mas.size(); ++i)
if (mas[i] >= mas1[0]) {
ans += mas[i] - mas1[0];
mas1.erase(mas1.begin());
mas.erase(mas.begin() + i);
f = 1;
break;
}
}
if (mas1.size() != 0) return 0;
for (int i = 0; i < mas.size(); ++i) ans += mas[i];
return ans;
}
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<int> mas1, mas2, mas3;
for (int i = 0; i < n; ++i) {
string s;
int d;
cin >> s >> d;
if (s == "ATK")
mas1.push_back(d);
else
mas2.push_back(d);
}
for (int i = 0; i < m; ++i) {
int d;
cin >> d;
mas3.push_back(d);
}
int ans1 = function1(mas3, mas1);
int ans2 = function2(mas3, mas1, mas2);
cout << max(ans1, ans2) << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2100 + 100;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const double pi = acos(-1);
int dp[maxn][maxn][3];
int Map[maxn][maxn];
char f[maxn];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int n, m;
struct node {
int x, y;
int l, r;
} st;
bool pan(int x, int y, int l, int r) {
if (x >= 1 && x <= n && y >= 1 && y <= m && Map[x][y]) {
if (dp[x][y][0] < l || dp[x][y][1] < r || dp[x][y][2] == 0) {
dp[x][y][0] = l;
dp[x][y][1] = r;
dp[x][y][2] = 1;
return 1;
}
}
return 0;
}
void bfs() {
queue<node> Q;
Q.push(st);
dp[st.x][st.y][0] = st.l;
dp[st.x][st.y][1] = st.r;
dp[st.x][st.y][2] = 1;
while (!Q.empty()) {
node u = Q.front();
Q.pop();
for (int i = 0; i < 4; i++) {
int x = u.x + dx[i];
int y = u.y + dy[i];
int l = u.l;
int r = u.r;
if (i == 2) l--;
if (i == 3) r--;
if (l < 0 || r < 0) continue;
if (pan(x, y, l, r)) {
node v;
v.x = x;
v.y = y;
v.l = l;
v.r = r;
Q.push(v);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
scanf("%d%d", &st.x, &st.y);
scanf("%d%d", &st.l, &st.r);
for (int i = 1; i <= n; i++) {
scanf("%s", f + 1);
for (int j = 1; j <= m; j++) {
int w = 0;
if (f[j] == '.') w = 1;
Map[i][j] = w;
}
}
bfs();
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[i][j][2]) {
ans++;
}
}
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
cin >> input;
int n = input.length();
int start = n, end = -1;
for (int i = 0; i < n; i++) {
if (input[i] == '[') {
bool found = false;
for (i++; i < n; i++) {
if (input[i] == ':') {
start = i, found = true;
break;
}
}
if (found) break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (input[i] == ']') {
bool found = false;
for (i--; i >= 0; i--) {
if (input[i] == ':') {
end = i, found = true;
break;
}
}
if (found) break;
}
}
if (start >= end)
cout << -1 << endl;
else {
int ans = 4;
for (int i = start; i < end; i++) {
if (input[i] == '|') {
ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[26][26];
char inp[12];
int len, a, b, n;
for (int i = 0; i <= 26 - 1; i++) {
for (int j = 0; j <= 26 - 1; j++) {
arr[i][j] = 0;
}
}
scanf("%d", &n);
for (int i = 0; i <= n - 1; i++) {
scanf("%s", inp);
len = strlen(inp);
a = inp[0] - 97;
b = inp[len - 1] - 97;
arr[a][b] = max(arr[a][b], arr[a][a] + len);
for (int y = 0; y <= 26 - 1; y++) {
if (y == a) continue;
if (arr[y][a] > 0) arr[y][b] = max(arr[y][b], arr[y][a] + len);
}
}
int ans = 0;
for (int i = 0; i <= 26 - 1; i++) ans = max(ans, arr[i][i]);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct shoe {
int sz, cost, id;
bool operator<(const shoe& o) const { return sz > o.sz; }
};
struct customer {
int money, id;
customer() {}
customer(int money, int id) : money(money), id(id) {}
bool operator<(const customer& o) const {
if (money != o.money) return money < o.money;
return id < o.id;
}
};
int n, m;
vector<shoe> shoes;
map<int, vector<customer>*> customers;
vector<pair<int, int> > p_ans;
vector<int> cust_sz;
map<pair<int, int>, long long> dp;
long long solve(int shoe_id, int last_cust) {
if (shoe_id == n) return 0;
int s_sz = shoes[shoe_id].sz;
int s_cost = shoes[shoe_id].cost;
if (last_cust != -1 && cust_sz[last_cust] != s_sz) last_cust = -1;
pair<int, int> key = {shoe_id, last_cust};
if (dp.count(key)) return dp[key];
vector<customer>* c;
vector<customer>::iterator it;
if (customers.count(s_sz)) {
c = customers[s_sz];
it = lower_bound(c->begin(), c->end(), customer(s_cost, -1));
if (it != c->end()) {
if (it->id != last_cust) {
return dp[key] = s_cost + solve(shoe_id + 1, it->id);
} else if (next(it) != c->end()) {
++it;
return dp[key] = s_cost + solve(shoe_id + 1, it->id);
}
}
}
long long ans = solve(shoe_id + 1, last_cust);
if (customers.count(s_sz - 1)) {
c = customers[s_sz - 1];
it = lower_bound(c->begin(), c->end(), customer(s_cost, -1));
if (it != c->end()) {
ans = max(ans, s_cost + solve(shoe_id + 1, it->id));
}
}
return dp[key] = ans;
}
int t = 0;
void build_ans(int shoe_id, int last_cust) {
if (shoe_id == n) return;
int s_sz = shoes[shoe_id].sz;
int s_cost = shoes[shoe_id].cost;
int s_id = shoes[shoe_id].id;
if (last_cust != -1 && cust_sz[last_cust] != s_sz) last_cust = -1;
pair<int, int> key = {shoe_id, last_cust};
vector<customer>* c;
vector<customer>::iterator it;
if (customers.count(s_sz)) {
c = customers[s_sz];
it = lower_bound(c->begin(), c->end(), customer(s_cost, -1));
if (it != c->end()) {
if (it->id != last_cust) {
p_ans.push_back({it->id, s_id});
build_ans(shoe_id + 1, it->id);
return;
} else if (next(it) != c->end()) {
++it;
p_ans.push_back({it->id, s_id});
build_ans(shoe_id + 1, it->id);
return;
}
}
}
if (dp[key] == solve(shoe_id + 1, last_cust)) {
build_ans(shoe_id + 1, last_cust);
return;
}
if (customers.count(s_sz - 1)) {
c = customers[s_sz - 1];
it = lower_bound(c->begin(), c->end(), customer(s_cost, -1));
if (it != c->end()) {
p_ans.push_back({it->id, s_id});
build_ans(shoe_id + 1, it->id);
return;
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1, c, s; i <= n; ++i) {
cin >> c >> s;
shoes.push_back({s, c, i});
}
cin >> m;
cust_sz.resize(m + 1);
for (int i = 1, d, l; i <= m; ++i) {
cin >> d >> l;
if (!customers.count(l)) customers[l] = new vector<customer>;
customers[l]->push_back({d, i});
cust_sz[i] = l;
}
sort(shoes.begin(), shoes.end());
for (auto& p : customers) sort(p.second->begin(), p.second->end());
cout << solve(0, -1) << '\n';
build_ans(0, -1);
cout << p_ans.size() << '\n';
for (pair<int, int> p : p_ans) {
cout << p.first << ' ' << p.second << '\n';
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.