solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int bounty, increase, damage;
int maxH[100000], startH[100000], regen[100000];
vector<pair<int, int> > updates[100000];
vector<pair<int, int> > events;
int main() {
scanf("%d %d", &n, &m);
scanf("%d %d %d", &bounty, &increase, &damage);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", maxH + i, startH + i, regen + i);
updates[i].push_back({0, startH[i]});
if (maxH[i] <= damage && increase) {
cout << -1;
return 0;
}
}
for (int i = 0; i < m; i++) {
int t, e, h;
scanf("%d %d %d", &t, &e, &h);
e--;
updates[e].push_back({t, h});
}
for (int i = 0; i < n; i++) {
sort(updates[i].begin(), updates[i].end());
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < updates[i].size(); j++) {
int t = updates[i][j].first;
int curH = updates[i][j].second;
if (curH > damage) continue;
if (!regen[i] && j == updates[i].size() - 1 && increase) {
cout << -1;
return 0;
}
int addT = !regen[i] ? 2 * (int)1e9 : ((damage - curH) / regen[i] + t);
if (j < updates[i].size() - 1)
addT = min(addT, updates[i][j + 1].first - 1);
events.push_back({t - 1, -1});
events.push_back({addT, 1});
}
}
sort(events.begin(), events.end());
reverse(events.begin(), events.end());
long long ans = 0;
long long curEnem = 0;
for (int i = 0; i < events.size(); i++) {
int t = events[i].first;
while (i < events.size() && events[i].first == t) {
curEnem += events[i].second;
i++;
}
ans = max(ans, 1ll * curEnem * (bounty + 1ll * t * increase));
i--;
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 150003, EPS = 1e-10, D = 30;
struct participant {
int p, t;
} a[N];
int n, t[N];
long long b[N], c[N], d[N];
bool Cmp(const participant& a, const participant& b) {
return (long long)a.p * b.t > (long long)b.p * a.t;
}
bool Cmpt(const int& i, const int& j) { return a[i].p < a[j].p; }
inline bool Check(double g) {
double x = 0;
std::sort(t + 1, t + 1 + n, Cmpt);
for (int i, j = 1, k, l = 1; j <= n; j++)
if (j == n || a[t[j]].p != a[t[j + 1]].p) {
for (k = l; k <= j; k++) {
i = t[k];
if (x - EPS > a[i].p * (1 - g / b[n] * d[i])) return 0;
}
for (k = l; k <= j; k++) {
i = t[k];
x = std::max(x, a[i].p * (1 - g / b[n] * c[i]));
}
l = j + 1;
}
return 1;
}
int main() {
double l = 0, r = 1, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].t);
std::sort(a + 1, a + 1 + n, Cmp);
for (int i = 1; i <= n; i++) b[i] = b[i - 1] + a[i].t;
for (int i = 1, j = 0, k; i <= n; i++)
if (i == n ||
(long long)a[i].p * a[i + 1].t != (long long)a[i + 1].p * a[i].t) {
for (k = j + 1; k <= i; k++) c[k] = b[j] + a[k].t, d[k] = b[i];
j = i;
}
for (int i = 1; i <= n; i++) t[i] = i;
for (int j = 0; j < D; j++) m = (l + r) / 2, Check(m) ? l = m : r = m;
printf("%.12lf\n", m);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> mp;
long long n, l;
vector<long long> adj[100005];
vector<pair<long long, long long>> edges;
long long timer;
vector<long long> tin, tout;
vector<vector<long long>> up;
long long ans[100005];
void dfs1(long long v, long long p) {
for (long long u : adj[v]) {
if (u != p) {
dfs1(u, v);
mp[{min(u, v), max(u, v)}] += ans[u];
ans[v] += ans[u];
}
}
}
void dfs(long long v, long long p) {
tin[v] = ++timer;
up[v][0] = p;
for (long long i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (long long u : adj[v]) {
if (u != p) dfs(u, v);
}
tout[v] = ++timer;
}
bool is_ancestor(long long u, long long v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
long long lca(long long u, long long v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (long long i = l; i >= 0; --i) {
if (!is_ancestor(up[u][i], v)) u = up[u][i];
}
return up[u][0];
}
void preprocess(long long root) {
tin.resize(n);
tout.resize(n);
timer = 0;
l = ceil(log2(n));
up.assign(n, vector<long long>(l + 1));
dfs(root, root);
}
void solve() {
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
edges.push_back({min(a, b), max(a, b)});
}
preprocess(0);
long long k;
cin >> k;
for (long long i = 0; i < k; i++) {
long long s, e;
cin >> s >> e;
s--;
e--;
ans[s]++;
ans[e]++;
ans[lca(s, e)] -= 2;
}
dfs1(0, 0);
for (long long i = 0; i < edges.size(); i++) {
cout << mp[{edges[i].first, edges[i].second}] << " ";
}
}
int32_t main() {
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long ncr(int n, int m) {
long long res = 1;
m = min(m, n - m);
for (int i = 0; i < m; i++) {
res = res * (n - i) / (i + 1);
}
return res;
}
map<long long, int> mp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x, y, z;
cin >> x >> y >> z;
long long res = 0;
for (int w = 4; w <= x; w++) {
for (int i = 1; i <= y; i++) {
if (w + i != z || w > x || i > y)
continue;
else
res += (ncr(x, w) * ncr((y), i));
}
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (1e5) + 5;
string getSum(string A, string B) {
while (A.size() < B.size()) {
A = '0' + A;
}
while (A.size() > B.size()) {
B = '0' + B;
}
int n = A.size(), carry = 0;
string ret = "";
for (int i = n - 1; i >= 0; i--) {
int a = A[i] - '0';
int b = B[i] - '0';
int x = a + b + carry;
int newChar = x % 10;
char ch = newChar + '0';
ret = ch + ret;
carry = x / 10;
}
if (carry) {
char ch = carry + '0';
ret = ch + ret;
}
return ret;
}
string str, show;
int main() {
ios::sync_with_stdio(false);
int ml, n;
cin >> n;
ml = n;
cin >> str;
show = str;
for (int i = 0; i < n; i++) {
if (str[i] != '0') ml = min(ml, max(i, n - i));
}
for (int i = 0; i < n; i++) {
if (str[i] != '0' && ml == max(i, n - i)) {
string A = str.substr(0, i);
string B = str.substr(i, n - i);
string ret = getSum(A, B);
if (ret.size() < show.size())
show = ret;
else if (ret.size() == show.size() && ret < show)
show = ret;
}
}
cout << show << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MILION = 1e6 + 5;
const int TYSIAC = 1000 + 5;
const int MILIARD = 1e9 + 7;
int t[TYSIAC][TYSIAC], n, m, q;
multiset<int> wyniczki;
int res[TYSIAC];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &t[i][j]);
}
}
for (int i = 1; i <= n; ++i) {
int ile = 0;
int result = 0;
for (int j = 1; j <= m; ++j) {
ile++;
if (t[i][j] == 0) {
ile = 0;
}
result = max(result, ile);
}
wyniczki.insert(-result);
res[i] = result;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
t[x][y] ^= 1;
int ile = 0;
int result = 0;
for (int j = 1; j <= m; ++j) {
ile++;
if (t[x][j] == 0) {
ile = 0;
}
result = max(result, ile);
}
wyniczki.erase(wyniczki.find(-res[x]));
res[x] = result;
wyniczki.insert(-result);
printf("%d\n", -(*(wyniczki.begin())));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, i, mn, mx, x, y;
int A[4], C[4], B[8];
bool L[8][8];
char str[100];
void rec(int i) {
int j, x, s;
if (i == 7) {
C[0] = C[1] = C[2] = 0;
for (j = 0; j < 7; j++) {
C[B[j]]++;
}
if (!C[0] || !C[1] || !C[2]) return;
x = max(A[0] / C[0], max(A[1] / C[1], A[2] / C[2])) -
min(A[0] / C[0], min(A[1] / C[1], A[2] / C[2]));
for (i = s = 0; i < 7; i++)
for (j = 0; j < 7; j++)
if (B[i] == B[j] && L[i][j]) s++;
if (mn == -1 || x < mn || (x == mn && s > mx)) {
mx = s;
mn = x;
}
} else
for (j = 0; j < 3; j++) {
B[i] = j;
rec(i + 1);
}
}
int f() {
scanf("%s", str);
if (!strcmp(str, "Anka"))
return 0;
else if (!strcmp(str, "Chapay"))
return 1;
else if (!strcmp(str, "Cleo"))
return 2;
else if (!strcmp(str, "Troll"))
return 3;
else if (!strcmp(str, "Dracul"))
return 4;
else if (!strcmp(str, "Snowy"))
return 5;
else
return 6;
}
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
x = f();
scanf("%s", str);
y = f();
L[x][y] = 1;
}
scanf("%d%d%d", &A[0], &A[1], &A[2]);
mn = -1;
rec(0);
printf("%d %d\n", mn, mx);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int v[10];
int mn = INT_MAX, val;
for (int i = 1; i < 10; i++) {
scanf("%d", &v[i]);
if (v[i] <= mn) {
mn = v[i];
val = i;
}
}
int mx = n / v[val];
if (mx == 0) {
printf("-1");
return 0;
}
int a[mx];
for (int i = 0; i < mx; i++) a[i] = val;
int left = n % v[val];
for (int i = 0; i < mx; i++) {
for (int j = 9; j > val; j--) {
if (v[j] <= v[val] + left) {
left = v[val] + left - v[j];
a[i] = j;
break;
}
}
}
for (int i = 0; i < mx; i++) printf("%d", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
int N, M;
bool potential_killer[MAXN];
int A[MAXN];
int its_killer[MAXN];
int its_not_killer[MAXN];
int killers_cnt = 0;
int says_who_killer = 0;
int says_who_notkiller = 0;
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) {
int a;
cin >> a;
A[i] = a;
if (a > 0) {
its_killer[a]++;
says_who_killer++;
} else {
its_not_killer[-a]++;
says_who_notkiller++;
}
}
for (int i = 1; i <= N; i++) {
int says_true = its_killer[i] + (says_who_notkiller - its_not_killer[i]);
int says_false = its_not_killer[i] + (says_who_killer - its_killer[i]);
if (says_true == M) {
killers_cnt++;
potential_killer[i] = 1;
}
}
for (int i = 1; i <= N; i++) {
if (A[i] < 0) {
if (killers_cnt == 1 && potential_killer[-A[i]]) cout << "Lie" << endl;
if (killers_cnt > 1 && potential_killer[-A[i]])
cout << "Not defined" << endl;
if (!potential_killer[-A[i]]) cout << "Truth" << endl;
} else {
if (killers_cnt == 1 && potential_killer[A[i]]) cout << "Truth" << endl;
if (killers_cnt > 1 && potential_killer[A[i]])
cout << "Not defined" << endl;
if (!potential_killer[A[i]]) cout << "Lie" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
namespace ringo {
template <class T>
inline void read(T &x) {
x = 0;
register char c = getchar();
register bool f = 0;
while (!isdigit(c)) f ^= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
}
template <class T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar('0' + x % 10);
}
template <class T>
inline void print(T x, char c) {
print(x), putchar(c);
}
const int N = 1e5 + 10, mod = 1e9 + 7;
int n, s, max, ans, a[N], f[N];
inline int dec(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int inc(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline int mul(int a, int b) {
return (long long)a * b - (long long)a * b / mod * mod;
}
inline int inv(int x) { return x < 2 ? 1 : mul(mod - mod / x, inv(mod % x)); }
void main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
s = inc(s, a[i]);
max = std::max(max, a[i]);
}
f[0] = 0, f[1] = mul(mul(dec(s, 1), dec(s, 1)), inv(s));
for (int i = 1; i < max; i++) {
f[i + 1] =
dec(dec(inc(f[i], f[i]), f[i - 1]), mul(dec(s, 1), inv(dec(s, i))));
}
for (int i = 1; i <= n; i++) {
ans = inc(ans, f[a[i]]);
}
print(ans, '\n');
}
} // namespace ringo
signed main() { return ringo::main(), 0; }
| 10 |
#include <bits/stdc++.h>
int x, y;
char in[60][60];
int block[60][60], xa[6060], xb[6060], ya[6060], yb[6060], block_size;
int fst[6000][4][2];
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int main() {
int i, j, k, l, m, n;
int a, b, tm;
int now, d1, d2;
int nx, ny;
scanf("%d%d", &x, &n);
for (i = 0; i < x; i++) scanf("%s", in[i]);
y = strlen(in[0]);
for (i = 0; i < x; i++)
for (j = 0; j < y; j++) block[i][j] = -1;
block_size = 0;
for (i = 0; i < x; i++)
for (j = 0; j < y; j++)
if (block[i][j] == -1 && in[i][j] != '0') {
for (k = i; k < x; k++)
if (in[k][j] != in[i][j]) break;
for (l = j; l < y; l++)
if (in[i][l] != in[i][j]) break;
xa[block_size] = i;
xb[block_size] = k - 1;
ya[block_size] = j;
yb[block_size] = l - 1;
for (a = i; a < k; a++)
for (b = j; b < l; b++) block[a][b] = block_size;
block_size++;
}
for (i = 0; i < block_size; i++)
for (j = 0; j < 4; j++)
for (k = 0; k < 2; k++) fst[i][j][k] = -1;
tm = 0;
now = 0;
d1 = 0;
d2 = 0;
while (tm < n) {
if (fst[now][d1][d2] >= 0) {
int step = tm - fst[now][d1][d2];
k = (n - tm - 10) / step;
if (k > 0) n -= step * k;
} else {
fst[now][d1][d2] = tm;
}
tm++;
if (d1 == 0 && d2 == 0) nx = xa[now], ny = yb[now] + 1;
if (d1 == 0 && d2 == 1) nx = xb[now], ny = yb[now] + 1;
if (d1 == 1 && d2 == 0) nx = xb[now] + 1, ny = yb[now];
if (d1 == 1 && d2 == 1) nx = xb[now] + 1, ny = ya[now];
if (d1 == 2 && d2 == 0) nx = xb[now], ny = ya[now] - 1;
if (d1 == 2 && d2 == 1) nx = xa[now], ny = ya[now] - 1;
if (d1 == 3 && d2 == 0) nx = xa[now] - 1, ny = ya[now];
if (d1 == 3 && d2 == 1) nx = xa[now] - 1, ny = yb[now];
if (nx < 0 || nx >= x || ny < 0 || ny >= y || block[nx][ny] == -1) {
if (d2 == 1) d1 = (d1 + 1) % 4;
d2 = (d2 + 1) % 2;
} else {
now = block[nx][ny];
}
}
nx = xa[now];
ny = ya[now];
printf("%d\n", (int)(in[nx][ny] - '0'));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
map<int, int> m;
for (int i = 1; i < n; i++) {
m[arr[i] - arr[i - 1]] += 1;
}
map<int, int>::iterator p;
p = m.begin();
cout << p->first << " " << p->second << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-12;
const int MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e3 + 4;
const int maxm = 1e3 + 4;
inline long long rule(long long x) { return (x %= MOD) += x < 0 ? MOD : 0; }
char s[maxn][maxn];
int n, m, K;
bool judge(int x, int y) {
return x >= 1 && x <= n && y >= 1 && y <= m && s[x][y] == '.';
}
struct State {
int x, y, d;
bool operator<(const State& rhs) const { return d > rhs.d; }
};
int dis[maxn][maxn];
int res[maxn][maxn][4];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
priority_queue<State> pq;
void dijkstra(int x, int y) {
memset(dis, 0x3f, sizeof dis);
memset(res, 0, sizeof res);
dis[x][y] = 0;
pq.push({x, y, 0});
while (pq.size()) {
State top = pq.top();
pq.pop();
int x = top.x, y = top.y, D = top.d;
if (dis[x][y] != D) continue;
for (int i = 0; i < 4; ++i) {
int nx = x + dir[i][0], ny = y + dir[i][1];
if (!judge(nx, ny)) continue;
int t = res[x][y][i];
int add = (t == 0 ? 1 : 0);
int nxt = (t == 0 ? K - 1 : t - 1);
if (dis[nx][ny] > add + dis[x][y]) {
dis[nx][ny] = add + dis[x][y];
for (int j = 0; j < 4; ++j) res[nx][ny][j] = 0;
res[nx][ny][i] = nxt;
pq.push({nx, ny, dis[nx][ny]});
} else if (dis[nx][ny] == add + dis[x][y])
res[nx][ny][i] = max(res[nx][ny][i], nxt);
}
}
return;
}
int main() {
int ik, i, j, k, kase;
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
int x, y;
scanf("%d%d", &x, &y);
dijkstra(x, y);
scanf("%d%d", &x, &y);
if (dis[x][y] == inf)
puts("-1");
else
printf("%d\n", dis[x][y]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7, K = 10, MX = 50;
vector<pair<int, int>> adj[N];
int id[K][K];
vector<int> in[N];
bool adj2[MX][MX];
int cnt[MX];
int cliques = 0;
void make_clique(vector<int> v) {
cliques++;
for (int x : v) cnt[x]++;
for (int i = 0; i < v.size(); i++)
for (int j = 0; j < i; j++) adj2[v[i]][v[j]] = adj2[v[j]][v[i]] = 1;
}
int n, m, k;
vector<vector<int>> perms;
vector<int> cur;
void gen(int x) {
if (x > k) {
perms.push_back(cur);
return;
}
cur.push_back(0);
for (int i = 1; i <= x; i++) {
cur.back()++;
gen(x + 1);
}
cur.pop_back();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
gen(1);
int sz = 0;
for (int i = 1; i <= k; i++)
for (int j = 1; j <= i; j++) id[i][j] = ++sz;
while (m--) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({w, v});
}
for (int i = 1; i <= n; i++) {
sort(adj[i].begin(), adj[i].end());
int d = adj[i].size();
for (int j = 0; j < d; j++) {
int v = adj[i][j].second;
in[v].push_back(id[d][j + 1]);
}
}
for (int v = 1; v <= n; v++) {
sort(in[v].begin(), in[v].end());
in[v].erase(unique(in[v].begin(), in[v].end()), in[v].end());
make_clique(in[v]);
}
for (int i = 1; i <= k; i++) {
vector<int> v;
for (int j = 1; j <= i; j++) v.push_back(id[i][j]);
make_clique(v);
}
int ans = 0;
for (vector<int> p : perms) {
bool bad = false;
int sum = 0;
for (int i = 0; i < p.size(); i++) {
int u = id[i + 1][p[i]];
for (int j = 0; j < i; j++) {
int v = id[j + 1][p[j]];
if (adj2[u][v]) bad = true;
}
sum += cnt[u];
}
if (sum != cliques) bad = true;
ans += !bad;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const int N = 100 + 5;
int a[N], C[N][N], d[N][N * N];
int n, K;
long long m;
int Pow(int x, long long b) {
int re = 1;
while (b) {
if (b % 2 == 1) re = (long long)re * x % mod;
x = (long long)x * x % mod;
b = b / 2;
}
return re;
}
int G1[N], G2[N];
void prepare() {
memset(C, 0, sizeof C);
for (int i = 0; i <= n; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
int v = m % n;
for (int i = 0; i <= n; ++i) {
G1[i] = Pow(C[n][i], m / n + 1);
G2[i] = Pow(C[n][i], m / n);
}
memset(d, 0, sizeof d);
memset(a, 0, sizeof a);
d[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i * n && j <= K; ++j)
for (int k = 0; k <= n && k <= j; ++k)
if (d[i - 1][j - k] > 0) {
if (i <= v)
d[i][j] =
(d[i][j] + (long long)d[i - 1][j - k] * G1[k] % mod) % mod;
else
d[i][j] =
(d[i][j] + (long long)d[i - 1][j - k] * G2[k] % mod) % mod;
}
}
void work() {
scanf("%d%I64d%d", &n, &m, &K);
prepare();
int v = m % n;
printf("%d\n", d[n][K]);
}
int main() {
work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int sum = 0;
int main() {
scanf("%d%d", &n, &x);
if (n == 2 && x == 0)
printf("NO\n");
else if (n == 1) {
printf("YES\n%d\n", x);
} else {
printf("YES\n");
for (int i = 1; i <= n - 2; i++) {
sum ^= i;
}
int mx = 300000;
if (sum == 0 || sum == x) {
sum = 0;
for (int i = 0; i < n - 2; i++) {
sum ^= i;
}
if (sum == 0 || sum == x) {
sum = 0;
for (int i = 2; i <= n - 1; i++) {
sum ^= i;
printf("%d ", i);
}
} else {
for (int i = 0; i < n - 2; i++) printf("%d ", i);
}
} else {
for (int i = 1; i <= n - 2; i++) printf("%d ", i);
}
printf("%d ", mx);
sum ^= mx;
sum ^= x;
printf("%d\n", sum);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
const int bsize = 300;
struct block {
vector<int> d;
int min_val;
block* next;
void recalc() {
min_val = 2e9;
for (auto i : d) {
min_val = min(min_val, i);
}
}
block(vector<int> a) {
d = a;
next = 0;
recalc();
}
};
int a[arr];
block* first = 0;
block* last = 0;
void rebuild() {
vector<int> all_a(0);
block* cur1 = first;
while (cur1) {
for (auto i : cur1->d) {
all_a.push_back(i);
}
cur1 = cur1->next;
}
first = 0;
vector<int> cur(0);
for (auto i : all_a) {
cur.push_back(i);
if (cur.size() == bsize) {
block* current = new block(cur);
if (last) {
last->next = current;
}
last = current;
if (!first) {
first = last;
}
cur.clear();
}
}
if (!cur.empty()) {
block* current = new block(cur);
if (last) {
last->next = current;
}
last = current;
if (!first) {
first = last;
}
cur.clear();
}
}
void debug_all() {
block* cur1 = first;
while (cur1) {
for (auto i : cur1->d) {
cerr << i << " ";
}
cur1 = cur1->next;
cerr << "|| ";
}
cerr << "\n";
}
int main() {
"" != "" ? freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout)
: 0;
"" != "" ? freopen(
""
".dat",
"r", stdin),
freopen(
""
".sol",
"w", stdout)
: 0;
int n;
scanf("%d", &n);
vector<int> cur(0);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
cur.push_back(a[i]);
if (cur.size() == bsize) {
block* current = new block(cur);
if (last) {
last->next = current;
}
last = current;
if (!first) {
first = last;
}
cur.clear();
}
}
if (!cur.empty()) {
block* current = new block(cur);
if (last) {
last->next = current;
}
last = current;
if (!first) {
first = last;
}
cur.clear();
}
sort(a, a + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i % bsize == 0) {
rebuild();
}
int cnt = 0;
block* cur = first;
while (cur->min_val != a[i]) {
cnt += cur->d.size();
cur = cur->next;
}
for (int j = 0; j < cur->d.size(); j++) {
cnt++;
if (cur->d[j] == a[i]) {
ans += cnt;
cur->d.erase(cur->d.begin() + j);
vector<int> right(0);
for (int k = j; k < cur->d.size(); k++) {
right.push_back(cur->d[k]);
}
while (cur->d.size() > j) {
cur->d.pop_back();
}
block* current = new block(right);
last->next = first;
current->next = cur->next;
cur->next = current;
first = current;
last = cur;
cur->next = 0;
cur->recalc();
current->recalc();
break;
}
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
pair<int, int> eve[maxn];
int dp[1 << 10], num[1 << 10]{0};
int pos[maxn];
set<int> st;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
m = 0;
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
eve[m++] = pair<int, int>{l, i};
eve[m++] = pair<int, int>{r + 1, -i};
}
sort(eve, eve + m);
for (int i = 0; i < (1 << k); i++) {
dp[i] = -inf;
num[i] = num[i >> 1] ^ (i & 1);
}
for (int i = 0; i < k; i++) st.insert(i);
int pre = 0;
dp[0] = 0;
for (int i = 0; i < m; i++) {
int x = eve[i].first, is = eve[i].second;
for (int j = 0; j < (1 << k); j++) dp[j] = dp[j] + (x - pre) * num[j];
if (is > 0) {
int p = *st.begin();
st.erase(p);
pos[is] = p;
for (int j = 0; j < (1 << k); j++) {
if (!(j & (1 << p))) {
dp[j | (1 << p)] = max(dp[j | (1 << p)], dp[j]);
}
}
} else {
int p = pos[-is];
st.insert(p);
for (int j = 0; j < (1 << k); j++) {
if (j & (1 << p)) {
dp[j ^ (1 << p)] = max(dp[j ^ (1 << p)], dp[j]);
dp[j] = -inf;
}
}
}
pre = x;
}
cout << dp[0] << endl;
}
| 8 |
#include <bits/stdc++.h>
constexpr int P = 998244353;
struct P2 {
int x, y;
P2(int x, int y) : x(x), y(y) {}
friend P2 operator*(const P2 &a, const P2 &b) {
return P2((1ll * a.x * b.x + 1ll * a.y * b.y) % P,
(1ll * a.x * b.y + 1ll * a.y * b.x) % P);
}
};
P2 power(P2 base, long long e) {
P2 res(1, 0);
while (e > 0) {
if (e % 2 == 1) res = res * base;
base = base * base;
e /= 2;
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m, L, R;
std::cin >> n >> m >> L >> R;
R = R - L + 1;
if (n % 2 == 0 || m % 2 == 0) {
std::cout << power(P2(R / 2, R - R / 2), 1ll * n * m).x << "\n";
} else {
std::cout << power(P2(R, 0), 1ll * n * m).x << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int read() {
register int n = 0;
bool b = 0;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
b = 1;
}
}
for (; isdigit(c); c = getchar()) {
n = 10 * n + (c - 48);
}
return b ? -n : n;
}
void fail() {
printf("-1\n");
exit(0);
}
int main() {
int N = read(), M = read();
std::vector<std::vector<int>> refs(N + 10, std::vector<int>());
std::vector<int> vals(N + 10);
for (int i = 1; i <= M; ++i) {
int from = read(), to = read();
refs[to].push_back(from);
refs[from].push_back(to);
}
for (int i = 1; i <= N; ++i) {
vals[i] = read();
}
std::vector<int> idx(N);
std::iota(idx.begin(), idx.end(), 1);
auto comp = [&](const int lhs, const int rhs) {
return vals[lhs] < vals[rhs];
};
std::stable_sort(begin(idx), end(idx), comp);
const int MAXK = 500010;
bool done[MAXK];
memset(done, 0, MAXK);
for (int t = 1, i = idx[t - 1]; t <= N; ++t, i = idx[t - 1]) {
done[i] = 1;
int target = vals[i];
std::vector<bool> conn(target + 5);
for (auto ref : refs[i]) {
if (done[ref]) {
if (vals[ref] == target) {
fail();
} else if (vals[ref] < target) {
conn[vals[ref]] = 1;
}
}
}
for (int j = 1; j < target; ++j) {
if (!conn[j]) {
fail();
}
}
}
for (int i = 0; i < N; ++i) {
printf("%d ", idx[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
int lou, dian, tl, ans, temp, sum;
lou = abs((x - y)) * t1;
dian = abs((x - y)) * t2 + abs((x - z)) * t2 + 3 * t3;
if (dian <= lou) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int num[N] = {};
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> num[i];
stack<int> ans;
vector<int> ans1;
for (int i = n - 1; i >= 0; i--) {
while (!ans.empty() && num[ans.top()] < num[i]) {
ans1.push_back(num[ans.top()] ^ num[i]);
ans.pop();
}
if (!ans.empty()) ans1.push_back(num[ans.top()] ^ num[i]);
ans.push(i);
}
sort(ans1.begin(), ans1.end());
cout << ans1[ans1.size() - 1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, cap;
vector<pair<int, int> > bus;
int sol[100050];
inline int depart(int t) {
sort(bus.begin(), bus.end());
int d = 0;
int j;
for (int i = 0; i < (int)bus.size(); i = j) {
int x = bus[i].first;
for (j = i; j < (int)bus.size() && bus[j].first == x; j++) {
int v = bus[j].second;
sol[v] = t + x + d;
}
int c = j - i;
d += 1 + c / 2;
}
return d + 2 * bus.back().first;
}
int main(void) {
scanf("%d %d", &n, &cap);
int t = 0;
for (int i = 0; i < n; i++) {
int x, t2;
scanf("%d %d", &t2, &x);
if (t2 > t) t = t2;
bus.push_back(make_pair(x, i));
if ((i + 1) % cap == 0 || i == n - 1) {
t += depart(t);
bus.clear();
}
}
for (int i = 0; i < n; i++) printf("%d%c", sol[i], i < n - 1 ? ' ' : '\n');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int A[n];
for (i = 0; i < n; i++) cin >> A[i];
while (clock() < 1400) sort(A, A + n);
for (int i = 0; i < n; i++) cout << A[i] << " ";
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, s = 1, i, maxa = 0;
cin >> n;
long long k, b[100001];
for (i = 0; i < n; i++) {
b[i] = 0;
}
for (i = 1; i <= n; i++) {
cin >> k;
b[k] += k;
maxa = max(maxa, k);
}
long long dp[100001];
dp[0] = b[0];
dp[1] = b[1];
for (i = 2; i <= 100000; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + b[i]);
}
cout << dp[100000];
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
long long n;
long long ans[23333] = {1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0};
int main() {
cin >> n;
cout << ans[n - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int e = 5e5 + 100;
int n, m, a[e], ton1[e], cnt[e], cnx[e], b[e], s[e], mm[e * 2];
int main() {
cin >> n;
int maxn = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ton1[a[i]]++;
maxn = ((maxn) > (ton1[a[i]]) ? (maxn) : (ton1[a[i]]));
}
int pd = 0;
for (int i = 1; i <= n; i++) {
if (pd != 0 and ton1[i] == maxn) {
cout << n;
return 0;
}
if (ton1[i] == maxn) {
pd = i;
}
}
int k = sqrt(n), ans = 0;
for (int i = 1, lim = ((k) < (ton1[pd]) ? (k) : (ton1[pd])); i <= lim; i++) {
int l = 0, r = 0, mxcn = 0;
memset(cnx, 0, sizeof(cnx));
memset(cnt, 0, sizeof(cnt));
cnx[0] = n;
while (r <= n) {
for (; cnt[pd] <= i and r <= n;) {
if (cnx[mxcn] > 1) ans = ((ans) > (r - l) ? (ans) : (r - l));
r++;
cnx[cnt[a[r]]]--;
cnt[a[r]]++;
mxcn = ((mxcn) > (cnt[a[r]]) ? (mxcn) : (cnt[a[r]]));
cnx[cnt[a[r]]]++;
}
for (; cnt[pd] > i and l <= r;) {
++l;
cnx[cnt[a[l]]]--;
if (cnt[a[l]] == mxcn and cnx[cnt[a[l]]] == 0) mxcn--;
cnt[a[l]]--;
cnx[cnt[a[l]]]++;
}
}
}
for (int i = 1; i <= n; i++) {
if (i == pd) continue;
if (ton1[i] > k) {
memset(mm, 0x3f, sizeof(mm));
mm[e] = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == i) {
b[j] = -1;
} else if (a[j] == pd) {
b[j] = 1;
} else
b[j] = 0;
s[j] = s[j - 1] + b[j];
mm[s[j] + e] = ((mm[s[j] + e]) < (j) ? (mm[s[j] + e]) : (j));
ans = ((ans) > (j - mm[s[j] + e]) ? (ans) : (j - mm[s[j] + e]));
}
}
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
int j = 1;
int num = 1;
int MAX = 1;
for (int i = 0; i < n; ++i) {
for (; j < n; ++j) {
if (a[i] * 2 >= a[j]) {
num++;
MAX = MAX > num ? MAX : num;
} else {
num--;
j--;
if (j == i) {
j = i + 2;
num = 1;
}
break;
}
}
}
cout << MAX;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, first, second, z, p;
cin >> n >> m >> first >> second >> z >> p;
vector<pair<int, int> > a(p);
for (int i = 0; i < p; i++) {
cin >> a[i].first >> a[i].second;
a[i].first -= 1;
a[i].second -= 1;
}
first %= 4;
second %= 2;
z %= 4;
for (int j = 0; j < first; j++) {
for (int i = 0; i < p; i++) {
int orgX = a[i].first, orgY = a[i].second;
a[i].first = orgY;
a[i].second = n - 1 - orgX;
}
swap(n, m);
}
for (int i = 0; i < p; i++) {
if (second == 1) {
a[i].second = abs(a[i].second - m + 1);
}
}
for (int j = 0; j < z; j++) {
for (int i = 0; i < p; i++) {
int orgX = a[i].first, orgY = a[i].second;
a[i].first = m - 1 - orgY;
a[i].second = orgX;
}
swap(n, m);
}
for (int i = 0; i < p; i++) {
cout << a[i].first + 1 << " " << a[i].second + 1 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p[100010], q[100010], ans[100010];
bool foo;
int main() {
scanf("%d %d", &n, &m);
double st = clock();
mt19937 rnd(time(0) * 233);
if (n > m) swap(n, m), foo = 1;
if (m >= 4) {
iota(q + 1, q + m + 1, 1);
while (1) {
shuffle(q + 1, q + m + 1, rnd);
bool flag = 1;
for (int i = 1; i < m && flag; i++) {
flag &= (abs(q[i + 1] - q[i]) != 1);
}
if (flag) break;
}
for (int i = 1; i <= m; i++) {
ans[i] = q[i];
}
for (int i = 2; i <= n; i++) {
iota(p + 1, p + m + 1, (i - 1) * m + 1);
while (1) {
shuffle(p + 1, p + m + 1, rnd);
bool flag = 1;
for (int i = 1; i <= m && flag; i++) {
flag &= (abs(p[i] - q[i]) != m);
if (i < m) flag &= (abs(p[i] - p[i + 1]) != 1);
}
if (flag) break;
}
copy(p + 1, p + m + 1, q + 1);
for (int j = 1; j <= m; j++) {
ans[(i - 1) * m + j] = q[j];
}
}
printf("YES\n");
if (!foo) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", ans[(i - 1) * m + j]);
}
printf("\n");
}
} else {
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
int x = ans[(i - 1) * m + j];
int r = (x - 1) / m + 1, c = (x - 1) % m + 1;
printf("%d ", (c - 1) * n + r);
}
printf("\n");
}
}
exit(0);
}
iota(p + 1, p + n * m + 1, 1);
shuffle(p + 1, p + n * m + 1, rnd);
while (1) {
if ((clock() - st) / CLOCKS_PER_SEC > 0.1) printf("NO\n"), exit(0);
shuffle(p + 1, p + n * m + 1, rnd);
bool flag = 1;
auto chk = [&](int x, int y) {
if (abs(x - y) == m) return 0;
if (abs(x - y) < m && abs((x - 1) % m - (y - 1) % m) == 1) return 0;
return 1;
};
for (int i = 1; i <= n && flag; i++) {
for (int j = 1; j <= m && flag; j++) {
if (j > 1) flag &= chk(p[(i - 1) * m + j], p[(i - 1) * m + j - 1]);
if (i > 1) flag &= chk(p[(i - 1) * m + j], p[(i - 2) * m + j]);
}
}
if (!flag) continue;
printf("YES\n");
if (!foo) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", p[(i - 1) * m + j]);
}
printf("\n");
}
} else {
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
int x = p[(i - 1) * m + j];
int r = (x - 1) / m + 1, c = (x - 1) % m + 1;
printf("%d ", (c - 1) * n + r);
}
printf("\n");
}
}
exit(0);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const long long MAXQ = 1e9 + 7;
struct point {
long long x, r, q;
} Q[MAXN];
bool cmp(point &a, point &b) { return a.r > b.r; }
map<long long, int> mp;
int tot = 0;
int ls[MAXN * 40];
int rs[MAXN * 40];
int sum[MAXN * 40];
void update(int L, long long l, long long r, int &rt) {
if (rt == 0) rt = ++tot;
if (l == r) {
sum[rt]++;
return;
}
long long m = (l + r) / 2;
if (L <= m)
update(L, l, m, ls[rt]);
else
update(L, m + 1, r, rs[rt]);
sum[rt] = sum[ls[rt]] + sum[rs[rt]];
}
int query(int L, int R, long long l, long long r, int rt) {
if (rt == 0) return 0;
if (L <= l && r <= R) return sum[rt];
long long m = (l + r) / 2;
int ans = 0;
if (L <= m) ans += query(L, R, l, m, ls[rt]);
if (R > m) ans += query(L, R, m + 1, r, rs[rt]);
return ans;
}
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 0; i < N; i++) scanf("%lld%lld%lld", &Q[i].x, &Q[i].r, &Q[i].q);
sort(Q, Q + N, cmp);
long long ans = 0;
for (int i = 0; i < N; i++) {
for (long long j = Q[i].q - K; j <= Q[i].q + K; j++) {
if (!mp[j]) continue;
ans = ans + query(max(0ll, Q[i].x - Q[i].r), min(MAXQ, Q[i].x + Q[i].r),
0, MAXQ, mp[j]);
}
update(Q[i].x, 0, MAXQ, mp[Q[i].q]);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n;
int X[100 + 9];
char str[100 + 9];
int pwr(int x, int n) {
if (n == 0) return 1;
if (n % 2 == 1)
return 1LL * x * pwr(x, n - 1) % (1000000007);
else
return pwr(1LL * x * x % (1000000007), n / 2);
}
int rec(int i = 0, int dep = 1) {
if (i == n) return 0;
int ret = 0;
if (X[i] == 1) {
ret += 1LL * pwr(2, 2 * (n - 1 - i)) * dep % (1000000007);
}
ret += rec(i + 1, dep * 2 % (1000000007));
ret %= (1000000007);
return ret;
}
int main() {
read_file();
while (scanf("%s", str) != EOF) {
n = strlen(str);
for (int i = 0; i < n; i++) X[i] = str[i] - '0';
int ans;
ans = rec();
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char bf[100];
char mp[2][100];
bool build(int a, int b) {
if (bf[a] != bf[b]) return false;
if (b == 26) reverse(bf, bf + a);
int d = b - a;
int col = (d + 1) / 2;
int pos;
pos = a;
int i;
for (i = col - 1; i >= 0; i--) {
mp[0][i] = bf[pos++];
}
for (i = 0; pos < b; i++) {
mp[1][i] = bf[pos++];
}
int tmp = i;
pos = (b + 1) % 27;
for (i = col; i < 13; i++) {
mp[0][i] = bf[pos];
pos = (pos + 1) % 27;
}
for (i = 12; i >= tmp; i--) {
mp[1][i] = bf[pos];
pos = (pos + 1) % 27;
}
return true;
}
int main() {
scanf("%s", bf);
bool find = false;
for (int i = 0; i < 27 && !find; i++)
for (int j = i + 2; j < 27 && !find; j++) {
find = build(i, j);
}
if (find) {
printf("%s\n%s\n", mp[0], mp[1]);
} else
printf("Impossible\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
int act_pos[26], prime_no[1050], included[1050], a[26];
char t[1050];
int main() {
char s[1050];
int pos2 = 0, char_to_int, i, j;
scanf("%s", s);
int k = strlen(s);
if (k == 1) {
printf("YES\n");
printf("%s", s);
return 0;
}
for (i = 0; i < k; i++) {
char_to_int = s[i] - 97;
a[char_to_int]++;
}
int max = a[0];
for (i = 0; i < 26; i++) {
if (max < a[i]) {
max = a[i];
pos2 = i;
}
}
int b[k + 1], m = 0;
for (i = 2; i <= k; i++) {
if (!prime_no[i] && i * 2 <= k) {
included[i - 1] = 1;
b[m++] = i - 1;
for (j = i + 1; j <= k; j++) {
if (j % i == 0) {
prime_no[j] = 1;
if (!included[j - 1]) {
included[j - 1] = 1;
b[m++] = j - 1;
}
}
}
}
}
if (max < m) {
printf("NO");
return 0;
}
printf("YES\n");
char c = (char)pos2 + 97;
for (i = 0; i < m; i++) t[b[i]] = c;
j = 0;
int time = 0;
i = 0;
while (i < k) {
if (t[j] == '\0') {
while (s[i] == c && ++time <= m && i < k) i++;
if (i < k) {
t[j] = s[i];
j++;
i++;
}
} else {
while (t[j] != '\0') j++;
}
}
for (i = 0; i < k; i++) printf("%c", t[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[110], b[110];
int p[110];
void work(int x) {
if (x == 1)
p[0] = 1;
else if (x == 2) {
p[0] = 3;
p[1] = 4;
} else {
if (x & 1) {
p[x - 1] = (x / 2 + 1);
p[x - 2] = 2;
for (int i = 0; i < x - 2; i++) p[i] = 1;
} else {
for (int i = 0; i < x - 1; i++) p[i] = 1;
p[x - 1] = (x / 2 - 1);
}
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
work(n);
for (int i = 0; i < n; i++) a[i] = p[i];
work(m);
for (int i = 0; i < m; i++) b[i] = p[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d ", a[i] * b[j]);
puts("");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
vector<string> v(n);
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
vector<long long int> row(n, 0);
vector<long long int> col(n, 0);
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (v[i][j] == '.') {
row[i] = 1;
col[j] = 1;
}
}
}
long long int s = 0;
for (long long int i = 0; i < n; i++) {
if (row[i]) {
s++;
}
}
if (s == n) {
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (v[i][j] == '.') {
cout << (i + 1) << " " << (j + 1) << endl;
break;
}
}
}
return 0;
}
s = 0;
for (long long int i = 0; i < n; i++) {
if (col[i]) {
s++;
}
}
if (s == n) {
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (v[j][i] == '.') {
cout << (j + 1) << " " << (i + 1) << endl;
break;
}
}
}
return 0;
}
cout << "-1" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
char s1[1000010], s2[1000010];
int main() {
scanf("%s", s1);
scanf("%s", s2);
const int len1 = strlen(s1);
int j = 0, differencesCount = 0;
int differenceIndex;
for (int i = 0; i < len1; i += 1) {
if (s1[i] == s2[j]) {
j += 1;
} else {
differenceIndex = i;
differencesCount += 1;
}
}
if (differencesCount > 1) {
printf("0");
return 0;
}
int ans = 0;
for (int i = differenceIndex - 1; i >= 0; i -= 1) {
if (s1[i] == s1[differenceIndex]) {
ans += 1;
} else {
break;
}
}
printf("%d\n", ans + 1);
for (int i = differenceIndex - ans; i <= differenceIndex; i += 1) {
printf("%d ", i + 1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const long long int maxn = 100010;
const long long int maxnlg = 20;
long long int n, m;
vector<pair<long long int, long long int> > g[maxn];
bool mon[maxn];
pair<long long int, long long int> down[maxn], up[maxn];
long long int ps[maxn];
long long int st[maxn], ft[maxn], pars[maxnlg][maxn];
long long int tim = 0;
void dfs_down(long long int x, long long int par) {
st[x] = tim++;
pars[0][x] = par;
for (long long int i = (0); i < (maxnlg - 1); ++i) {
pars[i + 1][x] = pars[i][pars[i][x]];
}
down[x] = {mon[x] ? 0 : -BIG, x};
for (auto y : g[x]) {
long long int v = y.first, w = y.second;
if (v == par) continue;
dfs_down(v, x);
if (down[v].first + w > down[x].first) {
down[x] = {down[v].first + w, down[v].second};
} else if (down[v].first + w == down[x].first) {
down[x].second = x;
}
}
ft[x] = tim;
}
void dfs_up(long long int x, long long int par) {
vector<pair<pair<long long int, long long int>, long long int> > vals;
vals.push_back({up[x], -1});
vals.push_back({{mon[x] ? 0 : -BIG, x}, x});
for (auto y : g[x]) {
long long int v = y.first, w = y.second;
if (v == par) continue;
vals.push_back({{down[v].first + w, down[v].second}, v});
}
sort((vals).begin(), (vals).end(),
greater<pair<pair<long long int, long long int>, long long int> >());
long long int valn = vals.size();
long long int mxc = 0;
while (mxc < valn && vals[mxc].first.first == vals[0].first.first) ++mxc;
for (auto y : g[x]) {
long long int v = y.first, w = y.second;
if (v == par) continue;
if (mxc == 1 && v == vals[0].second) {
up[v].first = vals[1].first.first + w;
if (vals[1].first.first == vals[2].first.first)
up[v].second = x;
else
up[v].second = vals[1].first.second;
} else if (mxc == 2 && v == vals[0].second) {
up[v] = {vals[1].first.first + w, vals[1].first.second};
} else if (mxc == 1 || mxc == 2 && v == vals[1].second) {
up[v] = {vals[0].first.first + w, vals[0].first.second};
} else {
up[v] = {vals[0].first.first + w, x};
}
dfs_up(v, x);
}
}
long long int LCA(long long int a, long long int b) {
if (st[a] > st[b]) swap(a, b);
if (ft[a] >= ft[b]) return a;
for (long long int i = (maxnlg)-1; i >= (0); --i) {
if (ft[pars[i][a]] < ft[b]) {
a = pars[i][a];
}
}
return pars[0][a];
}
void dfs_cnt(long long int x, long long int par) {
for (auto y : g[x]) {
long long int v = y.first;
if (v != par) {
dfs_cnt(v, x);
ps[x] += ps[v];
}
}
}
void MAIN() {
cin >> n >> m;
for (long long int i = (0); i < (m); ++i) {
long long int x;
cin >> x;
--x;
mon[x] = true;
}
for (long long int i = (0); i < (n - 1); ++i) {
long long int a, b, c;
cin >> a >> b >> c;
--a, --b;
g[a].emplace_back(b, c), g[b].emplace_back(a, c);
}
dfs_down(0, 0);
up[0] = {-BIG, -1};
dfs_up(0, -1);
pars[0][0] = n;
for (long long int x = (0); x < (n); ++x) {
if (!mon[x]) continue;
if (down[x].first > up[x].first) {
ps[down[x].second]++;
ps[x]--;
}
if (up[x].first > down[x].first) {
ps[x]++;
ps[up[x].second]++;
long long int lca = LCA(x, up[x].second);
ps[lca]--;
ps[pars[0][lca]]--;
}
}
dfs_cnt(0, 0);
long long int mx = 0;
long long int cnt = 0;
for (long long int i = (0); i < (n); ++i) {
if (mon[i]) continue;
if (ps[i] > mx)
mx = ps[i], cnt = 1;
else if (ps[i] == mx)
++cnt;
}
cout << mx << ' ' << cnt;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
8 5
7 2 5 4 8
1 2 1
2 3 2
1 4 1
4 5 2
1 6 1
6 7 8
6 8 10
)";
MAIN();
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
bool v[100000];
int len, ps[100000];
void Sieve() {
for (int i = 2; i < 100000; i += 2) ps[i] = 2;
for (int i = 3; i < 100000; i += 2) {
if (!v[i]) {
ps[i] = i;
for (int j = i; (j * i) < 100000; j += 2) {
if (!v[j * i]) v[j * i] = true, ps[j * i] = i;
}
}
}
}
int CEIL(int num, int den) {
int res = num / den;
if (num % den) res++;
return res;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int bin1(int x) {
int r = 0;
while (x) {
r++;
x &= x - 1;
}
return r;
}
int exgcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int x1, y1, gcd = exgcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
int power(int b, int e) {
if (e == 0) return 1;
if (e % 2 == 0) return power(b * b, e / 2);
return b * power(b * b, e / 2);
}
double powerf(double b, int e) {
if (e == 0) return 1;
if (e % 2 == 0)
return powerf(b * b, e / 2);
else {
if (e > 0)
return b * powerf(b * b, e / 2);
else
return powerf(b * b, e / 2) / b;
}
}
int modpow(int b, int e, int m) {
int r = 1;
b = b % m;
while (e > 0) {
if (e % 2 == 1) r = (r * b) % m;
e /= 2;
b = (b * b) % m;
}
return r;
}
int modinverse(int a, int mod) { return modpow(a, mod - 2, mod); }
int modinverse2(int a, int m) {
int x, y;
exgcd(a, m, x, y);
while (x < 0) x += m;
return x;
}
int nCrmod(int n, int r, int m) {
if (r > n) r = n - r;
int res = 1;
for (int i = r; i >= 1; i--) {
res = (res * (n - i + 1)) % m;
res = (res * modinverse(i, m));
}
return res;
}
int nCr(int n, int r) {
if (r > n) r = n - r;
int res = 1;
for (int i = r; i >= 1; i--) {
res *= (n - i + 1);
res /= i;
}
return res;
}
int totient(int n) {
int res = n, p;
for (p = 2; p * p <= n; p++) {
if (n % p == 0) {
while (n % p == 0) n /= p;
res -= res / p;
}
}
if (n > 1) res -= res / n;
return res;
}
bool isprime(int x) {
if (x == 1) return false;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
bool isvowel(char c) {
if (isupper(c)) c = tolower(c);
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
bool istriangle(int a, int b, int c) {
return (a + b > c) && (a + c > b) && (b + c > a);
}
int stringmod(string s, int mod) {
int res = 0;
for (unsigned int i = 0; i < s.size(); i++)
res = (res * 10 + s[i] - '0') % mod;
return res;
}
int powinfact(int n, int p) {
int res = 0, pw = p;
while (n >= pw) {
res += (n / pw);
pw *= p;
}
return res;
}
vector<vector<int> > matrixmultiply(vector<vector<int> > A,
vector<vector<int> > B, int n) {
vector<vector<int> > C(2, vector<int>(n));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) C[i][j] = (C[i][j] + A[i][k] * B[k][j]);
return C;
}
vector<vector<int> > modmatrixmultiply(vector<vector<int> > A,
vector<vector<int> > B, int n, int mod) {
vector<vector<int> > C(2, vector<int>(n));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % mod;
return C;
}
vector<vector<int> > powermatrix(vector<vector<int> > A, int exp, int n) {
if (exp == 1) return A;
if (exp % 2) return matrixmultiply(A, powermatrix(A, exp - 1, n), n);
vector<vector<int> > X = powermatrix(A, exp / 2, n);
return matrixmultiply(X, X, n);
}
vector<vector<int> > modpowmatrix(vector<vector<int> > A, int exp, int n,
int mod) {
if (exp == 1) return A;
if (exp % 2)
return modmatrixmultiply(A, modpowmatrix(A, exp - 1, n, mod), n, mod);
vector<vector<int> > X = modpowmatrix(A, exp / 2, n, mod);
return modmatrixmultiply(X, X, n, mod);
}
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
void pre() {}
void judge() {
int t, k, s = 0, i, j, temp, num;
cin >> num;
t = 0;
for (int i = 0; i < num; i++) {
cin >> k;
if (k > t) t = k;
}
if (t > 25)
cout << t - 25;
else
cout << "0";
}
void gcj() {
freopen("B-large.in", "r", stdin);
freopen("B-large-output.out", "w", stdout);
int t;
cin >> t;
for (int c = 1; c <= t; c++) {
cout << "Case #" << c << ": ";
judge();
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pre();
int tt = 1;
while (tt--) {
judge();
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[(1 << 21) + 3], b[(1 << 21) + 3];
void FWT(long long* A, int len) {
for (int mid = 2; mid <= len; mid <<= 1)
for (int i = 0; i < len; i += mid)
for (int j = i; j < i + (mid >> 1); ++j) A[j + (mid >> 1)] += A[j];
}
void IFWT(long long* A, int len) {
for (int mid = 2; mid <= len; mid <<= 1)
for (int i = 0; i < len; i += mid)
for (int j = i; j < i + (mid >> 1); ++j) A[j + (mid >> 1)] -= A[j];
}
long long bit[(1 << 21) + 3];
void solve() {
cin >> n;
n = (1 << n);
int pr;
for (int i = (0), iend = (n - 1); i <= iend; ++i)
bit[i] = (1ll << 2 * __builtin_popcount(i));
for (int i = (0), iend = (n - 1); i <= iend; ++i)
scanf("%1d", &pr), a[i] = pr * bit[i];
for (int i = (0), iend = (n - 1); i <= iend; ++i)
scanf("%1d", &pr), b[i] = pr * bit[i];
FWT(a, n), FWT(b, n);
for (int i = (0), iend = (n - 1); i <= iend; ++i) a[i] = a[i] * b[i];
IFWT(a, n);
for (int i = (0), iend = (n - 1); i <= iend; ++i)
pr = (a[i] / bit[i]) & 3, printf("%d", pr);
}
signed main() { solve(); }
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n;
long long a[N], b[N];
vector<long long> primeDiv;
void addDivisor(long long x) {
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
while (x % i == 0) x /= i;
primeDiv.push_back(i);
}
}
if (x > 1) primeDiv.push_back(x);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i];
addDivisor(a[1]);
addDivisor(b[1]);
for (long long d : primeDiv) {
bool flag = true;
for (long long i = 2; i <= n; i++) {
if (a[i] % d != 0 and b[i] % d != 0) {
flag = false;
break;
}
}
if (flag) {
cout << d;
return 0;
}
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long double PI = 4 * atan((long double)1);
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a *= a;
n /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
long long int a[n];
for (int i = (0); i < (n); ++i) cin >> a[i];
long long int dp[n][2];
for (int i = (0); i < (n); ++i) dp[i][1] = INT_MIN;
dp[n - 1][0] = 1;
for (int i = n - 2; i >= 0; i--) {
if (a[i] < a[i + 1]) {
dp[i][0] = dp[i + 1][0] + 1;
if (dp[i + 1][1] != INT_MIN) dp[i][1] = dp[i + 1][1] + 1;
} else {
if (i != n - 2 && i != 0 && a[i + 2] - a[i] > 1) {
dp[i][0] = 1;
dp[i][1] = dp[i + 1][0] + 1;
} else if (i == 0) {
dp[i][0] = 1;
dp[i][1] = dp[i + 1][0] + 1;
} else if (i == n - 2) {
dp[i][0] = 1;
dp[i][1] = dp[i + 1][0] + 1;
} else {
if (a[i + 1] - a[i - 1] > 1) {
dp[i][0] = 1;
dp[i - 1][0] = 2;
dp[i][1] = dp[i + 1][0] + 1;
dp[i - 1][1] = dp[i][1] + 1;
i--;
continue;
}
dp[i][0] = 1;
dp[i][1] = dp[i][0] + 1;
}
}
}
long long int max = INT_MIN, k;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (2); ++j) {
if (dp[i][j] > max) {
max = dp[i][j];
k = j;
}
if (k == 1 && dp[i][j] == max) {
k = j;
}
}
}
if (k == 1 || max == n)
cout << max;
else
cout << max + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int const dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
int64_t const LIM = 150, INF = 1e9, MOD = 1e9 + 7;
double const PI = 3.141592653589793, EPS = 1e-7;
string a, b, c;
tuple<int, int, int> p[LIM][LIM][LIM];
bool use[LIM][LIM][LIM];
int d[LIM][LIM][LIM];
int relax(string s) {
string c1 = c;
reverse(c1.begin(), c1.end());
string t = c1 + '$' + s;
vector<int> p(t.length());
for (int i = 1; i < (int)p.size(); i++) {
int j = p[i - 1];
while (j > 0 && t[i] != t[j]) j = p[j - 1];
if (t[i] == t[j]) ++j;
p[i] = j;
}
return p.back();
}
int f(int i, int j, int k, string s) {
if (k == (int)c.length()) return -1;
if (i == 0 || j == 0) return 0;
if (d[i][j][k] != -1) return d[i][j][k];
int x1 =
(a[i] == b[j] ? (f(i - 1, j - 1, relax(s + a[i]), s + a[i]) + 1) : 0);
int x2 = f(i - 1, j, k, s);
int x3 = f(i, j - 1, k, s);
d[i][j][k] = x1;
use[i][j][k] = true;
p[i][j][k] = make_tuple(i - 1, j - 1, relax(s + a[i]));
if (x2 > d[i][j][k]) {
d[i][j][k] = x2;
use[i][j][k] = false;
p[i][j][k] = make_tuple(i - 1, j, k);
}
if (x3 > d[i][j][k]) {
use[i][j][k] = false;
d[i][j][k] = x3;
p[i][j][k] = make_tuple(i, j - 1, k);
}
if (d[i][j][k] == 0) {
use[i][j][k] = false;
p[i][j][k] = make_tuple(i, j, k);
}
return d[i][j][k];
}
string go(int i, int j, int k) {
if (i == 0 || j == 0) return "";
string res;
if (p[i][j][k] != make_tuple(i, j, k))
res = go(get<0>(p[i][j][k]), get<1>(p[i][j][k]), get<2>(p[i][j][k]));
if (a[i] == b[j] && use[i][j][k]) res += a[i];
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b >> c;
a = " " + a;
b = " " + b;
for (int i = 0; i < (int)a.length() + 1; i++)
for (int j = 0; j < (int)b.length() + 1; j++)
for (int k = 0; k < (int)c.length() + 1; k++) {
d[i][j][k] = -1;
p[i][j][k] = make_tuple(i, j, k);
}
if (f(a.length() - 1, b.length() - 1, 0, "")) {
reverse(c.begin(), c.end());
string ans = go(a.length() - 1, b.length() - 1, 0);
cout << ans << '\n';
} else {
cout << 0 << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000;
const int INF = 1000000001;
struct event {
double t;
int w;
event() {}
event(double t, int w) : t(t), w(w) {}
bool operator<(const event &rhs) const { return t < rhs.t; }
};
int A[MAX];
double res[MAX + 1];
int n, l, v1, v2;
double t, s;
int main(int argc, char *argv[]) {
scanf("%d %d %d %d", &n, &l, &v1, &v2);
t = (double)l / (v1 + v2);
s = t * v2;
vector<event> E;
for (int i = 0; i < n; ++i) {
scanf("%d", A + i);
E.push_back(event(A[i], -1));
E.push_back(event((double)A[i] - s, 1));
if (E.back().t < 0.0) E.back().t += 2.0 * l;
}
sort((E).begin(), (E).end());
int now = 0;
for (int i = 0; i < 2 * n; ++i)
if (E[i].w == 1 && E[0].t - s - 1e-8 < E[i].t - 2.0 * l &&
E[i].t - 2.0 * l < E[0].t)
++now;
E.push_back(E[0]);
E.back().t += 2.0 * l;
for (int i = 0; i < 2 * n; ++i) {
now += E[i].w;
res[now] += E[i + 1].t - E[i].t;
}
for (int i = 0; i <= n; ++i) printf("%.10lf\n", res[i] / (2.0 * l));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int INF = 1e9 + 7;
unsigned long long pre[maxn], h[maxn];
int k[maxn], len[maxn];
vector<pair<unsigned long long, int> > save[maxn];
vector<int> entry[maxn];
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int lens = s.size();
pre[0] = 1;
for (int i = 1; i < maxn; i++) pre[i] = pre[i - 1] * 163;
h[0] = s[0] - 'a' + 1;
for (int i = 1; i < lens; i++) h[i] = h[i - 1] * 163 + (s[i] - 'a' + 1);
int Q;
cin >> Q;
for (int i = 0; i < Q; i++) {
string m;
cin >> k[i] >> m;
len[i] = m.size();
unsigned long long temp = m[0] - 'a' + 1;
for (int j = 1; j < len[i]; j++) temp = temp * 163 + (m[j] - 'a' + 1);
save[len[i]].push_back(make_pair(temp, i));
}
for (int i = 1; i <= lens; i++) {
if (save[i].empty()) continue;
sort(save[i].begin(), save[i].end());
for (int j = 0; j + i - 1 < lens; j++) {
unsigned long long temp;
if (!j)
temp = h[i - 1];
else
temp = h[j + i - 1] - h[j - 1] * pre[i];
int pos =
lower_bound(save[i].begin(), save[i].end(), make_pair(temp, 0)) -
save[i].begin();
if (pos != save[i].size() && save[i][pos].first == temp)
entry[save[i][pos].second].push_back(j);
}
}
for (int i = 0; i < Q; i++) {
if (entry[i].size() < k[i]) {
cout << -1 << endl;
continue;
}
int ans = INF;
for (int j = 0; j + k[i] - 1 < entry[i].size(); j++)
ans = min(ans, entry[i][j + k[i] - 1] - entry[i][j] + len[i]);
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long t[8000010];
void Push_Up(int now) { t[now] = t[now << 1] + t[now << 1 | 1]; }
void Up_Data(int l, int r, int lo, int ro, int now) {
if (lo <= l && r <= ro) {
t[now]++;
return;
}
int mid = l + r >> 1;
if (lo <= mid) Up_Data(l, mid, lo, ro, now << 1);
if (mid < ro) Up_Data(mid + 1, r, lo, ro, now << 1 | 1);
Push_Up(now);
}
void Get_Sum(int l, int r, int lo, int ro, int now, long long& res) {
if (lo <= l && r <= ro) {
res += t[now];
return;
}
int mid = l + r >> 1;
if (lo <= mid) Get_Sum(l, mid, lo, ro, now << 1, res);
if (mid < ro) Get_Sum(mid + 1, r, lo, ro, now << 1 | 1, res);
}
int n;
void D(int& x) {
if (x > n) x -= n;
if (x < 1) x += n;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int l, r, m, k, p = 1;
cin >> n >> m;
long long res = 1, sum, f;
for (int i = 0; i < n; ++i) {
k = p + m, f = 0, sum = 1;
D(k);
l = p, r = k;
if (l > r) swap(l, r);
if (r - l < n + l - r) {
Get_Sum(1, n, l + 1, r - 1, 1, sum);
} else {
if (r + 1 <= n) Get_Sum(1, n, r + 1, n, 1, sum);
if (l - 1 > 0) Get_Sum(1, n, 1, l - 1, 1, sum);
}
res += sum;
cout << res << '\n';
Up_Data(1, n, p, p, 1);
Up_Data(1, n, k, k, 1);
p = k;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long i, j, l, r, q, t, n, z, test, x, y, k;
cin >> n;
long long count1 = 0, total1 = 0, count2 = 0, total2 = 0;
while (n--) {
cin >> i >> j >> k;
if (i == 1) {
count1 += j;
total1 += k;
} else {
count2 += j;
total2 += k;
}
}
if (count1 >= total1)
cout << "LIVE\n";
else
cout << "DEAD\n";
if (count2 >= total2)
cout << "LIVE\n";
else
cout << "DEAD\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
}
| 0 |
// #include<bits/stdc++.h>
// using namespace std;
// #define sl 200000
// int main(){
// int t;
// cin >> t;
// while(t--){
// int n;
// cin >> n;
// map <int,int> mp;
// vector <int> v[sl];
// for(int i = 0; i < n; i++){
// int a;
// cin>>a;
// mp[a]++;
// v[a].push_back(i);
// }
// if(mp.size() == 1)
// cout<<"0\n";
// else if(mp.size() == n)
// cout<<"1\n";
// else
// {
// int mx = INT_MAX;
// for(auto it:mp){
// int cnt =0;
// for(int j=0;j<v[it.first].size() ; j++){
// if(v[it.first][j] !=0 && v[it.first][j]!=v[it.first][j]-1)
// cnt++;
// if(j==v[it.first].size()-1 && v[it.first][j] != n-1)
// cnt++;
// }
// if(cnt < mx)
// mx = cnt;
// }
// cout<<mx<<"\n";
// }
// }
// return 0;
// }
// /*
// int max = 0;
// for(auto it:mp){
// if(it.second > max)
// max = it.second;
// }
// int mx = INT_MAX;
// for(auto it:mp){
// int cnt =0;
// if(it.second == max)
// {
// cout<<it.first<<" ";
// for(int j=0;j<v[it.first].size() ; j++){
// if(j!=0 && v[it.first][j]!=v[it.first][j-1]+1)
// cnt++;
// else if(j==v[it.first].size()-1 && v[it.first][j] != n-1)
// cnt++;
// }
// cout<<cnt<<" ";
// if(cnt < mx)
// mx = cnt;
// }
// }
// cout<<mx<<"m\n";
// */
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
map <int,int> mp;
int Ar[n];
for(int i=0;i<n;i++){
cin>>Ar[i];
}
if(n==1)
cout<<"0\n";
else {
for(int i=0;i<n;i++){
if(i==0 && Ar[i]!=Ar[i+1])
mp[Ar[i]] = 1;
else if(i==0 && Ar[i]==Ar[i+1])
mp[Ar[i]] = 0;
else if(i<n-1)
{
if(mp[Ar[i]] == 0)
{
if(Ar[i+1]==Ar[i])
mp[Ar[i]] += 0;
else if(Ar[i+1]!=Ar[i])
mp[Ar[i]] += 1;
if(Ar[i-1]==Ar[i])
mp[Ar[i]] += 0;
else if(Ar[i-1]!=Ar[i])
mp[Ar[i]] += 1;
}
else
{
if(Ar[i+1]==Ar[i])
mp[Ar[i]] += 0;
else
mp[Ar[i]] += 1;
}
}
else if(i==n-1)
{
if(Ar[i-1]!=Ar[i] && mp[Ar[i]]==0)
mp[Ar[i]] += 1;
else
mp[Ar[i]] += 0;
}
}
int mn = INT_MAX;
for(auto it:mp){
mn = min(mn,it.second);
}
cout<<mn<<endl;
}
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
long long n, m, res, a[N][N], b[N][N], c[N][N], d[N][N], e[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
b[i][j] = max(b[i - 1][j], b[i][j - 1]) + a[i][j];
c[n - i + 1][m - j + 1] =
max(c[n - i + 2][m - j + 1], c[n - i + 1][m - j + 2]) +
a[n - i + 1][m - j + 1];
d[n - i + 1][j] =
max(d[n - i + 2][j], d[n - i + 1][j - 1]) + a[n - i + 1][j];
e[i][m - j + 1] =
max(e[i - 1][m - j + 1], e[i][m - j + 2]) + a[i][m - j + 1];
}
}
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
res = max(res, b[i - 1][j] + c[i + 1][j] + d[i][j - 1] + e[i][j + 1]);
res = max(res, b[i][j - 1] + c[i][j + 1] + d[i + 1][j] + e[i - 1][j]);
}
}
printf("%d\n", res);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1005][1005], r[2000005], c[2000005];
priority_queue<long long> sh, susu;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long i, j, k, l, m, n, t, x, y, p, cnt, ans, car1, car2;
cin >> n >> m >> k >> p;
for (i = 0; i < n; i++) {
cnt = 0;
for (j = 0; j < m; j++) {
cin >> arr[i][j];
cnt += arr[i][j];
}
sh.push(cnt);
}
for (j = 0; j < m; j++) {
cnt = 0;
for (i = 0; i < n; i++) {
cnt += arr[i][j];
}
susu.push(cnt);
}
for (i = 1; i <= k; i++) {
r[i] = r[i - 1] + sh.top();
sh.pop();
sh.push(r[i] - r[i - 1] - m * p);
c[i] = c[i - 1] + susu.top();
susu.pop();
susu.push(c[i] - c[i - 1] - n * p);
}
ans = r[0] + c[k];
for (i = 0; i <= k; i++) {
ans = max(ans, (c[i] + r[k - i] - i * (k - i) * p));
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > 1000000007) x %= 1000000007;
}
y = (y * y);
if (y > 1000000007) y %= 1000000007;
b /= 2;
}
return x;
}
int main() {
int n;
cin >> n;
vector<int> a;
if (n == 1) {
puts("0");
return 0;
}
int i, j, k, c;
for (i = 2; i <= n; i++) {
int flag = 0;
for (j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
flag = 1;
break;
}
}
if (!flag) {
k = i;
while (k <= n) {
a.push_back(k);
k = k * i;
}
}
}
cout << a.size() << endl;
for (i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
return 0;
}
| 3 |
// Template begins
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <stdio.h>
#include <stack>
#include <math.h>
#include <complex>
using namespace std;
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define endl "\n"
#define lb lower_bound
#define ub upper_bound
#define fo(i,a,b) for(i=a;i<=b;i++)
#define all(v) (v).begin(),(v).end()
#define sort0(v) sort(all(v))
#define lbb(a,b,arr,x) lower_bound(arr+a,arr+b+1,x)-arr
#define ubb(a,b,arr,x) upper_bound(arr+a,arr+b+1,x)-arr
#define freq(a,b,arr,x) upper_bound(arr+a,arr+b+1,x)-lower_bound(arr+a,arr+b+1,x)
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define d0(x) cout<<(x)<<" "
#define d1(x) cout<<(x)<<endl
#define d2(x,y) cout<<(x)<<" "<<(y)<<endl
#define d3(x,y,z) cout<<(x)<<" "<<(y)<<" "<<(z)<<endl
#define d4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define d5(a,b,c,d,e) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<" "<<(e)<<endl
#define d6(a,b,c,d,e,f) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<" "<<(e)<<" "<<(f)<<endl
#define max3(a,b,c) max(max((a),(b)),(c))
#define max4(a,b,c,d) max(max((a),(b)),max((c),(d)))
#define ss second
#define ff first
#define pb push_back
#define mp make_pair
#define printp(x) cout << x.ff << " " << x.ss << endl
template<class T> ostream& operator<<(ostream &os, vector<T> V) {
for(auto v : V) os << v << " ";
return cout << "";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
for(auto s:S) os<<s<<" ";
return cout << "";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
return os << P.first << " " << P.second;
}
const ll mod=1e9+7;
#define inf 9999999999999
ll inv(ll i){if(i==1) return 1;return (mod-((mod/i)*inv(mod%i))%mod)%mod;}
ll gcd(ll a,ll b){ if (b==0) return a;return gcd(b,a%b);}
ll pwr(ll a, ll b) {a %= mod; ll res = 1;while (b > 0) {if (b & 1) res = res * a % mod; a = a * a % mod; b >>= 1;}return res;}
//Template ends
ll a[200010], t[800010],T[800010];
int n;
void buildm(int v, int tl, int tr){
if(tl>tr) return;
if(tl==tr){
t[v] = a[tl];
return;
}
int tm = (tl+tr)/2;
buildm(2*v,tl,tm);
buildm(2*v+1,tm+1,tr);
t[v] = min(t[2*v], t[2*v+1]);
}
void buildM(int v, int tl, int tr){
if(tl>tr) return;
if(tl==tr){
T[v] = a[tl];
return;
}
int tm = (tl+tr)/2;
buildM(2*v,tl,tm);
buildM(2*v+1,tm+1,tr);
T[v] = max(T[2*v], T[2*v+1]);
}
ll minq(int v, int tl, int tr, int l, int r){
if(l>tr or r<tl) return 1000000000;
if(tl==l and tr==r){
return t[v];
}
int tm = (tl+tr)/2;
return min(minq(2*v,tl,tm,l,min(r,tm)),minq(2*v+1,tm+1,tr,max(tm+1,l),r));
}
ll minn(int l,int r){
return minq(1,1,n,l,r);
}
ll maxq(int v, int tl, int tr, int l, int r){
if(l>tr or r<tl) return 0;
if(tl==l and tr==r){
return T[v];
}
int tm = (tl+tr)/2;
return max(maxq(2*v,tl,tm,l,min(r,tm)),maxq(2*v+1,tm+1,tr,max(tm+1,l),r));
}
ll maxx(int l,int r){
return maxq(1,1,n,l,r);
}
int main(){
fio;
int t0,i;
cin >> t0;
while(t0--){
cin >> n;
for(i=1;i<=n;i++) cin >> a[i];
buildm(1,1,n);
buildM(1,1,n);
ll curr = 0;
bool z = false;
for(i=1;i<=n;i++){
curr = max(curr, a[i]);
int l = i+1;
int r = n-1;
while(l<=r){
int mid = (l+r)/2;
ll val1 = minn(i+1,mid);
ll val2 = maxx(mid+1,n);
//d5(i,mid,val1,val2,curr);
if(val1 == val2 and val1 == curr){
z = true;
d1("YES");
d3(i,mid-i,n-mid);
break;
}
if(val1 < curr or (val1 == curr and val2 < curr)){
r = mid - 1;
}
else{
l = mid + 1;
}
}
if(z) break;
}
if(z){
continue;
}
else{
d1("NO");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __read(T& a) {
cin >> a;
}
template <typename T, typename... Args>
void __read(T& a, Args&... args) {
cin >> a;
__read(args...);
}
void solve2() {
long long k;
__read(k);
if (k == 1) {
cout << 1 << "\n";
return;
}
long long now = 2;
long long prev = 1;
k--;
long long ln = 1;
while (k > 0) {
ln = (long long)to_string(now).size();
if (k > prev + ln) {
k -= prev + ln;
prev += ln;
now++;
} else
break;
}
long long pw = 9;
ln = 1;
now = 1;
while (k > 0) {
if (pw * ln < k) {
k -= pw * ln;
now += pw;
pw *= 10;
++ln;
} else
break;
}
while (k > 0) {
ln = (long long)to_string(now).size();
if (ln < k) {
k -= ln;
} else
break;
++now;
}
string ans = to_string(now);
cout << ans[k - 1] << endl;
}
void solve() {
long long tests;
__read(tests);
while (tests--) solve2();
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, t;
cin >> n >> k >> t;
if (t <= k)
cout << t;
else if (t > k and t <= n)
cout << k;
else if (t > n)
cout << n - (t - k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int source, sink, pr[150], _index[150];
int vis[150];
struct edge {
int v, c, ri;
int w;
edge() {}
edge(int _v, int _c, int _w, int _ri) { v = _v, c = _c, w = _w, ri = _ri; }
bool operator<(const edge& p) const { return w > p.w; }
};
vector<edge> g[150];
void addEdge(int u, int v, int c, int w) {
g[u].push_back(edge(v, c, w, g[v].size()));
g[v].push_back(edge(u, 0, -w, g[u].size() - 1));
return;
}
bool BF() {
for (int i = 0; i <= sink; i++) {
vis[i] = 1 << 28;
pr[i] = -1;
}
pr[source] = -2;
vis[source] = 0;
for (int k = 0, done = 0; done < 1 && k <= sink; k++) {
done = 1;
for (int i = 0; i <= sink; i++) {
if (vis[i] == (1 << 28)) continue;
for (int j = 0; j < (int)g[i].size(); j++) {
if (vis[g[i][j].v] > vis[i] + g[i][j].w && g[i][j].c > 0) {
vis[g[i][j].v] = vis[i] + g[i][j].w;
pr[g[i][j].v] = i;
_index[g[i][j].v] = j;
done = 0;
}
}
}
}
return (vis[sink] < (1 << 28));
}
bool dijkstra() {
for (int i = 0; i <= sink; i++) {
vis[i] = 1 << 28;
pr[i] = -1;
}
priority_queue<edge> q;
q.push(edge(source, 0, 0, 0));
vis[source] = 0;
pr[source] = -2;
while (!q.empty()) {
edge src = q.top();
q.pop();
for (int i = 0; i < (int)g[src.v].size(); i++) {
int s = src.v, d = g[s][i].v, z = g[s][i].c;
int y = g[s][i].w;
if (vis[d] > (vis[s] + y) && z > 0) {
vis[d] = vis[s] + y;
pr[d] = s;
_index[d] = i;
q.push(edge(d, 0, vis[d], 0));
}
}
}
return vis[sink] < (1 << 28);
}
int calc(int k, string cipher, string answer) {
for (int i = 0; i < 150; i++) g[i].clear();
source = 141, sink = source + 2;
int frq[256][256];
memset(frq, 0, sizeof(frq));
for (int i = 0; i < (int)cipher.size(); i++) {
frq[cipher[i]][answer[i]]++;
}
for (int i = 0; i < k; i++) {
addEdge(source, i, 1, 0);
addEdge(i + k, sink, 1, 0);
for (int j = 0; j < k; j++) {
char x = (i < 26) ? 'a' + i : 'A' + i - 26;
char y = (j < 26) ? 'a' + j : 'A' + j - 26;
addEdge(i, j + k, 1, -frq[x][y]);
}
}
int cost = 0, flow = 0;
while (dijkstra()) {
int y;
for (y = sink; pr[y] >= 0; y = pr[y]) {
g[pr[y]][_index[y]].c--;
g[y][g[pr[y]][_index[y]].ri].c++;
}
cost += (vis[sink]);
flow++;
}
return -cost;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
string cipher, answer;
int n, k;
cin >> n >> k >> cipher >> answer;
cout << calc(k, cipher, answer) << "\n";
string ans = "";
for (int i = 0; i < k; i++) {
for (int j = 0; j < (int)g[i].size(); j++) {
if (g[i][j].v >= k && g[i][j].v < 2 * k) {
if (g[i][j].c == 0) {
int y = g[i][j].v - k;
char x = (y < 26) ? 'a' + y : 'A' + y - 26;
ans += x;
}
}
}
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void test() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> gaps;
int gap = 0;
char prev = s[0];
bool w = false;
int ans = 0;
int start = 0;
if (prev == 'W') {
w = true;
ans++;
start = 0;
} else
start++;
for (int i = 1; i < n; i++) {
char cur = s[i];
if (!w) {
if (cur == 'W') {
w = true;
} else
start++;
} else {
if (cur == 'W') {
if (gap != 0) gaps.push_back(gap);
gap = 0;
} else {
gap++;
}
}
if (cur == 'W') {
if (prev == cur)
ans += 2;
else
ans++;
}
prev = cur;
}
if (w == false) {
if (k == 0) {
cout << 0 << endl;
return;
}
int res = 2 * min(k, n) - 1;
cout << res << endl;
return;
}
int end = gap;
sort(gaps.begin(), gaps.end());
for (int i = 0; i < gaps.size(); i++) {
int g = gaps[i];
if (g <= k) {
k -= g;
ans += 2 * g + 1;
} else {
ans += 2 * k;
k = 0;
break;
}
}
if (k > 0) {
int ori = k;
k -= end;
k = max(0, k);
ans += 2 * (ori - k);
if (k > 0) ans += 2 * min(start, k);
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
test();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
void solve() {
long long n, r;
cin >> n >> r;
double PI = 3.141592653589793;
double x = (360 * 1.0) / (2 * n * 1.0);
double y = x * PI / (180 * 1.0);
double q = sin(y);
double result = (r * q) / (1 - q);
cout << fixed << setprecision(10);
cout << result << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, num;
cin >> n;
num = n + 1;
while (1) {
n = num;
int a, b, c, d;
a = n % 10;
n = n / 10;
b = n % 10;
n /= 10;
c = n % 10;
n /= 10;
d = n % 10;
if (a != b && a != c && a != d && b != c && b != d && c != d) {
cout << num << endl;
break;
}
num++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int mx[] = {0, 0, 1, -1};
int my[] = {1, -1, 0, 0};
int r1, r2, t1, t2;
int t;
int size = 50;
double ans = 999999;
vector<string> arr;
void calc(int sx, int sy, int x, int y, int vis[51][51]) {
vis[sx][sy] = 1;
ans = min(ans, pow(x - sx, 2) + pow(y - sy, 2));
for (int i = 0; i < 4; i++) {
if (sx + mx[i] >= 0 and sx + mx[i] < t and sy + my[i] >= 0 and
sy + my[i] < t) {
if (!vis[sx + mx[i]][sy + my[i]] and arr[sx + mx[i]][sy + my[i]] != '1') {
vis[sx + mx[i]][sy + my[i]] = 1;
calc(sx + mx[i], sy + my[i], x, y, vis);
}
}
}
}
void cost(int x, int y) {
int vis[51][51];
for (int i = 0; i < 51; i++) {
for (int j = 0; j < 51; j++) vis[i][j] = 0;
}
vis[x][y] = 0;
ans = min(ans, pow(x - r2, 2) + pow(y - t2, 2));
calc(r2, t2, x, y, vis);
}
void solve(int sx, int sy, int vis[51][51]) {
for (int i = 0; i < 4; i++) {
if (sx + mx[i] >= 0 and sx + mx[i] < t and sy + my[i] >= 0 and
sy + my[i] < t) {
if (!vis[sx + mx[i]][sy + my[i]] and arr[sx + mx[i]][sy + my[i]] != '1') {
vis[sx][sy] = 1;
cost(sx + mx[i], sy + my[i]);
solve(sx + mx[i], sy + my[i], vis);
}
}
}
}
int main() {
cin >> t;
cin >> r1 >> t1 >> r2 >> t2;
arr.resize(t, "");
r2--;
t2--;
for (int i = 0; i < t; i++) cin >> arr[i];
int vis[51][51];
for (int i = 0; i < 51; i++) {
for (int j = 0; j < 51; j++) vis[i][j] = 0;
}
cost(r1 - 1, t1 - 1);
solve(r1 - 1, t1 - 1, vis);
int an = (int)ans;
cout << an;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string bin(long long int n) {
string s = "";
while (n != 0) {
if (n % 2)
s += "1";
else
s += "0";
n = n / 2;
}
reverse(s.begin(), s.end());
return s;
}
long long int dec(string n) {
string num = n;
long long int dec_value = 0;
long long int base = 1;
int len = num.length();
for (long long int i = len - 1; i >= 0; i--) {
if (num[i] == '1') dec_value += base;
base = base * 2;
}
return dec_value;
}
int comp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.first == b.first)
return a.second < b.second;
else
return a.first > b.first;
}
int main() {
long long int t, n, k, a, b;
cin >> n;
map<long long int, long long int> parent;
vector<long long int> child[n + 1];
vector<long long int> ganda, ans;
long long int color[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> a >> b;
parent[i] = a;
if (a != -1) child[a].push_back(i);
if (b == 1) {
ganda.push_back(i);
color[i] = 1;
} else
color[i] = 0;
}
sort(ganda.begin(), ganda.end());
int co[n + 1];
memset(co, 0, sizeof(co));
for (long long int i = 1; i <= n; i++) {
if (parent[i] != -1) {
if (color[i] == 0) {
co[parent[i]] = 1;
}
}
}
for (long long int i = 0; i < ganda.size(); i++) {
if (co[ganda[i]] != 1) ans.push_back(ganda[i]);
}
if (ans.empty()) {
cout << -1;
return 0;
}
for (long long int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
using poly = vector<int>;
const int mod = 998244353;
int Pow(int a, int first) {
int res = 1;
for (; first; a = 1ll * a * a % mod, first >>= 1)
if (first & 1) res = 1ll * res * a % mod;
return res;
}
const int G = 3, iG = Pow(G, mod - 2);
vector<int> rev;
void NTT(poly& a, int t) {
int n = int((a).size());
for (int i = (0), I = (n); i < I; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int mid = 1; mid < n; mid <<= 1) {
int wn = Pow(~t ? G : iG, (mod - 1) / (mid << 1));
for (int i = 0; i < n; i += (mid << 1)) {
int w = 1;
for (int k = (i), I = (mid + i); k < I; k++) {
int first = a[k], second = 1ll * w * a[mid + k] % mod;
a[k] = (first + second) % mod,
a[mid + k] = (first - second + mod) % mod;
w = 1ll * w * wn % mod;
}
}
}
if (!~t) {
int in = Pow(n, mod - 2);
for (int i = (0), I = (n); i < I; i++) a[i] = 1ll * a[i] * in % mod;
}
}
poly operator*(poly p, poly q) {
int pn = int((p).size()), qn = int((q).size()),
k = 1 << int(ceil(log2(pn + qn)));
rev.assign(k, 0), p.resize(k, 0), q.resize(k, 0);
for (int i = (0), I = (k); i < I; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) * (k >> 1));
NTT(p, 1), NTT(q, 1);
for (int i = (0), I = (k); i < I; i++) p[i] = 1ll * q[i] * p[i] % mod;
NTT(p, -1), p.resize(pn + qn - 1);
return p;
}
int n, cnt;
map<int, int> pcnt;
struct cmp {
bool operator()(poly p, poly q) { return int((p).size()) > int((q).size()); }
};
priority_queue<poly, vector<poly>, cmp> que;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n, cnt = n / 2;
for (int i = (0), I = (n); i < I; i++) {
int p;
cin >> p, pcnt[p]++;
}
for (auto u : pcnt) que.push(poly(u.second + 1, 1));
while (int((que).size()) > 1) {
poly p, q;
p = que.top(), que.pop(), q = que.top(), que.pop();
p = p * q;
if (int((p).size()) > cnt + 1) p.resize(cnt + 1);
que.push(p);
}
cout << (que.top())[cnt] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long BIG = 100000000100000;
long long a[100001];
long long b[100001];
long long n, m;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long ypa(long long k) {
for (long long i = 1; i <= n; i++) b[i] = a[i];
long long t = n;
long long g = m;
long long s;
while (g > 0 && t != 0) {
while (b[t] == 0 && t != 0) t--;
if (t >= k) return 0;
g--;
s = max(0, k - t);
while (s != 0 && t != 0) {
long long mn = min(s, b[t]);
s -= mn;
b[t] -= mn;
while (b[t] == 0 && t != 0) t--;
}
}
if (t == 0)
return 1;
else
return 0;
}
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long l = 1, r = BIG;
long long mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (ypa(mid)) {
r = mid;
} else {
l = mid;
}
}
cout << r << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k;
while (scanf("%d", &n) != EOF) {
if (n <= 9) {
printf("%d\n", n);
continue;
} else if (n > 9 && n <= 189) {
n -= 9;
i = n % 2;
n /= 2;
if (i) {
printf("%d\n", n / 10 + 1);
continue;
} else {
printf("%d\n", (n + 9) % 10);
continue;
}
} else {
n -= 189;
i = n % 3;
n /= 3;
if (i == 1) {
printf("%d\n", n / 100 + 1);
continue;
} else if (i == 2) {
printf("%d\n", n / 10 % 10);
continue;
} else {
printf("%d\n", (n + 9) % 10);
continue;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int fhi[1 << 18];
int fps[26];
vector<int> bps[26];
int main() {
memset(fhi, -1, sizeof fhi);
string a, b;
cin >> a >> b;
int bp = 0;
for (int i = 0; i < (int)(a.length()); i++) {
if (bp < (int)(b.length()) && a[i] == b[bp]) {
fps[a[i] - 'a'] = bp;
++bp;
}
fhi[i] = fps[a[i] - 'a'];
}
bp = (int)(b.length()) - 1;
bool good = 1;
for (int i = (int)(a.length()) - 1; i >= 0; i--) {
if (bp >= 0 && a[i] == b[bp]) {
bps[a[i] - 'a'].push_back(bp);
--bp;
}
int lo = 0, hi = (int)(bps[a[i] - 'a'].size()) - 1;
bool found = 0;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (bps[a[i] - 'a'][mid] > fhi[i])
lo = mid + 1;
else if (bps[a[i] - 'a'][mid] < fhi[i])
hi = mid - 1;
else {
found = 1;
break;
}
}
good &= found;
}
cout << (good ? "Yes" : "No") << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<long long>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
istream &operator>>(istream &, vector<T> &);
template <class T>
ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U>
istream &operator>>(istream &, pair<T, U> &);
template <class T, class U>
ostream &operator<<(ostream &, const pair<T, U> &);
template <class T>
struct Inf {
static constexpr T inf() {
return std::numeric_limits<T>::has_infinity()
? std::numeric_limits<T>::infinty()
: std::numeric_limits<T>::max();
}
};
template <>
struct Inf<int> {
static constexpr int inf() { return 0x3f3f3f3f; }
};
template <>
struct Inf<long long> {
static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; }
};
constexpr int INF = Inf<int>::inf();
constexpr ll BINF = Inf<ll>::inf();
int solve() {
int n, k;
cin >> n >> k;
vi a(n);
cin >> a;
ll ans = a[n - 1] - a[0];
vi wtf;
for (int i = 0; i + 1 < n; i++) wtf.push_back(a[i] - a[i + 1]);
sort(wtf.begin(), wtf.end());
for (int i = 0; i < k - 1; i++) ans += wtf[i];
cout << ans << endl;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) is >> *it;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end();)
os << *it, os << " \n"[++it == v.end()];
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, k, m = 0, ans = 0, temp = 0, ind = 0;
scanf("%d%d", &n, &k);
int arr[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
for (int i = 1; i <= k; i++) {
ans = 0;
temp = i;
for (int j = 1; j <= n / k; j++) {
ans += arr[temp % (n + 1)];
temp += k;
}
if (!m || m > ans) {
m = ans;
ind = i;
}
}
printf("%d", ind);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str, str2;
int i;
vector<char> v;
vector<char> v2;
cin >> str;
cin >> str2;
for (i = 0; str[i] != '\0'; i++) {
v.push_back(str[i]);
}
for (i = 0; str2[i] != '\0'; i++) {
v2.push_back(str2[i]);
}
reverse(v.begin(), v.end());
if (v2 == v) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, long long>>> adj;
vector<unordered_set<long long>> tra;
long long n;
long long m;
long long dijkstra() {
long long source = 1;
long long destination = n;
long long var[n + 1];
long long fix[n + 1];
for (long long i = 1; i <= n; i++) {
var[i] = 1e18;
}
memset(fix, -1, sizeof(fix));
set<pair<long long, long long>> s;
s.insert({0, source});
fix[source] = 0;
while (s.size()) {
pair<long long, long long> cur = *(s.begin());
s.erase(cur);
fix[cur.second] = cur.first;
long long leave = 0;
while (tra[cur.second].count(cur.first + leave)) {
leave++;
}
for (auto x : adj[cur.second]) {
long long check = cur.first + x.second;
if (var[x.first] > cur.first + x.second + leave) {
s.erase({var[x.first], x.first});
var[x.first] = cur.first + x.second + leave;
s.insert({var[x.first], x.first});
}
}
}
return fix[destination];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> m;
adj.resize(n + 1);
tra.resize(n + 1);
for (long long i = 0; i < m; i++) {
long long a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
for (long long i = 1; i <= n; i++) {
long long siz;
cin >> siz;
for (long long j = 0; j < siz; j++) {
long long x;
cin >> x;
tra[i].insert(x);
}
}
cout << dijkstra();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long N = pow(10, 9) + 7;
void ipgraph(long long n, long long m);
long long power(long long a, long long b, long long p);
vector<vector<long long>> v;
vector<bool> vis;
void solve() {
long long n, m;
cin >> n >> m;
set<long long> s;
for (long long i = 0; i < n; i++) s.insert(i + 1);
long long l, r, x;
vector<long long> ans(n + 1, 0);
while (m--) {
cin >> l >> r >> x;
auto it = s.lower_bound(l);
long long f = 0;
while (it != s.end() && *it <= r) {
f = 0;
if (*it != x) {
ans[*it] = x;
s.erase(it);
f = 1;
it = s.lower_bound(l);
}
if (!f) it = s.lower_bound(x + 1);
}
}
ans.erase(ans.begin());
for (auto x : ans) {
cout << x << " ";
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) solve();
cerr << endl
<< "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
void ipgraph(long long n, long long m) {
v.assign(n, {});
vis.assign(n, 0);
long long x, y;
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
}
}
long long power(long long a, long long b, long long p) {
if (b == 0) return 1;
long long c = power(a, b / 2, p);
if (b % 2 == 0)
return ((c * c) % p);
else
return ((((c * c) % p) * a) % p);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000;
int x[MAXN + 2];
int y[MAXN + 2];
int z[MAXN + 2];
int main() {
string s;
int y1, x1, z1, m, ix = 0, iy = 0, iz = 0, r, l;
cin >> s >> m;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'x')
++ix;
else if (s[i] == 'y')
++iy;
else
++iz;
x[i + 1] = ix;
y[i + 1] = iy;
z[i + 1] = iz;
}
for (int i = 0; i < m; i++) {
cin >> l >> r;
if (r - l < 2) {
cout << "YES" << endl;
continue;
}
y1 = y[r] - y[l - 1];
x1 = x[r] - x[l - 1];
z1 = z[r] - z[l - 1];
if ((x1 > y1 ? x1 - y1 : y1 - x1) > 1 ||
(x1 > z1 ? x1 - z1 : z1 - x1) > 1 || (z1 > y1 ? z1 - y1 : y1 - z1) > 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream f("bb.in");
int n;
int c;
int d;
int val, a = -2100000000, b = 2100000000;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c >> d;
if (d == 1) {
if (a < 1900) a = 1900;
a = a + c;
b = b + c;
}
if (d == 2) {
if (b > 1899) b = 1899;
a = a + c;
b = b + c;
}
if (a > b) {
cout << "Impossible";
return 0;
}
}
if (b > 100000000) {
cout << "Infinity";
return 0;
}
cout << b;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
string a = "", b = "", c = "", num1, num2;
int len;
int check(string &w) {
if (w == "") return 2;
int wlen = w.size(), flag1 = 0, flag2 = 0, flag3 = 1;
if (w[0] == '0') {
if (w.size() == 1)
return 1;
else
return 2;
}
for (int i = 0; i < wlen; i++) {
if (w[i] >= 'a' && w[i] <= 'z' || w[i] >= 'A' && w[i] <= 'Z' ||
w[i] == '.') {
return 2;
}
}
return 1;
}
vector<string> v[2];
int main() {
cin >> s;
s += ',';
int len = s.size(), flag0 = 0, flag1 = 0;
if (len == 1) {
if (s[0] == ',' || s[0] == ';')
cout << "-" << endl << "-" << endl;
else if (s[0] >= '0' && s[0] <= '9')
cout << "\"" << s[0] << "\"" << endl << "-" << endl;
else
cout << "-" << endl << "\"" << s[0] << "\"" << endl;
} else {
for (int i = 0; i < len; i++) {
c = "";
for (int j = i; j < len; j++) {
if (s[j] != ',' && s[j] != ';') {
c += s[j];
} else {
int num = check(c);
if (num == 1) {
flag0 = 1;
v[0].push_back(c);
}
if (num == 2 || num == 0) {
flag1 = 1;
v[1].push_back(c);
}
i = j;
break;
}
}
}
int len1 = v[0].size(), len2 = v[1].size();
if (!flag0)
puts("-");
else {
cout << "\"";
for (int i = 0; i < len1; i++) {
cout << v[0][i];
if (i != len1 - 1) cout << ",";
}
cout << "\"" << endl;
}
if (!flag1)
puts("-");
else {
cout << "\"";
for (int i = 0; i < len2; i++) {
cout << v[1][i];
if (i != len2 - 1) cout << ",";
}
cout << "\"" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
unsigned n, m;
vector<long long> a;
vector<long long> prefix;
map<long long, long long, greater<long long> > time;
cin >> n >> m;
prefix.resize(n + 1, 0);
a.resize(n);
for (unsigned i = 0; i < n; cin >> a[i++])
;
for (unsigned i = 0; i < n; ++i) prefix[i + 1] += prefix[i] + a[i];
long long time_left, fail_count, d;
for (unsigned i = 0; i < n; ++i) {
time_left = m - prefix[i];
fail_count = 0;
for (auto item : time) {
time_left = min(time_left, a[i]);
d = min(item.second, static_cast<long long>(
ceil(1.0 * (a[i] - time_left) / item.first)));
time_left += d * item.first;
fail_count += d;
if (!d) break;
}
cout << fail_count << " ";
time[a[i]]++;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 1100;
const int maxk = 2 * maxn;
long long dp[maxn][maxk][4];
long long st[4][4] = {{0, 1, 1, 1}, {1, 0, 1, 1}, {0, 0, 0, 2}, {0, 0, 2, 0}};
int main() {
int n, k;
scanf("%d%d", &n, &k);
dp[1][1][0] = 1;
dp[1][1][1] = 1;
dp[1][2][2] = 1;
dp[1][2][3] = 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= k; j++)
for (int a = 0; a < 4; a++)
for (int b = 0; b < 4; b++)
dp[i][j + st[b][a]][a] += dp[i - 1][j][b] % mod;
printf("%d\n", (dp[n][k][0] + dp[n][k][1] + dp[n][k][2] + dp[n][k][3]) % mod);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000;
string pix[MAXN];
struct point {
int r, c;
};
bool mark[MAXN][MAXN];
int rdp[MAXN][MAXN], cdp[MAXN][MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> pix[i];
}
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < m; ++j) {
if (pix[i][j] == 'w') {
if (i == n - 1) {
cdp[i][j] = 1;
} else {
cdp[i][j] = cdp[i + 1][j] + 1;
}
} else {
if (i != n - 1) {
cdp[i][j] = cdp[i + 1][j];
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (j != 0) {
rdp[i][j] = rdp[i][j - 1];
}
if (pix[i][j] == 'w') {
rdp[i][j]++;
}
}
}
int rm = -1, bm = -1, tm = -1, lm = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (pix[i][j] == 'w') {
if (rm == -1) {
rm = j;
}
if (bm == -1) bm = i;
if (tm == -1) tm = i;
if (lm == -1) lm = j;
rm = max(rm, j);
bm = max(bm, i);
lm = min(lm, j);
tm = min(tm, i);
}
}
}
if (rm - lm != bm - tm) {
int cnt_lborder = cdp[tm][lm] - cdp[bm + 1][lm];
cnt_lborder = cnt_lborder - ((pix[tm][lm] == 'w') ? 1 : 0) -
((pix[bm][lm] == 'w') ? 1 : 0);
if (tm == bm) {
cnt_lborder++;
}
if (cnt_lborder == 0) {
while (lm > 0 and rm - lm < bm - tm) {
lm--;
}
}
int cnt_tborder = rdp[tm][rm] - ((lm > 0) ? rdp[tm][lm - 1] : 0);
cnt_tborder = cnt_tborder - ((pix[tm][lm] == 'w') ? 1 : 0) -
((pix[tm][rm] == 'w') ? 1 : 0);
if (rm == lm) {
cnt_tborder++;
}
if (cnt_tborder == 0) {
while (tm > 0 and bm - tm < rm - lm) {
tm--;
}
}
int cnt_bborder = rdp[bm][rm] - ((lm > 0) ? rdp[bm][lm - 1] : 0);
cnt_bborder = cnt_bborder - ((pix[bm][lm] == 'w') ? 1 : 0) -
((pix[bm][rm] == 'w') ? 1 : 0);
if (rm == lm) {
cnt_bborder++;
}
if (cnt_bborder == 0) {
while (bm < n - 1 and bm - tm < rm - lm) {
bm++;
}
}
int cnt_rborder = cdp[tm][rm] - cdp[bm + 1][rm];
cnt_rborder = cnt_rborder - ((pix[tm][rm] == 'w') ? 1 : 0) -
((pix[bm][rm] == 'w') ? 1 : 0);
if (tm == bm) {
cnt_rborder++;
}
if (cnt_rborder == 0) {
while (rm < m - 1 and rm - lm < bm - tm) {
rm++;
}
}
int width = rm - lm;
int height = bm - tm;
if (width and !height) {
if (tm >= width) {
while (bm - tm < width) {
tm--;
}
} else if (n - 1 - tm >= width) {
while (bm - tm < width) {
bm++;
}
}
} else if (height and !width) {
if (lm >= height) {
while (lm > 0 and rm - lm < height) {
lm--;
}
} else if (m - 1 - rm >= height) {
while (rm < m - 1 and rm - lm < height) {
rm++;
}
}
}
if (rm - lm != bm - tm) {
cout << -1;
return 0;
}
}
for (int j = lm; j <= rm; ++j) {
mark[tm][j] = true;
mark[bm][j] = true;
}
for (int i = tm; i <= bm; ++i) {
mark[i][lm] = true;
mark[i][rm] = true;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (pix[i][j] == 'w') {
if (!mark[i][j]) {
cout << -1 << "\n";
return 0;
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (mark[i][j]) {
if (pix[i][j] == 'w') {
cout << 'w';
} else {
cout << '+';
}
} else {
cout << '.';
}
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, f, count = 0;
cin >> n >> f;
long long int no[n], cus[n];
vector<pair<long long int, long long int> > v;
for (long long int i = 0; i < n; i++) {
cin >> no[i] >> cus[i];
v.push_back(make_pair(min(2 * no[i], cus[i]) - min(no[i], cus[i]), i));
}
sort(v.rbegin(), v.rend());
for (long long int i = 0; i < f; i++) {
long long int pos = v[i].second;
count += min(2 * no[pos], cus[pos]);
}
for (long long int i = f; i < n; i++) {
count += min(no[v[i].second], cus[v[i].second]);
}
cout << count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 1000005;
int f[N], phi[N];
int g[N], h[N];
int S1(int x) { return 1ll * x * (x + 1) % mo * (mo + 1) / 2 % mo; }
int S2(int x) {
return 1ll * x * (x + 1) % mo * (2 * x + 1) % mo * (mo + 1) / 2 % mo *
(mo + 1) / 3 % mo;
}
void init() {
for (int i = (int)(1); i <= (int)(N - 1); i++)
f[i] = (1ll * i * i + 1ll * S1(i) * i + mo - S2(i)) % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++) phi[i] = i;
for (int i = (int)(1); i <= (int)(N - 1); i++)
for (int j = (int)(2); j <= (int)((N - 1) / i); j++) phi[i * j] -= phi[i];
;
for (int i = (int)(1); i <= (int)(N - 1); i++)
for (int j = (int)(1); j <= (int)((N - 1) / i); j++)
f[i * j] = (f[i * j] + mo - phi[i] * j) % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++) f[i] = 2ll * f[i] % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++)
f[i] = (1ll * i * i * i + mo - f[i]) % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++)
g[i] = 1ll * f[i] * i % mo, h[i] = 1ll * f[i] * i % mo * i % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++) f[i] = (f[i] + f[i - 1]) % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++) g[i] = (g[i] + g[i - 1]) % mo;
for (int i = (int)(1); i <= (int)(N - 1); i++) h[i] = (h[i] + h[i - 1]) % mo;
}
void solve() {
int n, m, ans = 0;
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
ans = 1ll * (n + 1) * (m + 1) % mo * f[n] % mo;
ans = (ans + mo - 1ll * (n + m + 2) * g[n] % mo) % mo;
ans = (ans + h[n]) % mo;
printf("%d\n", ans);
}
int main() {
init();
int T;
scanf("%d", &T);
while (T--) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 1 && n >= 3) {
n -= 3;
cout << 7;
}
while (n) {
cout << 1;
n -= 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1E9 + 9;
int Add(int a, int b, int m = MOD) {
a += b;
if (a >= m) a -= m;
return a;
}
int Sub(int a, int b, int m = MOD) {
a -= b;
if (a < 0) a += m;
return a;
}
int AddTo(int& to, int w, int m = MOD) {
to += w;
if (to >= m) to -= m;
return to;
}
int SubTo(int& to, int w, int m = MOD) {
to -= w;
if (to < 0) to += m;
return to;
}
int Mult(int a, int b, int m = MOD) { return (a * 1LL * b) % m; }
int Pow(int a, long long deg, int m = MOD) {
int res = 1 % m;
for (; deg > 0; deg >>= 1, a = Mult(a, a, m))
if (deg & 1) res = Mult(res, a, m);
return res;
}
int Oem(int to, int m = MOD) { return Pow(to, m - 2, m); }
int Div(int a, int b, int m = MOD) { return Mult(a, Oem(b, m), m); }
int n, a, b, k;
char buf[100010];
int SumProg(int how, int koef) {
if (how == 0) return 0;
if (how == 1) return 1;
if (how % 2 == 1) {
return Add(SumProg(how - 1, koef), Pow(koef, how - 1));
} else {
int s = SumProg(how / 2, koef);
return Add(s, Mult(s, Pow(koef, how / 2)));
}
}
int main() {
scanf("%d%d%d%d", &n, &a, &b, &k);
scanf("%s", buf);
int base = 0;
for (int i = 0; i < k; ++i) {
if (buf[i] == '-') {
SubTo(base, Mult(Pow(a, n - i), Pow(b, i)));
} else {
AddTo(base, Mult(Pow(a, n - i), Pow(b, i)));
}
}
int koef = Div(Pow(b, k), Pow(a, k));
int sum = SumProg((n + 1) / k, koef);
printf("%d\n", Mult(sum, base));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int numbers[4], a, b, c;
for (int i = 0; i < 4; i++) cin >> numbers[i];
sort(begin(numbers), end(numbers));
c = numbers[3] - numbers[0];
b = numbers[1] - c;
a = numbers[2] - c;
cout << a << " " << b << " " << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q, t, id;
set<pair<int, int> > data;
vector<int> inf;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> q;
inf.resize(n);
for (int i = 0; i < n; ++i) {
cin >> inf[i];
}
for (int i = 0; i < q; ++i) {
cin >> t >> id;
--id;
if (t == 1) {
data.insert(make_pair(-inf[id], id));
if (data.size() > k) {
data.erase(--data.end());
}
} else {
bool find = false;
for (set<pair<int, int> >::iterator it = data.begin(); it != data.end();
++it) {
if (it->second == id) {
find = true;
}
}
if (find == true) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double i3, i4, i5;
cin >> i3 >> i4 >> i5;
double I3, I4, I5;
I3 = (sqrt(3) / 2.0 * i3 * i3 / 2.0 * sqrt(6) / 3.0 * i3) / 3.0;
I4 = (i4 * i4 * sqrt(2) / 2.0 * i4) / 3.0;
double pi = acos(-1), t = pi / 5.0, x = i5 / 2.0 / sin(t),
y = sqrt(i5 * i5 - x * x);
I5 = 0.5 * x * i5 * sin(54 / 180.0 * pi) * 5 * y / 3.0;
printf("%.12lf\n", I3 + I4 + I5);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sg[110][3][3];
struct node {
int x, y;
};
bool cmp(node p, node q) { return p.x < q.x; }
int get_sg(int len, int x, int y) {
if (sg[len][x][y] != -1) return sg[len][x][y];
if (len == 0) return sg[len][x][y] = sg[len][y][x] = 0;
if (x > y) swap(x, y);
if (len == 1 && x == 1 && y == 2) return sg[len][x][y] = sg[len][y][x] = 0;
if (len == 1) return sg[len][x][y] = sg[len][y][x] = 1;
bool vs[110];
memset(vs, 0, sizeof vs);
for (int len1 = 0; len1 < len; len1++) {
int len2 = len - 1 - len1;
if (len1 == 0) {
if (x == 0) {
vs[get_sg(len2, 1, y)] = 1;
vs[get_sg(len2, 2, y)] = 1;
} else
vs[get_sg(len2, x, y)] = 1;
} else if (len2 == 0) {
if (y == 0) {
vs[get_sg(len1, x, 1)] = 1;
vs[get_sg(len1, x, 2)] = 1;
} else
vs[get_sg(len1, x, y)] = 1;
} else {
vs[get_sg(len1, x, 1) ^ get_sg(len2, 1, y)] = 1;
vs[get_sg(len1, x, 2) ^ get_sg(len2, 2, y)] = 1;
}
}
for (int i = 0; i < 110; i++)
if (!vs[i]) return sg[len][x][y] = sg[len][y][x] = i;
}
node arr[110];
int main() {
memset(sg, -1, sizeof(sg));
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> arr[i].x >> arr[i].y;
}
sort(arr, arr + m, cmp);
int result = 0;
result ^= get_sg(arr[0].x - 1, 0, arr[0].y);
for (int i = 1; i < m; i++) {
result ^= get_sg(arr[i].x - arr[i - 1].x - 1, arr[i].y, arr[i - 1].y);
}
result ^= get_sg(n - arr[m - 1].x, 0, arr[m - 1].y);
if (result) {
cout << "WIN\n";
} else {
cout << "LOSE\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int MAXP = 6;
int n;
char s[MAXN + 1];
int p[MAXP], np;
int val[MAXN];
bool solve() {
{
int x = n;
np = 0;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
p[np++] = i;
while (x % i == 0) x /= i;
}
if (x != 1) p[np++] = x;
}
for (int j = (0); j < (n); ++j) val[j] = s[j] - '0';
for (int i = (0); i < (np); ++i) {
int a = n / p[i], b = p[i], c = 1;
while (a % p[i] == 0) a /= p[i], b *= p[i], c *= p[i];
for (int off = (0); off < (c); ++off)
for (int j = off; j < n; j += b) {
int by = -val[j];
for (int k = (0); k < (p[i]); ++k) {
int idx = (j + k * a * c) % n;
val[idx] += by;
}
}
}
bool ok = true;
for (int j = (0); j < (n); ++j)
if (val[j] != 0) ok = false;
return ok;
}
void run() {
scanf("%d", &n);
scanf("%s", s);
printf("%s\n", solve() ? "YES" : "NO");
}
void stress() {
for (int rep = (0); rep < (1000); ++rep) {
n = 4 * 9 * 5 * 7;
for (int i = (0); i < (n); ++i) s[i] = '0';
s[n] = '\0';
vector<int> d;
for (int i = (1); i < (n); ++i)
if (n % i == 0) d.push_back(i);
int times = rand() % (2 * n);
for (int it = (0); it < (times); ++it) {
int idx = rand() % ((int)(d).size());
int off = rand() % d[idx];
bool ok = true;
for (int i = (0); i < (n / d[idx]); ++i)
if (s[off + d[idx] * i] == '9') ok = false;
if (!ok) continue;
for (int i = (0); i < (n / d[idx]); ++i) ++s[off + d[idx] * i];
}
printf("%s\n", s);
bool have = solve();
if (have) {
printf(".");
continue;
}
printf("err\n");
break;
}
}
int main() {
run();
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int P = 998244353;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n;
std::cin >> n;
std::vector<std::vector<int>> E(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
std::cin >> u >> v;
--u, --v;
E[u].push_back(v);
E[v].push_back(u);
}
int ans = n;
for (int r = 0; r <= n; ++r) {
std::vector<std::vector<int>> f(n, std::vector<int>(1));
std::vector<std::vector<int>> g(n, std::vector<int>(1));
std::vector<int> h(n);
std::function<void(int, int)> dfs = [&](int u, int fa) {
h[u] = 0;
f[u][0] = g[u][0] = (P + 1) / 2;
for (int v : E[u]) {
if (v != fa) {
dfs(v, u);
std::vector<int> tf(std::max(h[u], h[v] + 1) + 1);
std::vector<int> tg(std::max(h[u], h[v] + 1) + 1);
for (int i = 0; i <= h[u]; ++i) {
for (int j = 0; j <= h[v]; ++j) {
tf[std::min(i, j + 1)] = (tf[std::min(i, j + 1)] + 1ll * f[u][i] * f[v][j]) % P;
tg[std::max(i, j + 1)] = (tg[std::max(i, j + 1)] + 1ll * g[u][i] * g[v][j]) % P;
if (i + j + 1 <= r) {
tf[i] = (tf[i] + 1ll * f[u][i] * g[v][j]) % P;
tf[j + 1] = (tf[j + 1] + 1ll * g[u][i] * f[v][j]) % P;
} else {
tg[i] = (tg[i] + 1ll * g[u][i] * f[v][j]) % P;
tg[j + 1] = (tg[j + 1] + 1ll * f[u][i] * g[v][j]) % P;
}
}
}
h[u] = std::max(h[u], h[v] + 1);
f[u].swap(tf);
g[u].swap(tg);
}
}
};
dfs(0, -1);
int sum = std::accumulate(f[0].begin(), f[0].end(), 0, [](int a, int b) {
return (a + b) % P;
});
ans = (ans + P - sum) % P;
}
std::cout << ans << "\n";
} | 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXX = 110;
int n, q, c, mtr[MAXX][MAXX][13], precalc[MAXX][MAXX][13];
int main() {
scanf("%d %d %d", &n, &q, &c);
for (int i = 1, x, y, s; i <= n; ++i) {
scanf("%d %d %d", &x, &y, &s);
mtr[x][y][s]++;
}
for (int i = 0, j, k; i <= c; ++i)
for (j = 1; j <= 100; ++j)
for (k = 1; k <= 100; ++k)
precalc[j][k][i] = precalc[j][k - 1][i] + precalc[j - 1][k][i] -
precalc[j - 1][k - 1][i] + mtr[j][k][i];
while (q--) {
int t, x1, y1, x2, y2, ans = 0;
scanf("%d %d %d %d %d", &t, &x1, &y1, &x2, &y2);
t %= (c + 1);
for (int i = 0; i <= c; ++i)
ans += (precalc[x2][y2][i] - precalc[x2][y1 - 1][i] -
precalc[x1 - 1][y2][i] + precalc[x1 - 1][y1 - 1][i]) *
((i + t) % (c + 1));
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int m, n, a[33];
inline int Ask(int x) {
printf("%d\n", x);
fflush(stdout);
int d = read();
if (!d) exit(0);
return d;
}
int main() {
m = read(), n = read();
for (int i = 1; i <= n; ++i) {
a[i] = Ask(1);
}
int l = 1, r = m + 1, o = 1;
while (l < r) {
int mid = (l + r) >> 1;
int t = Ask(mid) * a[(o - 1) % n + 1];
++o;
if (t == 1) {
l = mid + 1;
} else {
r = mid;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAX_N = (int)1e5 + 123;
const int inf = (int)1e9 + 123;
using namespace std;
int n, m;
int a[25][25];
void solve() {
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= m; j++)
if (a[i][j] != j) cnt++;
if (cnt > 2) return;
}
cout << "YES";
exit(0);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
solve();
for (int j = 1; j <= m; j++)
for (int j2 = j + 1; j2 <= m; j2++) {
for (int i = 1; i <= n; i++) swap(a[i][j], a[i][j2]);
solve();
for (int i = 1; i <= n; i++) swap(a[i][j], a[i][j2]);
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
long long mpow(long long a, long long n) {
if (a == 0) return 1;
if (n == 0) return 1;
if (n == 1) return a;
if (n & 1) return mpow(a, n - 1) * a;
long long dop = mpow(a, n / 2);
return dop * dop;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
if (n <= 3) {
cout << 0;
return 0;
}
vector<long long> v(n + 1);
long long now = 0, mmax = 0;
for (long long c = 2; c < n; c++) {
long long can = (n / c * (c - 1));
can += max((n - c * (n / c) - 1), 0ll);
can -= (c - 1);
if (can > mmax) {
mmax = can;
now = c;
}
}
cout << now << " ";
for (long long c = 1; c < now; c++) {
cout << c << " ";
v[c] = 1;
}
cout << now + 1;
v[now + 1] = 1;
cout << endl;
long long last = now;
long long next = now + 2;
if (next % now == 0) next++;
while (next <= n - 1) {
vector<long long> dd;
long long t;
cin >> t;
for (long long c = t; c < t + last; c++) {
long long e = c;
if (e > n) e -= n;
if (v[e]) dd.push_back(e);
}
last = dd.size() + 1;
cout << last << " ";
for (auto i : dd) cout << i << " ";
cout << next << endl;
v[next] = 1;
next++;
if (next % now == 0) next++;
}
cin >> now;
cout << 0;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
struct cow {
int v, next;
} E[200009 << 1];
int head[200009];
int n, k;
int tot = 0;
void add(int u, int v) {
E[++tot].v = v;
E[tot].next = head[u];
head[u] = tot;
E[++tot].v = u;
E[tot].next = head[v];
head[v] = tot;
}
int dep[200009], fa[200009][30];
void dfs(int u, int faa, int dis) {
dep[u] = dis;
fa[u][0] = faa;
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].v;
if (v == faa) continue;
dfs(v, u, dis + 1);
}
}
void init(int n) {
for (int k = 1; k <= 23; k++) {
for (int i = 1; i <= n; i++) {
fa[i][k] = fa[fa[i][k - 1]][k - 1];
}
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 23; i >= 0; i--) {
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 23; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int get(int a, int b) {
int lca = LCA(a, b);
return dep[a] + dep[b] - dep[lca] * 2;
}
int main() {
int n = read(), u, v, x, y, a, b, k, tmp, cir;
for (int i = 1; i < n; i++) {
u = read();
v = read();
add(u, v);
}
dfs(1, 0, 0);
init(n);
int m = read();
while (m--) {
x = read();
y = read();
a = read();
b = read();
k = read();
tmp = k - get(a, b);
if (tmp >= 0 && tmp % 2 == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, x) + get(b, y) + 1);
if (tmp >= 0 && tmp % 2 == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, y) + get(b, x) + 1);
if (tmp >= 0 && tmp % 2 == 0) {
printf("YES\n");
continue;
}
cir = get(x, y) + 1;
tmp = k - (get(a, x) + get(b, y) + 1);
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, y) + get(b, x) + 1);
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, x) + get(b, y) + get(x, y));
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, y) + get(b, x) + get(x, y));
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int getInt() {
int s;
scanf("%d\n", &s);
return s;
}
int main() {
const int n = getInt();
const int k = getInt();
vector<int> keys(256);
vector<int> used(256);
for (int i = 0; i < (int)(256); i++) keys[i] = i;
for (int i = 0; i < (int)(n); i++) {
const int p = getInt();
int key = p;
for (int j = 0; j < (int)(k); j++)
if (p - j >= 0) {
if (used[p - j]) {
if (keys[p - j] + k - 1 >= p) {
key = keys[p - j];
}
break;
}
if (!used[p - j]) key = p - j;
}
for (int j = key; j <= p; j++) {
keys[j] = key;
used[j] = 1;
}
printf("%d%c", key, i == n - 1 ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if ((long double)a.first / (a.second * 1.0) <
(long double)b.first / (b.second * 1.0))
return true;
else if ((long double)a.first / (a.second * 1.0) ==
(long double)b.first / (b.second * 1.0))
return a.second > b.second;
else
return false;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n % 2 != 0) {
res *= a;
n -= 1;
res %= 1000000007;
} else {
a *= a;
n /= 2;
a %= 1000000007;
}
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
void primeFactors(long long n) {
while (n % 2 == 0) {
cout << 2 << " ";
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cout << i << " ";
n = n / i;
}
}
if (n > 2) {
cout << n << " ";
}
}
void printDivisors(long long n) {
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cout << i << " ";
else
cout << i << " " << n / i << " ";
}
}
}
void BellmanFord(long long graph[][3], long long V, long long E,
long long src) {
long long dis[V];
for (long long i = 0; i < V; i++) dis[i] = INT_MAX;
dis[src] = 0;
for (long long i = 0; i < V - 1; i++) {
for (long long j = 0; j < E; j++) {
if (dis[graph[j][0]] + graph[j][2] < dis[graph[j][1]])
dis[graph[j][1]] = dis[graph[j][0]] + graph[j][2];
}
}
bool flag = true;
for (long long i = 0; i < E; i++) {
long long x = graph[i][0], y = graph[i][1], weight = graph[i][2];
if (dis[x] != INT_MAX && dis[x] + weight < dis[y]) {
flag = false;
break;
}
}
}
void topoSort(long long n, long long m, vector<vector<bool>> &e,
vector<bool> &visited, long long x) {
visited[x] = true;
for (long long i = n - 1; i >= 0; i--) {
if (e[x][i] and !visited[i]) {
topoSort(n, m, e, visited, i);
}
}
return;
}
void convertGraphToTree(long long x, vector<vector<long long>> &v,
vector<bool> &visited,
vector<vector<long long>> &newedges) {
visited[x] = true;
for (long long i = 0; i < v[x].size(); i++) {
if (!visited[v[x][i]]) {
newedges[x].push_back(v[x][i]);
convertGraphToTree(v[x][i], v, visited, newedges);
}
}
return;
}
long long subtreeCount(long long x, vector<vector<long long>> &v,
vector<bool> &visited, vector<long long> &count) {
visited[x] = true;
long long ans = 1;
for (long long i = 0; i < v[x].size(); i++) {
if (!visited[v[x][i]]) {
ans += subtreeCount(v[x][i], v, visited, count);
}
}
count[x] = ans;
return ans;
}
void create_sparse_table(long long n, vector<long long> &v) {
long long k = (long long)log2(n * 1.0);
vector<vector<long long>> st(n + 1, vector<long long>(k + 1, 0));
for (long long i = 0; i < n; i++) st[i][0] = v[i];
for (long long j = 1; j <= k; j++) {
for (long long i = 0; i + (1 << j) <= n; i++)
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
return;
}
vector<long long> fact(200001, 1);
void preNCR() {
for (long long i = 2; i < 200001; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
}
return;
}
long long ncr(long long n, long long r) {
if (r > n) {
return 0;
}
long long res = fact[n];
res *= (power(fact[r], 1000000007 - 2) % 1000000007);
res %= 1000000007;
res *= (power(fact[n - r], 1000000007 - 2) % 1000000007);
res %= 1000000007;
return res;
}
void yes() { cout << "YES" << '\n'; }
void no() { cout << "NO" << '\n'; }
void helper(long long n, vector<long long> &v) {
vector<vector<long long>> temp(62, vector<long long>());
long long largest = -1, thatpow = -1;
for (long long i = 0; i < n; i++) {
long long count = 0;
long long farzi = v[i];
while (v[i] % 2 == 0) v[i] /= 2, count += 1;
temp[count].push_back(farzi);
if (largest < temp[count].size())
largest = max(largest, (long long)temp[count].size()), thatpow = count;
}
long long ans = n - largest;
cout << ans << '\n';
for (long long i = 0; i < 62; i++) {
if (i != thatpow and temp[i].size()) {
for (long long j = 0; j < temp[i].size(); j++) cout << temp[i][j] << '\n';
}
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> v(n, 0);
for (long long i = 0; i < n; i++) cin >> v[i];
helper(n, v);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 16][129];
char c[16], st[4];
int r[16], b[16];
int costb[1 << 16], costr[1 << 16];
int main() {
int i, j, n, k, tr = 0, tb = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%s%d%d", st, &r[i], &b[i]);
c[i] = st[0];
tr += r[i], tb += b[i];
}
for (i = 0; i < 1 << 16; ++i) {
for (j = 0; j < 129; ++j) {
dp[i][j] = -10000000;
}
}
dp[0][0] = 0;
for (i = 0; i < (1 << n); ++i) {
for (j = 0; j < n; ++j) {
if ((1 << j) & i) {
costr[i] += (c[j] == 'R'), costb[i] += (c[j] == 'B');
}
}
}
for (i = 0; i < (1 << n); ++i) {
for (k = 0; k < 129; ++k) {
for (j = 0; j < n; ++j) {
if (i & (1 << j)) continue;
int nxt = i | (1 << j);
int red = min(r[j], costr[i]), blue = min(b[j], costb[i]);
dp[nxt][k + red] = max(dp[nxt][k + red], dp[i][k] + blue);
}
}
}
int ans = 1000000000;
for (i = 0; i < 129; ++i) {
if (dp[(1 << n) - 1][i] >= 0) {
ans = min(ans, n + max(tr - i, tb - dp[(1 << n) - 1][i]));
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct seg {
int l;
int r;
double p;
};
int n;
int a[110000];
int lg[110000];
int st[20][110000];
seg x[5100];
pair<int, int> x2[5100];
set<int> q, q2;
void build() {
for (int i = 0; i <= n; i++)
if (i > 1)
lg[i] = lg[i / 2] + 1;
else
lg[i] = 0;
for (int p = 0; (1 << p) <= n; p++) {
for (int i = 0; i + (1 << p) <= n; i++) {
if (p == 0)
st[p][i] = a[i];
else {
st[p][i] = max(st[p - 1][i], st[p - 1][i + (1 << (p - 1))]);
}
}
}
}
int get(int l, int r) {
int p = lg[r - l + 1];
return max(st[p][l], st[p][r - (1 << p) + 1]);
}
int froms[5010];
double p[5010][5010];
pair<double, double> tmp[5010];
pair<double, double> tmp2[5010];
double ans = 0;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(12);
int m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
build();
for (int i = 0; i < m; i++) {
seg r;
cin >> x[i].l >> x[i].r >> x[i].p;
x2[i] = make_pair(x[i].r - x[i].l, i);
}
m++;
x[m - 1].l = 1;
x[m - 1].r = n;
x[m - 1].p = 0;
x2[m - 1] = make_pair(n - 1, m - 1);
sort(x2, x2 + m);
for (int i = 0; i < m; i++) {
int ind = x2[i].second;
int l = x[ind].l;
int r = x[ind].r;
int from = get(l - 1, r - 1);
froms[ind] = from;
double pp = x[ind].p;
for (int j = 0; j <= 5001; j++) p[ind][j] = 0;
p[ind][0] = 1;
q2 = q;
for (set<int>::iterator it = q.begin(); it != q.end(); it++)
if (x[*it].l >= l && x[*it].r <= r) {
for (int j = 0; j <= 5001; j++) {
tmp[j] = make_pair(p[ind][j], 0.0);
p[ind][j] = 0;
}
double sum = 1;
for (int j = 0; j <= 5001; j++)
if (froms[*it] + j >= from) {
tmp[froms[*it] + j - from].second = p[*it][j];
sum -= p[*it][j];
}
tmp2[0] = make_pair(0, sum);
for (int j = 1; j <= 5001; j++) {
tmp2[j].first = tmp2[j - 1].first + tmp[j - 1].first;
tmp2[j].second = tmp2[j - 1].second + tmp[j - 1].second;
}
q2.erase(*it);
for (int j = 0; j <= 5001; j++) {
if (tmp[j].first != 0 || tmp[j].second != 0) {
p[ind][j] += tmp[j].first * tmp[j].second +
tmp[j].first * tmp2[j].second +
tmp[j].second * tmp2[j].first;
}
}
}
q = q2;
q.insert(x2[i].second);
for (int j = 5001; j >= 0; j--)
if (j)
p[ind][j] = p[ind][j] * (1 - pp) + p[ind][j - 1] * (pp);
else
p[ind][j] = p[ind][j] * (1 - pp);
ans = 0;
if (i == m - 1)
for (int j = 0; j <= 5001; j++)
if (p[ind][j] > 0) {
ans += (from + j) * p[ind][j];
}
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, id;
} t[1000100];
const int B = 1000;
bool cmp(node a, node b) {
if (a.x / 1000 == b.x / 1000)
return ((a.x / 1000) & 1) ? a.y < b.y : a.y > b.y;
return a.x / 1000 < b.x / 1000;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d %d", &t[i].x, &t[i].y), t[i].id = i;
sort(t + 1, t + n + 1, cmp);
for (int i = 1; i <= n; i++) {
printf("%d ", t[i].id);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
if (n > a * b) {
cout << -1;
} else {
bool turn = true;
int cnt1 = 1;
int cnt2 = 2;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
if (turn) {
if (cnt1 <= n) {
cout << cnt1 << " ";
} else {
cout << 0 << " ";
}
cnt1 += 2;
} else {
if (cnt2 <= n) {
cout << cnt2 << " ";
} else {
cout << 0 << " ";
}
cnt2 += 2;
}
turn = !turn;
}
if (b % 2 == 0) {
turn = !turn;
}
cout << endl;
}
}
int j = 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int N, M0[MAXN], M1[MAXN], L;
vector<int> children[MAXN];
void dfs(int u, int len) {
if (len % 2 == 0) {
M1[u] = MAXN;
} else {
M0[u] = MAXN;
}
for (int i = 0; i < ((int)children[u].size()); i++) {
int v = children[u][i];
dfs(v, len + 1);
if (len % 2 == 0) {
M0[u] += M0[v];
M1[u] = min(M1[v], M1[u]);
} else {
M0[u] = min(M0[v], M0[u]);
M1[u] += M1[v];
}
}
if (((int)children[u].size()) == 0) {
M0[u] = 1;
M1[u] = 1;
++L;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> N;
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v;
--u;
--v;
children[u].push_back(v);
}
dfs(0, 0);
int res1 = L - M1[0] + 1;
int res2 = M0[0];
cout << res1 << ' ' << res2 << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int n, a[11111], sum;
bool used[11111];
vector<int> v;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
++a[x];
}
for (int i = 1; i <= 5000; ++i) {
if (a[i] > 0 && i <= n) {
sum += (a[i] - 1);
} else {
sum += a[i];
}
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline void scanint(int& x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
int cmp_double(double a, double b, double eps = 1e-9) {
return a + eps > b ? b + eps > a ? 0 : 1 : -1;
}
using namespace std;
const int INF = 0x3F3F3F3F;
const int NEGINF = 0xC0C0C0C0;
void build(vector<int>& out, vector<vector<int> >& g, vector<int>& e, int v) {
while (!g[v].empty()) {
int ce = g[v].back();
g[v].pop_back();
if (e[ce] == -1) continue;
int nxt = e[ce] - v;
e[ce] = -1;
build(out, g, e, nxt);
}
out.push_back(v);
}
int main() {
int N, M;
scanf(" %d %d", &N, &M);
vector<int> e;
vector<int> deg(N, 0);
vector<vector<int> > g(N);
for (__typeof__(0) i = (0); i < (M); ++i) {
int a, b;
scanf(" %d %d", &a, &b);
a--;
b--;
deg[a]++;
deg[b]++;
g[a].push_back(i);
g[b].push_back(i);
e.push_back(a + b);
}
int last = -1;
for (__typeof__(0) i = (0); i < (N); ++i) {
if (!(deg[i] % 2)) continue;
if (last == -1)
last = i;
else {
g[i].push_back(e.size());
g[last].push_back(e.size());
deg[i]++;
deg[last]++;
e.push_back(last + i);
last = -1;
M++;
}
}
if ((M % 2)) {
g[0].push_back(e.size());
e.push_back(0);
M++;
}
vector<int> out;
build(out, g, e, 0);
printf("%d\n", M);
for (__typeof__(0) i = (0); i < (M); ++i) {
if (i % 2)
printf("%d %d\n", out[i] + 1, out[(i + 1) % out.size()] + 1);
else
printf("%d %d\n", out[(i + 1) % out.size()] + 1, out[i] + 1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007, oo = 1000000009;
void Emsawy() {}
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
vector<vector<pair<int, int> > > adj;
int n, m, k, w, h;
struct Node {
vector<int> ord;
int cnt;
Node() {
ord = vector<int>(26, -1);
cnt = 0;
}
void Add(vector<int>& v) { ord = v; }
};
int main() {
Emsawy();
string a, b;
while (cin >> a >> b) {
vector<Node> L(a.size()), R(a.size());
int po = 0;
for (int i = 0; i < a.size(); i++) {
if (i > 0) L[i].Add(L[i - 1].ord);
if (po < b.size() && b[po] == a[i]) {
L[i].ord[b[po] - 'a'] = i;
po++;
}
L[i].cnt = po;
}
po = b.size() - 1;
for (int i = a.size() - 1; i >= 0; i--) {
if (i < a.size() - 1) R[i].Add(R[i + 1].ord);
if (po >= 0 && b[po] == a[i]) {
R[i].ord[b[po] - 'a'] = i;
po--;
}
R[i].cnt = b.size() - po - 1;
}
bool ok = 1;
for (int i = 0; i < a.size(); i++) {
int pl = L[i].ord[a[i] - 'a'];
int pr = R[i].ord[a[i] - 'a'];
if (pl == -1 && pr == -1) {
ok = 0;
break;
}
int mx = 0;
if (pl != -1) {
mx = max(mx, L[pl].cnt + (i + 1 < a.size() ? R[i + 1].cnt : 0));
}
if (pr != -1) {
mx = max(mx, R[pr].cnt + (i - 1 >= 0 ? L[i].cnt : 0));
}
if (mx < b.size()) {
ok = 0;
break;
}
}
if (ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.