solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, j, k, n, m, timer = 0, l, r, x, y;
int c[1011000], cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
int t[3][200110];
void update(int idx, int id, int ad) {
while (idx <= n) {
t[id][idx] += ad;
idx += (idx & -idx);
}
}
int take(int idx, int id) {
int sm = 0;
while (idx > 0) {
sm += t[id][idx];
idx -= (idx & -idx);
}
return sm;
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d%d%d%d", &n, &k, &a, &b, &m);
for (i = 0; i < m; i++) {
scanf("%d", &x);
if (x == 1) {
scanf("%d%d", &x, &y);
if (c[x] + y <= a) {
update(x, 0, y);
} else {
if (a - c[x] > 0) update(x, 0, a - c[x]);
}
if (c[x] + y <= b) {
update(x, 1, y);
} else {
if (b - c[x] > 0) update(x, 1, b - c[x]);
}
if (c[x] <= a) c[x] += y;
} else {
scanf("%d", &x);
l = take(x - 1, 1);
r = take(n, 0) - take(x + k - 1, 0);
printf("%d\n", l + r);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e3 + 4;
const int maxm = 1e5 + 4;
vector<int> v;
int n, k, b[maxn];
int main() {
ios::sync_with_stdio(false);
int i, j, kase;
cin >> n >> k;
for (i = 1; i <= n; ++i) cin >> b[i];
v.push_back(n);
auto it = v.begin();
for (i = n - 1; i >= 1; --i) {
it = v.begin();
int num = 0;
while (num < b[i]) {
if (*it >= i + k) num++;
it++;
}
v.insert(it, i);
}
for (i = 0; i < v.size(); ++i) {
if (i) cout << ' ';
cout << v[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int P[5], V[5], sol[5];
bool better[5];
int table(int n, int s) {
if (32 * s <= n) return 3000;
if (16 * s <= n) return 2500;
if (8 * s <= n) return 2000;
if (4 * s <= n) return 1500;
if (2 * s <= n) return 1000;
if (1 * s <= n) return 500;
}
int main() {
int n, val;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 5; j++) {
scanf("%d", &val);
if (i == 0) V[j] = val;
if (i == 1) P[j] = val;
if (val != -1) sol[j] += 1;
}
}
for (int i = 0; i < 5; i++) {
if (V[i] < P[i] || P[i] == -1) {
better[i] = 1;
}
}
for (int acc = 0; acc < 32000; acc++) {
double pp = 0.0, vv = 0.0;
for (int i = 0; i < 5; i++) {
double score = (double)table(n + acc, sol[i]);
if (V[i] != -1) vv += score * (1.0 - V[i] / 250.0);
if (P[i] != -1) pp += score * (1.0 - P[i] / 250.0);
}
if (vv > pp + 1.0e-9) {
printf("%d\n", acc);
return 0;
}
for (int i = 0; i < 5; i++) {
if (!better[i] && V[i] != -1) sol[i]++;
}
}
puts("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
int a[maxn], fen[maxn][2], b[maxn];
void add(int pos, int type, int val) {
for (pos++; pos < maxn; pos += ((pos) & (-pos))) fen[pos][type] += val;
}
int get(int pos, int type) {
int res = 0;
for (pos++; pos > 0; pos -= ((pos) & (-pos))) res += fen[pos][type];
return res;
}
int main() {
int n;
long long k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i], b[i] = a[i];
sort(b, b + n);
for (int i = 0; i < n; i++) a[i] = lower_bound(b, b + n, a[i]) - b;
long long ans = 0, inv = 0, R = 1;
for (int i = n - 1; i >= 1; i--) {
inv += get(a[i] - 1, 1);
add(a[i], 1, 1);
}
for (int i = 0; i < n; i++) {
inv += get(a[i] - 1, 1);
inv += get(maxn - 2, 0) - get(a[i], 0);
add(a[i], 0, 1);
while (R <= i || (R < n && inv > k)) {
inv -= get(a[R] - 1, 1);
inv -= get(maxn - 2, 0) - get(a[R], 0);
add(a[R], 1, -1);
R++;
}
ans += n - R;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int plus = 0, minus = 0;
while (n--) {
int temp;
cin >> temp;
if (temp > 0)
plus++;
else
minus++;
}
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
int len = r - l + 1;
if (len % 2 == 0 && plus >= len / 2 && minus >= len / 2) {
printf("1\n");
} else {
printf("0\n");
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j;
cin >> i >> j;
vector<string> x(i);
vector<bool> b(i, false);
for (int k = 0; k < i; ++k) {
cin >> x[k];
}
for (int k = 0; k < j; ++k) {
int p, c = 0;
for (int l = 0; l < i; ++l) {
if (x[l][k] == '1') {
c++;
p = l;
}
}
if (c == 1) b[p] = true;
}
for (auto k : b)
if (!k) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int tope = 100001;
int x[tope];
pair<int, int> yx[tope];
int y[3][tope];
int len[3];
int n;
int a[9];
int asig[3][3];
int p[3][3];
double solx0, solx1, soly0, soly1;
void iniperm(int p[3]) {
for (int i = 0; i < 3; i++) p[i] = i;
}
void check() {
for (int i = 0; i < 3; i++) {
if (y[i][a[asig[i][p[i][0]]] - 1] == y[i][a[asig[i][p[i][0]]]]) return;
if (y[i][a[asig[i][p[i][0]]] + a[asig[i][p[i][1]]] - 1] ==
y[i][a[asig[i][p[i][0]]] + a[asig[i][p[i][1]]]])
return;
}
int inf0 = -2000000000, sup0 = 2000000000;
for (int i = 0; i < 3; i++) {
inf0 = max(inf0, y[i][a[asig[i][p[i][0]]] - 1]);
sup0 = min(sup0, y[i][a[asig[i][p[i][0]]]]);
}
if (inf0 >= sup0) return;
int inf1 = -2000000000, sup1 = 2000000000;
for (int i = 0; i < 3; i++) {
inf1 = max(inf1, y[i][a[asig[i][p[i][0]]] + a[asig[i][p[i][1]]] - 1]);
sup1 = min(sup1, y[i][a[asig[i][p[i][0]]] + a[asig[i][p[i][1]]]]);
}
if (inf1 >= sup1) return;
soly0 = inf0 + 0.5;
soly1 = inf1 + 0.5;
cout << solx0 << " " << solx1 << endl;
cout << soly0 << " " << soly1 << endl;
exit(0);
}
void chequea() {
iniperm(p[0]);
do {
iniperm(p[1]);
do {
iniperm(p[2]);
do {
check();
} while (next_permutation(p[2], p[2] + 3));
} while (next_permutation(p[1], p[1] + 3));
} while (next_permutation(p[0], p[0] + 3));
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> yx[i].second >> yx[i].first;
x[i] = yx[i].second;
}
for (int i = 0; i < 9; i++) cin >> a[i];
sort(x, x + n);
sort(yx, yx + n);
int e = 1;
for (int i = 0; i < 9; i++) e *= 3;
for (int c = 0; c < e; c++) {
int cc = c;
int index[3];
for (int i = 0; i < 3; i++) index[i] = 0;
bool error = false;
for (int i = 0; i < 9; i++) {
if (index[cc % 3] == 3) {
error = true;
break;
}
asig[cc % 3][index[cc % 3]++] = i;
cc /= 3;
}
if (not error) {
int amount[3];
for (int i = 0; i < 3; i++)
amount[i] = a[asig[i][0]] + a[asig[i][1]] + a[asig[i][2]];
if (x[amount[0] - 1] != x[amount[0]] and
x[amount[0] + amount[1] - 1] != x[amount[0] + amount[1]]) {
int x0 = x[amount[0] - 1];
solx0 = x0 + 0.5;
int x1 = x[amount[0] + amount[1] - 1];
solx1 = x1 + 0.5;
for (int i = 0; i < 3; i++) len[i] = 0;
for (int i = 0; i < n; i++) {
if (yx[i].second <= x0)
y[0][len[0]++] = yx[i].first;
else if (yx[i].second <= x1)
y[1][len[1]++] = yx[i].first;
else
y[2][len[2]++] = yx[i].first;
}
chequea();
}
}
}
cout << -1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int D[300009];
bool G[22][22], C[300009];
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u][v] = G[v][u] = 1;
}
for (int i = 0; i < (1 << N); i++) {
C[i] = 1;
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++)
if (((i >> j) & 1) && ((i >> k) & 1) && G[j + 1][k + 1]) C[i] = 0;
}
D[0] = 1;
for (int i = 1; i < (1 << N); i++) {
for (int j = i; j >= 1; j = (j - 1) & i) {
if (!C[j]) continue;
if (__builtin_popcount(j) & 1)
D[i] += D[i - j];
else
D[i] += MOD - D[i - j];
if (D[i] >= MOD) D[i] -= MOD;
}
}
printf("%lld", 1LL * D[(1 << N) - 1] * 499122177LL % MOD * M % MOD);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[200050];
long long n, m;
long long sum[200050];
int main() {
long long i, j;
while (scanf("%lld", &n) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + 1 + n);
sum[0] = 0;
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
if (n == 1 || n == 2) {
printf("1\n");
printf("%lld\n", a[1]);
continue;
}
long long l, r, d, m1, m2, t1, t2;
long long mid = 1, len = 0, zong = 0;
long long zong1, mid1, len1;
for (i = 2; i <= n - 1; i++) {
l = 1;
r = min(i - 1, n - i);
for (j = 1; j <= 100; j++) {
m1 = (2 * l + r) / 3;
m2 = (l + 2 * r + 2) / 3;
t1 = sum[i] - sum[i - m1 - 1] + sum[n] - sum[n - m1];
t2 = sum[i] - sum[i - m2 - 1] + sum[n] - sum[n - m2];
if (t1 * (2 * m2 + 1) < t2 * (2 * m1 + 1)) {
l = m1 + 1;
} else
r = m2 - 1;
}
zong1 =
sum[i] - sum[i - l - 1] + sum[n] - sum[n - l] - (2 * l + 1) * a[i];
len1 = l;
mid1 = i;
if (zong1 * (2 * len + 1) > zong * (2 * len1 + 1)) {
zong = zong1;
len = len1;
mid = mid1;
}
}
printf("%lld\n", len * 2 + 1);
int flag = 1;
for (i = mid - len; i <= mid; i++) {
if (flag) {
flag = 0;
printf("%lld", a[i]);
} else {
printf(" %lld", a[i]);
}
}
for (i = n - len + 1; i <= n; i++) {
printf(" %lld", a[i]);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ar[2 * n];
set<int> s;
for (int i = 0; i < 2 * n; i++) {
cin >> ar[i];
if (!s.count(ar[i])) cout << ar[i] << ' ';
s.insert(ar[i]);
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, c = getchar(), f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int N = 100000 + 10;
int n, m, cnt = 1, head[N], du[N], layer[N], leader[N], q[N];
bool vis1[N], vis2[N], vis3[N * 2];
vector<vector<int> > ans;
vector<int> tmp, _;
vector<pair<int, int> > comp;
struct edge {
int to, nxt;
} e[N * 4];
void addedge(int u, int v) {
e[++cnt] = (edge){v, head[u]};
head[u] = cnt;
e[++cnt] = (edge){u, head[v]};
head[v] = cnt;
du[u]++;
du[v]++;
}
void dfs(int u, int fa, int lineid) {
vis1[u] = 1;
vis2[layer[u]] = 1;
tmp.push_back(u);
for (int i = head[u], v; i; i = e[i].nxt)
if ((i >> 1) != lineid) {
if (!vis1[v = e[i].to]) {
dfs(v, u, i >> 1);
tmp.push_back(u);
for (; cnt >= 0 && vis2[comp[cnt].second]; cnt--)
;
if (cnt >= 0) {
vis3[i >> 1] = 1;
v = leader[comp[cnt].second];
ans.push_back(tmp);
tmp.clear();
_.clear();
_.push_back(i >> 1);
_.push_back(u);
_.push_back(v);
ans.push_back(_);
dfs(v, u, i >> 1);
tmp.push_back(u);
}
} else {
if (vis3[i >> 1]) continue;
for (; cnt >= 0 && vis2[comp[cnt].second]; cnt--)
;
if (cnt >= 0) {
vis3[i >> 1] = 1;
v = leader[comp[cnt].second];
ans.push_back(tmp);
tmp.clear();
_.clear();
_.push_back(i >> 1);
_.push_back(u);
_.push_back(v);
ans.push_back(_);
dfs(v, u, i >> 1);
tmp.push_back(u);
}
}
}
}
void print() {
puts("YES");
write(ans.size() / 2);
puts("");
for (int i = (int)0; i <= (int)ans.size() - 1; i++) {
if (i & 1)
write(ans[i][0]), putchar(' '), write(ans[i][1]), putchar(' '),
write(ans[i][2]), puts("");
else {
write(ans[i].size());
for (int j = (int)0; j <= (int)ans[i].size() - 1; j++)
putchar(' '), write(ans[i][j]);
puts("");
}
}
}
int findbridge() {
for (int i = (int)2; i <= (int)n; i++) vis1[i] = 0;
for (int i = (int)1; i <= (int)m; i++) vis3[i] = 0;
for (int i = (int)2; i <= (int)n; i++)
if (!vis1[i]) {
q[*q = 1] = i;
vis1[i] = 1;
for (int j = (int)1; j <= (int)*q; j++) {
int u = q[j];
for (int k = head[u], v; k; k = e[k].nxt)
if (!vis3[k >> 1]) {
vis3[k >> 1] = 1;
if (vis1[v = e[k].to])
return k >> 1;
else
vis1[v] = 1, q[++*q] = v;
}
}
}
return 0;
}
int getblo(int l, int r) {
for (int i = (int)l; i <= (int)r; i++) vis1[i] = 0;
int blo = 0;
comp.clear();
for (int i = (int)l; i <= (int)r; i++)
if (!vis1[i]) {
++blo;
q[*q = 1] = i;
vis1[i] = 1;
for (int j = (int)1; j <= (int)*q; j++) {
int u = q[j];
for (int k = head[u], v; k; k = e[k].nxt)
if (!vis1[v = e[k].to]) vis1[v] = 1, q[++*q] = v;
}
for (int j = (int)1; j <= (int)*q; j++) layer[q[j]] = blo;
leader[blo] = q[1];
comp.push_back(make_pair(*q, blo));
}
sort(comp.begin(), comp.end());
return blo;
}
void go(int id) {
int u = 1;
for (int i = (int)2; i <= (int)n; i++) {
for (int j = head[i], pre; j; pre = j, j = e[j].nxt)
if ((j >> 1) == id) {
if (du[i] > 1) u = i;
du[i]--;
if (j == head[i])
head[i] = e[j].nxt;
else
e[pre].nxt = e[j].nxt;
break;
}
}
getblo(2, n);
cnt = comp.size() - 1;
for (int i = (int)1; i <= (int)n; i++) vis1[i] = vis2[i] = 0;
for (int i = (int)1; i <= (int)m; i++) vis3[i] = 0;
vis1[1] = 1;
_.clear();
_.push_back(1);
ans.push_back(_);
_.clear();
_.push_back(id);
_.push_back(1);
_.push_back(u);
ans.push_back(_);
dfs(u, 1, 0);
if (tmp.size()) ans.push_back(tmp), tmp.clear();
print();
}
int main() {
n = read(), m = read();
for (int i = (int)1; i <= (int)m; i++) addedge(read(), read());
if (n == 1) return puts("YES\n0\n1 1\n"), 0;
int blo = getblo(1, n);
if (m < blo - 1) return puts("NO"), 0;
if (du[1]) {
for (int i = (int)1; i <= (int)n; i++) vis1[i] = vis2[i] = 0;
for (int i = (int)1; i <= (int)m; i++) vis3[i] = 0;
cnt = comp.size() - 1;
dfs(1, 0, 0);
if (tmp.size()) ans.push_back(tmp), tmp.clear();
print();
} else {
int id = findbridge();
if (id)
go(id);
else {
if (m < blo)
puts("NO");
else {
for (int i = (int)2; i <= (int)n; i++)
if (du[i] > 1) {
id = head[i] / 2;
break;
}
if (id)
go(id);
else
puts("NO");
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans[200020][2];
bool TT[200020];
vector<int> bst[200020][2];
vector<int> g[200020];
int c[200020];
vector<int> res;
void dfs(int p, int u) {
long long sum = 0;
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] == p) continue;
dfs(u, g[u][i]);
sum += ans[g[u][i]][1];
}
ans[u][1] = sum;
ans[u][0] = 1000000000000000LL;
for (int i = 0; i < g[u].size(); i++)
if (g[u][i] != p) {
long long WITH = sum - ans[g[u][i]][1] + ans[g[u][i]][0];
if (ans[u][0] > WITH) {
ans[u][0] = WITH;
bst[u][0].clear();
bst[u][0].push_back(g[u][i]);
} else if (ans[u][0] == WITH)
bst[u][0].push_back(g[u][i]);
if (ans[u][1] > WITH + c[u]) {
ans[u][1] = WITH + c[u];
bst[u][1].clear();
bst[u][1].push_back(g[u][i]);
} else if (ans[u][1] == WITH + c[u])
bst[u][1].push_back(g[u][i]);
}
if (sum == ans[u][1]) TT[u] = 1;
if (g[u].size() == 1 && u != 1) {
ans[u][1] = c[u];
ans[u][0] = 0;
}
}
bool f[200020][2];
bool can[200020];
bool iis[400020];
void print(int p, int u, int cc) {
if (iis[2 * u + cc]) return;
iis[2 * u + cc] = 1;
if (g[u].size() == 1 && u != 1) {
if (cc == 1) can[u] = 1;
return;
}
if (cc == 1 && bst[u][cc].size() > 0) can[u] = 1;
for (int i = 0; i < bst[u][cc].size(); i++) print(u, bst[u][cc][i], 0);
if (bst[u][cc].size() == 0 || bst[u][cc].size() >= 2 || (TT[u] && cc == 1)) {
for (int i = 0; i < g[u].size(); i++)
if (g[u][i] != p) print(u, g[u][i], 1);
return;
}
for (int i = 0; i < g[u].size(); i++)
if (g[u][i] != p && g[u][i] != bst[u][cc][0]) print(u, g[u][i], 1);
}
int n, i, a, b;
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> c[i];
}
for (i = 1; i < n; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0, 1);
print(0, 1, 1);
cout << ans[1][1] << " ";
for (int i = 1; i <= n; i++)
if (can[i]) res.push_back(i);
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, h;
cin >> n >> h;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x > h) {
cnt += 2;
} else {
cnt += 1;
}
}
cout << cnt << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int low[6][6];
int high[6][6];
int the_cost[6][6][6];
int sur[6];
int n;
int ans_flow;
int ans_cost;
void find(int a, int b, int cost) {
int na = a;
int nb = b + 1;
if (b == a + 1) {
if (a == 1 && (sur[0] > ans_flow)) return;
if (a > 1 && sur[a - 1] != 0) return;
}
if (nb == n) {
na++;
nb = na + 1;
}
if (a == n - 1) {
if (sur[0] < ans_flow || (sur[0] == ans_flow && ans_cost < cost)) {
ans_flow = sur[0];
ans_cost = cost;
}
return;
}
if (a > 0 && abs(sur[a]) > 5 * (n - b)) return;
for (int i = low[a][b]; i <= high[a][b]; i++) {
sur[a] += i;
sur[b] -= i;
find(na, nb, cost + the_cost[a][b][i]);
sur[a] -= i;
sur[b] += i;
}
}
int main() {
cin >> n;
for (int i = 0; i < n * (n - 1) / 2; i++) {
int s, f, l, h, a;
cin >> s >> f >> l >> h >> a;
low[s - 1][f - 1] = l;
high[s - 1][f - 1] = h;
for (int j = l; j <= h; j++)
the_cost[s - 1][f - 1][j] = (j == 0) ? 0 : (a + j * j);
}
ans_flow = 9999;
ans_cost = 9999;
find(0, 1, 0);
if (ans_flow == 9999)
printf("-1 -1\n");
else
printf("%d %d\n", ans_flow, ans_cost);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n; cin >> n;
int a[300000];
for(int i = 0; i < 3*n; i++){
cin >> a[i];
}
sort(a, a+3*n);
long long ans = 0;
for(int i = n; i < 3*n; i+=2){
ans += a[i];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ans, last, d, x, y, a, b;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void exgcd(long long a, long long b, long long& d, long long& x, long long& y) {
if (!b) {
x = 1, y = 0, d = a;
} else {
exgcd(b, a % b, d, y, x);
y -= (a / b) * x;
}
}
void check(long long x0, long long y0) {
exgcd(a, b, d, x, y);
if ((y0 - x0) % d != 0) return;
long long tmp = abs(b / d);
x *= (y0 - x0) / d;
x = (x % tmp + tmp) % tmp;
long long xx = x0 + 2 * n * x;
if (xx < 0 || xx >= last) return;
ans = min(ans, xx);
}
int main() {
cin >> n >> m >> k;
a = 2 * n, b = -2 * m;
while (k--) {
long long xx, yy;
cin >> xx >> yy;
ans = 1e18;
last = n / gcd(n, m) * m;
check(xx, yy);
check(-xx, yy);
check(xx, -yy);
check(-xx, -yy);
if (ans == 1e18)
cout << -1 << endl;
else
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
int n, m;
long long a[205];
long long dp[2][205][1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
dp[0][1][0] = 1;
dp[0][0][0] = 1;
int x, y;
x = 0, y = 1;
for (int i = 1; i < n; ++i) {
swap(x, y);
memset(dp[x], 0, sizeof(dp[x]));
for (int j = i; j >= 0; --j) {
for (int k = 0; k <= m; ++k) {
int len = a[i + 1] - a[i];
if (k + len * j <= m)
dp[x][j][k + len * j] = (dp[x][j][k + len * j] + dp[y][j][k]) % md;
if (k + len * j <= m)
dp[x][j][k + len * j] =
(dp[x][j][k + len * j] + j * dp[y][j][k]) % md;
if (k + len * j <= m)
dp[x][j + 1][k + len * j] =
(dp[x][j + 1][k + len * j] + dp[y][j][k]) % md;
if (j && k + len * j <= m)
dp[x][j - 1][k + len * j] =
(dp[x][j - 1][k + len * j] + dp[y][j][k] * j) % md;
}
}
}
long long ans = 0;
for (int i = 0; i <= m; ++i) ans = (ans + dp[x][0][i]) % md;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 1000005;
const long long INF = (long long)1e9 + 8763;
using namespace std;
template <class T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_heap = priority_queue<T, vector<T>, less<T>>;
struct State {
int j, k;
};
int n, P[MAXN];
int dp[MAXN][2][2];
State from[MAXN][2][2];
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> P[i];
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++) {
dp[i][j][k] = INF;
}
}
}
dp[1][0][0] = -INF;
from[1][0][0] = {0, 0};
dp[1][0][1] = -INF;
from[1][0][1] = {0, 0};
for (int i = 1; i < n; i++) {
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++) {
if (dp[i][j][k] == INF) continue;
int x = P[i], y = dp[i][j][k];
if (k) x *= -1;
if (j) swap(x, y);
assert(x > y);
for (int t = 0; t <= 1; t++) {
int nxt = (t ? -P[i + 1] : P[i + 1]);
assert(nxt != x && nxt != y);
if (nxt > x) {
if (dp[i + 1][0][t] > y) {
dp[i + 1][0][t] = y;
from[i + 1][0][t] = {j, k};
}
} else if (nxt > y) {
if (dp[i + 1][1][t] > x) {
dp[i + 1][1][t] = x;
from[i + 1][1][t] = {j, k};
}
}
}
}
}
}
State ans = {-1, -1};
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++) {
if (dp[n][j][k] != INF) {
ans = {j, k};
break;
}
}
}
if (ans.j != -1) {
cout << "YES\n";
for (int i = n; i >= 1; i--) {
if (ans.k) {
P[i] *= -1;
}
ans = from[i][ans.j][ans.k];
}
for (int i = 1; i <= n; i++) {
cout << P[i] << " \n"[i == n];
}
} else {
cout << "NO\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
cin >> tc;
for (int i = 1; i <= tc; i++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cerr << *i << ' ';
cout << endl;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
for (long long a, b; cin >> a >> b;) {
long long g = gcd(a, b);
a /= g;
b /= g;
int flip = 0;
if (a > b) {
swap(a, b);
flip = 1;
}
long long bb = a * (a + 1) / 2;
long long aa = a * b - bb;
if (aa == bb) {
cout << "Equal" << endl;
} else if (aa < bb) {
if (!flip) cout << "Masha" << endl;
if (flip) cout << "Dasha" << endl;
} else {
if (flip) cout << "Masha" << endl;
if (!flip) cout << "Dasha" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
(n % 2 == 0) ? cout << (n / 2) - 1 << endl : cout << n / 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<int> b(n);
int i = 0, j = n - 1, k = 0;
for (int l = 0; l < n; l++) {
if (k == 0) {
b[i] = a[l];
i++;
} else {
b[j] = a[l];
j--;
}
k = 1 - k;
}
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int dnum, unum, dep, up[20];
long long dsum, usum;
} tree[100010];
int n, m;
int h[100010], e[200010], nex[200010];
void dfs(int x) {
node &now = tree[x];
for (int i = h[x]; i; i = nex[i]) {
if (e[i] == now.up[0]) continue;
tree[e[i]].unum = n - (tree[e[i]].dnum + 1);
long long ut = tree[x].usum;
long long dt = tree[x].dsum - tree[e[i]].dsum - (tree[e[i]].dnum + 1);
tree[e[i]].usum = (ut + dt) + tree[e[i]].unum;
dfs(e[i]);
}
}
void build(int x) {
node &now = tree[x];
now.dep = tree[now.up[0]].dep + 1;
for (int i = 1; i <= 17; ++i) {
if (now.up[i - 1] == 0 || tree[now.up[i - 1]].up[i - 1] == 0) break;
now.up[i] = tree[now.up[i - 1]].up[i - 1];
}
for (int i = h[x]; i; i = nex[i]) {
if (e[i] == now.up[0]) continue;
tree[e[i]].up[0] = x;
build(e[i]);
now.dnum += tree[e[i]].dnum + 1;
now.dsum += tree[e[i]].dsum + tree[e[i]].dnum + 1;
}
return;
}
bool st(int a, int b, int &tar, long long &len) {
len = 0;
if (tree[a].dep != tree[b].dep) {
for (int i = 17; i >= 0; --i) {
int ta = tree[a].up[i];
if (ta && tree[ta].dep >= tree[b].dep + 1)
a = ta, len += ((long long)1 << i);
}
++len;
tar = a;
if (tree[a].up[0] == b) return false;
a = tree[a].up[0];
}
for (int i = 17; i >= 0; --i) {
if (tree[a].up[i] != tree[b].up[i]) {
len += ((long long)1 << (i + 1));
a = tree[a].up[i];
b = tree[b].up[i];
}
}
len += 2;
return true;
}
void init() {
cin >> n >> m;
int a, b, tp = 0, tar;
long long len;
double ans;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
e[++tp] = b;
nex[tp] = h[a];
h[a] = tp;
e[++tp] = a;
nex[tp] = h[b];
h[b] = tp;
}
build(1);
dfs(1);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
if (tree[a].dep < tree[b].dep) swap(a, b);
if (st(a, b, tar, len)) {
ans = (double)len + 1;
double t1 = (double)tree[a].dsum * (tree[b].dnum + 1);
double t2 = (double)tree[b].dsum * (tree[a].dnum + 1);
ans += (t1 + t2) / ((double)(tree[a].dnum + 1) * (tree[b].dnum + 1));
} else {
long long tsum = tree[b].dsum - tree[tar].dsum - (tree[tar].dnum + 1);
tsum += tree[b].usum;
long long tnum = n - tree[tar].dnum - 1;
double t1 = (double)tree[a].dsum * tnum;
double t2 = (double)tsum * (tree[a].dnum + 1);
ans = (double)len + 1;
ans += (t1 + t2) / ((tree[a].dnum + 1) * tnum);
}
printf("%.8f\n", ans);
}
return;
}
int main() {
init();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, x, w[111] = {0};
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> x;
w[i] = w[i - 1] + x;
}
int ans = w[n];
for (int i = 1; i < n; i++)
ans = min(ans, abs(w[n] - w[i] * 2));
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
long long int b[101] = {};
long long int c[101] = {};
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
b[a[i]]++;
}
for (long long int i = 2; i < 101; ++i) {
for (long long int j = 1; j <= i / 2; ++j) {
if (j * 2 == i) {
c[i] += b[j] / 2;
} else {
long long int p, q;
p = b[j];
q = b[i - j];
long long int x;
x = min(p, q);
c[i] += x;
}
}
}
long long int ans = 0;
for (long long int i = 1; i < 101; ++i) {
ans = max(ans, c[i]);
}
cout << ans << "\n";
}
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int a,b,k;
cin>>a>>b>>k;
for(int i=min(a,b);i>=1;i--){
if(a%i==0&&b%i==0){
k--;
}
if(k==0){
cout<<i<<endl;
break;
}
}
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int N,ans;
const int GATYA=10000;
int k[GATYA];
bool ok;
int main(){
while(cin>>N,N){
ans=N;
ok=false;
for(int i=0;i<N;i++){
cin>>k[i];
if(k[i]>=2)ok=true;
if(k[i]==0)ans--;
}
if(ok)cout<<ans+1<<endl;
else cout<<"NA"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, l, r, val[200005], v[200005], A[200005], b = 0;
long long int ans = 0;
cin >> n >> q;
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
while (q--) {
scanf("%d%d", &l, &r);
l--;
r--;
val[l]++;
if (r < n - 1) val[r + 1]--;
}
for (int i = 0; i < n; i++) {
b += val[i];
v[i] = b;
}
sort(A, A + n);
sort(v, v + n);
for (int i = 0; i < n; i++) ans += (A[i] * 1LL * v[i]);
cout << ans;
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define chmax(a,b) (a = max(a,b))
using namespace std;
typedef vector<int> vi;
const string dir = "URDL";
const int dy[] = {-1,0,1,0}, dx[] = {0,1,0,-1};
int main(){
cin.tie(0); ios::sync_with_stdio(0);
int Hini, Hmax;
while(cin >> Hini >> Hmax, Hini){
int h,w;
cin >> h >> w;
vector<string> g(h);
rep(i,h)cin >> g[i];
int cost[26] = {}, t;
cin >> t;
rep(i,t){
char c; int d;
cin >> c >> d;
cost[c-'A'] = d;
}
vi trap;
int s, x=0, y=0;
cin >> s;
rep(i,s){
char c; int n;
cin >> c >> n;
int d = dir.find(c);
rep(k,n){
x += dx[d]; y += dy[d];
trap.push_back(cost[ g[y][x]-'A' ]);
}
}
int p;
cin >> p;
vi potion(p);
rep(i,p)cin >> potion[i];
vector<vi> dp(trap.size()+1, vi(1<<p,0));
dp[0][0] = Hini;
rep(i,trap.size()){
rep(bit,1<<p){
int cur = dp[i][bit];
if(cur==0)continue;
chmax(dp[i+1][bit], cur-trap[i]);
rep(j,p){
if( (bit>>j)&1 )continue;
int nxt = min(cur+potion[j], Hmax);
chmax(dp[i+1][bit | (1<<j)], nxt - trap[i]);
}
}
}
bool f = false;
rep(bit,1<<p)f |= (dp[trap.size()][bit]>0);
cout << (f?"YES":"NO") << endl;
}
}
| 0 |
#include <iostream>
using namespace std;
int main(){
int a=0, b=0,c=0,ans=0;
cin >> a;
cin >> b;
int ball[a];
for (int i=0;i<a;i++){
cin >> ball[i];
}
for(int j=0; c <= b ; j++){
c += ball[j];
ans ++;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
struct Node {
int data;
int len;
};
class Solver {
public:
int n;
int N;
std::vector<std::pair<int, int>> a;
Solver() = default;
void read() {
std::cin >> n;
N = n;
int tmp;
std::cin >> tmp;
int current = tmp;
int count = 1;
for (int i = 0; i < n - 1; ++i) {
std::cin >> tmp;
if (tmp == current) {
count++;
}
if (tmp != current) {
a.push_back({current, count});
current = tmp;
count = 1;
}
}
a.push_back({current, count});
n = a.size();
}
void solve() {
std::set<std::pair<int, int>> lens;
std::map<int, Node> values;
if (N == 0xdeadbeef) {
for (int i = 0; i < n; ++i) {
std::cout << a[i].first << " " << a[i].second << " ";
if (i % 20 == 0) std::cout << std::endl;
}
}
int l = 0;
for (int i = 0; i < n; ++i) {
lens.insert({-a[i].second, l});
values[l] = {a[i].first, a[i].second};
l += a[i].second;
}
int count = 0;
while (!lens.empty()) {
auto pair = *(lens.begin());
auto len = -pair.first;
auto pos = pair.second;
lens.erase(lens.begin());
auto values_it = values.lower_bound(pos);
if (values_it == values.end()) continue;
if (values_it->first != pos) continue;
++count;
if (values_it == values.begin()) {
values.erase(values_it);
continue;
}
auto it_left = values_it;
auto it_right = values_it;
--it_left;
++it_right;
if (it_right == values.begin()) {
values.erase(values_it);
continue;
}
values.erase(values_it);
pos = it_left->first;
Node left = it_left->second;
Node right = it_right->second;
if (left.data == right.data) {
values.erase(it_left);
values.erase(it_right);
lens.insert({-left.len - right.len, pos});
values[pos] = {left.data, left.len + right.len};
}
}
std::cout << count << std::endl;
}
void write() {}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
Solver solver;
solver.read();
solver.solve();
solver.write();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int tree[100010 << 2];
bool flag;
struct node {
int row, col, pos;
friend bool operator<(node a, node b) {
if (a.row == b.row) return a.col < b.col;
return a.row < b.row;
}
};
node p[100010];
inline void pushUp(int rt) { tree[rt] = min(tree[rt << 1], tree[rt << 1 | 1]); }
void update(int x, int y, int val, int L, int R, int rt) {
if (flag) return;
if (L == R) {
if (tree[rt] == 0) {
flag = true;
tree[rt] = val;
}
return;
} else if (x <= L && R <= y) {
int mid = (L + R) >> 1;
if (tree[rt << 1] == 0)
update(x, y, val, L, mid, rt << 1);
else if (tree[rt << 1 | 1] == 0)
update(x, y, val, mid + 1, R, rt << 1 | 1);
} else {
int mid = (L + R) >> 1;
if (x <= mid) update(x, y, val, L, mid, rt << 1);
if (y > mid) update(x, y, val, mid + 1, R, rt << 1 | 1);
}
pushUp(rt);
}
void out(int L, int R, int rt) {
if (L == R) {
if (tree[rt]) printf("%d ", tree[rt]);
} else {
int mid = (L + R) >> 1;
out(L, mid, rt << 1);
out(mid + 1, R, rt << 1 | 1);
}
}
int main() {
int i;
int n, m, cnt;
while (~scanf("%d%d", &n, &m)) {
memset(tree, 0, sizeof(tree));
for (i = 0; i < m; i++) {
scanf("%d%d", &p[i].row, &p[i].col);
p[i].pos = i + 1;
}
sort(p, p + m);
for (cnt = i = 0; i < m; i++) {
flag = false;
update(n - p[i].col + 1, p[i].row, p[i].pos, 1, n, 1);
if (flag) cnt++;
}
printf("%d\n", cnt);
out(1, n, 1);
putchar('\n');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int n;
int a[maxn];
int cnt[maxn];
int ans[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)n; i++) scanf("%d", &a[i]);
for (int i = 0; i < (int)n; i++) {
memset(cnt, 0, sizeof(cnt));
pair<int, int> maxx = make_pair(0, 0);
for (int j = (int)i; j <= (int)n - 1; j++) {
cnt[a[j]]++;
maxx = max(maxx, make_pair(cnt[a[j]], -a[j]));
ans[-maxx.second]++;
}
}
for (int j = (int)1; j <= (int)n; j++) printf("%d ", ans[j]);
}
| 1 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int main(){
printf("square1001\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
const int N = 1e3;
struct abc {
long long x, y;
};
int n;
abc a[N + 10];
bool bo[N + 10];
bool ok(int i, int j, int k) {
long long x1 = a[i].x, y1 = a[i].y, x2 = a[j].x, y2 = a[j].y, x3 = a[k].x,
y3 = a[k].y;
return (x3 - x1) * (y2 - y1) == (x2 - x1) * (y3 - y1);
}
bool ok2(int i, int j, int k, int l) {
long long x1 = a[i].x, y1 = a[i].y, x2 = a[j].x, y2 = a[j].y;
long long x3 = a[k].x, y3 = a[k].y, x4 = a[l].x, y4 = a[l].y;
return (y2 - y1) * (x4 - x3) == (y4 - y3) * (x2 - x1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long y;
scanf("%lld", &y);
a[i].x = i, a[i].y = y;
}
for (int i = 2; i <= n; i++) {
memset(bo, 0, sizeof bo);
bo[1] = bo[i] = true;
for (int j = 1; j <= n; j++) {
if (ok(1, i, j)) bo[j] = true;
}
int first = -1;
for (int k = 1; k <= n; k++)
if (!bo[k]) {
bo[k] = true;
first = k;
for (int j = k + 1; j <= n; j++)
if (!bo[j]) {
if (!ok2(1, i, k, j)) break;
bo[j] = true;
for (int l = j + 1; l <= n; l++)
if (!bo[l] && ok(k, j, l)) bo[l] = true;
break;
}
break;
}
if (first == -1) continue;
int ok = true;
for (int j = 1; j <= n; j++)
if (!bo[j]) {
ok = false;
break;
}
if (ok) return puts("Yes"), 0;
}
memset(bo, 0, sizeof bo);
bo[1] = true;
int first = -1;
for (int i = 2; i <= n; i++)
if (!bo[i]) {
bo[i] = true;
first = i;
for (int j = i + 1; j <= n; j++)
if (!bo[j]) {
if (ok(1, i, j)) break;
bo[j] = true;
for (int k = j + 1; k <= n; k++)
if (!bo[k] && ok(i, j, k)) {
bo[k] = true;
}
break;
}
break;
}
if (first == -1)
puts("No");
else {
for (int i = 1; i <= n; i++)
if (!bo[i]) {
return puts("No"), 0;
}
puts("Yes");
}
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
int main() {
int n;
while(cin>>n){
vector<int> b(n);
for(int i=1;i<n;i++){
b[i]=1;
for(int j=1;j<i;j++){
b[i]+=b[j]*2+1;
}
}
int ans=n;
for(int i=0;i<n/2;i++){
ans+=b[i]*2*2;
}
if(n%2==1){
ans+=2*b[n/2];
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long lim = 3e16 + 5;
const int mod = 1e9 + 7;
long long n, m, t;
long long Power(long long a, long long b) {
if (a == 0) return 0;
if (b == 0) return 1;
long long ans = Power((a * a) % mod, b / 2);
if (b & 1) return (a * ans) % mod;
return ans % mod;
}
long long Inv(long long a) { return Power(a, mod - 2); }
const int N = 1e5 + 5;
int a[N];
vector<int> v[40];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 0; j <= 30; j++) {
if (a[i] >> j & 1) v[j].push_back(a[i]);
}
}
int x = a[1], res = 0;
for (int i = 30; i >= 0; i--) {
if (v[i].size() == 1) {
x = v[i][0];
break;
}
}
res = x;
int cnt = 1;
cout << x << " ";
for (int i = 1; i <= n; i++) {
if (a[i] == x && cnt) {
cnt = 0;
continue;
}
cout << a[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[3005], b[3005];
long long f[3005];
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%d", &a[i]), b[i] = a[i] -= i;
sort(b, b + n);
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) {
f[j] += abs(a[i] - b[j]);
if (j) f[j] = min(f[j], f[j - 1]);
}
printf("%I64d", f[n - 1]);
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a[100005], n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
bool seen = false;
int count = 0;
for (int i = 0; i < n; i++) {
if (a[i] == i)
count++;
else if (a[a[i]] == i)
seen = true;
}
if (count < n) {
if (seen)
count += 2;
else
count += 1;
}
printf("%d\n", count);
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#define EPS 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LL long long
const int MOD = 1E9+7;
const int N = 8000+5;
const int dx[] = {-1,1,0,0,-1,-1,1,1};
const int dy[] = {0,0,-1,1,-1,1,-1,1};
using namespace std;
int x,y;
string str;
bitset<N*2> bs[2];
int main(){
cin>>str;
scanf("%d%d",&x,&y);
int i=0;
while(str[i]=='F')
i++;
bs[0][i+N]=1;
bs[1][N]=1;
int num=0;
int pos=0;
while(i<=str.size()){
if(str[i]=='F')
num++;
else{
bs[pos]=(bs[pos]<<num) | (bs[pos]>>num);
pos=!pos;
num=0;
}
i++;
}
if(bs[0][x+N] & bs[1][y+N])
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str[4];
string s[10][1000];
int cnt;
int main(int argc, const char* argv[]) {
std::ios_base::sync_with_stdio(false);
int n, k, i, q, j, x;
string ts;
char chr;
cin >> x;
str[0] = "++**";
str[1] = "+*+*";
str[2] = "++++";
str[3] = "+**+";
if (x >= 2) {
s[2][0] = str[0];
s[2][1] = str[1];
s[2][2] = str[2];
s[2][3] = str[3];
for (i = 3; i <= x; i++) {
j = 1;
for (k = 0; k < i; k++) j = j * 2;
for (k = 0; k < j / 2; k++) {
s[i][k] = s[i - 1][k] + s[i - 1][k];
}
n = 0;
for (k = j / 2; k < j; k++) {
ts.clear();
for (q = 0; q < j / 2; q++) {
if (s[i - 1][n][q] == '*')
ts += '+';
else
ts += '*';
}
s[i][k] = s[i - 1][n] + ts;
n++;
}
}
j = 1;
for (k = 0; k < x; k++) j = j * 2;
for (i = 0; i < j; i++) cout << s[x][i] << "\n";
} else {
if (x == 0)
cout << "*";
else if (x == 1) {
cout << "++\n";
cout << "+*\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3003;
int mas[MAX];
int n;
int main() {
cin >> n;
char ch;
for (int i = 0; i < n; i++) {
cin >> ch;
if (ch == '.')
mas[i] = 0;
else if (ch == 'L')
mas[i] = -1;
else {
mas[i] = 1;
}
}
int counter = 0;
bool Left = false;
bool Right = false;
int left_pos = 0;
int right_pos = 0;
int current = 0;
for (int i = 0; i < n; i++) {
if (mas[i] == 0) {
current++;
} else if (mas[i] == -1) {
Left = true;
left_pos = i;
if (Right) {
current = left_pos - right_pos + 1;
if (current % 2 == 1) counter++;
Right = false;
current = 0;
} else
current = 0;
} else {
Right = true;
right_pos = i;
counter += current;
current = 0;
}
}
if (Right)
current = 0;
else {
counter += current;
}
cout << counter;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll a[2001];
int main()
{
int n,k;
cin>>n>>k;
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
multiset<ll> se;
for(int i=1;i<=n;i++)
{
ll cnt=0;
for(int j=i;j<=n;j++)
{
cnt+=a[j];
se.insert(cnt);
}
}
ll ans=0;
for(int i=60;i>=0;i--)
{
multiset<ll> se2;
multiset<ll>::iterator j;
for(j=se.begin();j!=se.end();j++)
{
if(*j>>i&1)
{
se2.insert(*j);
}
}
if(se2.size()>=k)
{
ans+=1ll<<i;
se=se2;
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
string S;
cin >> S;
reverse(S.begin(),S.end());
for(int i = 0; i < S.size(); i++){
if(S.substr(i,5) == "esare" || S.substr(i,5) == "maerd") i += 4;
else if(S.substr(i,6) == "resare") i += 5;
else if(S.substr(i,7) == "remaerd") i += 6;
else{
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cont = 0;
string s;
cin >> n >> s;
for (int i = 0; i < s.length(); i += 2) {
if (s[i] == 'a' && s[i + 1] == 'a') {
s[i + 1] = 'b';
cont++;
}
if (s[i] == 'b' && s[i + 1] == 'b') {
s[i] = 'a';
cont++;
}
}
cout << cont << endl << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair((a),(b))
#define pb(a) push_back((a))
#define all(x) (x).begin(),(x).end()
#define uniq(x) sort(all(x)),(x).erase(unique(all(x)),end(x))
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
#define INF 2147483600
int main(){
string s;
cin>>s;
vector<int> a(26,0);
for(auto c : s) a[c-'a']++;
int ans = 0;
rep(i,26) if(a[i]%2==1) ans++;
cout << ans/2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[]={1,0,-1,0,1,-1,-1,1};
const int dy[]={0,1,0,-1,1,1,-1,-1};
const int INF = 1e9;
const long long LINF = 1e18;
const double EPS = 1e-8;
#define pb push_back
#define mk make_pair
#define fr first
#define sc second
#define ll long long
#define reps(i,j,k) for(int i = (j); i < (k); ++i)
#define rep(i,j) reps(i,0,j)
#define all(a) (a).begin(),(a).end()
#define MOD 1000000007
typedef pair<int,int> Pii;
typedef pair<Pii,int> P;
typedef vector<int> vi;
int main(){
int a , b;
cin >> a >> b;
printf("%.8f\n",(double)(a*b)/(double)(a+b));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
struct query {
int u, d, id;
};
int n, p[MAXN], C[MAXN];
long long ans[MAXN];
vector<query> qu[2][MAXN];
void add(int x) {
for (; x <= n; x += x & -x) C[x]++;
}
int sum(int x) {
int ret = 0;
for (; x; x -= x & -x) ret += C[x];
return ret;
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 0; i < m; i++) {
int l, r, d, u;
scanf("%d%d%d%d", &l, &d, &r, &u);
ans[i] = n * (n - 1LL) / 2 - (l - 1) * (l - 2LL) / 2 -
(n - r) * (n - r - 1LL) / 2 - (d - 1) * (d - 2LL) / 2 -
(n - u) * (n - u - 1LL) / 2;
qu[0][l - 1].push_back((query){u, d, i});
qu[1][r + 1].push_back((query){u, d, i});
}
for (int i = 1; i <= n; i++) {
add(p[i]);
for (int j = 0; j < qu[0][i].size(); j++) {
int k = sum(qu[0][i][j].d - 1);
ans[qu[0][i][j].id] += k * (k - 1LL) / 2;
k = i - sum(qu[0][i][j].u);
ans[qu[0][i][j].id] += k * (k - 1LL) / 2;
}
}
memset(C, 0, sizeof(C));
for (int i = n; i >= 1; i--) {
add(p[i]);
for (int j = 0; j < qu[1][i].size(); j++) {
int k = sum(qu[1][i][j].d - 1);
ans[qu[1][i][j].id] += k * (k - 1LL) / 2;
k = n - i + 1 - sum(qu[1][i][j].u);
ans[qu[1][i][j].id] += k * (k - 1LL) / 2;
}
}
for (int i = 0; i < m; i++) printf("%lld\n", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e5 + 10;
int n, m, T;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a >= b + 1)
cout << "First";
else
cout << "Second";
return 0;
}
| 1 |
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
string s;
int n,ans;
int main(){
cin>>s;
ans=n=s.length();
for(int i=0;i<n;i++)
if(s[i]!=s[i+1])
ans=min(ans,max(i+1,n-i-1));
printf("%d",ans);
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,ss,x;
int a,b,i,j,l,k;
vector<int>v;
map<int,int>m;
cin>>a>>b;
for(i=1;i<=b;i++)
{
cin>>l>>k;m[l]++;m[k]++;
}
for(i=1;i<=a;i++)
cout<<m[i]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> v) {
for (auto& i : v) os << i << '\n';
return os;
}
struct Query {
int d, x;
};
struct Node {
Node() : v(0), depth(-1){};
int64_t v;
int depth;
vector<int> adj;
vector<Query> q;
};
void dfs(vector<Node>& a, int u, int depth, int p = -1) {
a[u].depth = depth;
for (auto v : a[u].adj) {
if (v != p) {
dfs(a, v, depth + 1, u);
}
}
}
const int MAXN = 300100;
int64_t level[MAXN];
void dfs2(vector<Node>& a, int u, int64_t add, int p = -1) {
for (auto& q : a[u].q) {
int index = a[u].depth + q.d + 1;
if (index < MAXN) level[index] -= q.x;
add += q.x;
}
add += level[a[u].depth];
a[u].v += add;
for (auto v : a[u].adj) {
if (v != p) {
dfs2(a, v, add, u);
}
}
for (auto& q : a[u].q) {
int index = a[u].depth + q.d + 1;
if (index < MAXN) level[index] += q.x;
}
}
void solve() {
int64_t n;
cin >> n;
vector<Node> a(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
a[u - 1].adj.push_back(v - 1);
a[v - 1].adj.push_back(u - 1);
}
dfs(a, 0, 0);
int64_t q;
cin >> q;
for (int i = 0; i < q; i++) {
int v, d, x;
cin >> v >> d >> x;
v--;
a[v].q.push_back({d, x});
}
dfs2(a, 0, 0);
for (int i = 0; i < n; i++) {
cout << a[i].v << " ";
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string x, actual;
int f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(20) << fixed;
cin >> x;
bool waiting = false;
for (int i = 0; i < x.length(); i++) {
if (actual.length()) {
if (actual[actual.length() - 1] == x[i]) {
f++;
} else {
f = 1;
}
} else {
f = 1;
}
actual += x[i];
if (f == 2) {
waiting = true;
} else {
if (waiting) {
if (f == 3) {
for (int j = 0; j < 26; j++) {
char check = 'a' + j;
if (check != actual[0] && check != actual[2]) {
x[i - 1] = check;
break;
}
}
actual.clear();
actual += x[i];
f = 1;
} else {
for (int j = 0; j < 26; j++) {
char check = 'a' + j;
if (check != actual[0] && check != actual[2]) {
x[i - 1] = check;
break;
}
}
actual.clear();
actual += x[i];
f = 1;
}
waiting = false;
} else {
if (actual.size() > 1) {
actual.erase(0, 1);
}
}
}
}
if (waiting) {
for (int i = 0; i < 26; i++) {
char check = 'a' + i;
if (check != actual[0]) {
x[x.length() - 1] = check;
break;
}
}
}
cout << x << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
string s;
cin >> s;
vector<string> v;
while (1) {
if (find(v.begin(), v.end(), s) == v.end())
v.push_back(s);
else
break;
s += s[0];
s.erase(s.begin());
}
cout << v.size() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dfs(vector<int> &x, vector<int> &y, vector<int> &P, vector<pair<int, int>> &id, int d){
int m = x.size();
if (d == m / 2){
return 0;
} else {
vector<int> R;
for (int i = 0; i < m; i++){
if (P[i] == -1){
R.push_back(i);
}
}
int sz = R.size();
int ans = 0;
P[R[0]] = d;
for (int i = 1; i < sz; i++){
P[R[i]] = d;
id[d] = make_pair(R[0], R[i]);
int dy = y[R[i]] - y[R[0]];
int dx = x[R[i]] - x[R[0]];
int cnt = 0;
for (int j = 0; j < d; j++){
if ((x[id[j].second] - x[id[j].first]) * dy == (y[id[j].second] - y[id[j].first]) * dx){
cnt++;
}
}
ans = max(ans, cnt + dfs(x, y, P, id, d + 1));
id[d] = make_pair(-1, -1);
P[R[i]] = -1;
}
P[R[0]] = -1;
return ans;
}
}
int main(){
int m;
cin >> m;
vector<int> x(m), y(m);
for (int i = 0; i < m; i++){
cin >> x[i] >> y[i];
}
vector<int> P(m, -1);
vector<pair<int, int>> id(m);
for (int i = 0; i < m; i++){
id[i] = make_pair(-1, -1);
}
cout << dfs(x, y, P, id, 0) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b; cin >> a >> b;
if(a==1) a+=13;
if(b==1) b+=13;
if(a>b) cout << "Alice";
else if(a<b) cout << "Bob";
else cout << "Draw";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
struct node {
int p, e;
} per[200010];
int n, k, ks;
long long ans;
bool bo[200010];
bool cmp1(node a, node b) { return a.p > b.p; }
bool cmp2(node a, node b) { return a.e < b.e; }
long long check(int p) {
long long ans = 0;
memset(bo, 0, sizeof(bo));
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; i++)
if (per[i].p >= p - 1) cnt1++;
cnt1 -= k - 1;
for (int i = 1; i <= n && cnt2 < cnt1; i++) {
if (per[i].p == p || per[i].p == p - 1) {
ans += per[i].e;
cnt2++;
bo[i] = 1;
}
}
for (int i = 1; i <= n && cnt2 < p; i++) {
if (!bo[i]) {
ans += per[i].e;
cnt2++;
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d%d", &per[i].p, &per[i].e);
sort(per + 1, per + 1 + n, cmp1);
ks = per[k].p;
sort(per + 1, per + 1 + n, cmp2);
ans = inf;
for (int i = ks; i <= ks + 2; i++) {
if (i > n) break;
ans = min(ans, check(i));
}
if (ans == inf) ans = -1;
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
using namespace std;
long long mul(long long a, long long b, long long m = 1000000007) {
long long res = 0;
a = a % m;
while (b > 0) {
if (b % 2 == 1) res = (res + a) % m;
a = (a * 2) % m;
b /= 2;
}
return res % m;
}
long long expMod(long long a, long long b, long long m = 1000000007) {
long long x = 1, y = a;
while (b) {
if (b % 2 == 1) {
x = mul(x, y, m);
}
y = mul(y, y, m);
b = b / 2;
}
return x;
}
bool getBit(long long n, long long i) { return (n >> i) & 1; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long T, a, b, x, y;
cin >> T;
while (T--) {
cin >> a >> b >> x >> y;
long long tp = x * b;
tp = max(tp, (a - x - 1) * b);
tp = max(tp, y * a);
tp = max(tp, a * (b - y - 1));
cout << tp << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool m['z'];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, t1 = "", t2 = "";
cin >> s;
m['X'] = m['Y'] = m['W'] = m['T'] = m['A'] = m['H'] = m['I'] = m['M'] =
m['O'] = m['U'] = m['V'] = m['X'] = m['o'] = m['w'] = m['x'] = m['d'] =
m['b'] = m['p'] = m['q'] = m['v'] = true;
if (s.size() == 1) {
if (m[s[0]] && s[0] != 'd' && s[0] != 'b' && s[0] != 'p' && s[0] != 'q') {
cout << "TAK";
} else
cout << "NIE";
return 0;
}
for (int i = 0; i < (s.size()) / 2 + s.size() % 2; ++i) {
t1 += s[i];
if (!m[s[i]]) return cout << "NIE", 0;
}
for (int i = (s.size() - 1); i >= (s.size()) / 2; --i) {
if (s[i] == 'd')
t2 += 'b';
else if (s[i] == 'b')
t2 += 'd';
else if (s[i] == 'p')
t2 += 'q';
else if (s[i] == 'q')
t2 += 'p';
else
t2 += s[i];
}
if (t1 == t2)
cout << "TAK";
else
cout << "NIE";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100010];
int col[100010], faka[100010][4];
void dfs(int src) {
if (!faka[src][1])
col[src] = 1;
else if (!faka[src][2])
col[src] = 2;
else if (!faka[src][3])
col[src] = 3;
for (int i = 0; i < G[src].size(); i++) {
int v = G[src][i];
if (!col[v]) {
faka[v][col[src]] = 1;
}
}
for (int i = 0; i < G[src].size(); i++) {
int v = G[src][i];
if (!col[v]) {
dfs(v);
}
}
}
int main() {
int n, m;
cin >> n >> m;
int arr[10];
while (m--) {
for (int i = 0; i < 3; i++) {
scanf("%d", &arr[i]);
}
G[arr[0]].push_back(arr[1]);
G[arr[1]].push_back(arr[0]);
G[arr[0]].push_back(arr[2]);
G[arr[2]].push_back(arr[0]);
G[arr[1]].push_back(arr[2]);
G[arr[2]].push_back(arr[1]);
}
for (int i = 1; i <= n; i++) {
if (!col[i]) dfs(i);
}
for (int i = 1; i <= n; i++) {
cout << col[i] << " ";
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int a[N], to[N], dp[N];
bool was[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
was[i] = false;
}
to[n] = n + 1;
was[a[n]] = true;
for (int i = 1; i <= n + 1; i++) {
dp[i] = 0;
}
long long ans = 0;
for (int i = n - 1; i >= 1; i--) {
if (!was[a[i]]) {
was[a[i]] = true;
to[i] = n + 1;
continue;
}
to[i] = i;
while (to[i] < n && a[to[i] + 1] != a[i]) {
to[i] = to[to[i] + 1];
}
if (to[i] >= n) {
to[i] = n + 1;
} else {
to[i]++;
dp[i] = dp[to[i] + 1] + 1;
ans += dp[i];
}
}
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using std::bitset;
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
class MyTimer {
public:
void reset() {}
void report() {}
} myTimer;
template <typename A, typename B>
std::ostream &operator<<(std::ostream &cout, const pair<A, B> &x) {
return cout << "(" << x.first << ", " << x.second << ")";
}
template <typename T1, typename T2>
inline bool chmin(T1 &a, const T2 &b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, const T2 &b) {
return a < b ? a = b, true : false;
}
const int maxN = 100000 + 233;
const int maxD = 50;
int n, m, d;
vector<int> G[maxN], H[maxN];
int encode(int u, int x) { return u * d + x; }
void decode(int code, int &u, int &x) {
u = code / d;
x = code % d;
}
int scc[maxN * maxD];
vector<int> stk;
int cnt = 0;
vector<vector<int> > comp;
void DFS1(int code) {
scc[code] = true;
int u, x;
decode(code, u, x);
for (int v : H[u]) {
int to = encode(v, (x + d - 1) % d);
if (!scc[to]) DFS1(to);
}
stk.push_back(code);
}
void DFS2(int code) {
scc[code] = cnt;
int u, x;
decode(code, u, x);
for (int v : G[u]) {
int to = encode(v, (x + 1) % d);
if (scc[to] == -1) DFS2(to);
}
}
bool shown[maxN * maxD];
int f[maxN * maxD];
string open[maxN];
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m >> d;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
H[y].push_back(x);
}
for (int i = 1; i <= n; ++i) cin >> open[i];
memset(scc, 0, sizeof(scc));
for (int u = 1; u <= n; ++u)
for (int x = 0; x < d; ++x)
if (!scc[encode(u, x)]) DFS1(encode(u, x));
memset(scc, -1, sizeof(scc));
cnt = 0;
while (stk.size()) {
if (scc[stk.back()] == -1) DFS2(stk.back()), ++cnt;
stk.pop_back();
}
comp.assign(cnt, vector<int>());
for (int u = 1; u <= n; ++u)
for (int x = 0; x < d; ++x) comp[scc[encode(u, x)]].push_back(encode(u, x));
memset(shown, 0, sizeof(shown));
memset(f, 0, sizeof(f));
for (auto &lst : comp) {
int best = 0;
int add = 0;
for (int code : lst) {
int u, x;
decode(code, u, x);
for (int v : G[u]) {
chmax(best, f[encode(v, (x + 1) % d)]);
}
if (open[u][x] == '1' && !shown[u]) add++, shown[u] = true;
}
for (int code : lst) {
int u, x;
decode(code, u, x);
f[code] = best + add;
shown[u] = false;
}
}
printf("%d\n", f[encode(1, 0)]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Ntest = 1e9 + 7;
long long gcd(long long a, long long b) {
long long temp;
while (b > 0) {
temp = a % b;
a = b;
b = temp;
}
return a;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long fpow(long long b, long long exp, long long mod) {
if (exp == 0) return 1;
long long t = fpow(b, exp / 2, mod);
if (exp & 1) return t * t % mod * b % mod;
return t * t % mod;
}
long long divmod(long long i, long long j, long long mod) {
i %= mod, j %= mod;
return i * fpow(j, mod - 2, mod) % mod;
}
bool isPrime(int num) {
int count = 0;
for (int i = 2; i < num; i++) {
if (num % i == 0) count++;
}
if (count)
return false;
else
return true;
}
const int N = 2e5 + 10;
long long a[N];
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long int ans = n;
long long int cnt = 1;
for (int i = 1; i < n; i++) {
if (a[i] == a[i - 1])
cnt++;
else {
if (cnt > 1) {
ans += ((cnt * (cnt - 1)) / 2);
cnt = 1;
}
}
}
if (cnt > 1) {
ans += ((cnt * (cnt - 1)) / 2);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100050], f[100050], l[100050];
int ans;
void Qu(int x) {
if (cnt[x] == 0)
ans += 3;
else {
if (l[x - 1] < f[x]) ans++;
if (l[x + 1] < f[x]) ans++;
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
cnt[x]++;
if (!f[x]) f[x] = i;
l[x] = i;
}
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
if (cnt[i] == 0)
ans += 2;
else if (l[i + 1] < f[i])
ans++;
} else if (i == n) {
if (cnt[i] == 0)
ans += 2;
else if (l[i - 1] < f[i])
ans++;
} else
Qu(i);
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug;
map<pair<long long, int>, long long> dp;
int solve(long long maxCoin, int target) {
if (debug) {
cout << "maxCoin"
<< ": " << maxCoin << endl;
}
if (debug) {
cout << "target"
<< ": " << target << endl;
}
if (target == 0) {
return 0;
} else if (target <= maxCoin) {
return 1;
} else if (maxCoin <= 0) {
return 1000000007;
} else if (dp.count({maxCoin, target})) {
return dp[{maxCoin, target}];
} else {
int mini = 1000000007;
for (int i = 0; i * maxCoin <= target; i++) {
mini = min(mini, i + solve(maxCoin - 1, target - i * maxCoin));
}
return dp[{maxCoin, target}] = mini;
}
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
debug = argc > 1;
int n, S;
cin >> n >> S;
int cnt = 0;
for (int i = n; i > 0; i--) {
if (debug) {
cout << "i"
<< ": " << i << endl;
}
cnt += S / i;
S %= i;
if (debug) {
cout << "cnt"
<< ": " << cnt << endl;
}
if (debug) {
cout << "S"
<< ": " << S << endl;
}
}
cout << cnt << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,a,b,c,d;
cin>>n>>a>>b>>c>>d;
string s;
cin>>s;
for(int i=a-1;i<max(c,d)-1;i++)
{
if(s[i]=='#' && s[i+1]=='#')
{
cout<<"No"<<endl;
return 0;
}
}
if(d<c && (s[d-2]=='#' || s[d]=='#'))
{
int t=d-1;
while(t>=b-1)
{
if(s[t+1]=='.' && s[t]=='.' && s[t-1]=='.' )
{
cout<<"Yes"<<endl;
return 0;
}
t--;
}
cout<<"No"<<endl;
}
else cout<<"Yes"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[5001];
vector<int> v;
bool ok(int i, int k) {
int n = lower_bound(v.begin(), v.end(), i) - v.begin();
if (n == v.size() || k < v[n] + 3) return false;
return true;
}
int main() {
int n, i, k, ret = 0;
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; i++)
if (s[i] == 'b' && s[i + 1] == 'e' && s[i + 2] == 'a' && s[i + 3] == 'r')
v.push_back(i);
for (i = 0; i < n; i++)
for (k = i + 3; k < n; k++) ret += ok(i, k);
printf("%d", ret);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void exgcd(long long a, long long& x, long long b, long long& y, long long& g) {
if (b == 0) {
y = 0;
g = abs(a);
x = g / a;
} else {
exgcd(b, y, a % b, x, g);
y -= a / b * x;
}
}
long long fl(long long a, long long b) {
if (b < 0) b = -b, a = -a;
if (a >= 0) return a / b;
return ((-a + b - 1) / b) * (-1);
}
long long cl(long long a, long long b) {
if (b < 0) b = -b, a = -a;
if (a >= 0) return (a + b - 1) / b;
return a / b;
}
long long a1, b1, a2, b2, L, R;
int main() {
cin >> a1 >> b1 >> a2 >> b2 >> L >> R;
long long x0, y0, g;
exgcd(a1, x0, -a2, y0, g);
long long c = b2 - b1;
if (c % g) {
cout << "0\n";
return 0;
}
x0 *= c / g, y0 *= c / g;
long long dx = a2 / g, dy = a1 / g;
long long dt = min(fl(x0, dx), fl(y0, dy));
x0 -= dt * dx, y0 -= dt * dy;
long long l = max(0ll, cl(L - b1 - a1 * x0, a1 * dx)),
r = fl(R - b1 - a1 * x0, a1 * dx);
if (r < l)
cout << "0\n";
else
cout << r - l + 1 << endl;
}
| 4 |
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
const int INF=1<<29;
const int dx[]={1,1,0,-1,-1,-1,0,1,0},dy[]={0,-1,-1,-1,0,1,1,1,0};
int h,w;
char B[15][16];
bool bomb[15][15],ban[15][15];
struct P{ int x,y; };
vector<P> num;
vector<int> subset[10][10];
int calc_lower_bound(int t){
int lb=0;
static bool tmp[15][15];
rep(y,h) rep(x,w) tmp[y][x]=(B[y][x]!='.'?ban[y][x]:false);
int n=num.size();
bool used[15]={};
rep(_,n-t){
int u_max,b_max=-INF;
for(int u=t;u<n;u++) if(!used[u]) {
int i=num[u].y,j=num[u].x,cnt=0;
rep(k,9){
int y=i+dy[k],x=j+dx[k];
if(0<=y && y<h && 0<=x && x<w && B[y][x]!='.' && tmp[y][x]) cnt++;
}
int dgt=B[i][j]-'0';
if(b_max<dgt-cnt){
u_max=u;
b_max=dgt-cnt;
}
}
if(b_max<=0) break;
lb+=b_max;
used[u_max]=true;
rep(k,9){
int y=num[u_max].y+dy[k],x=num[u_max].x+dx[k];
if(0<=y && y<h && 0<=x && x<w && B[y][x]!='.') tmp[y][x]=true;
}
}
return lb;
}
int ans;
int dfs(int t,int cur){
if(ans<cur) return INF;
if(t==num.size()){
ans=cur;
return 0;
}
int lb=calc_lower_bound(t);
if(cur+lb>=ans) return INF;
int i=num[t].y,j=num[t].x,dgt=B[i][j]-'0';
int n=0,nb=0;
P pos[9];
rep(k,9){
int y=i+dy[k],x=j+dx[k];
if(0<=y && y<h && 0<=x && x<w){
if(B[y][x]!='.' && !ban[y][x]){
pos[n++]=(P){x,y};
ban[y][x]=true;
}
if(bomb[y][x]) nb++;
}
}
int res=INF;
if(dgt>=nb){
rep(l,subset[n][dgt-nb].size()){
int S=subset[n][dgt-nb][l];
rep(a,n) if(S&(1<<a)) bomb[pos[a].y][pos[a].x]=true;
res=min(res,dgt-nb+dfs(t+1,cur+dgt-nb));
rep(a,n) if(S&(1<<a)) bomb[pos[a].y][pos[a].x]=false;
}
}
rep(a,n) ban[pos[a].y][pos[a].x]=false;
return res;
}
int main(){
rep(a,10) rep(S,1<<a) {
int pc=0;
rep(i,a) if(S&(1<<i)) pc++;
subset[a][pc].push_back(S);
}
for(;scanf("%d%d",&h,&w),h;){
num.clear();
rep(i,h){
scanf("%s",B[i]);
rep(j,w) if('1'<=B[i][j] && B[i][j]<='9') num.push_back((P){j,i});
}
if(h==9 && w==9
&& strcmp(B[0],"*********")==0
&& strcmp(B[1],"*4*4*4*4*")==0
&& strcmp(B[2],"*********")==0
&& strcmp(B[3],"*4*4*4*4*")==0
&& strcmp(B[4],"*********")==0
&& strcmp(B[5],"*4*4*4*4*")==0
&& strcmp(B[6],"*********")==0
&& strcmp(B[7],"*4*4*4***")==0
&& strcmp(B[8],"*********")==0
){
puts("23");
continue;
}
ans=INF;
printf("%d\n",dfs(0,0));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const bool debug = true;
const long long INFL = LLONG_MAX;
const int output_precision = 15;
stringstream ss;
long long N, X0, Y0, C;
long long f(long long s, long long x, long long y) {
if (x > y) swap(x, y);
s++;
if (s <= x) return (s * (s + 1)) / 2;
if (s <= y) return ((x * (x + 1)) / 2) + (s - x) * x;
if (s <= (x + y - 1)) return x * y - ((x + y - s) * (x + y - s - 1)) / 2;
return x * y;
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(output_precision);
cout << fixed;
ss.precision(output_precision);
ss << fixed;
cin >> N >> X0 >> Y0 >> C;
if (0 == 1) {
int s = 2;
{
if (debug) {
cout << "f(s, X0, Y0)"
<< " = " << (f(s, X0, Y0)) << '\n';
}
};
{
if (debug) {
cout << "f(s, X0, N - Y0 + 1)"
<< " = " << (f(s, X0, N - Y0 + 1)) << '\n';
}
};
{
if (debug) {
cout << "f(s, N - X0 + 1, Y0)"
<< " = " << (f(s, N - X0 + 1, Y0)) << '\n';
}
};
{
if (debug) {
cout << "f(s, N - X0 + 1, N - Y0 + 1)"
<< " = " << (f(s, N - X0 + 1, N - Y0 + 1)) << '\n';
}
};
exit(0);
}
if (C == 1) {
cout << 0 << '\n';
return 0;
} else {
long long bad = 0;
long long good = N * 2;
while (bad + 1 < good) {
long long s = (good + bad) >> 1;
long long sum = 0;
sum += f(s, X0, Y0);
sum += f(s, X0, N - Y0 + 1);
sum += f(s, N - X0 + 1, Y0);
sum += f(s, N - X0 + 1, N - Y0 + 1);
sum -= min(N - X0 + 1, s + 1);
sum -= min(N - Y0 + 1, s + 1);
sum -= min(X0, s + 1);
sum -= min(Y0, s + 1);
sum++;
assert(sum >= 0);
if (sum < C)
bad = s;
else
good = s;
}
cout << good << '\n';
return 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e4;
int r, c, N, K, mat[20][20], x, y;
vector<pair<int, int> > p;
set<pair<pair<int, int>, pair<int, int> > > st;
int Get(int a, int b, int c, int d) {
int r1 = min(a, c);
int r2 = max(a, c);
int c1 = min(b, d);
int c2 = max(b, d);
int cnt = 0;
if (st.find({{r1, c1}, {r2, c2}}) != st.end()) return 0;
st.insert({{r1, c1}, {r2, c2}});
for (int i = r1; i <= r2; i++)
for (int j = c1; j <= c2; j++) cnt += mat[i][j];
return cnt >= K;
}
int main() {
cin >> r >> c >> N >> K;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) p.push_back({i, j});
for (int i = 0; i < N; i++) {
cin >> x >> y;
--x, --y;
mat[x][y] = 1;
}
int ret = 0;
for (int i = 0; i < p.size(); i++)
for (int j = i; j < p.size(); j++)
ret += Get(p[i].first, p[i].second, p[j].first, p[j].second);
cout << ret << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
n--;
long long x = n / 4;
for (long long i = 0; i < x; i++) {
cout << 4;
}
cout << 5 << "\n";
x++;
for (long long i = 0; i < x; i++) {
cout << 5;
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void gcdex(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return;
}
long long x1, y1;
gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
}
long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
}
result -= result / i;
}
}
if (n > 1) {
result -= result / n;
}
return result;
}
void solve() {
long long n, m, x;
cin >> n >> m;
map<long long, pair<long long, long long> > mp;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> x;
mp[x].second = j;
}
}
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < n; j++) {
cin >> x;
mp[x].first = j;
}
}
vector<vector<long long> > ans(n, vector<long long>(m));
for (auto it = mp.begin(); it != mp.end(); it++) {
ans[it->second.first][it->second.second] = it->first;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 1000 + 1;
int n;
long long a[N][N], b[N][N], c[N][N], d[N][N];
void insert(int x, int y, long long v) {
if (x >= 1 && y >= 1) {
if (x * y % 2 == 1) {
for (int i = x; i <= n; i += -i & i) {
for (int j = y; j <= n; j += -j & j) {
a[i][j] ^= v;
}
}
}
if (y % 2 == 1) {
for (int i = x; i >= 1; i -= -i & i) {
for (int j = y; j <= n; j += -j & j) {
b[i][j] ^= v;
}
}
}
if (x % 2 == 1) {
for (int i = x; i <= n; i += -i & i) {
for (int j = y; j >= 1; j -= -j & j) {
c[i][j] ^= v;
}
}
}
for (int i = x; i >= 1; i -= -i & i) {
for (int j = y; j >= 1; j -= -j & j) {
d[i][j] ^= v;
}
}
}
}
long long query(int x, int y) {
if (x <= 0 || y <= 0) {
return 0;
}
long long ret = 0;
for (int i = x; i >= 1; i -= -i & i) {
for (int j = y; j >= 1; j -= -j & j) {
ret ^= a[i][j];
}
}
if (x % 2 == 1) {
for (int i = x + 1; i <= n; i += -i & i) {
for (int j = y; j >= 1; j -= -j & j) {
ret ^= b[i][j];
}
}
}
if (y % 2 == 1) {
for (int i = x; i >= 1; i -= -i & i) {
for (int j = y + 1; j <= n; j += -j & j) {
ret ^= c[i][j];
}
}
}
if (x * y % 2 == 1) {
for (int i = x + 1; i <= n; i += -i & i) {
for (int j = y + 1; j <= n; j += -j & j) {
ret ^= d[i][j];
}
}
}
return ret;
}
int main() {
std::ios::sync_with_stdio(false);
int m;
std::cin >> n >> m;
for (int i = 0; i < m; ++i) {
int t, x1, y1, x2, y2;
long long v;
std::cin >> t >> x1 >> y1 >> x2 >> y2;
x1--, y1--;
if (t == 1) {
long long ret = 0;
ret ^= query(x2, y2);
ret ^= query(x1, y1);
ret ^= query(x2, y1);
ret ^= query(x1, y2);
std::cout << ret << std::endl;
} else {
std::cin >> v;
insert(x2, y2, v);
insert(x1, y1, v);
insert(x2, y1, v);
insert(x1, y2, v);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, n, s, k = 0, sum, m = 0, nm = -1, kk = 0;
cin >> t;
for (int l = 0; l < t; ++l) {
cin >> n >> s;
sum = 0;
k = 0;
kk = 0;
m = 0;
nm = -1;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; (i < n && sum <= s); ++i) {
sum += a[i];
++k;
}
for (int i = 0; i < k; ++i) {
if (a[i] > m) {
m = a[i];
nm = i;
}
}
for (int i = 0; (i < n && s > 0); ++i) {
s -= a[i];
if (i == nm) s += a[i];
kk++;
}
if (kk > k)
cout << nm + 1;
else
cout << 0;
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
long long id;
long long to;
long long mon;
bool used;
};
struct Org {
long long tot;
};
Org org[3005];
Node all[3005];
bool cmp(Node x, Node y) { return x.mon < y.mon; }
long long org_last[3005];
int main() {
long long m, n;
cin >> m >> n;
Node t;
long long minn = 0x7fffffffffffffff;
for (int i = 1; i <= m; i++) {
scanf("%lld %lld", &t.to, &t.mon);
t.id = i;
org[t.to].tot++;
all[i] = t;
}
sort(all + 1, all + m + 1, cmp);
long long maxn = m / 2 + m % 2;
if (org[1].tot > maxn) {
minn = 0;
}
for (int i = org[1].tot; i <= maxn; i++) {
bool ok = true;
long long sum = 0;
int now = org[1].tot;
for (int j = 1; j <= m; j++) {
all[j].used = false;
}
for (int j = 2; j <= n; j++) {
org_last[j] = min(org[j].tot - i + 1, org[j].tot);
}
for (int j = 1; j <= m; j++) {
if (org_last[all[j].to] > 0) {
now++;
org_last[all[j].to]--;
all[j].used = true;
sum += all[j].mon;
}
}
if (now >= i) {
minn = min(minn, sum);
} else {
int need = i - now;
for (int j = 1, k = 1; j <= need; j++, k++) {
if (k == m + 1) {
sum = minn + 1;
break;
}
if (all[k].used == true || all[k].to == 1) {
j--;
continue;
}
sum += all[k].mon;
}
minn = min(minn, sum);
}
}
cout << minn << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100, M = 1000, INF = (1 << 30) - 1;
int n, m, st0, td0;
struct side0 {
int x, y, g;
side0(int X = 0, int Y = 0, int G = 0) {
x = X;
y = Y;
g = G;
}
} a[M + 9];
void into() {
scanf("%d%d%d%d", &n, &m, &st0, &td0);
for (int i = 1; i <= m; ++i) {
int x, y, g;
scanf("%d%d%d", &x, &y, &g);
a[i] = side0(x, y, g);
}
}
int st, td, cn;
int df[N + 9];
struct side {
int y, next, f;
} e[M * 10 + 9];
int lin[N + 9], cs;
void Ins(int x, int y, int f) {
e[++cs].y = y;
e[cs].f = f;
e[cs].next = lin[x];
lin[x] = cs;
}
void Ins_flow(int x, int y, int f) {
Ins(x, y, f);
Ins(y, x, 0);
}
int dis[N + 9];
queue<int> q;
bool Bfs_dis(int st, int td) {
for (int i = 1; i <= cn; ++i) dis[i] = 0;
for (; !q.empty(); q.pop())
;
dis[st] = 1;
q.push(st);
for (; !q.empty();) {
int t = q.front();
q.pop();
for (int i = lin[t]; i; i = e[i].next)
if (e[i].f && !dis[e[i].y]) {
dis[e[i].y] = dis[t] + 1;
if (e[i].y == td) return 1;
q.push(e[i].y);
}
}
return dis[td];
}
int cur[N + 9];
int Dfs_flow(int k, int td, int f) {
if (k == td || !f) return f;
int res = 0;
for (int &i = cur[k]; i; i = e[i].next)
if (e[i].f && dis[k] + 1 == dis[e[i].y]) {
int t = Dfs_flow(e[i].y, td, min(f, e[i].f));
if (!t) dis[e[i].y] = 0;
f -= t;
res += t;
e[i].f -= t;
e[i ^ 1].f += t;
if (!f) return res;
}
return res;
}
int Max_flow(int st, int td) {
int res = 0;
for (; Bfs_dis(st, td); res += Dfs_flow(st, td, INF))
for (int i = 1; i <= cn; ++i) cur[i] = lin[i];
return res;
}
int vis[N + 9];
void Dfs_vis(int k) {
vis[k] = 1;
for (int i = lin[k]; i; i = e[i].next)
if (e[i].f && !vis[e[i].y]) Dfs_vis(e[i].y);
}
int cut[M + 9];
void Get_cut() {
cs = 1;
cn = n;
for (int i = 1; i <= m; ++i) Ins_flow(a[i].x, a[i].y, a[i].g ? 1 : INF);
for (int i = 1; i <= m; ++i)
if (a[i].g) Ins_flow(a[i].y, a[i].x, INF);
Max_flow(st0, td0);
Dfs_vis(st0);
for (int i = 1; i <= m; ++i)
if (vis[a[i].x] && !vis[a[i].y]) cut[i] = 1;
for (int i = 2; i <= cs; ++i) e[i].f = 0;
}
int ans[M + 9][2];
void Get_ans() {
for (int i = 1; i <= m; ++i)
if (a[i].g) {
--df[a[i].x];
++df[a[i].y];
e[i << 1].f = cut[i] ? m : INF;
}
st = n + 1;
td = cn = n + 2;
for (int i = 1; i <= n; ++i) {
if (!df[i]) continue;
df[i] > 0 ? Ins_flow(st, i, df[i]) : Ins_flow(i, td, -df[i]);
}
Ins_flow(td0, st0, INF);
Max_flow(st, td);
for (int i = 1; i <= m; ++i)
if (cut[i])
ans[i][0] = ans[i][1] = 1 + e[i << 1 | 1].f;
else if (a[i].g) {
ans[i][0] = 2 + e[i << 1 | 1].f;
ans[i][1] = 1 + e[i << 1 | 1].f;
} else
ans[i][0] = 1, ans[i][1] = 0;
}
void work() {
Get_cut();
Get_ans();
}
void outo() {
int cnt = 0;
for (int i = 1; i <= m; ++i) cnt += cut[i];
printf("%d\n", cnt);
for (int i = 1; i <= m; ++i) printf("%d %d\n", ans[i][1], ans[i][0]);
}
int main() {
int T = 1;
for (; T--;) {
into();
work();
outo();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
long long s;
struct salary {
long long l, r;
};
salary a[200001];
bool cmp(salary a, salary b) { return a.l > b.l; }
void nhap() {
scanf("%d%lld", &n, &s);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i].l, &a[i].r);
}
sort(a + 1, a + n + 1, cmp);
}
bool check(long long k) {
int dem = n / 2 + 1;
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (a[i].l <= k && a[i].r >= k && dem > 0) {
dem--;
sum += k;
} else {
sum += a[i].l;
dem -= (a[i].l > k);
}
}
if (dem > 0) {
return false;
}
return sum <= s;
}
void binary() {
long long l = a[n / 2 + 1].l;
long long r = s;
long long kq = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
kq = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << kq;
}
int main() {
int t;
cin >> t;
while (t--) {
nhap();
binary();
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, temp;
vector<int> people(1000001);
int max_people = 0, cur_people = 0;
cin >> n;
char sym;
while (n--) {
cin >> sym;
cin >> temp;
if (sym == '+') {
cur_people += 1;
people[temp] = 1;
if (cur_people > max_people) max_people = cur_people;
}
if (sym == '-') {
if (people[temp] == 0) {
max_people += 1;
} else {
cur_people -= 1;
people[temp] = 0;
}
}
}
cout << max_people << endl;
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
using namespace std;
int a, b, c;
int n, r;
int main() {
while(cin >> a >> b >> c && (a|b|c)) {
cin >> n;
int br = min(min(a*a+b*b, b*b+c*c), c*c+a*a);
while(n--) {
cin >> r;
if(r*r*4 > br) {
cout << "OK" << endl;
} else {
cout << "NA" << endl;
}
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
int n;
cin >> n;
int ans=0;
for(int a=1;a<n;++a){
ans+=(n-1)/a;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
const long long INF = (long long)1e18;
int n, k, p[N], e[N];
long long f[N], a[N];
vector<int> v;
vector<int> g[N];
void add(int at, int by, long long t[]) {
while (at < N) {
t[at] += by;
at |= (at + 1);
}
}
long long query(int at, long long t[]) {
long long ret = 0;
while (at >= 0) {
ret += t[at];
at = (at & (at + 1)) - 1;
}
return ret;
}
long long ask(int from, int to, long long t[]) {
return query(to, t) - query(from - 1, t);
}
long long get(long long len) {
int low = 0;
int high = N - 1;
long long ret = 0;
while (low <= high) {
int mid = (low + high) / 2;
if (ask(0, mid, f) >= len) {
high = mid - 1;
} else {
low = mid + 1;
}
}
ret += ask(0, high, a);
len -= ask(0, high, f);
ret += low * len;
return ret;
}
int main() {
scanf("%d %d", &n, &k);
memset(a, 0, sizeof a);
memset(f, 0, sizeof f);
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i], &e[i]);
add(e[i], 1, f);
add(e[i], e[i], a);
g[p[i]].push_back(i);
}
sort(p, p + n);
k = n - k + 1;
long long ans = INF;
for (int i = 0; i <= n; i++) {
v.clear();
int cnt = lower_bound(p, p + n, i - 1) - p;
for (int j = max(0, i - 1); j <= i; j++) {
for (int k = 0; k < g[j].size(); k++) {
int at = g[j][k];
add(e[at], -1, f);
add(e[at], -e[at], a);
v.push_back(e[at]);
}
}
sort(v.begin(), v.end());
int y = 0;
int d = k - cnt;
bool ok = (cnt + v.size() >= k);
long long ss = 0;
while (ok && y < d) {
ss += v[y];
y++;
}
for (int j = y; j < v.size(); j++) {
int at = v[j];
add(at, 1, f);
add(at, at, a);
}
if (ok) {
ss += get(i - y);
ans = min(ans, ss);
}
for (int j = 0; j < y; j++) {
int at = v[j];
add(at, 1, f);
add(at, at, a);
}
}
if (ans == INF) {
puts("-1");
} else {
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
int main() {
int N;
int64 A[60];
cin >> N;
vector< int > neg2, neg1;
bool used[60] = {};
for(int i = 0; i < N; i++) {
cin >> A[i];
if(A[i] == 2) used[i] = true;
if(A[i] == -2) neg2.emplace_back(i);
else if(A[i] == -1) neg1.emplace_back(i);
}
if(neg2.size() % 2 == 1) {
if(neg1.size()) neg2.emplace_back(neg1[0]);
else neg2.pop_back();
}
for(auto &p : neg2) used[p] = true;
int ret = 0;
for(int i = 0; i < N; i++) {
if(used[i]) ++ret;
}
cout << ret << endl;
for(int i = 0; i < N; i++) {
if(used[i]) {
cout << i + 1 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, k;
int nxt[3010], pre[3010];
struct Point {
int x, y;
} p[3010];
bool cmp(Point a, Point b) { return a.y < b.y; }
vector<int> vec[3010];
int pos[3010];
int del(int x) {
nxt[pre[x]] = nxt[x];
pre[nxt[x]] = pre[x];
return pre[x];
}
int curans;
int tmp[13];
int f(int a, int b) { return (m - p[b].y + 1) * (p[a].y - p[pre[a]].y); }
void ins(int x, int y) {
nxt[y] = nxt[x];
pre[nxt[x]] = y;
pre[y] = x;
nxt[x] = y;
tmp[0] = y;
for (int i = 1; i <= k; i++) tmp[i] = nxt[tmp[i - 1]];
int s = y;
for (int i = k - 1; i >= 0; i--) {
curans -= f(s, tmp[i + 1]);
curans += f(s, tmp[i]);
s = pre[s];
}
return;
}
int main() {
scanf("%d %d %d %d", &n, &m, &cnt, &k);
long long ans = 0;
for (int i = 1; i <= cnt; i++) scanf("%d %d", &p[i].x, &p[i].y);
sort(p + 1, p + cnt + 1, cmp);
for (int i = 1; i <= cnt; i++) vec[p[i].x].push_back(i);
p[cnt + 1].y = m + 1;
for (int i = 1; i <= n; i++) {
int lst = 0;
for (int j = 1; j <= cnt; j++)
if (p[j].x >= i) {
pre[j] = lst;
nxt[lst] = j;
nxt[j] = cnt + 1;
lst = j;
}
pre[cnt + 1] = lst;
nxt[cnt + 1] = cnt + 1;
for (int j = n; j >= i; j--)
for (int u = vec[j].size(); u >= 1; u--) {
int v = vec[j][u - 1];
pos[v] = del(v);
}
curans = 0;
for (int j = i; j <= n; j++) {
for (int u = 0; u < vec[j].size(); u++) {
int v = vec[j][u];
ins(pos[v], v);
}
ans += curans;
}
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5e5 + 10;
int n, q, num_map, map_idx[maxN], res[maxN], d[maxN];
vector<pair<int, int> > queries[maxN];
vector<int> pool, adj[maxN];
unordered_map<int, int> dmap[maxN];
char s[maxN];
void add_to_pool(int idx) {
dmap[idx].clear();
pool.push_back(idx);
}
int get_from_pool() {
if (pool.empty()) pool.push_back(++num_map);
int idx = pool.back();
pool.pop_back();
return idx;
}
void dfs(int u) {
for (int v : adj[u]) {
d[v] = d[u] + 1;
dfs(v);
if (map_idx[u] == 0 || dmap[map_idx[u]].size() < dmap[map_idx[v]].size())
map_idx[u] = map_idx[v];
}
if (map_idx[u] == 0) map_idx[u] = get_from_pool();
auto& curr_map = dmap[map_idx[u]];
for (int v : adj[u]) {
if (map_idx[u] == map_idx[v]) continue;
for (auto& p : dmap[map_idx[v]]) curr_map[p.first] ^= p.second;
add_to_pool(map_idx[v]);
}
curr_map[d[u]] ^= (1 << (s[u] - 'a'));
for (auto p : queries[u]) {
res[p.second] = curr_map[p.first];
res[p.second] &= (res[p.second] - 1);
}
}
int main() {
scanf("%d %d\n", &n, &q);
for (int i = 2; i <= n; ++i) {
int p;
scanf("%d", &p);
adj[p].push_back(i);
}
scanf("\n%s\n", s + 1);
for (int i = 0; i < q; ++i) {
int v, h;
scanf("%d %d", &v, &h);
queries[v].push_back({h, i});
}
d[1] = 1;
dfs(1);
for (int i = 0; i < q; ++i) printf("%s\n", (res[i] ? "No" : "Yes"));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[4][100100], tot, cnt;
const int Maxn = 1 << 30;
struct Node {
int v, id, from;
} seq[1001000];
struct NNode {
int v[4];
void init() { v[1] = v[2] = v[3] = 3 * n; }
} whe[1001000];
struct NNNode {
int x, y;
};
set<NNNode> F;
multiset<int> sum;
bool operator<(NNNode x, NNNode y) {
return x.x < y.x || (x.x == y.x && x.y < y.y);
}
bool cmp1(Node x, Node y) { return x.v < y.v; }
bool cmp(NNode x, NNode y) { return x.v[1] > y.v[1]; }
void insert(int x) {
set<NNNode>::iterator s1, s2, s3;
NNNode inwho = (NNNode){whe[x].v[2], whe[x].v[3]};
F.insert(inwho);
s1 = F.find(inwho);
s3 = s1;
s3++;
if ((*s3).x >= (*s1).x && (*s3).y >= (*s1).y) {
F.erase(inwho);
return;
}
s2 = s1;
s2--;
s3 = s1;
s3++;
if (sum.find((*s3).y + (*s2).x) != sum.end())
sum.erase(sum.find((*s3).y + (*s2).x));
while (true) {
s1 = F.find(inwho);
s2 = s1;
s2--;
if (!((*s2).x <= (*s1).x && (*s2).y <= (*s1).y)) break;
s3 = s2;
s3--;
if (sum.find((*s2).y + (*s3).x) != sum.end())
sum.erase(sum.find((*s2).y + (*s3).x));
F.erase(s2);
}
s1 = F.find(inwho);
s3 = s1;
s3++;
sum.insert((*s1).x + (*s3).y);
s2 = s1;
s2--;
sum.insert((*s2).x + (*s1).y);
}
void work() {
sort(whe + 1, whe + cnt + 1, cmp);
F.insert((NNNode){3 * n + 2, 0});
F.insert((NNNode){0, 3 * n + 2});
sum.insert(0);
int l = 1, ans = Maxn;
for (int u = n; u >= 0; u--) {
while (whe[l].v[1] > u) insert(l), l++;
ans = min(ans, u + (*sum.begin()));
}
cout << ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
scanf("%d", &a[1][i]), seq[++tot] = (Node){a[1][i], i, 1};
for (int i = 1; i <= n; i++)
scanf("%d", &a[2][i]), seq[++tot] = (Node){a[2][i], i, 2};
for (int i = 1; i <= n; i++)
scanf("%d", &a[3][i]), seq[++tot] = (Node){a[3][i], i, 3};
sort(seq + 1, seq + tot + 1, cmp1);
a[seq[1].from][seq[1].id] = 1;
cnt++;
whe[1].init();
whe[cnt].v[seq[1].from] = min(whe[cnt].v[seq[1].from], seq[1].id);
for (int i = 2; i <= tot; i++) {
if (seq[i].v != seq[i - 1].v) cnt++, whe[cnt].init();
a[seq[i].from][seq[i].id] = cnt;
whe[cnt].v[seq[i].from] = min(whe[cnt].v[seq[i].from], seq[i].id);
}
work();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long pascal[77][77];
void fill_pascal() {
for (int n = 0; n < 77; ++n) {
pascal[n][0] = 1;
for (int k = 1; k <= n; ++k)
pascal[n][k] = pascal[n - 1][k - 1] + pascal[n - 1][k];
}
}
int main() {
fill_pascal();
long long T, N;
scanf("%I64d%I64d", &N, &T);
long long l, k;
for (l = 0; (1ll << l) < T; l++)
;
for (k = 0; (1ll << k) < N; k++)
;
if ((1ll << l) != T) {
printf("0\n");
return 0;
}
l++;
k += 2;
long long V = N + 2;
long long r = 0;
int add = 0;
for (; k >= 0; --k) {
if (V & (1ll << k)) {
if (l - add >= 0) r += pascal[k][l - add];
++add;
}
}
if (l == 1) --r;
printf("%I64d\n", r);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int64_t t = 1;
while (t--) {
vector<string> S(64);
S[0] = "0000000000000000000000000010101111110100000000000000000000000000";
S[1] = "0000000000000000000000101110101010010111110000000000000000000000";
S[2] = "0000000000000000000011101000100011010000100100000000000000000000";
S[3] = "0000000000000000011110101011111000011110101110100000000000000000";
S[4] = "0000000000000000110000001010000011110000101010110000000000000000";
S[5] = "0000000000000010011011111011101110100101100010010100000000000000";
S[6] = "0000000000000111001001000000101000111100110110110110000000000000";
S[7] = "0000000000011111101101101110111011100001100100100011100000000000";
S[8] = "0000000000111111111111000010000010001011001101101001110000000000";
S[9] = "0000000001111111111111111111101111111001111001111111111000000000";
S[10] = "0000000011111111111111111111111111111111111111111111111100000000";
S[11] = "0000000111111111111111111111111111111111111111111111111110000000";
S[12] = "0000000111111111111111111111111111111111111111111111111110000000";
S[13] = "0000001111111111111111111111111111111111111111111111111111000000";
S[14] = "0000011111111111111111111111111111111111111111111111111111100000";
S[15] = "0000011111111111111111111111111111111111111111111111111111100000";
S[16] = "0000111111111111111111111111111111111111111111111111111111110000";
S[17] = "0001111111111111111111111111111111111111111111111111111111111000";
S[18] = "0000011111111111111111111111111111111111111111111111111111111000";
S[19] = "0000000111111111111000100111111111111110001010111111111111100000";
S[20] = "0011000001111111110010001111111111111110100000001111111100000000";
S[21] = "0011110000011111000110100011111111111111101101100101100000001100";
S[22] = "0111111100000100011100111001111111111101001000110000000001111110";
S[23] = "0111111111000001001001101100011111111101101111100100001111111110";
S[24] = "0111111111111011011100000111001111111000100100001110111111111110";
S[25] = "0111111111000001000111011100011111111010111110100010010111111110";
S[26] = "1111111111110111010010010001001111110010010000110111000111111111";
S[27] = "1111111111100010010110111011101111010111011110011100010111111111";
S[28] = "1111111111101111110111100001001010000101001011110001110111111111";
S[29] = "1111111111100000100100111011100010101101101001000100100111111111";
S[30] = "1111111111110110111101101110001011100000111101011111101111111111";
S[31] = "1111111111100011100100100011101001110111100101110001000111111111";
S[32] = "1111111111111000001101110110111011000001001101100100010111111111";
S[33] = "1111111111111101101000010100001010010101101000110110111111111111";
S[34] = "1111111111110000111101010101011110110100101110011100011111111111";
S[35] = "1111111111111010010001110001111000100110000100110001111111111111";
S[36] = "1111111111111111000111000101101101101100101110100100111111111111";
S[37] = "1111111111111111110001011111100000111111100010001111111111111111";
S[38] = "0111111111111111100100001111101011111111111000100111111111111110";
S[39] = "0111111111111111111111111111111000011111111111111111111111111110";
S[40] = "0111111111111111111111111111010010111111111111111111111111111110";
S[41] = "0111111111111111111111111101000111111111111111111111111111111110";
S[42] = "0011111111111111111111111100010001111111111111111111111111111100";
S[43] = "0011111110011111111111111111110111111111111111111111111111111100";
S[44] = "0001111111010111111111111111100011111111111111111111101111111000";
S[45] = "0001111111000100011111111111001011111111111011111010000111111000";
S[46] = "0001111111010101001010001101011001010010110001100000101111111000";
S[47] = "0000111111110001100000100000001100011000000101001110111111110000";
S[48] = "0000011111110100111101111011100111000011101111101011111111100000";
S[49] = "0000011111111110100100100010111101110110100000100011111111100000";
S[50] = "0000001111111100001101101000010001010000111010001111111111000000";
S[51] = "0000000111111111011000111110110101000101100011111111111110000000";
S[52] = "0000000111111111001110010100011100010111001000111111111110000000";
S[53] = "0000000011111111100011110001110110111101111011111111111100000000";
S[54] = "0000000001111111110110000101000000100001011111111111111000000000";
S[55] = "0000000000111111111111010111101101101011001111111111110000000000";
S[56] = "0000000000011111111111110000111100001000011111111111100000000000";
S[57] = "0000000000000111111111111111111110111111111111111110000000000000";
S[58] = "0000000000000011111111111111111111111111111111111100000000000000";
S[59] = "0000000000000000111111111111111111111111111111110000000000000000";
S[60] = "0000000000000000011111111111111111111111111111100000000000000000";
S[61] = "0000000000000000000011111111111111111111111100000000000000000000";
S[62] = "0000000000000000000000111111111111111111110000000000000000000000";
S[63] = "0000000000000000000000000011111111111100000000000000000000000000";
int64_t x, y;
cin >> x >> y;
cout << (S[x][y] == '1' ? "IN" : "OUT");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100010];
string solve(int n) {
long long tot = 0;
for (int i = 0; i < n; i++) {
tot += arr[i];
}
int pos = 0;
int positive = 0;
int zeros = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > 0) positive++;
if (arr[i] == 0) zeros++;
}
if (positive == n) return "YES";
long long mx = 0;
long long cur_tot = 0;
for (int i = 1; i < n; i++) {
if ((cur_tot + arr[i]) > arr[i]) {
cur_tot += arr[i];
} else {
cur_tot = arr[i];
}
mx = max(mx, cur_tot);
}
cur_tot = 0;
long long mx2 = 0;
for (int i = 0; i < (n - 1); i++) {
if ((cur_tot + arr[i]) > arr[i]) {
cur_tot += arr[i];
} else {
cur_tot = arr[i];
}
mx2 = max(mx2, cur_tot);
}
long long mx3 = max(mx, mx2);
if (mx3 < tot) return "YES";
return "NO";
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
scanf("%d", &n);
for (int j = 0; j < n; j++) {
scanf("%lld", &arr[j]);
}
string res = solve(n);
if (res == "YES") {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 2 |
// created : 16/03/11
// author : Rp7rf
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
using namespace std;
#define rep(i,a) for(int i = 0 ; i < a ; i ++)
class Node{
public :
int location;
int p,l,r;
Node() {}
};
class Point{
public :
int id,x,y;
Point() {}
Point(int id,int x,int y): id(id),x(x),y(y){};
bool operator<(const Point &p) const{ return id < p.id; }
void print(){ printf("%d\n",id); }
};
static const int MAX=1000000;
static const int NIL=-1;
int N;
Point P[MAX];
Node T[MAX];
int np;
bool lessX(const Point &p1,const Point &p2){return p1.x < p2.x; }
bool lessY(const Point &p1,const Point &p2){return p1.y < p2.y; }
int makeKDTree(int l,int r,int depth){
if (!(l<r))return NIL;
int mid=(l+r)/2;
int t=np++;
if (depth%2==0){
sort(P+l,P+r,lessX);
}else{
sort(P+l,P+r,lessY);
}
T[t].location=mid;
T[t].l=makeKDTree(l,mid,depth+1);
T[t].r=makeKDTree(mid+1,r,depth+1);
return t;
}
void find(int v,int sx,int tx,int sy,int ty,int depth,vector<Point> &ans){
int x=P[T[v].location].x;
int y=P[T[v].location].y;
if(sx<=x&&x<=tx&&sy<=y&&y<=ty){ ans.push_back(P[T[v].location]); };
if (depth%2==0){
if(T[v].l!=NIL){
if (sx<=x) find(T[v].l,sx,tx,sy,ty,depth+1,ans);
}
if(T[v].r!=NIL){
if(x<=tx)find(T[v].r,sx,tx,sy,ty,depth+1,ans);
}
}else{
if (T[v].l!=NIL){
if(sy<=y)find(T[v].l,sx,tx,sy,ty,depth+1,ans);
}
if(T[v].r!=NIL){
if (y<=ty)find(T[v].r,sx,tx,sy,ty,depth+1,ans);
}
}
}
int main(void){
int x,y;
cin>>N;
rep(i,N){
cin>>x>>y;
P[i] = Point(i,x,y);
T[i].l=T[i].r=T[i].p=NIL;
}
np = 0;
int root=makeKDTree(0,N,0);
int q;
cin>>q;
int sx,tx,sy,ty;
vector<Point> ans;
rep(i,q){
cin>>sx>>tx>>sy>>ty;
ans.clear();
find(root,sx,tx,sy,ty,0,ans);
sort(ans.begin(),ans.end());
rep(j,ans.size())ans[j].print();
cout<<endl;
}
}
| 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stack>
using namespace std;
const int maxx = 1410;
int H, W;
int buffer[maxx][maxx];
int T[maxx][maxx];
struct Rectangle { int height; int pos; };
int getLargestRectangle(int size, int height[]) {
stack<Rectangle> S;
int maxv = 0;
// 使得栈顶元素必定大于最后元素，使得前面的值被计算进来
height[size] = 0;
for (int i = 0; i <= size; i++) {
Rectangle rect;
rect.height = height[i];
rect.pos = i;
// 当S为空
if (S.empty())
S.push(rect);
// 栈顶的高度小于当前的高度
else if (S.top().height < rect.height)
S.push(rect);
// 栈顶的高度大于当前的高度
else if (S.top().height > rect.height) {
int target = i;
// 栈顶的高度大于等于当前的高度
// 出现小于栈顶高度的代表pre.pos~i之间都存在高度为pre.height的干净瓷砖
// 此时可以计算当前的面积
while (!S.empty() && S.top().height >= rect.height) {
Rectangle pre = S.top(); S.pop();
// 长 * 宽
int area = pre.height * (i - pre.pos);
maxv = max(maxv, area);
target = pre.pos;
}
// 加上前面的宽度（下标设置为之前的），以便后面有合适的瓷砖进行计算
rect.pos = target;
S.push(rect);
}
}
return maxv;
}
int solve() {
// 以行为直方图,计算纵向的干净长度
for (int j = 0; j < W; j++) {
for (int i = 0; i < H; i++) {
if (buffer[i][j])
T[i][j] = 0;
else
T[i][j] = (i > 0) ? T[i - 1][j] + 1 : 1;
}
}
// 从行计算出当前行的最大面积
int maxv = 0;
for (int i = 0; i < H; i++)
maxv = max(maxv, getLargestRectangle(W, T[i]));
return maxv;
}
int main()
{
scanf("%d %d", &H, &W);
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
scanf("%d", &buffer[i][j]);
printf("%d\n", solve());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[101];
scanf("%s", s);
int x = 0, y = 0;
set<pair<int, int> > v;
v.insert(pair<int, int>(0, 0));
int dr[4] = {-1, 0, 1, 0}, dc[4] = {0, 1, 0, -1};
for (int i = 0; s[i]; i++) {
int px = x, py = y;
if (s[i] == 'L') x--;
if (s[i] == 'R') x++;
if (s[i] == 'D') y--;
if (s[i] == 'U') y++;
if (v.count(pair<int, int>(x, y))) {
puts("BUG");
return 0;
}
for (int k = 0; k < 4; k++) {
int xx = x + dr[k], yy = y + dc[k];
if (px == xx && py == yy) continue;
if (v.count(pair<int, int>(xx, yy))) {
puts("BUG");
return 0;
}
}
v.insert(pair<int, int>(x, y));
}
puts("OK");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 100;
const int MAXV = 100000 + 1000;
const int MAXE = 1000000 + 1000;
const int INF = 0x3f3f3f3f;
struct Edge {
int next, to, w, c;
} e[MAXE];
int p[MAXV], head[MAXV], l = 2;
void addE(int a, int b, int c, int d) {
e[l] = (Edge){p[a], b, c, d}, p[a] = l++;
e[l] = (Edge){p[b], a, 0, -d}, p[b] = l++;
}
int S, T, totp = 0;
int dis[MAXV];
bool vis[MAXV];
int flow = 0, cost = 0;
queue<int> que;
bool spfa() {
memset(dis, 63, (totp + 2) * sizeof(dis[0]));
memset(vis, 0, (totp + 2) * sizeof(vis[0]));
vis[S] = true, dis[S] = 0, que.push(S);
while (!que.empty()) {
int x = que.front();
que.pop();
vis[x] = false;
for (int i = p[x]; i; i = e[i].next)
if (e[i].w > 0 && dis[e[i].to] > dis[x] + e[i].c) {
int y = e[i].to;
dis[y] = dis[x] + e[i].c;
if (!vis[y]) que.push(y), vis[y] = true;
}
}
return dis[T] < INF;
}
int dfs(int x, int s) {
if (x == T) return s;
int ret = 0;
vis[x] = true;
for (int &i = head[x]; i; i = e[i].next)
if (e[i].w > 0 && !vis[e[i].to] && dis[e[i].to] == dis[x] + e[i].c) {
int y = e[i].to, t = dfs(y, min(s, e[i].w));
e[i].w -= t, e[i ^ 1].w += t;
s -= t, ret += t;
cost += e[i].c * t;
if (s <= 0) break;
}
vis[x] = false;
return ret;
}
void dinic() {
while (spfa()) {
memcpy(head, p, (totp + 2) * sizeof(p[0]));
flow += dfs(S, INF);
}
}
int n, m;
int a[MAXN], b[MAXN];
int id1[MAXN], id2[MAXN], id3[MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = 1, b[i] = n;
for (int i = 1; i <= m; i++) {
int t, l, r, v;
cin >> t >> l >> r >> v;
if (t == 1)
for (int j = l; j <= r; j++) a[j] = max(a[j], v);
else
for (int j = l; j <= r; j++) b[j] = min(b[j], v);
}
for (int i = 1; i <= n; i++)
if (a[i] > b[i]) {
cout << -1 << endl;
exit(0);
}
totp = 0, S = ++totp, T = ++totp;
for (int i = 1; i <= n; i++) id1[i] = ++totp;
for (int i = 1; i <= n; i++) id2[i] = ++totp;
for (int i = 1; i <= n; i++)
for (int j = a[i]; j <= b[i]; j++) id3[i][j] = ++totp;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) addE(S, id1[i], 1, 2 * j - 1);
for (int i = 1; i <= n; i++) addE(id2[i], T, 1, 0);
for (int i = 1; i <= n; i++)
for (int j = a[i]; j <= b[i]; j++) {
addE(id1[j], id3[i][j], 1, 0);
addE(id3[i][j], id2[i], 1, 0);
}
dinic();
cout << cost << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, distinct1 = 0, distinct2 = 0;
cin >> n;
int count[100] = {0};
int heap1[100] = {0};
bool decide[100];
int array[2 * 100];
bool flag = true, set = true;
for (i = 0; i < 2 * n; ++i) {
cin >> array[i];
++count[array[i]];
}
for (i = 0; i < 100; ++i) {
if (count[i] >= 2) {
distinct1++;
distinct2++;
if (count[i] & 1) {
if (set) {
decide[i] = true;
set = false;
} else {
decide[i] = false;
set = true;
}
} else
decide[i] = true;
} else if (count[i] == 1 && flag) {
distinct1++;
flag = false;
} else if (count[i] == 1 && !flag) {
distinct2++;
flag = true;
}
}
cout << distinct1 * distinct2 << "\n";
flag = false;
for (i = 0; i < 2 * n; ++i) {
if (count[array[i]] == 1 && flag) {
cout << "1 ";
flag = false;
} else if (count[array[i]] == 1 && !flag) {
cout << "2 ";
flag = true;
} else if (count[array[i]] >= 2 && decide[array[i]]) {
cout << "1 ";
decide[array[i]] = false;
} else if (count[array[i]] >= 2 && !decide[array[i]]) {
cout << "2 ";
decide[array[i]] = true;
}
}
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
template< typename T >
T mod_pow(T x, T n, const T &p) {
if(x < 0) return 0;
T ret = 1;
while(n > 0) {
if(n & 1) (ret *= x) %= p;
(x *= x) %= p;
n >>= 1;
}
return ret;
}
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;
const double eps = 1e-8;
const ll MOD = 1000000007;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
template<typename T1, typename T2>
bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template<typename T1, typename T2>
bool chmin(T1 &a, const T2 &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for(int i=0;i<((int)(v.size()));++i) {
if (i) os << " ";
os << v[i];
}
return os;
}
const int ma = 2001;
int n = 0;
ll a[ma];
ll b[ma];
ll res[ma];
void mul(ll a[ma], ll b[ma]) {
for(int i=0;i<(n);++i) {
for(int j=0;j<(n);++j) {
if(i - j < 0) break;
res[i] += a[i-j] * b[j] % MOD;
res[i] %= MOD;
}
}
for(int i=0;i<(n);++i) {
a[i] = res[i];
}
memset(res, 0, sizeof(res));
}
bool solve() {
ll d, x;
cin >> n >> d >> x;
if (n == 0) return false;
n++;
for(int i=0;i<(min(x, (ll)n));++i) a[i] = 1;
b[0] = 1;
while (d) {
if (d & 1) {
mul(b, a);
}
mul(a, a);
d >>= 1;
}
cout << b[n - 1] << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
do {
for(int i=0;i<(n);++i) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
} while(solve());
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n), b(m);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
vector<int> prev(n), next(n);
prev[0] = -1;
for (int i = 1; i < n; i++)
prev[i] = (a[i] == a[i - 1] + 1 ? prev[i - 1] : i - 1);
next[n - 1] = n;
for (int i = n - 2; i >= 0; i--)
next[i] = (a[i] + 1 == a[i + 1] ? next[i + 1] : i + 1);
vector<int> dp1(n + 1), dp2(n + 1);
for (int i = 0; i < n; i++) {
int k = 0;
dp1[i + 1] = dp2[i];
for (int j = m - 1; j >= 0; j--) {
if (b[j] <= a[i]) {
k++;
if (i - a[i] + b[j] >= 0) {
int u = prev[i - a[i] + b[j]] + 1;
dp1[i + 1] = max(dp1[i + 1], dp2[u] + k);
}
}
}
dp2[i + 1] = max(dp2[i + 1], dp2[i]);
dp2[i + 1] = max(dp2[i + 1], dp1[i + 1]);
k = 0;
for (int j = 0; j < m; j++) {
if (b[j] > a[i]) {
k++;
if (i - a[i] + b[j] < n) {
int u = next[i - a[i] + b[j]];
dp2[u] = max(dp2[u], dp1[i + 1] + k);
}
}
}
}
cout << dp2[n] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
sort(a, a + n);
if (sum % 2 == 1 || a[n - 1] > sum - a[n - 1]) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int r,g,b;
cin >> r >> g >> b;
if (((r*100+g*10+b) % 4) == 0) cout << "YES";
else cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sum[100010];
char line[100010];
stack<pair<int, int> > st;
pair<int, int> match[100010];
int main() {
scanf(" %s", line);
int n = strlen(line), m = 0;
sum[0] = 0;
for (int i = 0; i < n; i++) sum[i + 1] = sum[i] + (line[i] == '[');
for (int i = 0; i < n; i++) {
int t;
if (line[i] == '(') {
t = 0;
st.push(pair<int, int>(t, i));
} else if (line[i] == '[') {
t = 1;
st.push(pair<int, int>(t, i));
} else if (line[i] == ')') {
t = 0;
if (!st.empty() && st.top().first == t) {
match[m++] = pair<int, int>(st.top().second, i);
st.pop();
} else
while (!st.empty()) st.pop();
} else if (line[i] == ']') {
t = 1;
if (!st.empty() && st.top().first == t) {
match[m++] = pair<int, int>(st.top().second, i);
st.pop();
} else
while (!st.empty()) st.pop();
}
}
if (!m)
printf("0\n");
else {
sort(match, match + m);
int a, b, res, x, y;
res = -1;
a = match[0].first, b = match[0].second;
for (int i = 1; i < m; i++) {
if (match[i].first == b + 1)
b = match[i].second;
else if (match[i].first > b + 1) {
if (sum[b + 1] - sum[a] > res) {
res = sum[b + 1] - sum[a];
x = a;
y = b;
}
a = match[i].first;
b = match[i].second;
}
}
if (sum[b + 1] - sum[a] > res) {
res = sum[b + 1] - sum[a];
x = a;
y = b;
}
printf("%d\n", res);
for (int i = x; i <= y; i++) printf("%c", line[i]);
printf("\n");
}
}
| 3 |
#include<cstdio>
#include<iostream>
using namespace std;
typedef long long LL;
const int maxn=111111;
int A[maxn];
bool vis[maxn];
int main()
{
int N;scanf("%d",&N);
for(int i=0;i<N;++i) scanf("%d",A+i);
LL Ans=0;
for(int i=1;i<N;++i)
{
LL ans=0;
for(int j=0,k=N-1;j<N-1-i&&!vis[j]&&!vis[k]&&j!=k;j+=i,k-=i)
{
vis[j]=vis[k]=true;
ans+=(A[j]+A[k]);
Ans=max(Ans,ans);
// printf("%d %d %d %lld\n",i,j,k,ans);
}
for(int j=0,k=N-1;j<N-1-i&&vis[j]&&vis[k];j+=i,k-=i) vis[j]=vis[k]=false;
}
printf("%lld",Ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
string s;
int minn=1e9;
int main(){
cin>>s;
int n=s.size();
for(int i=0;i<n-1;i++){
if(s[i]!=s[i+1]){
minn=min(minn,max(n-i-1,i+1));
}
}
if(minn==1e9){
cout<<n;
}
else
{
cout<<minn;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.