solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a, ans;
int main() {
cin >> a;
while (a) {
if (a % 8 == 1) ans++;
a /= 8;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 100 * 1000 + 10;
long long int dp[MAXN][2];
char solved[MAXN][2];
int a[MAXN];
int n;
long long int solve(int x, int step) {
if (x < 0 || x >= n) return 0;
if (x == 0) return -1;
if (solved[x][step] == 2) return dp[x][step];
if (solved[x][step] == 1) return -1;
solved[x][step] = 1;
long long int ans;
if (step)
ans = solve(x - a[x], !step);
else
ans = solve(x + a[x], !step);
solved[x][step] = 2;
if (ans == -1)
return dp[x][step] = ans;
else
return dp[x][step] = ans + a[x];
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) cin >> a[i + 1];
for (int i = 0; i < n - 1; i++) {
solve(i + 1, 1);
if (dp[i + 1][1] == -1)
cout << -1 << endl;
else
cout << dp[i + 1][1] + i + 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int N(1e5 + 10);
int n, m, r[5][N], c[5][N];
long long f[1 << 5];
int main() {
n = read(), m = read();
for (int i = 1; i < m; i++)
for (int j = 0; j < n; j++) r[j][i] = read();
for (int i = 1; i <= m; i++)
for (int j = 0; j < n; j++) c[j][i] = read();
std::memset(f, 0x3f, sizeof f), f[0] = 0;
for (int i = 1; i < m; i++) {
for (int j = 0; j < (1 << n); j++)
for (int k = 0; k < n; k++)
if (!(j >> k & 1))
f[j | (1 << k)] = std::min(f[j | (1 << k)], f[j] + r[k][i]);
for (int j = 0; j < (1 << n); j++)
for (int k = 0; k < n; k++)
if (((j >> k) ^ (j >> ((k + 1) % n))) & 1) f[j] += c[k][i + 1];
}
std::printf("%lld\n", f[(1 << n) - 1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a, c[1000005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
c[a]++;
}
int sol = 0, p1 = 1, p2 = 1e6, can = 0;
while (can < n) {
p1++;
p2--;
can += c[p1] + c[p2];
sol++;
}
printf("%d\n", sol);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
int main() {
int t, n, r;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &r);
r--;
int sum = 0;
for (int i = 0; i < n - 1; i++) {
int x;
scanf("%d", &x);
sum += x - 1;
}
sum %= n;
printf("%d\n", (r - sum + n) % n + 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[52] = {0}, b[52] = {0};
for (int i = 0; i < n * n; i++) {
int k, l;
cin >> k >> l;
if (a[k] + b[l] == 0) {
cout << i + 1 << " ";
a[k]++;
b[l]++;
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int l[] = {0, 1, 2, 6, 12, 60, 60};
bool isprime(long long a) {
long long i = 2;
if (a == 2 || a == 3) return true;
if (a % 2 == 0) return false;
for (i++; i * i <= a; i += 2) {
if (a % i == 0) return false;
}
return true;
}
int main() {
long long n;
cin >> n;
long long ans;
if (n <= 6)
cout << l[n] << endl;
else {
if (n % 2 == 0) {
ans = 0;
long long i = 3;
while (!(isprime(i) && n % i != 0)) i += 2;
ans = n * (n - 1) * (n - i);
if ((n - 1) * (n - 2) * (n - 3) > ans) ans = (n - 1) * (n - 2) * (n - 3);
} else {
ans = n * (n - 1) * (n - 2);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:36777216")
using namespace std;
const int inf = 1000000000;
const int N = 2000000;
int d[8002][8002];
map<int, int> mp;
int transfer[1000005];
inline int getSum(int a, int b) {
int y = transfer[a];
int x = transfer[b];
return d[y][x];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
srand(16);
int start = clock();
int n;
cin >> n;
vector<int> arr(n);
for (long long int i = 0; i < n; ++i) {
cin >> arr[i];
}
int ans = 0;
for (long long int i = 0; i < n; ++i) {
if (arr[i] == 1) {
ans++;
for (int j = i + 1; j < n; ++j) {
if (arr[j] == 1) {
ans++;
} else {
if (arr[j - 1] == 1 && j != n - 1 && arr[j + 1] == 1) {
ans++;
}
}
}
break;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
struct Song {
int len;
int genre;
};
int const MOD = 1000000007;
int memo[1 << 15][4][226];
int n, t, N;
Song songs[20];
int ans(int bitmask, int sum, int genre) {
int& ret = memo[bitmask][genre][sum];
if (ret != -1) return ret;
ret = 0;
if (bitmask == 0) return ret;
if ((bitmask & (bitmask - 1)) == 0) {
for (int i = 0; i < n; ++i) {
if (bitmask & (1 << i)) {
if (songs[i].genre == genre and songs[i].len == sum) ret = 1;
break;
}
}
} else {
for (int i = 0; i < n; ++i) {
if (bitmask & (1 << i) and songs[i].genre == genre and
songs[i].len <= sum) {
const int nb = (bitmask ^ (1 << i));
for (int prev = 0; prev < 4; ++prev) {
if (prev == genre) continue;
ret = (ret + ans(nb, sum - songs[i].len, prev)) % MOD;
}
}
}
}
return ret;
}
int main() {
cin >> n >> t;
memset(memo, -1, sizeof(memo));
for (int i = 0; i < n; ++i) {
cin >> songs[i].len >> songs[i].genre;
--songs[i].genre;
}
int ret = 0;
N = (1 << n);
for (int i = 0; i < N; ++i)
for (int g = 0; g < 4; ++g) ret = (ret + ans(i, t, g)) % MOD;
cout << ret << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
int buf[42];
template <typename Tp>
inline void write(Tp x) {
int p = 0;
if (x < 0) {
putchar('-');
x = -x;
}
if (x == 0) {
putchar('0');
return;
}
while (x) {
buf[++p] = x % 10;
x /= 10;
}
for (int i = p; i; i--) putchar('0' + buf[i]);
}
const int N = 100000 + 5;
int n, q;
char s[N], nows[N];
int BIT[4][12][12][N];
inline int lb(int x) { return x & (-x); }
inline void add(int ch, int mod, int res, int pos, int v) {
for (int i = pos; i <= n; i += lb(i)) {
BIT[ch][mod][res][i] += v;
}
}
inline int sum(int ch, int mod, int res, int pos) {
int ret = 0;
for (int i = pos; i; i -= lb(i)) ret += BIT[ch][mod][res][i];
return ret;
}
inline int query(int ch, int mod, int res, int L, int R) {
return sum(ch, mod, res, R) - sum(ch, mod, res, L - 1);
}
int main() {
map<char, int> mp;
mp['A'] = 0;
mp['C'] = 1;
mp['G'] = 2;
mp['T'] = 3;
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &q);
for (int mod = 1; mod <= 10; mod++) {
for (int k = 1; k <= n; k++) {
add(mp[s[k]], mod, k % mod, k, +1);
}
}
for (int i = 1; i <= q; i++) {
int op, l, r;
scanf("%d", &op);
if (op == 1) {
char upd_chr;
scanf("%d %c", &l, &upd_chr);
for (int j = 1; j <= 10; j++) add(mp[s[l]], j, l % j, l, -1);
for (int j = 1; j <= 10; j++) add(mp[upd_chr], j, l % j, l, +1);
s[l] = upd_chr;
} else if (op == 2) {
scanf("%d %d %s", &l, &r, nows + 1);
int len = strlen(nows + 1);
int ans = 0;
for (int j = 1; j <= len; j++) {
ans += query(mp[nows[j]], len, (j + l - 1) % len, l, r);
}
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long mn = 1e18 + 7;
for (int i = 0; i < n - 1; i++) {
mn = min(mn, abs(a[i + 1] - a[i]));
}
int cnt = 0;
cout << mn << " ";
for (int i = 0; i < n - 1; i++) {
if (abs(a[i + 1] - a[i]) == mn) cnt++;
}
cout << cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 50;
int n;
int a[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = n; i < 2 * n; ++i) {
a[i] = a[i - n];
}
int ans = 0;
int tmp = 0;
for (int i = 0; i < 2 * n; ++i) {
while (a[i] == 1 && i < 2 * n) {
tmp++;
i++;
}
ans = max(ans, tmp);
tmp = 0;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long cur[100001];
int c[100001];
vector<pair<int, int> > v[100001];
int main() {
memset(cur, -1, sizeof(cur));
map<int, int> memo;
int n, cnt = 0;
scanf("%d", &n);
for (int i = 1, cc, s; i <= n; i++) {
scanf("%d%d", &cc, &s);
if (!memo.count(cc)) memo[cc] = cnt++;
v[memo[cc]].push_back(make_pair(s, i));
}
long long sum = 0;
int id1, id2, f1, f2;
for (int i = 0; i < cnt; i++) {
sort((v[i]).rbegin(), (v[i]).rend());
long long tmp = 0;
for (int j = 1; j <= ((int)(v[i]).size()); j++) {
tmp += v[i][j - 1].first;
int id = j - 1;
if (cur[j] > cur[id]) id = j;
if (cur[j + 1] > cur[id]) id = j + 1;
if (cur[id] == -1) continue;
if (cur[id] + tmp > sum) {
sum = cur[id] + tmp;
f1 = i;
f2 = c[id];
id1 = j;
id2 = id;
}
}
tmp = 0;
for (int j = 1; j <= ((int)(v[i]).size()); j++) {
tmp += v[i][j - 1].first;
if (tmp > cur[j]) {
cur[j] = tmp;
c[j] = i;
}
}
}
printf("%I64d\n%d\n", sum, id1 + id2);
bool p = 0;
int i = 0, j = 0;
if (id1 > id2) {
printf("%d ", v[f1][i++].second);
p = 1;
} else
printf("%d ", v[f2][j++].second);
for (; i < id1 || j < id2; p ^= 1) {
if (!p)
printf("%d ", v[f1][i++].second);
else
printf("%d ", v[f2][j++].second);
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[2005][2005];
int n, m, cnt, dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
void dfs(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m || s[x][y] != '.') return;
int t = -1, sum = 0;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i];
int ty = y + dy[i];
if (s[tx][ty] == '.') {
sum++;
t = i;
}
}
if (sum == 1) {
if (t == 0) {
s[x][y] = '<';
s[x][y + 1] = '>';
} else if (t == 1) {
s[x][y] = '>';
s[x][y - 1] = '<';
} else if (t == 2) {
s[x][y] = '^';
s[x + 1][y] = 'v';
} else if (t == 3) {
s[x][y] = 'v';
s[x - 1][y] = '^';
}
cnt += 2;
for (int i = 0; i < 4; i++) dfs(x + dx[t] + dx[i], y + dy[t] + dy[i]);
}
return;
}
inline void init() {
cnt = 0;
for (int i = 1; i <= n; i++) {
s[i][0] = '*';
s[i][m + 1] = '*';
}
for (int i = 1; i <= m; i++) {
s[0][i] = '*';
s[n + 1][i] = '*';
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '*') cnt++;
return;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
init();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) dfs(i, j);
if (cnt == n * m)
for (int i = 1; i <= n; i++) {
s[i][m + 1] = '\0';
printf("%s\n", s[i] + 1);
}
else
puts("Not unique");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void input_vec(std::vector<T> &v, int n) {
for (int i = 0; i < n; i++) {
cin >> v[i];
}
}
template <class T>
void show(vector<T> &v) {
for (T x : v) {
cout << x << " ";
}
cout << endl;
}
void solve() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO" << endl;
return;
}
std::vector<int> v(2 * n);
int c = 0;
int x = 1;
for (int k = 0; k < n; k++) {
v[c] = x++;
c = (c + n) % (2 * n);
v[c] = x++;
c = (c - 1 + 2 * n) % (2 * n);
}
cout << "YES" << endl;
show(v);
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
long long n;
double calculate(double x) {
double radius = 0.0;
for (long long i = 0; i < n; i++) {
double xi = v[i].first;
double yi = v[i].second;
radius = max(radius,
abs((1.0 * (xi - x) * (xi - x) + 1.0 * yi * yi) / (2.0 * yi)));
}
return radius;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
bool okay1 = false;
bool okay2 = false;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
if (y <= 0) {
okay1 = true;
}
if (y > 0) {
okay2 = true;
}
v.push_back(make_pair(x, y));
}
if (okay1 && okay2) {
cout << -1;
return 0;
}
double low = -100000000;
double high = 100000000;
for (long long i = 0; i < 1000; i++) {
double l1 = low + (high - low) / 3;
double l2 = high + (low - high) / 3;
if (calculate(l1) < calculate(l2)) {
high = l2;
} else
low = l1;
}
cout << setprecision(10) << fixed << calculate(low);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, m, ans, k, l, j, q, x, n, ma, mi;
vector<int> v, g;
string s;
int main() {
cin >> s;
n = s.size();
for (i = 0; i < n - 4; i++) {
if (s[i] == 'h' && s[i + 1] == 'e' && s[i + 2] == 'a' && s[i + 3] == 'v' &&
s[i + 4] == 'y') {
v.push_back(i);
i += 4;
}
if (s[i] == 'm' && s[i + 1] == 'e' && s[i + 2] == 't' && s[i + 3] == 'a' &&
s[i + 4] == 'l') {
g.push_back(i);
i += 4;
}
}
for (i = 0; i < g.size(); i++) {
vector<int>::iterator low, up;
low = lower_bound(v.begin(), v.end(), g[i]);
ans += (low - v.begin());
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
int fa[maxn], p[maxn], n;
bool vis[maxn];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
int main() {
cin >> n;
if (n & 1) return puts("-1"), 0;
for (int i = 0, x; i < n; vis[p[i++]] = 1)
if (!vis[x = i * 2 % n])
p[i] = x;
else
p[i] = (x + 1) % n;
for (int i = 0; i < n; i++) fa[i] = i, vis[i] = 0;
for (int i = 0; i < n; i++)
for (int x = i; !vis[x]; x = p[x]) vis[x] = 1, fa[getfa(x)] = getfa(i);
for (int i = 0, t; i < n / 2; i++) {
int x = (i + n / 2) % n, fx = getfa(i), fy = getfa(x);
if (fx != fy) t = p[x], p[x] = p[i], p[i] = t, fa[fx] = fy;
}
putchar('0');
for (int i = p[0]; i; i = p[i]) printf(" %d", i);
puts(" 0");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout.setf(ios_base::fixed);
cout.precision(28);
int n, m;
cin >> n >> m;
if (m == 1) {
cout << 1 << endl;
return 0;
}
vector<vector<long double> > prob(n + 1, vector<long double>(n * m + 1));
prob[0][0] = 1;
vector<int> v(n);
int ss = 0;
for (auto &x : v) {
cin >> x;
ss += x;
}
for (int i = 0; i < n; ++i) {
vector<long double> s(n * m + 2);
for (int j = 1; j < s.size(); ++j) {
s[j] = s[j - 1] + prob[i][j - 1];
}
for (int j = 0; j <= n * m; ++j) {
prob[i + 1][j] = (s[j] - (j >= m ? s[j - m] : 0) -
(j >= v[i] ? prob[i][j - v[i]] : 0)) /
(m - 1);
}
}
long double ans = 0;
for (int j = 0; j < ss; ++j) {
ans += prob[n][j];
}
cout << ans * (m - 1) + 1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 2e5 + 5;
int n, s;
int a[N], b[N];
int to[N];
int q;
bool vis[N];
struct edge {
int x, id, nxt;
} e[N];
int h[N], tot;
int col[N];
map<int, int> id;
int k;
void inse(int x, int y, int id) {
e[++tot].x = y;
e[tot].id = id;
e[tot].nxt = h[x];
h[x] = tot;
}
bool used[N];
int st;
int u;
int que[N];
pair<int, int> key[N];
int be[N];
void euler(int x) {
for (; h[x];) {
int p = h[x];
int id = e[p].id;
int y = e[p].x;
que[++u] = id;
h[x] = e[p].nxt;
euler(y);
}
}
int fa[N], c;
int getfather(int x) { return fa[x] == x ? x : fa[x] = getfather(fa[x]); }
void add(int l, int r, int c) {
to[l] = r;
int x = id[a[l]];
if (be[x] && getfather(be[x]) == getfather(c)) return;
int fx = getfather(be[x]), fc = getfather(c);
if (!key[x].first)
be[x] = c, key[x] = make_pair(l, r);
else {
to[l] = key[x].second;
to[key[x].first] = r;
key[x].first = l;
fa[fx] = fc;
}
}
void getto() {
c = 0;
for (int l = 1; l <= u;) {
int r = l;
c++;
fa[c] = c;
for (; a[que[r]] != b[que[l]]; r++)
;
int st = id[b[que[l]]];
for (int i = l; i <= r - 1; i++) {
add(que[i], que[i + 1], c);
}
add(que[r], que[l], c);
l = r + 1;
}
}
int Fa[N];
int getFa(int x) { return Fa[x] == x ? x : Fa[x] = getFa(Fa[x]); }
void merge(int x, int y) {
int tx = getFa(x), ty = getFa(y);
Fa[tx] = ty;
}
bool ad[N];
int kp[N];
int pv[N];
int main() {
n = get();
s = get();
for (int i = 1; i <= n; i++) a[i] = get();
for (int i = 1; i <= n; i++) b[i] = a[i];
sort(b + 1, b + 1 + n);
int len = n;
for (int i = 1; i <= n; i++)
if (b[i] == a[i]) to[i] = i, len--;
if (len > s) return printf("-1\n"), 0;
s -= len;
for (int i = 1; i <= n; i++)
if (!id[b[i]]) col[id[b[i]] = ++k] = b[i];
for (int i = 1; i <= k; i++) Fa[i] = i;
for (int i = 1; i <= n; i++) {
int x = id[a[i]], y = id[b[i]];
int tx = getFa(x), ty = getFa(y);
if (tx == ty) {
ad[i] = 1;
continue;
}
Fa[tx] = ty;
}
for (int i = 1; i <= n; i++)
if (ad[i] && a[i] != b[i]) {
int x = getFa(id[a[i]]);
if (!kp[x]) kp[x] = i;
}
int nq = 0;
for (int i = 1; i <= k; i++)
if (getFa(i) == i && kp[i]) nq++;
bool predo = 0;
int pl = 0;
if (nq > 1 && s > 1) {
predo = 1;
for (int i = 1; i <= k; i++)
if (getFa(i) == i && kp[i]) {
if (s) {
pv[++pl] = kp[i];
s--;
}
}
if (pl <= 1)
predo = 0;
else {
int tmp = a[pv[pl]];
for (int i = pl; i >= 2; i--) a[pv[i]] = a[pv[i - 1]];
a[pv[1]] = tmp;
}
}
for (int i = 1; i <= n; i++)
if (a[i] != b[i]) inse(id[b[i]], id[a[i]], i);
for (int i = 1; i <= n; i++) {
st = i;
u = 0;
euler(i);
getto();
}
int q = 0;
for (int i = 1; i <= n; i++)
if (a[i] != b[i] && !vis[i]) {
q++;
vis[i] = 1;
for (int x = to[i]; x != i; x = to[x]) vis[x] = 1;
}
printf("%d\n", q + predo);
if (predo) {
printf("%d\n", pl);
for (int i = 1; i <= pl; i++) printf("%d ", pv[i]);
putchar('\n');
}
for (int i = 1; i <= n; i++)
if (a[i] != b[i] && vis[i]) {
int len = 1;
vis[i] = 0;
for (int x = to[i]; x != i; x = to[x]) vis[x] = 0, len++;
printf("%d\n%d", len, i);
for (int x = to[i]; x != i; x = to[x]) printf(" %d", x);
putchar('\n');
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct nodo {
int pudo, sobro, falto;
} m, res;
char A[1000005];
int izq, der, uso, ctos = 1, pregs, saca;
nodo T[2097160];
void crea(int x, int y, int dnde) {
if (x == y) {
m.pudo = 0;
m.falto = 0;
m.sobro = 0;
if (A[x] == '(') {
m.sobro = 1;
T[dnde] = m;
m.sobro = 0;
} else {
m.falto = 1;
T[dnde] = m;
}
return;
}
crea(x, (x + y) / 2, dnde * 2);
crea((x + y) / 2 + 1, y, dnde * 2 + 1);
uso = min(T[dnde * 2 + 1].falto, T[dnde * 2].sobro);
m.pudo = T[dnde * 2].pudo + T[dnde * 2 + 1].pudo + uso * 2;
m.sobro = T[dnde * 2].sobro - uso + T[dnde * 2 + 1].sobro;
m.falto = T[dnde * 2].falto + T[dnde * 2 + 1].falto - uso;
T[dnde] = m;
}
void query(int x, int y, int dnde) {
if (x >= izq and y <= der) {
uso = min(T[dnde].falto, res.sobro);
res.pudo = res.pudo + T[dnde].pudo + uso * 2;
res.sobro = res.sobro - uso + T[dnde].sobro;
res.falto = res.falto + T[dnde].falto - uso;
return;
}
int mid = (x + y) / 2;
if (izq <= mid and der >= x) query(x, mid, dnde * 2);
if (izq <= y and der > mid) query(mid + 1, y, dnde * 2 + 1);
}
int main() {
scanf("%s", A + 1);
while (A[ctos] != '\0' and A[ctos] != '\n') ++ctos;
--ctos;
crea(1, ctos, 1);
scanf("%d", &pregs);
while (pregs--) {
scanf("%d%d", &izq, &der);
res.pudo = 0;
res.falto = 0;
res.sobro = 0;
query(1, ctos, 1);
saca = res.pudo;
printf("%d\n", saca);
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef long double ld;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define Pair vector<pair<ll,ll>>
#define vec vector <ll>
#define all(a) a.begin(),a.end()
#define mo 1000000007
#define decimal(i,n) fixed << setprecision(i) << n
#define show(a) for(auto xyz:a)cout<<xyz<<" ";cout<<endl;
#define show_nl(a) for(auto xyz:a)cout<<xyz<<endl;
#define MAX (ll)(pow(2,63)-1)
#define fill(a,b) memset(a, b, sizeof(a))
#define yes cout<<"YES"<<endl;
#define no cout<<"NO"<<endl;
//modular inverse
void eea(ll a,ll b,ll &x,ll &y)
{
if (a == 1)
{
x = 1; y = 0;
return;
}
ll x1, y1;
eea(b%a,a,x1,y1);
x=y1-(b/a)*x1;
y=x1;
}
ll mi(ll a,ll m)
{
ll x,y;
eea(a,m,x,y);
x= (x%m+m)%m;
return x;
}
//complete
void Sieve(int n)
{
int prime[n+1];
fill(prime,-1);
for (int p=2; p*p<=n; p++)
{
if (prime[p] == -1)
{
for (int i=p*p; i<=n; i += p)
prime[i] = 0;
}
}
for (int p=2; p<=n; p++)
{
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
// freopen("ladder.in", "r", stdin); // name of input file
// freopen("ladder.out", "w", stdout); // name of output file
// ifstream fin("art.in");
// ofstream fout("art.out");
// fstream file, output;
// file.open(R"()", ios::in); // add the address of local input file
// output.open(R"()", ios::out); // add the address of local output file
ll t=1,t1=1;
cin>>t;
while(t--)
{
ll n;
cin>>n;
string s;
cin>>s;
ll t=0,m=0,x=0;
for(ll i=0;i<n;i++)
{
if(s[i]=='M')
{
m++;
}
else if(s[i]=='T')
{
t++;
}
if(m>t)
x=1;
}
t=0,m=0;
for(ll i=n-1;i>=0;i--)
{
if(s[i]=='M')
{
m++;
}
else if(s[i]=='T')
{
t++;
}
if(m>t)
x=1;
}
if(2*m!=t)
x=1;
if(x==1)
cout<<"NO\n";
else
cout<<"YES\n";
}
}
/*
Some helpful points
1.) Calm yourself
2.) check for semicolon or data type mismatch
3.) It can be solved
*/ | 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> road;
int main() {
long long q, rule, u, v, w, ans;
cin >> q;
while (q--) {
cin >> rule;
if (rule == 1) {
cin >> u >> v >> w;
while (u != v) {
if (u < v) swap(u, v);
road[u] += w;
u /= 2;
}
} else {
cin >> u >> v;
ans = 0;
while (u != v) {
if (u < v) swap(u, v);
ans += road[u];
u /= 2;
}
cout << ans << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char grid[2005][2005];
int visited[2005][2005], ld[2005][2005], rd[2005][2005];
int n, m;
int ans = 0;
struct compare {
bool operator()(pair<int, pair<int, int> > const &e1,
pair<int, pair<int, int> > const &e2) {
return e1.first > e2.first;
}
};
void dfs(int sr, int sc, int ll, int rr) {
priority_queue<pair<int, pair<int, int> >,
vector<pair<int, pair<int, int> > >, compare>
pq;
pq.push(make_pair(0, make_pair(sr, sc)));
visited[sr][sc] = 1;
ld[sr][sc] = 0;
rd[sr][sc] = 0;
int pushes = 1;
while (!pq.empty()) {
pair<int, pair<int, int> > p = pq.top();
pq.pop();
pair<int, int> vtx = p.second;
int dist = p.first;
int x = vtx.first, y = vtx.second;
if (ld[x][y] <= ll && rd[x][y] <= rr) {
ans++;
}
if ((x == 1 && y == 3) || (x == 3 && y == 3) || (x == 4 && y == 3)) {
}
if (x - 1 > 0 && grid[x - 1][y] == '.' && !visited[x - 1][y]) {
pq.push(make_pair(dist, make_pair(x - 1, y)));
visited[x - 1][y] = 1;
ld[x - 1][y] = ld[x][y];
rd[x - 1][y] = rd[x][y];
pushes++;
}
if (y - 1 > 0 && grid[x][y - 1] == '.' && !visited[x][y - 1]) {
pq.push(make_pair(dist + 1, make_pair(x, y - 1)));
visited[x][y - 1] = 1;
ld[x][y - 1] = ld[x][y] + 1;
rd[x][y - 1] = rd[x][y];
pushes++;
}
if (x + 1 <= n && grid[x + 1][y] == '.' && !visited[x + 1][y]) {
pq.push(make_pair(dist, make_pair(x + 1, y)));
visited[x + 1][y] = 1;
ld[x + 1][y] = ld[x][y];
rd[x + 1][y] = rd[x][y];
pushes++;
}
if (y + 1 <= m && grid[x][y + 1] == '.' && !visited[x][y + 1]) {
pq.push(make_pair(dist + 1, make_pair(x, y + 1)));
visited[x][y + 1] = 1;
ld[x][y + 1] = ld[x][y];
rd[x][y + 1] = rd[x][y] + 1;
pushes++;
}
}
}
int main(int argc, char const *argv[]) {
int r, c, x, y;
cin >> n >> m >> r >> c >> x >> y;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> grid[i][j];
}
}
memset(visited, 0, sizeof(visited));
dfs(r, c, x, y);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, m;
cin >> n >> m;
vector<string> names(n);
for (int i = 0; i < n; i++) cin >> names[i];
long long ans = 1L;
long long M = 1000000007L;
for (int i = 0; i < m; i++) {
vector<char> chars;
for (int j = 0; j < n; j++) chars.push_back(names[j][i]);
sort(chars.begin(), chars.end());
int t = 1;
for (int j = 1; j < chars.size(); j++) t += chars[j] != chars[j - 1];
ans = ans * t % M;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct edge {
int u, v, next;
} edges[210000 * 2];
int head[210000], nCount = 0;
void AddEdge(int U, int V) {
edges[++nCount].u = U;
edges[nCount].v = V;
edges[nCount].next = head[U];
head[U] = nCount;
}
double f[210000];
int size[210000];
void getsize(int u) {
size[u] = 1;
for (int p = head[u]; p != -1; p = edges[p].next) {
int v = edges[p].v;
getsize(v);
size[u] += size[v];
}
}
void DFS(int u) {
int son = 0;
for (int p = head[u]; p != -1; p = edges[p].next) son++;
double tmp;
if (son == 1) {
for (int p = head[u]; p != -1; p = edges[p].next) {
int v = edges[p].v;
f[v] = f[u] + 1;
DFS(v);
}
return;
}
tmp = (double)(son - 1) * (double)son / 2.0;
for (int i = son - 1; i <= son; i++) tmp /= (double)i;
for (int p = head[u]; p != -1; p = edges[p].next) {
int v = edges[p].v;
f[v] = f[u] + tmp * (double)(size[u] - size[v] - 1) + 1;
DFS(v);
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int par;
scanf("%d", &par);
AddEdge(par, i);
}
getsize(1);
f[1] = 1;
DFS(1);
for (int i = 1; i <= n; i++) printf("%.7lf ", f[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
char ch;
int cnt;
bool operator<(const node &s) const { return cnt < s.cnt; }
};
node num[100002];
char str[100002];
string ans;
int main() {
int i = 0, j = 0, len = 0, k = 0;
string s;
scanf("%s", str);
scanf("%d", &k);
len = strlen(str);
for (i = 0; i < 26; i++) num[i].ch = i + 'a';
for (i = 0; i < len; i++) num[str[i] - 'a'].cnt++;
sort(num, num + 26);
i = 0;
while (num[i].cnt == 0) i++;
int sum = 0;
while (sum + num[i].cnt <= k) {
s += num[i].ch;
sum += num[i].cnt;
i++;
}
int cnt = 0;
set<char> df;
for (i = 0; i < len; i++) {
string::size_type it = s.find(str[i]);
if (it == s.npos) {
if (df.count(str[i]) == 0) df.insert(str[i]), cnt++;
ans += str[i];
}
}
cout << cnt << endl;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
ofstream fout("test.out");
ifstream fin("test.in");
const long long MX = 4e2 + 100, INF = 1e18, INF2 = -1e18, D = 1e9 + 7,
del = 12641;
long long n, m, arr[MX], cnt, flg, ans, xx[8] = {-1, 0, 1, 1, 1, 0, -1, -1},
yy[8] = {1, 1, 1, 0, -1, -1, -1, 0};
bool mark[310][310][10][30], mp[MX][MX];
void dfs(long long a, long long b, long long j, long long i) {
if (mark[a][b][j][i] || i >= n) return;
mark[a][b][j][i] = 1;
long long x = a, y = b;
for (long long k = 0; k < arr[i]; k++) {
x += xx[j];
y += yy[j];
mp[x][y] = 1;
}
dfs(x, y, (j + 1) % 8, i + 1);
dfs(x, y, (j + 7) % 8, i + 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
dfs(150, 150, 1, 0);
for (long long i = 0; i < MX; i++) {
for (long long j = 0; j < MX; j++) {
if (mp[i][j]) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int vis[1000005];
double a[1000005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int num = 0;
int n;
scanf("%d", &n);
int m = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
vis[x]++;
m = max(m, x);
}
for (int i = 1; i <= m; i++) {
while (vis[i] >= 2) {
a[num++] = 1.0 * i;
vis[i] -= 2;
}
vis[i] = 0;
}
int flag = 0;
int l, r;
double ans = 0x3f3f3f3f;
for (int i = 1; i < num; i++) {
if (a[i] == a[i - 1]) {
flag = 1;
printf("%d %d %d %d\n", (int)a[i], (int)a[i], (int)a[i], (int)a[i]);
break;
} else {
if (ans > (a[i] / a[i - 1] + a[i - 1] / a[i] + 2)) {
ans = (a[i] / a[i - 1] + a[i - 1] / a[i] + 2);
l = (int)a[i];
r = (int)a[i - 1];
}
}
}
if (!flag) printf("%d %d %d %d\n", l, l, r, r);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, k, f[2][810], s[N], ps[N];
vector<int> vec[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
vec[y].push_back(x - y + 1);
s[x - y + 1]++;
}
memset(f[0], 0xbf, sizeof(f[0]));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
memset(f[i & 1], 0xbf, sizeof(f[i & 1]));
int mx = 0xbfbfbfbf;
for (int j = 0, je = min(800, n - i + 1); j <= je; j++) {
if (j > 0) ps[j] = ps[j - 1] + s[n - i + 1 - j + 1];
mx = max(mx, f[(i & 1) ^ 1][j] - (j > 0 ? ps[j - 1] : 0) * 3);
f[i & 1][j] = max(f[(i & 1) ^ 1][j + 1],
mx - (j ? (j * (j + 1) / 2 + 2) : 0) + ps[j] * 3);
}
for (int y : vec[i]) s[y]--;
}
printf("%d\n", 3 * k - max(f[n & 1][0], f[n & 1][1]));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void solve() {
long long a, b, c;
cin >> a >> b >> c;
cout << a + b + c - 1 << endl;
}
int main() {
;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
cin >> T;
while (T--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
double p = (a / (double)b), q = (c / (double)d);
cout << p / (1 - (1 - p) * (1 - q)) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int l[1005], r[1005], t[1005], c[1005];
int ti[105];
int main() {
int n, m, i, j, total = 0;
cin >> n >> m;
for (i = 0; i < 105; i++) ti[i] = 1001;
for (i = 1; i <= m; i++) {
cin >> l[i] >> r[i] >> t[i] >> c[i];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (i >= l[j] && i <= r[j] && t[j] < ti[i]) ti[i] = t[j];
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (i >= l[j] && i <= r[j] && t[j] == ti[i]) {
total += c[j];
break;
}
}
cout << total << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, til, a[100005];
class segtree {
public:
int son[2];
double sum, laz, mul;
} c[100005 << 1];
inline int read() {
char ch = getchar();
int ret = 0, f = 1;
while (ch > '9' || ch < '0') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
int Build(int l, int r) {
int now = ++til;
if (l < r) {
int mid = (r - l >> 1) + l;
c[now].son[0] = Build(l, mid);
c[now].son[1] = Build(mid + 1, r);
c[now].sum = c[c[now].son[0]].sum + c[c[now].son[1]].sum;
} else
c[now].sum = a[l];
c[now].mul = 1.0;
return now;
}
inline void Pushdown(int x, int l, int r) {
if (c[x].mul != 1.0) {
c[c[x].son[0]].sum *= c[x].mul;
c[c[x].son[1]].sum *= c[x].mul;
c[c[x].son[0]].mul *= c[x].mul;
c[c[x].son[1]].mul *= c[x].mul;
c[c[x].son[0]].laz *= c[x].mul;
c[c[x].son[1]].laz *= c[x].mul;
c[x].mul = 1.0;
}
if (c[x].laz != 0.0) {
int mid = (r - l >> 1) + l;
c[c[x].son[0]].sum += c[x].laz * (mid - l + 1);
c[c[x].son[1]].sum += c[x].laz * (r - mid);
c[c[x].son[0]].laz += c[x].laz;
c[c[x].son[1]].laz += c[x].laz;
c[x].laz = 0.0;
}
}
double Query(int now, int l, int r, int a, int b) {
Pushdown(now, l, r);
if (a <= l && b >= r) return c[now].sum;
int mid = (r - l >> 1) + l;
double res = 0;
if (a <= mid) res += Query(c[now].son[0], l, mid, a, b);
if (b > mid) res += Query(c[now].son[1], mid + 1, r, a, b);
return res;
}
void Add(int now, int l, int r, int a, int b, double val) {
Pushdown(now, l, r);
if (a <= l && b >= r) {
c[now].sum += val * (r - l + 1);
c[now].laz += val;
return;
}
int mid = (r - l >> 1) + l;
if (a <= mid) Add(c[now].son[0], l, mid, a, b, val);
if (b > mid) Add(c[now].son[1], mid + 1, r, a, b, val);
c[now].sum = c[c[now].son[0]].sum + c[c[now].son[1]].sum;
}
void Mul(int now, int l, int r, int a, int b, double val) {
Pushdown(now, l, r);
if (a <= l && b >= r) {
c[now].sum *= val;
c[now].laz *= val;
c[now].mul *= val;
return;
}
int mid = (r - l >> 1) + l;
if (a <= mid) Mul(c[now].son[0], l, mid, a, b, val);
if (b > mid) Mul(c[now].son[1], mid + 1, r, a, b, val);
c[now].sum = c[c[now].son[0]].sum + c[c[now].son[1]].sum;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i] = read();
Build(1, n);
while (m--) {
int typ = read();
if (typ == 1) {
int l1 = read(), r1 = read();
int l2 = read(), r2 = read();
double len1 = r1 - l1 + 1, len2 = r2 - l2 + 1;
double sum1 = Query(1, 1, n, l1, r1);
double sum2 = Query(1, 1, n, l2, r2);
Mul(1, 1, n, l1, r1, (len1 - 1) / len1);
Mul(1, 1, n, l2, r2, (len2 - 1) / len2);
Add(1, 1, n, l1, r1, sum2 / len1 / len2);
Add(1, 1, n, l2, r2, sum1 / len2 / len1);
} else {
int l = read(), r = read();
printf("%.6lf\n", Query(1, 1, n, l, r));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int hh, mm, H, D, C, N, t = 0;
double s = 0, s1 = 0, s2 = 0, s3 = 0;
cin >> hh >> mm >> H >> D >> C >> N;
if (H % N == 0)
t = H / N;
else
t = H / N + 1;
if (hh >= 20) {
s = t * C * 0.8;
printf("%.4lf", s);
} else {
s1 = t * C;
if ((H + ((20 - hh - 1) * 60 + 60 - mm) * D) % N == 0) {
s2 = (H + ((20 - hh - 1) * 60 + 60 - mm) * D) / N * C * 0.8;
} else
s2 = ((H + ((20 - hh - 1) * 60 + 60 - mm) * D) / N + 1) * C * 0.8;
if (s1 > s2)
printf("%.4lf", s2);
else
printf("%.4lf", s1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, q, l, r;
char s[N], z[N];
inline int nxt(int idx, int t) {
idx += t;
while (idx >= l && idx <= r && z[idx] == '0' - 1) idx += t;
return idx;
}
int main() {
scanf("%d %d %s", &n, &q, s + 1);
while (q--) {
scanf("%d %d", &l, &r);
for (int i(l); i < (r + 1); i++) z[i] = s[i];
int idx = l, t = 1, c[10] = {0};
while (idx >= l && idx <= r) {
if (z[idx] == '>' || z[idx] == '<') {
if (z[idx] == '>')
t = 1;
else
t = -1;
if (nxt(idx, t) >= l && nxt(idx, t) <= r &&
(z[nxt(idx, t)] == '>' || z[nxt(idx, t)] == '<'))
z[idx] = '0' - 1;
} else if (z[idx] >= '0' && z[idx] <= '9') {
c[z[idx] - '0']++;
z[idx]--;
}
idx = nxt(idx, t);
}
for (int i(0); i < (10); i++) printf("%d ", c[i]);
printf("\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
for (int j = 1; j <= k; j++) {
long long n, m;
long long s = 0, p = 1;
cin >> n;
s = n * (n + 1) / 2;
m = floor(log2(n));
p = 1;
for (long i = 1; i <= m + 1; i++) p = p * 2;
cout << s - 2 * (p - 1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7, mod = 1e9 + 7, inf = 1e5 + 7;
const long long linf = (long long)1e18 + 7;
const long double eps = 1e-15, pi = 3.141592;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1},
dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
inline int get_int() {
char x = getchar();
while (!('0' <= x && x <= '9')) x = getchar();
int res = 0;
while ('0' <= x && x <= '9') res = res * 10 + x - '0', x = getchar();
return res;
}
int n, m;
int second[N], cnt[N], lvl[N], sz[N], ans[N];
bool ok[N][26], big[N];
vector<int> g[N];
vector<pair<int, int> > q[N];
inline void calc(int v = 1, int p = 1) {
lvl[v] = lvl[p] + 1, sz[v] = 1;
for (auto i : g[v]) calc(i, v), sz[v] += sz[i];
}
inline void add(int v) {
cnt[lvl[v]] -= ok[lvl[v]][second[v]];
ok[lvl[v]][second[v]] ^= 1;
cnt[lvl[v]] += ok[lvl[v]][second[v]];
for (auto i : g[v])
if (!big[i]) add(i);
}
inline void dfs(int v = 1, bool keep = 0) {
int mx = -1, id = -1;
for (auto i : g[v])
if (sz[i] > mx) mx = sz[i], id = i;
for (auto i : g[v])
if (i != id) dfs(i, 0);
if (id != -1) big[id] = 1, dfs(id, 1);
add(v);
for (auto i : q[v]) ans[i.second] = cnt[i.first] <= 1;
if (id != -1) big[id] = 0;
if (!keep) add(v);
}
int main() {
n = get_int(), m = get_int();
for (int i = 2; i <= n; ++i) {
int p;
p = get_int();
g[p].push_back(i);
}
scanf("\n");
for (int i = 1; i <= n; ++i) {
char x;
x = getchar();
second[i] = x - 'a';
}
for (int i = 1; i <= m; ++i) {
int v, deep;
v = get_int(), deep = get_int();
q[v].push_back({deep, i});
}
calc();
dfs();
for (int i = 1; i <= m; ++i) {
if (ans[i])
printf("Yes\n");
else
printf("No\n");
}
exit(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<string> a(n);
vector<vector<bool>> visited(n, vector<bool>(m, false));
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool flag = true;
for (int i = 1; i < (n - 1); i++) {
bool fg = false;
for (int j = 1; j < (a[i].length() - 1); j++) {
if (a[i][j] == '*' && !visited[i][j]) {
if (a[i][j + 1] == '*' && a[i][j - 1] == '*' && a[i - 1][j] == '*' &&
a[i + 1][j] == '*')
;
else
continue;
visited[i][j] = true;
int row = i - 1;
int col = j;
while (row >= 0 && a[row][j] == '*') {
visited[row][j] = true;
row--;
}
row = i + 1;
while (row < n && a[row][j] == '*') {
visited[row][j] = true;
row++;
}
col = j - 1;
while (col >= 0 && a[i][col] == '*') {
visited[i][col] = true;
col--;
}
col = j + 1;
while (col < m && a[i][col] == '*') {
visited[i][col] = true;
col++;
}
fg = true;
break;
}
}
if (!flag || fg) break;
}
if (!flag)
cout << "NO";
else {
flag = false;
bool present = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '*' && !visited[i][j]) {
flag = true;
break;
}
if (a[i][j] == '*') present = true;
}
if (flag) break;
}
if (flag || !present)
cout << "NO";
else
cout << "YES";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int imax = INT32_MAX;
const int imin = INT32_MIN;
const int mx = 1e6;
const int mod = 1e9 + 7;
template <class T>
void print(vector<T> vec) {
for (T i : vec) cout << i << " ";
cout << "\n";
}
template <class T>
void alloc(vector<vector<T>*> vec, T n) {
for (auto v : vec) v->resize(n + 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m)), ans(n, vector<int>(m));
vector<vector<int>> b(m, vector<int>(n));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int in;
cin >> in;
a[i][j] = in;
}
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) {
int in;
cin >> in;
b[i][j] = in;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
auto it = find(b[j].begin(), b[j].end(), a[i][0]);
if (it == b[j].end()) continue;
int index = it - b[j].begin();
ans[index] = a[i];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << ans[i][j] << " ";
cout << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define ff first
#define ss second
#define pb push_back
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int mod = 1e9 + 7;
const int cmod = 998244353;
const int N = 1e5 + 5;
const int inf = 1e16 + 2;
int power(int x , int y) {
int res = 1 ;
while(y) {
if(y & 1) res = (res * x) % mod;
y /= 2 ;
x = (x * x) % mod;
}
return res % mod ;
}
void solve(int Case){
int n , k ;
cin >> n >> k ;
int a[k] , d[n + 2] , ans[n + 2];
for(int i = 0 ; i <= n + 1 ; i ++) ans[i] = inf , d[i] = inf;
for(int i = 0 ; i < k ; i ++) cin >> a[i];
for(int i = 0 ; i < k ; i ++) {
int u ;
cin >> u ;
d[a[i]] = u ;
}
for(int i = 1 ; i <= n ; i ++) {
ans[i] = min(ans[i - 1] + 1 , d[i]) ;
}
for(int i = n ; i >= 0 ; i --) {
ans[i] = min({ans[i] , ans[i + 1] + 1 , d[i]}) ;
}
for(int i = 1 ; i <= n ; i ++) cout << ans[i] << ' ' ;
cout << '\n' ;
}
/*
*/
int32_t main() {
fastio
int testcase = 1;
cin >> testcase;
int Case = 1;
while(testcase --) {
solve(Case ++) ;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long T = 1, i, j;
while (T--) {
long long n;
cin >> n;
vector<long long> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
}
long long q;
cin >> q;
vector<vector<long long>> queries(q, vector<long long>(3));
for (i = 0; i < q; i++) {
long long a, b, c;
cin >> a;
if (a == 1) {
cin >> b >> c;
queries[i][0] = a;
queries[i][1] = b;
queries[i][2] = c;
} else {
cin >> b;
queries[i][0] = 2;
queries[i][1] = b;
queries[i][2] = -999999999999999999;
}
}
long long maxpayoff = -999999999999999999;
vector<bool> visited(n);
for (i = q - 1; i >= 0; i--) {
if (queries[i][0] == 1) {
long long ind = queries[i][1] - 1;
if (!visited[ind]) {
v[ind] = max(queries[i][2], maxpayoff);
visited[ind] = true;
}
} else {
maxpayoff = max(maxpayoff, queries[i][1]);
}
}
for (i = 0; i < n; i++) {
if (!visited[i]) v[i] = max(v[i], maxpayoff);
cout << v[i] << " ";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int scan() {
long long int t = 0;
char c, ch;
ch = getchar();
if (ch == '-') {
c = getchar();
} else {
c = ch;
}
while (c < '0' || c > '9') {
c = getchar();
}
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = getchar();
}
if (ch == '-') {
return -t;
} else {
return t;
}
}
int main() {
ios::sync_with_stdio(false);
long long int i, j, k, t, n, m, x, y, a, b, r;
cin >> r >> x >> y >> a >> b;
n = abs(x - a);
m = abs(y - b);
long long dis = n * n + m * m, ans = 0;
if (dis == 0)
cout << "0\n";
else if (dis <= (r * r)) {
cout << "1\n";
} else {
double val = sqrt(dis);
ans = val / (2 * r);
if (ans * 2 * r != val) ans++;
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ch[500005][26], cnt[500005], fail[500005], nxt[500005];
bool ed[500005];
int tot;
int pos_to_ed[500005], v[500005], mx[500005];
multiset<int> mp[500005];
inline void insert(string x, int pos) {
int p = 0;
for (int i = 0; i < x.length(); ++i) {
int t = x[i] - 'a';
if (ch[p][t])
p = ch[p][t];
else {
ch[p][t] = ++tot;
p = tot;
}
}
ed[p] = true;
pos_to_ed[pos] = p;
mp[p].insert(0);
}
void buildfail() {
queue<int> q;
for (int i = 0; i < 26; ++i)
if (ch[0][i]) {
fail[ch[0][i]] = 0;
q.push(ch[0][i]);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; ++i) {
if (ch[u][i]) {
fail[ch[u][i]] = ch[fail[u]][i];
nxt[ch[u][i]] =
ed[fail[ch[u][i]]] ? fail[ch[u][i]] : nxt[fail[ch[u][i]]];
q.push(ch[u][i]);
} else
ch[u][i] = ch[fail[u]][i];
}
}
}
bool vis[500005];
inline int find(string s) {
int p = 0, ans = -1;
for (int i = 0; i < s.length(); ++i) {
int t = s[i] - 'a';
p = ch[p][t];
for (int cur = p; cur; cur = nxt[cur]) {
if (ed[cur]) {
ans = max(ans, mx[cur]);
}
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
insert(s, i);
}
buildfail();
for (int i = 1; i <= m; ++i) {
int t;
cin >> t;
if (t == 2) {
string s;
cin >> s;
cout << find(s) << "\n";
} else {
int pos, x;
cin >> pos >> x;
int p = pos_to_ed[pos];
mp[p].erase(mp[p].find(v[pos]));
v[pos] = x;
mp[p].insert(x);
auto it = mp[p].end();
it--;
mx[p] = *it;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using Graph = vector<vector<long long>>;
const int INF = 1000000007;
const long long MOD = 1000000007;
struct SegmentTree {
private:
int n;
vector<int> node;
public:
SegmentTree(vector<int> v) {
int sz = v.size();
n = 1;
while (n < sz) n *= 2;
node.resize(2 * n - 1, INF);
for (int i = 0; i < sz; i++) node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
void update(int x, int val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
int getmin(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
if (r <= a || b <= l) return INF;
if (a <= l && r <= b) return node[k];
int vl = getmin(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = getmin(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<long long> a(n + 1), b(n + 1);
for (long long i = (0); i < (n); i++) cin >> a[i + 1];
for (long long i = (0); i < (n); i++) cin >> b[i + 1];
vector<int> v(n + 1, INF);
v[n] = 0;
vector<long long> memo(n + 1, -1);
SegmentTree tree(v);
map<long long, set<int>> mp;
mp[0].insert(n);
vector<long long> MEMO(n + 1);
for (long long i = n; i >= 1; i--) {
long long now = tree.getmin(0, i + 1);
MEMO[i] = *mp[now].begin();
long long pos = i + b[i];
long long to = pos - a[pos];
long long x = tree.getmin(to, to + 1);
if (now + 1 < x) {
tree.update(to, now + 1);
memo[to] = i;
mp[now + 1].insert(to);
}
}
long long A = tree.getmin(0, 1);
if (A >= MOD) {
cout << -1 << endl;
return 0;
}
cout << A << endl;
vector<long long> ans(1, 0);
long long X = 0;
while (X != n) {
X = memo[X];
if (X == n) break;
ans.push_back(X);
X = MEMO[X];
}
reverse((ans).begin(), (ans).end());
for (long long i = (0); i < (ans.size()); i++) cout << ans[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, l, pos, temp, temp1, ans = 0;
string str;
vector<long long int> v;
cin >> str;
l = str.length();
for (i = 0; i < str.length(); i++) {
if (str[i] == '@') v.push_back(i);
}
for (i = 0; i < v.size(); i++) {
pos = v[i];
temp = 0;
temp1 = 0;
for (j = pos - 1; j >= 0; j--) {
if (!((str[j] >= 'a' && str[j] <= 'z') ||
(str[j] >= '0' && str[j] <= '9') || str[j] == '_'))
break;
if (str[j] >= 'a' && str[j] <= 'z') temp++;
}
if (temp == 0) continue;
for (j = pos + 1; j < l; j++) {
if (!((str[j] >= 'a' && str[j] <= 'z') ||
(str[j] >= '0' && str[j] <= '9')))
break;
}
if (str[j] != '.' || j == pos + 1) continue;
for (k = j + 1; k < l; k++) {
if (!(str[k] >= 'a' && str[k] <= 'z')) break;
temp1++;
}
ans += temp * temp1;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> tree[100005];
int cat[100005];
bool vis[100005];
int n, m, ans = 0;
void dfs(int root, int num) {
vis[root] = true;
if (cat[root])
num++;
else
num = 0;
if (num > m) return;
if (tree[root].size() == 1 && vis[tree[root][0]]) {
ans++;
return;
}
for (int i = 0; i < tree[root].size(); i++) {
int c = tree[root][i];
if (!vis[c]) dfs(c, num);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &cat[i]);
for (int i = 0; i < n - 1; i++) {
int f, s;
scanf("%d %d", &f, &s);
tree[f].push_back(s);
tree[s].push_back(f);
}
dfs(1, 0);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int t;
int n, m;
int d[N], h[N];
int main() {
cin >> t;
for (int tc = 0; tc < t; ++tc) {
cin >> n >> m;
int maxDH = -2e9;
for (int i = 0; i < n; ++i) {
cin >> d[i] >> h[i];
maxDH = max(maxDH, d[i] - h[i]);
}
int res = 1;
int maxD = *max_element(d, d + n);
m -= maxD;
if (m > 0) {
if (maxDH <= 0)
res = -1;
else
res += (m + maxDH - 1) / maxDH;
}
cout << res << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (k <= 2) {
cout << 0 << endl;
return 0;
}
long long s = k / 2 + 1;
if (n < s) {
cout << 0 << endl;
} else {
cout << min(k - 1, n) - s + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k;
cin >> n;
if (n <= 9) {
cout << "1" << endl;
cout << n;
} else {
cout << n << endl;
for (i = 1; i <= n; i++)
cout << "1"
<< " ";
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, k, ar[1000], i, count = 0, lo = 0, sum = 0;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &ar[i]);
}
for (i = 0; i < n; i++) {
if (ar[i] <= k)
count++;
else
break;
}
for (i = n - 1; i >= 0; i--) {
if (ar[i] <= k)
lo++;
else
break;
}
sum = lo + count;
if (sum >= n) {
printf("%d", sum / 2);
} else {
printf("%d", lo + count);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str;
int main() {
getline(cin, str);
int _at = 0;
for (int i = 1; i < str.length(); i++) {
if (str[i] == 'a' && str[i + 1] == 't' && _at == 0) {
_at = 1;
str[i] = '@';
str[i + 1] = '^';
}
if (str[i] == 'd' && str[i + 1] == 'o' && str[i + 2] == 't' &&
i + 2 < str.length() - 1) {
str[i] = '.';
str[i + 1] = '^';
str[i + 2] = '^';
}
}
for (int i = 0; i < str.length(); i++) {
if (str[i] == '^')
continue;
else
cout << str[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
long a1, b1, a2, b2, a3, b3;
int Test() {
scanf("%ld%ld%ld%ld%ld%ld", &a1, &b1, &a2, &b2, &a3, &b3);
if (a2 + a3 <= a1 && b2 <= b1 && b3 <= b1) return 1;
if (a2 + a3 <= b1 && b2 <= a1 && b3 <= a1) return 1;
if (a2 + b3 <= a1 && b2 <= b1 && a3 <= b1) return 1;
if (a2 + b3 <= b1 && b2 <= a1 && a3 <= a1) return 1;
if (b2 + a3 <= a1 && a2 <= b1 && b3 <= b1) return 1;
if (b2 + a3 <= b1 && a2 <= a1 && b3 <= a1) return 1;
if (b2 + b3 <= a1 && a2 <= b1 && a3 <= b1) return 1;
if (b2 + b3 <= b1 && a2 <= a1 && a3 <= a1) return 1;
return 0;
}
int main() {
if (Test())
printf("YES");
else
printf("NO");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void PrintArrInt(int arr[], int s, int e) {
for (int i = (s); i <= (e); i++) printf("%d%c", arr[i], i == e ? '\n' : ' ');
}
const int maxn = 100000 + 5;
char str[maxn];
char ans[maxn][20];
char sta[maxn], dsta[maxn];
int top = 0, dtop = 0, alen[maxn], ista[maxn];
int main() {
scanf("%s", str);
int len = strlen(str);
for (int i = (len - 1); i >= (0); i--) {
if (top == 0 || sta[top] != str[i])
sta[++top] = str[i], ista[top] = i, dsta[++dtop] = str[i];
else if (ista[top] != i + 1)
sta[++top] = str[i], ista[top] = i;
else {
if (dtop <= 1 || dsta[dtop - 1] < str[i]) {
top--;
if (top == 0 || sta[top] != dsta[dtop]) dtop--;
} else
sta[++top] = str[i], ista[top] = i;
}
alen[len - i] = top;
if (top > 10) {
for (int j = (top); j >= (top - 4); j--) ans[len - i][top - j] = sta[j];
ans[len - i][5] = ans[len - i][6] = ans[len - i][7] = '.';
ans[len - i][8] = sta[2];
ans[len - i][9] = sta[1];
ans[len - i][10] = 0;
} else {
for (int j = (top); j >= (1); j--) ans[len - i][top - j] = sta[j];
ans[len - i][top] = 0;
}
}
for (int i = (len); i >= (1); i--) printf("%d %s\n", alen[i], ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
T BIGMOD(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
T DIS(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename T>
T GCD(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <typename T>
T EUCLIDE(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
int Check(int N, int pos) { return (N & (1 << pos)); }
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
double DEG(double x) { return (180.0 * x) / ((2.0 * acos(0.0))); }
double RAD(double x) { return (x * (double)(2.0 * acos(0.0))) / (180.0); }
void P_ARR(int *ar, int a, int b) {
if (a > b) swap(a, b);
if (a <= b) cout << ar[a];
for (int i = a + 1; i <= b; i++) cout << " " << ar[i];
cout << endl;
}
void P_BIN(int n) {
if (n == 0) return;
P_BIN(n / 2);
printf("%d", n % 2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int tc, cas = 1;
int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
z;
cin >> n >> m;
a = min(n, m);
if (a & 1)
cout << "Akshat" << endl;
else
cout << "Malvika" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define pb push_back
#define ll long long
#define ull unsigned long long
#define mp make_pair
#define si short int
#define speed ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define pill pair<ll,ll>
#define f first
#define s second
#define pilc pair<ll,char>
#define all(a) (a).begin(),(a).end()
#define rep(s,e,step) for(int i = (s); i < (e) ; i += step)
#define vrep(s,e,step) for(int j = (s); j < (e) ; j += step)
#define ex exit(0)
#define sz(a) (a).size()
#define triple pair<pill, ll>
#define pinode pair<node*, node*>
#define quadra pair<pill, pill>
#define ld long double
using namespace std;
const ll N = 3e5 + 11;
const ll M = 1E6;
const ll big = 1e16;
const ll hsh2 = 1964325029 ;
const long long mod = 1e9 + 7;
const long double EPS = 1e-15;
const ll block = 1e7;
const ll shift = 2e3;
ll n, t;
pill z[N];
int main() {
speed;
cin >> t;
while(t--) {
cin >> n;
for(int i = 1; i <= n; i++)
cin >> z[i].f;
for(int i = 1; i <= n; i++)
cin >> z[i].s;
sort(z + 1, z + n + 1);
ll a = 1, b = 1;
ll ans = 0;
for(int i = 1; i <= n; i++) {
ll dlt = z[i].f - a;
ll dlt2 = z[i].s - b, dlt3;
ll cur = (a + b) % 2;
if(cur) {
dlt -= dlt2;
ans += (dlt + 1)/2;
}
else {
if(dlt == dlt2) {
ans += dlt;
}
else {
dlt--;
dlt -= dlt2;
ans += (dlt + 1) / 2;
}
}
a = z[i].f, b = z[i].s;
}
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1234567];
int w[1234567];
int main() {
int n, m, q, i;
while (scanf("%d%d", &n, &m) != EOF) {
int k = 0;
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
scanf("%d", &q);
if (q < 1234560) a[q] = 1;
}
i = 1;
while (1) {
if (m < i) break;
if (a[i] == 0 && m >= i) {
m -= i;
w[k++] = i;
}
i++;
}
if (m != 0) {
for (i = m + w[k - 1]; i >= w[k - 1]; i--) {
if (a[i] == 0) {
w[k - 1] = i;
break;
}
}
}
printf("%d\n", k);
for (i = 0; i < k; i++) printf("%d%c", w[i], i == k - 1 ? '\n' : ' ');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 50 + 7;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = INF) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
int n;
vector<int> adj[MAX_N];
double dp[MAX_N][MAX_N];
double C[MAX_N][MAX_N];
int f[MAX_N];
void init() {
for (int i = (0), _b = (MAX_N); i < _b; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = (1), _b = (i); j < _b; ++j)
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
}
void dfs(int u, int r) {
fill_n(dp[u], MAX_N, 0);
dp[u][0] = 1;
f[u] = 1;
for (int v : adj[u])
if (v != r) {
dfs(v, u);
static double temp[MAX_N];
fill_n(temp, f[v] + 1, 0);
double rev_p = 1.0 / f[v];
for (int k = 0; k <= f[v]; ++k) {
if (k > 0) {
temp[k] += k * dp[v][k - 1] * rev_p;
}
for (int j = k; j < f[v]; ++j) temp[k] += dp[v][j] * 0.5 * rev_p;
}
static double dp_temp[MAX_N];
fill_n(dp_temp, MAX_N, 0);
for (int i = (0), _b = (f[u]); i < _b; ++i)
for (int j = (0), _b = (f[v] + 1); j < _b; ++j) {
double prop = C[i + j][j] * C[f[u] - 1 + f[v] - i - j][f[v] - j] /
C[f[u] + f[v] - 1][f[v]];
dp_temp[i + j] += dp[u][i] * temp[j] * prop;
}
f[u] += f[v];
for (int i = (0), _b = (f[u]); i < _b; ++i) dp[u][i] = dp_temp[i];
}
}
void solve() {
init();
cin >> n;
for (int i = (1), _b = (n); i < _b; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = (1), _b = (n + 1); i < _b; ++i) {
dfs(i, -1);
cout << std::fixed << std::setprecision(6) << dp[i][0] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int type[MAX], val[MAX], tim[MAX];
set<int> help;
map<int, int> mp;
map<int, int> bit[MAX];
void add(int ind, int v) {
while (ind < MAX) {
bit[ind][v]++;
ind += (ind & (-ind));
}
}
void remove(int ind, int v) {
while (ind < MAX) {
bit[ind][v]--;
ind += (ind & (-ind));
}
}
int read(int ind, int v) {
int ans = 0;
while (ind) {
ans += bit[ind][v];
ind -= (ind & (-ind));
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &type[i], &tim[i], &val[i]);
help.insert(tim[i]);
}
int cur = 1;
for (set<int>::iterator it = help.begin(); it != help.end(); it++) {
mp[*it] = cur;
cur++;
}
for (int i = 0; i < n; i++) {
int ord = mp[tim[i]];
int ty = type[i];
int vl = val[i];
if (ty == 1) add(ord, vl);
if (ty == 2) remove(ord, vl);
if (ty == 3) printf("%d\n", read(ord, vl));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y;
cin >> x >> y;
if (x == y) {
cout << "=";
return 0;
}
long double ans1;
ans1 = y * log(x);
long double ans2;
ans2 = x * log(y);
if (ans1 == ans2) {
cout << "=";
} else if (ans1 > ans2) {
cout << ">";
} else {
cout << "<";
}
}
| 1 |
/*
差不多得了 [流汗黄豆]
*/
// 392699
#include <bits/stdc++.h>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define int long long
// using namespace std;
template<class T> void fr(T &a, bool f = 0, char ch = getchar()) {
for (a = 0; ch < '0' || ch > '9'; ch = getchar()) ch == '-' ? f = 1 : 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) a = a * 10 + ch - '0';
a = f ? -a : a;
}
int fr() {
int a;
return fr(a), a;
}
const int N = 4e5, P = 1e9 + 7;
int frac[N + 10], ifrac[N + 10];
void InitC() {
frac[0] = frac[1] = ifrac[0] = ifrac[1] = 1;
for (int i = 2; i <= N; i++) ifrac[i] = (P - P / i) * ifrac[P % i] % P;
for (int i = 2; i <= N; i++) frac[i] = frac[i - 1] * i % P, ifrac[i] = ifrac[i] * ifrac[i - 1] % P;
}
int C(int x, int y) {
if (x < 0 || y < 0) return 0;
return frac[x + y] * ifrac[y] % P * ifrac[x] % P;
}
struct OI {
int RP, score;
} CSPS2021, NOIP2021;
signed main() {
CSPS2021.RP++, CSPS2021.score++, NOIP2021.RP++, NOIP2021.score++, 392699;
InitC();
for (int T = fr(); T--;) {
int ans = 0, n = fr(), l = fr(), r = fr(), dn = 0x7f7f7f7f, up = 0x7f7f7f7f, a, b, c, n2 = n / 2;
for (int i = 1; i <= n; i++) {
a = i - l, b = r - i, dn = min(dn, min(a, b)), up = min(up, max(a, b));
}
for (int i = dn + 1; i <= up; i++) {
a = min(n, n - i - l + 1), b = min(n, r - i);
if (a < 0) a = 0;
if (b < 0) b = 0;
c = min(a, min(b, r - 2 * i - l + 1));
if (c < 0) c = 0;
// printf("a = %lld b = %lld c = %lld\n", a, b, c);
if (max(a - c, b - c) > max(n2, n - n2)) break;
ans = (ans + C(n2 - a + c, n - n2 - b + c)) % P;
if (n % 2) ans = (ans + C(n - n2 - a + c, n2 - b + c)) % P;
}
ans = (ans + dn * C(n2, n - n2) % P) % P;
if (n % 2) ans = (ans + dn * C(n - n2, n2)) % P;
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void ff() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void in_out_txt() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
bool palindrome(string str) {
string s;
s = str;
reverse(s.begin(), s.end());
if (str.compare(s) == 0) return true;
return false;
}
int main() {
ff();
string str, s1, s2;
int num1, num2;
cin >> str;
int co = 0;
while (!palindrome(str)) {
s1 = str.substr(0, 2);
s2 = str.substr(3, 2);
num1 = stoi(s1), num2 = stoi(s2);
num2++;
if (num2 == 60) {
num2 = 0;
num1++;
if (num1 == 24) num1 = 0;
}
s1 = to_string(num1);
if (s1.size() == 1) s1 = '0' + s1;
s2 = to_string(num2);
if (s2.size() == 1) s2 = '0' + s2;
str = s1 + ':' + s2;
co++;
}
cout << co << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int n;
long long ai[maxn + 2], lim;
inline long long Ceil(long long a, long long b) {
if (a % b) return a / b + 1;
return a / b;
}
long long FindNext(long long a, long long d) {
if (a < d) return lim;
long long now = Ceil(a, d), res;
if (a % d == 0)
res = d;
else {
res = a / (a / d);
if (a % (res + 1) == 0) ++res;
}
return res;
}
int main() {
scanf("%d%lld", &n, &lim);
for (int i = 1; i <= n; ++i) scanf("%lld", ai + i), lim += ai[i];
long long ans = 0;
for (long long d = 1, nex = 0; d <= lim; d = nex + 1) {
long long sum = 0;
nex = lim;
for (int i = 1; i <= n; ++i) {
sum += Ceil(ai[i], d);
nex = min(nex, FindNext(ai[i], d));
}
long long l = d, r = nex, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (mid * sum <= lim)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400005;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const double eps = 1e-9;
int q, op, cnt;
long long a, b, last;
long long w[maxn], sum[maxn][25];
int fa[maxn][25];
void add(int u, int val) {
w[++cnt] = val;
if (w[cnt] <= w[u])
fa[cnt][0] = u;
else {
for (int i = 20; i >= 0; i--) {
if (w[fa[u][i]] < w[cnt]) u = fa[u][i];
}
fa[cnt][0] = fa[u][0];
}
if (fa[cnt][0] == 0)
sum[cnt][0] = INF;
else
sum[cnt][0] = w[fa[cnt][0]];
for (int i = 1; i <= 20; i++) {
fa[cnt][i] = fa[fa[cnt][i - 1]][i - 1];
if (fa[cnt][i] == 0)
sum[cnt][i] = INF;
else
sum[cnt][i] = sum[cnt][i - 1] + sum[fa[cnt][i - 1]][i - 1];
}
}
long long query(int u, long long val) {
if (w[u] > val) return 0;
val -= w[u];
long long ans = 1;
for (int i = 20; i >= 0; i--) {
if (val >= sum[u][i]) {
val -= sum[u][i];
ans += (1 << i);
u = fa[u][i];
}
}
return ans;
}
int main() {
w[0] = INF;
w[1] = 0;
last = 0;
cnt = 1;
memset((sum[1]), (0x3f), sizeof(sum[1]));
scanf("%d", &q);
while (q--) {
scanf("%d%lld%lld", &op, &a, &b);
a ^= last;
b ^= last;
if (op == 1)
add(a, b);
else
printf("%lld\n", last = query(a, b));
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
;
long long res = 0;
long long x, hh, h;
cin >> hh;
;
multiset<long long> ms;
bool stop = false;
for (int i = 0; i < n; i++) {
h = hh;
cin >> x;
if (stop) continue;
ms.insert(x);
long long l = 0;
for (multiset<long long>::reverse_iterator it = ms.rbegin();
it != ms.rend(); it++) {
long long u = *it;
if (u > h) {
stop = true;
}
if (stop) break;
if (l == 0) {
l = u;
} else {
h -= l;
l = 0;
}
}
if (!stop)
if (!stop) res++;
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dis[60][60][2];
long long ans[60][60][2];
bool inque[60][60][2];
int n, k, f, t;
const int inf = 1e6;
const int mod = 1000000007;
pair<pair<int, int>, int> make_pair(int x, int y, int i) {
return make_pair(make_pair(x, y), i);
}
int c[60][60];
int C(int n, int m) {
if (c[n][m] != 0) return c[n][m];
if (n == m || m == 0) return c[n][m] = 1;
return c[n][m] = (C(n - 1, m) + C(n - 1, m - 1)) % mod;
}
int main() {
scanf("%d%d", &n, &k);
for (int i(1); i <= n; ++i) {
int tmp;
scanf("%d", &tmp);
if (tmp == 50)
++f;
else
++t;
}
for (int i(0); i <= 50; ++i) {
for (int j(0); j <= 50; ++j) {
for (int k(0); k <= 1; ++k) {
dis[i][j][k] = inf;
}
}
}
dis[0][0][1] = 0;
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(0, 0, 1));
inque[0][0][1] = true;
while (!q.empty()) {
int x = q.front().first.first, y = q.front().first.second,
bk = q.front().second;
if (bk) {
for (int i(0); i <= f - x; ++i) {
if (i * 50 > k) break;
for (int j(0); j <= t - y; ++j) {
if (i * 50 + j * 100 > k) break;
if (i + j == 0) continue;
int tx = x + i, ty = y + j;
if (dis[tx][ty][0] > dis[x][y][1] + 1) {
dis[tx][ty][0] = dis[x][y][1] + 1;
if (!inque[tx][ty][0]) {
inque[tx][ty][0] = true;
q.push(make_pair(tx, ty, 0));
}
}
}
}
} else {
for (int i(0); i <= x; ++i) {
if (i * 50 > k) break;
for (int j(0); j <= y; ++j) {
if (i * 50 + j * 100 > k) break;
if (i + j == 0) continue;
int tx = x - i, ty = y - j;
if (dis[tx][ty][1] > dis[x][y][0] + 1) {
dis[tx][ty][1] = dis[x][y][0] + 1;
if (!inque[tx][ty][1]) {
inque[tx][ty][1] = true;
q.push(make_pair(tx, ty, 1));
}
}
}
}
}
q.pop();
inque[x][y][bk] = false;
}
if (dis[f][t][0] >= 1000) {
printf("-1\n0\n");
} else {
printf("%d\n", dis[f][t][0]);
q.push(make_pair(0, 0, 1));
ans[0][0][1] = 1;
inque[0][0][1] = true;
while (!q.empty()) {
int x = q.front().first.first, y = q.front().first.second,
bk = q.front().second;
if (bk) {
for (int i(0); i <= f - x; ++i) {
if (i * 50 > k) break;
for (int j(0); j <= t - y; ++j) {
if (i * 50 + j * 100 > k) break;
if (i + j == 0) continue;
int tx = x + i, ty = y + j;
if (dis[tx][ty][0] == dis[x][y][1] + 1) {
ans[tx][ty][0] +=
((ans[x][y][1] * C(f - x, i)) % mod * C(t - y, j)) % mod;
ans[tx][ty][0] %= mod;
if (!inque[tx][ty][0]) {
q.push(make_pair(tx, ty, 0));
inque[tx][ty][0] = true;
}
}
}
}
} else {
for (int i(0); i <= x; ++i) {
if (i * 50 > k) break;
for (int j(0); j <= y; ++j) {
if (i * 50 + j * 100 > k) break;
if (i + j == 0) continue;
int tx = x - i, ty = y - j;
if (dis[tx][ty][1] == dis[x][y][0] + 1) {
ans[tx][ty][1] +=
((ans[x][y][0] * C(x, i)) % mod * C(y, j)) % mod;
ans[tx][ty][1] %= mod;
if (!inque[tx][ty][1]) {
q.push(make_pair(tx, ty, 1));
inque[tx][ty][1] = true;
}
}
}
}
}
q.pop();
}
cout << ans[f][t][0] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a = 0, b = 0, res = 0;
int n;
cin >> n;
int x[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
if (x[i] == 0) b++;
a += x[i];
}
if (b > 0) {
res += b;
a += b;
}
if (a == 0) res++;
cout << res << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a;
int a1, a2;
int main() {
while (1) {
scanf("%c", &a);
if (a == '-') a1++;
if (a == 'o') a2++;
if (a == '\n') break;
}
if (a1 == 0 || a2 == 0)
printf("YES\n");
else if (a1 % a2 == 0)
printf("YES\n");
else
printf("NO\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long exp(long long taban, long long us) {
if (us < 0) return 0;
long long carpan = taban % 1000000007;
long long temp = us;
long long res = 1;
while (temp) {
if (temp % 2) res = (res * carpan) % 1000000007;
temp /= 2;
carpan = (carpan * carpan) % 1000000007;
}
return res;
}
long long ebob(long long a, long long b) {
if (!a) return b;
return ebob(b % a, a);
}
long long ekok(long long a, long long b) { return (a * b) / ebob(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> vec(n);
for (auto &x : vec) cin >> x;
int ptr1 = -1, ptr2 = -1;
bool check = 1;
vec.push_back(0);
vector<pair<int, int>> segs;
int basla = 0, bitir = 0;
for (int i = 0; i < n; i++) {
if (vec[i] < vec[i + 1]) {
bitir++;
} else {
segs.push_back({basla, bitir});
basla = i + 1;
bitir = i + 1;
}
}
int ans;
ans = segs[0].second - segs[0].first + 1;
for (int i = 0; i < segs.size() - 1; i++) {
pair<int, int> ilk = segs[i], iki = segs[i + 1];
if (ilk.first || ilk.second < n) ans = max(ans, ilk.second - ilk.first + 2);
if (iki.first || iki.second < n) ans = max(ans, iki.second - iki.first + 2);
if (ilk.first == ilk.second || iki.first == iki.second) {
ans = max(ans, iki.second - ilk.first + 1);
continue;
}
if ((iki.first + 1 < n && vec[ilk.second] + 1 < vec[iki.first + 1]) ||
(ilk.second && vec[iki.first] - 1 > vec[ilk.second - 1])) {
ans = max(ans, iki.second - ilk.first + 1);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void BOOM_BAAM() {
string s;
cin >> s;
long long n = s.size();
vector<long long> x(n, 0);
long long ab = 0, ba = 0;
for (long long i = 0; i < n - 1; i++) {
if (s[i] == 'a' && s[i + 1] == 'b') {
ab++;
}
if (s[i] == 'b' && s[i + 1] == 'a') {
ba++;
}
}
if (ab == ba) {
cout << s << endl;
return;
}
char z = 'a';
if (s[0] == 'a') {
z = 'b';
}
s[0] = z;
cout << s << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long T = 1;
cin >> T;
while (T--) {
BOOM_BAAM();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long x, a[n + 1];
long long ans, mi = 1000000000;
a[0] = 0;
for (long long i = 1; i <= n; i++) {
cin >> x;
a[i] = a[i - 1] + x;
if (i >= k && mi > (a[i] - a[i - k])) {
mi = a[i] - a[i - k];
ans = i - k + 1;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int main() {
int i, j, len, t, now;
scanf("%s", s);
len = strlen(s);
i = 0;
int r1, r2;
while (i < len) {
t = i;
i++;
j = 1;
while (i < len && s[i] == '0') i++, j++;
if (j > t)
now = 1;
else if (j == t) {
for (r1 = 0; r1 < j; r1++) {
if (s[r1] < s[r1 + t]) break;
}
if (r1 == j)
now++;
else
now = 1;
} else
now++;
}
printf("%d\n", now);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
float x;
scanf("%f", &x);
printf("%.0f", ceil(x / 5));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxC = 999999999;
string s, t;
int n, k, res, x, y, cost[505][505], f[505][505], g[505][505];
int cal(int x, int y) {
int len = y - x + 1, res = 0;
for (int i = 0; i < len / 2; i++)
if (s[x + i] != s[y - i]) res++;
return res;
}
void compute_cost() {
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) cost[i][j] = cal(i, j);
}
string take(int x, int y) {
string res = "";
int len = y - x + 1;
for (int i = x - 1; i < y; i++) res += s[i];
for (int i = 0; i < len / 2; i++) res[len - 1 - i] = res[i];
return res;
}
int main() {
if (0) {
freopen("a.inp", "r", stdin);
};
getline(cin, s);
n = s.length();
scanf("%d", &k);
compute_cost();
for (int i = 1; i <= n; i++) f[i][0] = maxC;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
f[i][j] = maxC;
for (int x = 1; x <= i; x++)
if (f[x - 1][j - 1] + cost[x - 1][i - 1] < f[i][j]) {
f[i][j] = f[x - 1][j - 1] + cost[x - 1][i - 1];
g[i][j] = x - 1;
}
}
res = maxC;
for (int i = 1; i <= k; i++)
if (f[n][i] < res) {
res = f[n][i];
y = i;
}
printf("%d\n", res);
t = "";
x = n;
while (y) {
t = take(g[x][y] + 1, x) + "+" + t;
x = g[x][y];
y--;
}
t.erase(t.length() - 1, 1);
cout << t << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxb = 22;
const int maxn = (1 << maxb) + 10;
int topol[maxn], sz, n, color[maxn], c = 1;
bool is[maxn], visited[maxn];
void dfs(int v) {
visited[v] = 1;
int sm = (1 << n) - 1 - v;
if (is[v] && !visited[sm]) dfs(sm);
for (int i = 0; i < n; i++)
if ((((v) >> (i)) & 1) && !visited[v ^ (1 << i)]) dfs(v ^ (1 << i));
topol[sz] = v;
sz--;
}
void sfd(int v) {
color[v] = c;
int sm = (1 << n) - 1 - v;
if (is[sm] && !color[sm]) sfd(sm);
for (int i = 0; i < n; i++)
if (!(((v) >> (i)) & 1) && !color[v ^ (1 << i)]) sfd(v ^ (1 << i));
}
int main() {
int m;
scanf("%d%d", &n, &m);
sz = (1 << n) - 1;
int a;
for (int i = 0; i < m; i++) scanf("%d", &a), is[a] = 1;
for (int i = 0; i < (1 << n); i++)
if (!visited[i]) dfs(i);
for (int i = 0; i < (1 << n); i++)
if (!color[topol[i]]) sfd(topol[i]), c++;
memset(visited, 0, sizeof visited);
int res = 0;
for (int i = 0; i < (1 << n); i++)
if (is[i] && !visited[color[i]]) {
visited[color[i]] = 1;
res++;
}
cout << res << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, pair<int, int>> m;
int x, y;
pair<int, int> p, q;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a[6] = {4, 8, 15, 16, 23, 42};
for (int i = 0; i < 6; i++) {
for (int j = i + 1; j < 6; j++) {
m[a[i] * a[j]] = {a[i], a[j]};
}
}
for (int k : {1, 4}) {
cout << "? " << k << ' ' << k + 1 << '\n' << flush;
cin >> x;
cout << "? " << k + 1 << ' ' << k + 2 << '\n' << flush;
cin >> y;
p = m[x], q = m[y];
if (p.first == q.first)
swap(p.first, p.second);
else if (p.first == q.second)
swap(p.first, p.second), swap(q.first, q.second);
else if (p.second == q.second)
swap(q.first, q.second);
v.emplace_back(p.first);
v.emplace_back(p.second);
v.emplace_back(q.second);
}
cout << '!';
for (int i = 0; i < 6; i++) {
cout << ' ' << v[i];
}
cout << '\n' << flush;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ans = 0, w = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') w = -1, c = getchar();
while (isdigit(c)) ans = (ans << 1) + (ans << 3) + c - '0', c = getchar();
return ans * w;
}
long long sum1[300010 << 2], sum2[300010 << 2];
void pu(int o) {
sum1[o] = sum1[(o << 1)] + sum1[((o << 1) | 1)];
sum2[o] = (sum2[(o << 1)] + sum2[((o << 1) | 1)]) % 1000000007;
}
int a[300010], w[300010];
int n, q;
long long mod(long long a) {
a %= 1000000007;
if (a < 0) a += 1000000007;
return a;
}
long long add(long long a, long long b) { return mod(a + b); }
long long mul(long long a, long long b) { return mod(a * b); }
void pushup1(int t) { sum1[t] = sum1[(t << 1)] + sum1[(t << 1 | 1)]; }
void pushup2(int t) { sum2[t] = add(sum2[(t << 1)], sum2[(t << 1 | 1)]); }
void modify1(int t, int l, int r, int pos, long long vl) {
if (l == r) {
sum1[t] = vl;
return;
}
if (pos <= ((l + r) >> 1))
modify1((t << 1), l, ((l + r) >> 1), pos, vl);
else
modify1((t << 1 | 1), ((l + r) >> 1) + 1, r, pos, vl);
pushup1(t);
}
void modify2(int t, int l, int r, int pos, long long vl) {
if (l == r) {
sum2[t] = vl;
return;
}
if (pos <= ((l + r) >> 1))
modify2((t << 1), l, ((l + r) >> 1), pos, vl);
else
modify2((t << 1 | 1), ((l + r) >> 1) + 1, r, pos, vl);
pushup2(t);
}
long long qry1(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum1[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans += qry1((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
ans += qry1(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
return ans;
}
long long qry2(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum2[o];
long long ans = 0;
if (((l + r) >> 1) >= ql) ans = qry2((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
(ans += qry2(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr)) %= 1000000007;
return ans;
}
int query1_pos(int t, int l, int r, int L, int R, long long vl) {
if (l == r) return l;
if (R <= ((l + r) >> 1))
return query1_pos((t << 1), l, ((l + r) >> 1), L, R, vl);
if (L > ((l + r) >> 1))
return query1_pos((t << 1 | 1), ((l + r) >> 1) + 1, r, L, R, vl);
long long suml = qry1((t << 1), l, ((l + r) >> 1), L, ((l + r) >> 1));
if (suml >= vl)
return query1_pos((t << 1), l, ((l + r) >> 1), L, ((l + r) >> 1), vl);
else
return query1_pos((t << 1 | 1), ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1,
R, vl - suml);
}
void build(int o, int l, int r) {
if (l == r) {
sum1[o] = w[l], sum2[o] = (long long)a[l] * w[l] % 1000000007;
return;
}
build((o << 1), l, ((l + r) >> 1)),
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
pu(o);
}
void update(int o, int l, int r, int first, int v) {
if (l == r) {
sum1[o] = v;
sum2[o] = (long long)v * a[l] % 1000000007;
return;
}
if (((l + r) >> 1) >= first)
update((o << 1), l, ((l + r) >> 1), first, v);
else
update(((o << 1) | 1), ((l + r) >> 1) + 1, r, first, v);
pu(o);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] -= i;
for (int i = 1; i <= n; ++i) scanf("%d", w + i);
build(1, 1, n);
while (q--) {
int first = read(), second = read();
if (first < 0)
update(1, 1, n, -first, second);
else {
long long sum = qry1(1, 1, n, first, second);
int l = first, r = second, pos = -1;
while (l <= r) {
if (2 * qry1(1, 1, n, first, ((l + r) >> 1)) >= sum)
pos = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
long long ans = 0;
ans = add(ans, mul(a[pos], add(qry1(1, 1, n, first, pos),
-qry1(1, 1, n, pos, second))));
ans =
add(ans, add(-qry2(1, 1, n, first, pos), qry2(1, 1, n, pos, second)));
printf("%lld\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 3e5;
vector<int> node[nax];
int dist[nax], par[nax];
int main() {
int n, m;
cin >> n >> m;
set<pair<int, int>> edges;
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
edges.insert({a, b});
edges.insert({b, a});
node[a].push_back(b);
node[b].push_back(a);
}
fill_n(dist, n, 1e9);
queue<int> q;
q.push(0);
dist[0] = 0;
while (q.size()) {
int p = q.front();
q.pop();
for (int i : node[p]) {
if (dist[i] == 1e9) {
dist[i] = dist[p] + 1;
par[i] = p;
q.push(i);
}
}
}
if (dist[n - 1] <= 4) {
vector<int> path;
for (int p = n - 1; p; p = par[p]) {
path.push_back(p);
}
path.push_back(0);
reverse(path.begin(), path.end());
cout << dist[n - 1] << endl;
for (int p : path) cout << p + 1 << ' ';
cout << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (dist[i] == 2) {
cout << 4 << endl;
cout << 1 << ' ' << par[i] + 1 << ' ' << i + 1 << ' ' << 1 << ' ' << n
<< endl;
return 0;
}
}
fill_n(dist, n, 1e9);
dist[0] = -1;
for (int i : node[0]) {
if (dist[i] != 1e9) continue;
vector<int> list = {i};
dist[i] = 0;
int s = 0;
while (s < list.size()) {
int p = list[s++];
for (int j : node[p]) {
if (dist[j] == 1e9) {
dist[j] = 0;
list.push_back(j);
}
}
}
for (int i : list) {
for (int j : list) {
if (i != j && !edges.count({i, j})) {
for (int a : node[i]) {
if (!a) continue;
for (int b : node[a]) {
if (!a || i == b || edges.count({i, b})) continue;
cout << 5 << endl;
cout << 1 << ' ' << i + 1 << ' ' << a + 1 << ' ' << b + 1 << ' '
<< i + 1 << ' ' << n << endl;
return 0;
}
}
assert(0);
}
}
}
}
cout << -1 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool check(string in) {
if (in[2] != '-' || in[5] != '-') return false;
int d = 0, m = 0, y = 0;
for (int ctr1 = 0; ctr1 < 10; ctr1++) {
if (ctr1 == 2) {
d = y;
y = 0;
continue;
}
if (ctr1 == 5) {
m = y;
y = 0;
continue;
}
if (!isdigit(in[ctr1])) return false;
y = y * 10 + in[ctr1] - '0';
}
if (y < 2013 || y > 2015) return false;
if (m <= 0 || m > 12) return false;
if (d <= 0 || d > days[m - 1]) return false;
return true;
}
int main() {
string prop;
cin >> prop;
map<string, int> mp;
for (int ctr1 = 0; ctr1 < prop.size() - 9; ctr1++) {
string cur = prop.substr(ctr1, 10);
if (check(cur)) {
mp[cur]++;
}
}
string rez;
int ma = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it->second > ma) {
ma = it->second;
rez = it->first;
}
}
cout << rez;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100009], cre[100009], prec[100009];
set<int> s, setr_2;
multiset<int> set_1;
int main() {
cin >> n;
for (int i = 0; i < n; i++) set_1.insert(0);
if (n <= 2) {
cout << n << endl;
return 0;
}
int res = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (prec[cre[a[i]]] == 1) setr_2.erase(cre[a[i]]);
s.insert(a[i]);
prec[cre[a[i]]]--;
set_1.erase(set_1.lower_bound(cre[a[i]]));
cre[a[i]]++;
prec[cre[a[i]]]++;
setr_2.insert(cre[a[i]]);
set_1.insert(cre[a[i]]);
if (s.size() == 1) res = max(res, i);
if (setr_2.size() == 1 && (*setr_2.begin() == 1)) res = max(res, i);
if (setr_2.size() == 2) {
int x = *setr_2.begin();
if (x == 1 && prec[x] == 1) res = max(res, i);
int y = (*(++setr_2.begin()));
if (y - x == 1 && prec[y] == 1) {
res = max(res, i);
}
}
}
cout << res + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int P = 998244353;
int main() {
int N, K;
cin >> N >> K;
if (K == 1) {
cout << 0;
return 0;
}
int f[501] = {0};
for (int n = 1; n <= N; n++) {
int g[501] = {0};
g[0] = 1;
for (int i = 1; i <= N; i++)
for (int len = 1; len <= i && len <= n; len++)
g[i] = (g[i] + g[i - len]) % P;
f[n] = (g[N] - accumulate(&f[0], &f[n - 1] + 1, 0ll) % P + P) % P;
}
int ans = 1;
for (int _ = 1; _ <= 2 * N - 1; _++) ans = (ans * 2) % P;
for (int i = 1; i <= N; i++)
for (int j = (int)ceil((double)K / i); j <= N; j++)
ans = (ans - ((2ll * f[i] * f[j]) % P) + P) % P;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sum[1000100];
int main() {
string a, b;
cin >> a >> b;
int cnt = 0;
for (int i = 0; i < b.size(); i++) {
if (b[i] == '1') cnt++;
}
sum[0] = a[0] - '0';
for (int i = 1; i < a.size(); i++) {
sum[i] = sum[i - 1] + a[i] - '0';
}
int l = 0, r = b.size() - 1;
int ans = 0;
while (r < a.size()) {
if (cnt % 2 == 0 && (sum[r] - sum[l] + a[l] - '0') % 2 == 0) {
ans++;
} else if (cnt % 2 != 0 && (sum[r] - sum[l] + a[l] - '0') % 2 != 0) {
ans++;
}
l++;
r++;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b;
cin >> n >> b;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> v;
v.push_back(b);
for (int i = 0; i < n - 1; i++) {
int flag = 0, max = a[i];
for (int j = i + 1; j < n; j++) {
if (a[j] > max) {
flag = 1;
max = a[j];
}
}
if (flag == 1) {
int x = b;
x = x % a[i];
x = x + max * (b / a[i]);
v.push_back(x);
}
}
cout << *max_element(v.begin(), v.end());
}
| 3 |
#include <bits/stdc++.h>
constexpr auto INF = 9223372036854775807;
using namespace std;
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
mt19937 mt(seed);
int myrand(int mod) { return mt() % mod; }
inline long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int mod_power(long long int x, long long int y) {
long long int res = 1;
x = x % (long long int)1000000007;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % (long long int)1000000007;
y = y >> 1;
x = (x * x) % (long long int)1000000007;
}
return res;
}
long long modInverse(long long n) {
return mod_power(n, (long long int)1000000007 - 2);
}
long long nCrModPFermat(long long n, long long int r) {
if (r == 0) return 1;
vector<long long int> fac(n + 1, 0);
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % (long long int)1000000007;
return (fac[n] * modInverse(fac[r]) % (long long int)1000000007 *
modInverse(fac[n - r]) % (long long int)1000000007) %
(long long int)1000000007;
}
bool isprime(long long int n) {
if (n == 2) return true;
if (n % 2 == 0 || n == 1) {
return false;
}
for (long long int j = 3; j <= sqrt(n); j += 2) {
if (n % j == 0) {
return false;
}
}
return true;
}
bool check(vector<long long int> arr) {
for (long long int i = 0; i < arr.size(); i += 1) {
if (i + 1 != arr[i]) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int n;
cin >> n;
vector<pair<long long int, long long int>> ans;
vector<long long int> arr(n, 0);
for (long long int i = 0; i < n; i += 1) cin >> arr[i];
for (long long int i = 0; i < n / 2; i += 1) {
if (arr[i] == i + 1) continue;
if (arr[i] <= n / 2) {
swap(arr[i], arr[n - 1]);
ans.push_back({i + 1, n});
ans.push_back({n, arr[n - 1]});
swap(arr[n - 1], arr[arr[n - 1] - 1]);
} else {
if (arr[i] == n) {
swap(arr[i], arr[n - 1]);
ans.push_back({i + 1, n});
if (arr[i] != i + 1) i -= 1;
continue;
}
swap(arr[i], arr[n - 1]);
ans.push_back({i + 1, n});
ans.push_back({1, n});
swap(arr[0], arr[n - 1]);
ans.push_back({1, arr[0]});
swap(arr[0], arr[arr[0] - 1]);
if (i != 0) {
ans.push_back({1, n});
swap(arr[0], arr[n - 1]);
}
}
if (arr[i] != i + 1) i -= 1;
}
for (long long int i = n / 2; i < n; i += 1) {
if (arr[i] == i + 1) continue;
ans.push_back({1, i + 1});
swap(arr[0], arr[i]);
ans.push_back({1, arr[0]});
swap(arr[0], arr[arr[0] - 1]);
ans.push_back({1, i + 1});
swap(arr[0], arr[i]);
if (arr[i] != i + 1) i -= 1;
}
if (!check(arr)) cout << "Wrong";
cout << ans.size() << '\n';
for (auto i : ans) cout << i.first << " " << i.second << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long myabs(long long xx) { return max(xx, -xx); }
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
long long sa = 0;
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
if (i % 2)
sa += tmp;
else
sa -= tmp;
}
vector<long long> b;
long long sb = 0;
deque<int> dq;
for (int i = 0; i < m; i++) {
int tmp;
scanf("%d", &tmp);
if (dq.size() >= (size_t)n) {
sb += dq.front();
dq.pop_front();
sb = (-sb);
dq.push_back(tmp);
if (n % 2)
sb -= tmp;
else
sb += tmp;
b.push_back(sb);
} else {
if (i % 2)
sb += tmp;
else
sb -= tmp;
dq.push_back(tmp);
if (dq.size() == (size_t)n) b.push_back(sb);
}
}
sort(b.begin(), b.end());
{
auto it = lower_bound(b.begin(), b.end(), sa);
if (it == b.end())
printf("%lld\n", myabs(b.back() - sa));
else if (it == b.begin())
printf("%lld\n", myabs(*it - sa));
else
printf("%lld\n", min(myabs(*it - sa), myabs(*(it - 1) - sa)));
}
while (q--) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
int num = r - l + 1;
if (num % 2) {
if (r % 2)
sa -= x;
else
sa += x;
}
auto it = lower_bound(b.begin(), b.end(), sa);
if (it == b.end())
printf("%lld\n", myabs(b.back() - sa));
else if (it == b.begin())
printf("%lld\n", myabs(*it - sa));
else
printf("%lld\n", min(myabs(*it - sa), myabs(*(it - 1) - sa)));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5;
const int Q = 1e9 + 7;
priority_queue<long long> heap;
int main() {
srand(time(NULL));
int i, n, k;
scanf("%d", &n);
scanf("%d", &k);
for (i = 0; i < k; i++) heap.push(0);
for (i = 0; i < n; i++) {
long long s, m;
scanf(
"%lld"
"%lld",
&s, &m);
long long cur = -heap.top();
heap.pop();
printf(
"%lld"
"\n",
max(cur, s) + m);
heap.push(-(max(cur, s) + m));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 15, M = 6e5 + 15, OO = 1e6 + 3;
int n, t, ss;
string in, in2, in3;
int cnt[27];
list<int> adj[N];
list<int>::iterator it;
int MOD(int a, int b) {
a %= b;
if (a < 0) a += b;
return a;
}
int main() {
cin >> in3;
n = in3.size();
for (int i = 0; i < n; ++i) {
in.push_back('a' + MOD(i, 26));
}
cout << "? " << in << endl;
cin >> in;
for (int i = 0; i < n; ++i) {
for (int j = in[i] - 'a'; j < n; j += 26) {
adj[i].push_back(j);
}
}
in.clear();
for (int i = 0; i < n; ++i) {
in.push_back('a' + MOD((i / 26), 26));
}
cout << "? " << in << endl;
cin >> in;
for (int i = 0; i < n; ++i) {
for (it = adj[i].begin(); it != adj[i].end();) {
if (in[i] - 'a' != MOD(((*it) / 26), 26))
it = adj[i].erase(it);
else
++it;
}
}
in.clear();
for (int i = 0; i < n; ++i) {
in.push_back('0');
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 26; ++j) {
cnt[j] = 0;
}
for (it = adj[i].begin(); it != adj[i].end(); ++it) {
if (in[(*it)] != '0') {
cnt[in[(*it)] - 'a'] = 1;
}
}
for (it = adj[i].begin(); it != adj[i].end(); ++it) {
if (in[(*it)] == '0') {
for (int j = 0; j < 26; ++j) {
if (!cnt[j]) {
in[(*it)] = j + 'a';
cnt[j] = 1;
}
}
}
}
}
for (int i = 0; i < n; ++i) {
if (in[i] == '0') in[i] = 'z';
in2.push_back(in[i]);
}
cout << "? " << in << endl;
cin >> in;
for (int i = 0; i < n; ++i) {
for (it = adj[i].begin(); it != adj[i].end();) {
if (in2[(*it)] != in[i])
it = adj[i].erase(it);
else
++it;
}
}
for (int i = 0; i < n; ++i) {
in[(*adj[i].begin())] = in3[i];
}
cout << "! " << in << endl;
}
| 7 |
#include <bits/stdc++.h>
const int MAXN = 100010;
int n, m, S;
long long T;
int to[40][MAXN];
int dp[2][MAXN];
void predo() {
int *now = dp[0], *lst = dp[1];
for (int i = 0; i < n; ++i) now[i] = i;
for (int i = 1, t; i < n; ++i) {
std::swap(lst, now);
t = std::min(n - i, m);
memcpy(now, lst + i, t << 2);
memcpy(now + t, lst, m - t << 2);
t = std::max(i, m);
memcpy(now + t, lst + t - i, n - t << 2);
memcpy(now + m, lst + m - i + n, t - m << 2);
}
for (int i = 0; i < n; ++i) to[0][i] = now[i];
for (int i = 1; i != 40; ++i)
for (int j = 0; j < n; ++j) to[i][j] = to[i - 1][to[i - 1][j]];
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> m >> S >> T;
--S;
while (T % n) S = (S >= m ? S - T-- % n + n : S + T--) % n;
T /= n, predo();
for (int i = 39; ~i; --i)
if (T >> i & 1) S = to[i][S];
std::cout << S + 1 << std::endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int k;
int call(int n) {
if (n == 0) return 0;
if (n == 1) return 1;
if (k % 2 == 0) {
if (n == 2) return 2;
if (n % 2) return 0;
return 1;
} else {
if (n == 3) return 1;
if (n % 2) return 0;
int ans[50] = {0};
ans[call(n - 1)] = 1;
ans[call(n / 2)] = 1;
for (int i = 0;; i++) {
if (!ans[i]) return i;
}
}
}
int main() {
int i, j, cs, t, n;
scanf("%d %d", &n, &k);
int ans = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &j);
ans ^= call(j);
}
if (ans)
printf("Kevin");
else
printf("Nicky");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const long long inf = 1e18;
int n, q;
int p[maxn];
int w[maxn];
vector<int> G[maxn];
vector<int> Q[maxn];
int id[maxn];
int out[maxn];
int rev[maxn];
int tim;
long long init[maxn];
int v[maxn];
int l[maxn];
int r[maxn];
long long ans[maxn];
long long tree[maxn * 4];
long long lazy[maxn * 4];
void dfs(int u, long long dis) {
dis += w[u];
id[u] = ++tim;
rev[tim] = u;
init[u] = dis;
for (int v : G[u]) {
dfs(v, dis);
}
out[u] = tim;
}
void pushup(int rt) { tree[rt] = min(tree[rt << 1], tree[rt << 1 | 1]); }
void pushdown(int rt) {
if (lazy[rt]) {
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
tree[rt << 1] += lazy[rt];
tree[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
}
void build(int rt, int l, int r) {
if (l >= r) {
tree[rt] = init[l];
return;
}
int m = (l + r) >> 1;
build(rt << 1, l, m);
build(rt << 1 | 1, m + 1, r);
pushup(rt);
}
void update(int rt, int l, int r, int L, int R, int val) {
if (L <= l && r <= R) {
tree[rt] += val;
lazy[rt] += val;
return;
}
pushdown(rt);
int m = (l + r) >> 1;
if (L <= m) {
update(rt << 1, l, m, L, R, val);
}
if (R > m) {
update(rt << 1 | 1, m + 1, r, L, R, val);
}
pushup(rt);
}
long long query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return tree[rt];
}
pushdown(rt);
int m = (l + r) >> 1;
long long ret = inf;
if (L <= m) {
ret = min(ret, query(rt << 1, l, m, L, R));
}
if (R > m) {
ret = min(ret, query(rt << 1 | 1, m + 1, r, L, R));
}
return ret;
}
void dfs2(int u, long long delta = 0) {
for (int i : Q[u]) {
ans[i] = query(1, 1, n, l[i], r[i]) + delta;
}
for (int v : G[u]) {
update(1, 1, n, id[v], out[v], -2 * w[v]);
dfs2(v, delta + w[v]);
update(1, 1, n, id[v], out[v], 2 * w[v]);
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; ++i) {
scanf("%d %d", &p[i], &w[i]);
G[p[i]].push_back(i);
}
for (int i = 0; i < q; ++i) {
scanf("%d %d %d", &v[i], &l[i], &r[i]);
Q[v[i]].push_back(i);
}
dfs(1, 0);
for (int i = 1; i <= n; ++i) {
if (!G[i].empty()) {
init[i] = inf;
}
}
build(1, 1, n);
dfs2(1);
for (int i = 0; i < q; ++i) {
printf("%lld\n", ans[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int cnts[256];
int main() {
string a, b;
cin >> a >> b;
while (b.size() < a.size()) b += ' ';
int n = a.size();
for (int i = 0; i < n; i++) cnts[a[i]]++;
string pref = "";
for (int i = 0; i < n; i++) {
bool prefdone = (pref > b.substr(0, i));
if (prefdone) {
for (char t = 'a'; t <= 'z'; t++) {
if (cnts[t]) {
pref += t;
cnts[t]--;
break;
}
}
} else {
for (char t = b[i]; t <= 'z'; t++) {
if (cnts[t] == 0) continue;
if (t > b[i]) {
pref += t;
cnts[t]--;
break;
} else {
cnts[t]--;
string rem = "";
rem += t;
for (char u = 'z'; u >= 'a'; u--) {
for (int j = 0; j < cnts[u]; j++) {
rem += u;
}
}
if (pref + rem > b) {
pref += t;
break;
}
cnts[t]++;
}
}
if ((int)pref.size() == i) {
cout << -1;
return 0;
}
}
}
cout << pref << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int inf = 1e9;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
namespace flow {
struct edge {
int to, w, nxt;
} e[N << 1];
int tot = 1, h[N], dep[N], cur[N], s, t;
void adde(int u, int v, int w) {
e[++tot] = (edge){v, w, h[u]};
h[u] = tot;
e[++tot] = (edge){u, 0, h[v]};
h[v] = tot;
}
bool bfs() {
memset(dep, 0, sizeof(dep));
queue<int> q;
q.push(s);
dep[s] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (!dep[v] && e[i].w) dep[v] = dep[u] + 1, q.push(v);
}
}
return dep[t];
}
int dfs(int u, int flow) {
if (u == t) return flow;
int ret = 0;
for (int &i = cur[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (dep[v] == dep[u] + 1 && e[i].w) {
int d = dfs(v, min(flow, e[i].w));
e[i].w -= d, e[i ^ 1].w += d, ret += d, flow -= d;
if (!flow) break;
}
}
return ret;
}
int dinic() {
int ret = 0;
while (bfs()) {
memcpy(cur, h, sizeof(h));
ret += dfs(s, inf);
}
return ret;
}
void clear() {
tot = 1;
memset(h, 0, sizeof(h));
}
} // namespace flow
void No() {
puts("-1");
exit(0);
}
int n;
namespace dsu {
int fa[N];
void init(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int getf(int x) { return x == fa[x] ? x : fa[x] = getf(fa[x]); }
bool merge(int x, int y) {
x = getf(x), y = getf(y);
if (x == y) return 0;
fa[y] = x;
return 1;
}
} // namespace dsu
int st[N], ed[N], d = 0, cur[N], cnt[10][10], id[10][10], tot = 0, tmp[10][10];
int getcount(int x) {
int ret = 0;
while (x) ++ret, x /= 10;
return ret;
}
vector<pair<int, int>> ans;
vector<pair<int, int>> e;
bool check() {
if (e.size() != d - 1) return 0;
dsu::init(d);
for (auto x : e)
if (!dsu::merge(x.first, x.second)) return 0;
flow::clear();
flow::s = 0, flow::t = tot + d + 1;
memcpy(tmp, cnt, sizeof(cnt));
for (auto x : e) {
if (tmp[x.first][x.second] == 0) return 0;
--tmp[x.first][x.second];
}
for (int i = 1; i <= d; i++)
for (int j = i + 1; j <= d; j++) {
flow::adde(flow::s, id[i][j], tmp[i][j]);
flow::adde(id[i][j], tot + i, inf);
flow::adde(id[i][j], tot + j, inf);
}
int need = 0;
for (int i = 1; i <= d; i++) {
flow::adde(tot + i, flow::t, ed[i] - cur[i]);
need += ed[i] - cur[i];
}
return flow::dinic() == need;
}
void print() {
for (int i = 1; i <= d; i++)
for (int j = i + 1; j <= d; j++) {
int u = id[i][j];
for (int k = flow::h[u]; k; k = flow::e[k].nxt) {
int v = flow::e[k].to;
if (tot + 1 <= v && v <= tot + d) {
v -= tot;
int w = inf - flow::e[k].w;
while (w--) {
if (v == i)
ans.push_back(make_pair(++cur[i], st[j]));
else
ans.push_back(make_pair(++cur[j], st[i]));
}
}
}
}
for (auto x : e) {
ans.push_back(make_pair(st[x.first], st[x.second]));
}
for (auto x : ans) {
printf("%d %d\n", x.first, x.second);
}
exit(0);
}
void dfs(int x, int y) {
if (y == d + 1) ++x, y = x + 1;
if (x == d) {
if (check()) print();
return;
}
e.push_back(make_pair(x, y));
dfs(x, y + 1);
e.pop_back();
dfs(x, y + 1);
}
int main() {
n = gi(), d = getcount(n);
if (d == 1) {
for (int i = 2; i <= n; i++) printf("%d %d\n", i - 1, i);
exit(0);
}
for (int i = 1; i <= d; i++)
st[i] = cur[i] = ed[i - 1] + 1, ed[i] = st[i] * 10 - 1;
ed[d] = n;
for (int i = 1; i < n; i++) {
string s;
cin >> s;
int u = s.length();
cin >> s;
int v = s.length();
if (u == v) {
if (cur[u] == ed[u]) No();
ans.push_back(make_pair(cur[u], cur[u] + 1));
++cur[u];
} else {
if (u > v) swap(u, v);
++cnt[u][v];
}
}
for (int i = 1; i <= d; i++)
for (int j = i + 1; j <= d; j++) id[i][j] = ++tot;
dfs(1, 2);
No();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int dp1[1000 + 10][1000 + 10] = {0};
int dp2[1000 + 10][1000 + 10] = {0};
int dp3[1000 + 10][1000 + 10] = {0};
int dp4[1000 + 10][1000 + 10] = {0};
int a[1000 + 10][1000 + 10];
int m, n;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp1[i][j] = max(dp1[i - 1][j], dp1[i][j - 1]) + a[i][j];
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
dp2[i][j] = max(dp2[i][j + 1], dp2[i + 1][j]) + a[i][j];
}
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
dp3[i][j] = max(dp3[i][j - 1], dp3[i + 1][j]) + a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
dp4[i][j] = max(dp4[i][j + 1], dp4[i - 1][j]) + a[i][j];
}
}
int ans = 0;
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
ans = max(ans,
dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]);
ans = max(ans,
dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> vis;
const int MAX = 100100;
int m, n, a[MAX], is[MAX * 2];
long long inv(long long a, long long m) {
if (a == 1) return 1;
return inv(m % a, m) * (m - m / a) % m;
}
int main(void) {
scanf("%d%d", &m, &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
if (n == 1 || n == m) {
printf("%d %d\n", a[0], 1);
return 0;
}
int on = n;
if (2 * n > m) {
n = m - n;
for (int i = 0; i < on; i++) is[a[i]] = 1;
for (int i = 0, j = 0; i < m; i++)
if (is[i] == 0) a[j++] = i;
if (n == 1) {
printf("%d %d\n", a[0] + 1, 1);
return 0;
}
} else
sort(a, a + n);
vis.clear();
int d = a[1] - a[0];
vis[a[1]] = 1;
int cnt = 1;
for (int i = 1; i < n; i++) {
if (binary_search(a, a + n, (d + a[i]) % m)) {
if (vis.find((d + a[i]) % m) != vis.end()) break;
vis[(d + a[i]) % m] = 1;
cnt++;
}
}
d = (long long)d * ((inv(n - cnt, m) + m) % m) % m;
vis.clear();
vis[a[0]] = 1;
int f = 0, b = 0;
for (int i = 1; i < n; i++) {
if (binary_search(a, a + n, (a[0] + (long long)d * i) % m) &&
vis.find((a[0] + (long long)d * i) % m) == vis.end()) {
vis[(a[0] + (long long)d * i) % m] = 1;
f++;
} else
break;
}
for (int i = 1; i < n; i++) {
if (binary_search(a, a + n, (a[0] + (long long)(m - d) * i) % m) &&
vis.find((a[0] + (long long)(m - d) * i) % m) == vis.end()) {
vis[(a[0] + (long long)(m - d) * i) % m] = 1;
b++;
} else
break;
}
if (f + b + 1 == n) {
int fir = (a[0] + (long long)(m - d) * b) % m;
if (on * 2 > m) fir = (a[0] + (long long)d * f + d) % m;
printf("%d %d\n", fir, d);
return 0;
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long p[200010];
long long dp[200010];
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long ret = exgcd(b, a % b, y, x);
y -= a / b * x;
return ret;
}
long long getInv(long long a, long long mod) {
long long x, y;
long long d = exgcd(a, mod, x, y);
return d == 1 ? (x % mod + mod) % mod : -1;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &p[i]);
}
dp[0] = 0;
for (long long i = 1; i <= n; i++) {
long long inv = getInv(p[i], 998244353);
dp[i] = 100 * (dp[i - 1] + 1) % 998244353 * inv % 998244353;
}
printf("%lld\n", dp[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, s;
cin >> n >> s;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int flag = 0;
if (a[s] != 0) {
flag++;
a[s] = 0;
}
vector<int> cnt(n + 1);
for (int i = 1; i <= n; i++) {
cnt[a[i]]++;
}
int val = n + 5;
int more = n - 1;
int zero = 0;
for (int h = 1; h < n; h++) {
if (!cnt[h])
zero++;
else
more -= cnt[h];
val = min(val, max(more, zero));
}
if (val == n + 5) val = 0;
cout << flag + val << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
bool flag = true;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin.ignore();
getline(cin, s);
s = "0" + s + "0";
for (int i = 1; i <= n && flag; i++) {
if (s[i - 1] == s[i] && s[i] == s[i + 1] && s[i] == '0') flag = false;
if (s[i] == s[i - 1] && s[i] == '1') flag = false;
}
cout << (flag ? "Yes" : "No") << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v1, v2;
int t, d;
cin >> v1 >> v2;
cin >> t >> d;
if (d == 0) {
cout << v1 * t << endl;
return 0;
}
if (v1 > v2) {
int temp = v1;
v1 = v2;
v2 = temp;
}
vector<int> ivector1, ivector2;
for (int i = 0; i < t; ++i) {
ivector1.push_back(v1 + i * d);
ivector2.push_back(v2 + i * d);
}
for (int j = 0; j < t - 1; ++j) {
int index = t - 2 - j;
if (abs(ivector1[j] - ivector2[index]) <= d) {
int sum = 0;
for (int i = 0; i <= j; ++i) sum += ivector1[i];
for (int i = 0; i <= index; ++i) sum += ivector2[i];
cout << sum << endl;
return 0;
}
}
int sum = 0;
for (int i = 0; i < t - 1; ++i) sum += ivector1[i];
sum += v2;
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
void solve() {
{
string s;
cin >> s;
int k = (int)s.size();
k--;
while (k % 2) {
k--;
}
string curans = string(k, '9');
k = (int)s.size();
if (k % 2) {
cout << curans << '\n';
return;
}
bitset<10> b;
b.reset();
for (auto i : s) {
b.flip(i - '0');
}
for (int i = k - 1; i >= 0; i--) {
b.flip(s[i] - '0');
for (int j = s[i] - '0' - 1; j >= 0; j--) {
b.flip(j);
int positions_left = k - 1 - i;
int oddcnt = b.count();
if (oddcnt <= positions_left) {
s[i] = j + '0';
for (int v = i + 1; v < (int)s.size(); v++) {
s[v] = '9';
}
int cur = (int)s.size() - 1;
for (int g = 0; g < 10; g++) {
if (b[g] == 0) continue;
s[cur] = g + '0';
b.flip(g);
cur--;
}
if (s[0] == '0') {
cout << string(k - 2, '9') << '\n';
return;
}
cout << s << '\n';
return;
}
b.flip(j);
}
}
cout << string(k - 2, '9') << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename A>
ostream& operator<<(ostream& cout, vector<A> const& v);
template <typename A, typename B>
ostream& operator<<(ostream& cout, pair<A, B> const& p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream& operator<<(ostream& cout, vector<A> const& v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream& operator>>(istream& cin, pair<A, B>& p) {
cin >> p.first;
return cin >> p.second;
}
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void usaco(string filename) {
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const long double pi = 3.14159265358979323846;
using cd = complex<double>;
const double PI = acos(-1);
void fft(vector<cd>& a, bool invert) {
long long n = a.size();
for (long long i = 1, j = 0; i < n; i++) {
long long bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (long long len = 2; len <= n; len <<= 1) {
double ang = 2 * PI / len * (invert ? -1 : 1);
cd wlen(cos(ang), sin(ang));
for (long long i = 0; i < n; i += len) {
cd w(1);
for (long long j = 0; j < len / 2; j++) {
cd u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert) {
for (cd& x : a) x /= n;
}
}
vector<int> multiply(vector<int> const& a, vector<int> const& b) {
vector<cd> fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < a.size() + b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa, false);
fft(fb, false);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, true);
vector<int> result(n);
for (int i = 0; i < n; i++) result[i] = round(fa[i].real());
return result;
}
long long n, m, q, k, l, r, x, y, z;
const long long template_array_size = 1e6 + 14742;
long long a[template_array_size];
long long b[template_array_size];
long long c[template_array_size];
string second, t;
long long ans = 0;
vector<long long> res;
void solve(int tc = 0) {
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
c[a[i]] = 1;
}
vector<int> v(m + 1);
for (long long i = 0; i < m + 1; i++) v[i] = c[i];
vector<int> sq = multiply(v, v);
for (long long i = 1; i <= m; i++) {
if (c[i]) {
if (!sq[i]) res.push_back(i);
} else {
if (sq[i]) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n";
cout << res.size() << '\n';
for (long long x : res) cout << x << " ";
cout << '\n';
}
int main() {
{ ios_base::sync_with_stdio(false); }
{ cin.tie(NULL); }
cout << setprecision(15) << fixed;
int tc = 1;
for (int t = 0; t < tc; t++) solve(t);
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.