solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], cnt[N];
int n, k;
int main() {
int maxn = 0;
int ans = 0;
int l = 1;
int temp;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &temp);
if (temp != a[l - 1]) {
a[l++] = temp;
}
}
for (int i = 1; i <= l - 1; i++) {
if (a[i - 1] == a[i + 1]) {
cnt[a[i]] += 2;
} else {
cnt[a[i]]++;
}
}
maxn = cnt[1];
ans = 1;
for (int i = 2; i <= k; i++) {
if (cnt[i] > maxn) {
maxn = cnt[i];
ans = i;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long min(long long a, long long b) { return (a < b) ? a : b; }
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long fp(long long a, long long b) {
if (b == 0) return 1;
long long x = fp(a, b / 2);
x = (x * x) % mod;
if (b & 1) x = (x * a) % mod;
return x;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n = 3, m = 4;
long long a[n + 1][m + 1];
long long k;
cin >> k;
long long x = 1;
while (x <= k) x <<= 1;
;
long long y = 2 * x;
long long mat[3][4] = {
{x + k, k, k, k}, {x, y, k, x}, {x + k, x + k, x + k, k}};
cout << n << " " << m << "\n";
for (long long i = 0; i < 3; i++) {
for (long long j = 0; j < 4; j++) cout << mat[i][j] << " ";
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
const int M = 200000 + 5;
const int INF = 1000000000;
const int lim = 314000000;
int n, m, cnt[M], v[M], to[M], minv[N], maxv[N], used[N];
bool vis[N], inf[N];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
vector<int> rel[N], use[N], rule[M];
inline void cmin(int& x, int y) {
if (y < x) x = y;
}
inline void cmax(int& x, int y) {
if (y > x) x = y;
}
inline void dij(void) {
int now;
vector<int>::iterator iter;
while (!pq.empty()) {
while (!pq.empty() && vis[pq.top().second]) pq.pop();
if (pq.empty()) break;
vis[now = pq.top().second] = 1;
pq.pop();
for (iter = rel[now].begin(); iter != rel[now].end(); ++iter) {
cmin(v[*iter] += minv[now], lim);
if (!--cnt[*iter])
cmin(minv[to[*iter]], v[*iter]),
pq.push(make_pair(minv[to[*iter]], to[*iter]));
}
}
}
inline int dfs(int now) {
if (used[now]) return maxv[now];
used[now] = 1;
vector<int>::iterator iter, it;
bool flag, cyc = 0;
int sum;
for (iter = use[now].begin(); iter != use[now].end(); ++iter) {
flag = 1;
sum = 0;
for (it = rule[*iter].begin(); it != rule[*iter].end(); ++it)
if (minv[*it] == INF) {
flag = 0;
break;
}
if (!flag) continue;
for (it = rule[*iter].begin(); it != rule[*iter].end(); ++it) {
if (!~(*it))
cmin(++sum, lim);
else if (used[*it] == 1)
cyc = 1;
else {
cmin(sum += dfs(*it), lim);
if (inf[*it]) cyc = 1;
}
}
cmax(maxv[now], min(sum, lim));
if (cyc) {
inf[now] = 1;
break;
}
}
used[now] = 2;
return maxv[now];
}
int main() {
int w, x;
scanf("%d%d", &m, &n);
for (int i = 1; i <= n; ++i) minv[i] = INF;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &to[i], &w);
use[to[i]].push_back(i);
for (int j = 1; j <= w; ++j) {
scanf("%d", &x);
rule[i].push_back(x);
if (!~x)
++v[i];
else
++cnt[i], rel[x].push_back(i);
}
if (!cnt[i])
cmin(minv[to[i]], v[i]), pq.push(make_pair(minv[to[i]], to[i]));
}
dij();
for (int i = 1; i <= n; ++i)
if (minv[i] != INF) dfs(i);
for (int i = 1; i <= n; ++i)
if (minv[i] == INF)
puts("-1 -1");
else
printf("%d %d\n", minv[i], inf[i] ? -2 : maxv[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0) * 2;
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T min1(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
template <class T>
inline int bitnum(T num) {
int ans = 0;
while (num) {
num -= lb(num);
ans++;
}
return ans;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 200100;
template <class t>
struct segment_node {
int be, en;
t maxv, add, sum, minv;
};
template <class t>
struct segment_tree {
int l;
segment_node<t> tree[maxn];
inline int gleft(int no) { return no << 1; }
inline int gright(int no) { return (no << 1) + 1; }
inline int gfa(int no) { return no >> 1; }
inline segment_tree() { l = 0; }
void build(int no, int l, int r, t orig = 0, t *a = NULL) {
if (l == r) {
tree[no].be = tree[no].en = l;
tree[no].add = 0;
if (a == NULL)
tree[no].maxv = orig, tree[no].minv = orig;
else
tree[no].maxv = a[l], tree[no].minv = a[l];
tree[no].add = 0;
tree[no].sum = tree[no].maxv;
return;
}
tree[no].be = l;
tree[no].en = r;
int mid = (l + r) / 2;
build(gleft(no), l, mid, orig, a);
build(gright(no), mid + 1, r, orig, a);
tree[no].sum = tree[gleft(no)].sum + tree[gright(no)].sum;
tree[no].add = 0;
tree[no].maxv = max1(tree[gleft(no)].maxv, tree[gright(no)].maxv);
tree[no].minv = min1(tree[gleft(no)].minv, tree[gright(no)].minv);
}
void down(int l, int r, int no, t ranadd) {
if (l <= tree[no].be && r >= tree[no].en) {
tree[no].add += ranadd;
tree[no].sum += ranadd * (tree[no].en - tree[no].be + 1);
tree[no].maxv = ranadd;
tree[no].minv = ranadd;
return;
}
int mid = (tree[no].be + tree[no].en) / 2;
if (r >= tree[no].be && l <= mid) down(l, r, gleft(no), ranadd);
if (r >= mid + 1 && l <= tree[no].en) down(l, r, gright(no), ranadd);
tree[no].sum = tree[no].add * (tree[no].en - tree[no].be + 1) +
tree[gleft(no)].sum + tree[gright(no)].sum;
tree[no].maxv = max1(tree[gleft(no)].maxv, tree[gright(no)].maxv);
tree[no].minv = min1(tree[gleft(no)].minv, tree[gright(no)].minv);
}
t getsum(int l, int r, int no) {
if (l > r) return 0;
if (l <= tree[no].be && r >= tree[no].en) return tree[no].sum;
t ans = 0;
int mid = (tree[no].be + tree[no].en) / 2;
if (r >= tree[no].be && l <= mid)
ans += getsum(max1(l, tree[no].be), min1(r, mid), gleft(no));
if (r >= mid + 1 && l <= tree[no].en)
ans += getsum(max1(l, mid + 1), min1(r, tree[no].en), gright(no));
ans += tree[no].add * (r - l + 1);
return ans;
}
int getrank(int rank, int no) {
if (rank > tree[no].sum) return -1;
if (tree[no].be == tree[no].en) return tree[no].be;
int mid = (tree[no].be + tree[no].en) / 2;
if (rank <= tree[gleft(no)].sum + tree[no].add * (mid - tree[no].be + 1))
return getrank(rank, gleft(no));
return getrank(
rank - (tree[gleft(no)].sum + tree[no].add * (mid - tree[no].be + 1)),
gright(no));
}
inline int section_getrank(int l, int r, int rank) {
return getrank(rank + getsum(0, l - 1, 1), 1);
}
t findminormax(int l, int r, int no, int cate) {
if (l > r) return -1;
if (l <= tree[no].be && r >= tree[no].en) {
if (cate)
return tree[no].maxv;
else
return tree[no].minv;
}
t ans = 0, ans1;
if (cate == 0) ans = ans1 = 1000000000;
int mid = (tree[no].be + tree[no].en) / 2;
if (r >= tree[no].be && l <= mid)
ans = findminormax(max1(l, tree[no].be), min1(r, mid), gleft(no), cate);
if (r >= mid + 1 && l <= tree[no].en)
ans1 = findminormax(max1(l, mid + 1), min1(r, tree[no].en), gright(no),
cate);
if (cate) return max1(ans, ans1);
return min1(ans, ans1);
}
};
int l, nq;
char str[maxn];
int fa[maxn];
int dp[maxn][10], sum[maxn][10], dpri[maxn][10], realst[maxn][10],
realdp[maxn][10];
vector<int> co, cole, cori;
struct node {
int dp[10], no;
} st[maxn];
int lst;
segment_tree<int> sgt;
struct query {
int be, en, no;
int ans[10];
} que[maxn];
inline bool cmp1(const query &a, const query &b) { return a.be > b.be; }
inline bool cmp2(const query &a, const query &b) { return a.no < b.no; }
int main() {
scanf("%d%d", &l, &nq);
scanf("%s", str);
for (int i = 0; i < l; i++) {
if (i != 0)
for (int j = 0; j < 10; j++)
sum[i][j] = sum[i - 1][j], realst[i][j] = realst[i - 1][j];
if (str[i] == '<') {
co.push_back(i);
bool ff = 1;
while (lst != 0 && ff) {
int maxnum = 9;
while (st[lst - 1].dp[maxnum] == 0 && maxnum > -1) maxnum--;
for (int i1 = 0; i1 < 10; i1++)
realst[i][i1] -= st[lst - 1].dp[i1],
realdp[i][i1] += st[lst - 1].dp[i1];
if ((maxnum & 1) == 0) {
fa[i] = st[lst - 1].no;
memcpy(dp[i], st[lst - 1].dp, sizeof(st[lst - 1].dp));
memset(st[lst - 1].dp, 0, sizeof(st[lst - 1].dp));
ff = 0;
} else {
lst--;
fa[st[lst].no] = i;
memcpy(dp[st[lst].no], st[lst].dp, sizeof(st[lst].dp));
}
}
if (ff) fa[i] = -1;
} else if (str[i] == '>') {
co.push_back(i);
if (lst > 0) {
int k = 0;
for (int i1 = 0; i1 < 10; i1++) k |= st[lst - 1].dp[i1];
if (k == 0) fa[st[--lst].no] = i;
}
memset(st[lst].dp, 0, sizeof(st[lst]));
st[lst++].no = i;
} else {
if (lst > 0) st[lst - 1].dp[str[i] - '0']++;
sum[i][str[i] - '0']++;
realst[i][str[i] - '0']++;
}
}
while (lst > 0) {
lst--;
fa[st[lst].no] = l;
memcpy(dp[st[lst].no], st[lst].dp, sizeof(st[lst].dp));
}
for (int i = 0; i < (int)co.size(); i++) {
if (str[co[i]] == '>')
memcpy(dpri[co[i]], dp[co[i]], sizeof(dp[co[i]])), cori.push_back(co[i]);
else
cole.push_back(co[i]);
}
for (int i = 1; i < l; i++)
for (int j = 0; j < 10; j++) dp[i][j] += dp[i - 1][j];
for (int i = 1; i < l; i++)
for (int j = 0; j < 10; j++) realdp[i][j] += realdp[i - 1][j];
for (int i = 1; i < l; i++)
for (int j = 0; j < 10; j++) dpri[i][j] += dpri[i - 1][j];
for (int i = 0; i < nq; i++) {
scanf("%d%d", &que[i].be, &que[i].en);
que[i].no = i;
que[i].be--;
que[i].en--;
}
sort(que, que + nq, cmp1);
sgt.build(1, 0, l + 2, l + 1);
for (int i1 = l - 1, j = 0; i1 >= 0; i1--) {
if (str[i1] == '<' || str[i1] == '>')
sgt.down(fa[i1] + 1, fa[i1] + 1, 1, i1);
for (; j < nq && que[j].be == i1; j++) {
vector<int>::iterator it;
int link = min1(sgt.findminormax(0, que[j].be, 1, 0),
sgt.findminormax(que[j].en + 2, l + 2, 1, 0));
if (link > que[j].en || link < que[j].be) {
if (que[j].be != 0)
for (int k = 0; k < 10; k++)
que[j].ans[k] = sum[que[j].en][k] - sum[que[j].be - 1][k];
else
for (int k = 0; k < 10; k++) que[j].ans[k] = sum[que[j].en][k];
continue;
}
if (str[link] == '<') {
if (link == 0) continue;
it = lower_bound(co.begin(), co.end(), que[j].be);
if (*it != 0)
for (int k = 0; k < 10; k++)
que[j].ans[k] = dp[link - 1][k] - dp[*it - 1][k];
else
for (int k = 0; k < 10; k++) que[j].ans[k] = dp[link - 1][k];
for (int k = 8; k >= 0; k--) que[j].ans[k] += que[j].ans[k + 1];
if (que[j].be != 0)
for (int k = 0; k < 10; k++) {
que[j].ans[k] += sum[*it - 1][k] - sum[que[j].be - 1][k];
if (k != 0)
que[j].ans[k - 1] += sum[*it - 1][k] - sum[que[j].be - 1][k];
}
else if (*it != 0)
for (int k = 0; k < 10; k++) {
que[j].ans[k] += sum[*it - 1][k];
if (k != 0) que[j].ans[k - 1] += sum[*it - 1][k];
}
} else {
if (que[j].be != 0) {
for (int k = 0; k < 10; k++)
que[j].ans[k] += realdp[que[j].en][k] - realdp[que[j].be - 1][k];
for (int k = 8; k >= 0; k--) que[j].ans[k] += que[j].ans[k + 1];
for (int k = 0; k < 10; k++)
que[j].ans[k] += realst[que[j].en][k] - realst[que[j].be - 1][k];
} else {
for (int k = 0; k < 10; k++) que[j].ans[k] += realdp[que[j].en][k];
for (int k = 8; k >= 0; k--) que[j].ans[k] += que[j].ans[k + 1];
for (int k = 0; k < 10; k++) que[j].ans[k] += realst[que[j].en][k];
}
}
}
}
sort(que, que + nq, cmp2);
for (int i = 0; i < nq; i++) {
for (int j = 0; j < 10; j++) printf("%d ", que[i].ans[j]);
printf("\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5) + 10;
const int LOGN = 20;
const int INF = int(2e9);
vector<int> tree[N];
int DP[N][LOGN];
int root;
int visited[N];
int n, m;
int prefixSumTime[N];
int level[N];
vector<pair<int, int> > ST[4 * N];
int baseArray[N];
int posInBaseArray[N];
int lenBA;
int numChain[N];
int chainHead[N];
int chainParent[N];
int sizeSubtree[N];
int chainNo;
void dfs(int u) {
visited[u] = 1;
sizeSubtree[u] = 1;
for (int i = 0; i < (int)(tree[u].size()); i++) {
int w = tree[u][i];
if (!visited[w]) {
level[w] = level[u] + 1;
dfs(w);
sizeSubtree[u] += sizeSubtree[w];
}
}
}
void HLD(int u) {
visited[u] = 1;
numChain[u] = chainNo;
posInBaseArray[u] = lenBA;
baseArray[lenBA++] = u;
int sc = -1;
int mx = -INF;
for (int i = 0; i < (int)(tree[u].size()); i++) {
int w = tree[u][i];
if (!visited[w] && sizeSubtree[w] > mx) {
sc = w;
mx = sizeSubtree[w];
}
}
if (sc != -1) HLD(sc);
for (int i = 0; i < (int)(tree[u].size()); i++) {
int w = tree[u][i];
if (!visited[w]) {
chainNo++;
chainHead[chainNo] = w;
chainParent[chainNo] = u;
HLD(w);
}
}
}
void build_ST(int node = 1, int l = 0, int r = lenBA) {
if (l == r - 1) {
ST[node].push_back(make_pair(0, 0));
return;
}
int leftChild = node << 1;
int rightChild = leftChild | 1;
int mid = (l + r) >> 1;
build_ST(leftChild, l, mid);
build_ST(rightChild, mid, r);
int la = ST[leftChild][0].second;
int ra = ST[rightChild][0].second;
ST[node].push_back(make_pair(0, la + ra));
}
void update_ST(int pos, int val, int year, int node = 1, int l = 0,
int r = lenBA) {
if (l == pos && l == r - 1) {
ST[node].push_back(make_pair(year, val));
return;
}
int leftChild = node << 1;
int rightChild = leftChild | 1;
int mid = (l + r) >> 1;
if (pos < mid)
update_ST(pos, val, year, leftChild, l, mid);
else
update_ST(pos, val, year, rightChild, mid, r);
int lc = (int)(ST[leftChild].size()) - 1;
int rc = (int)(ST[rightChild].size()) - 1;
ST[node].push_back(
make_pair(year, ST[leftChild][lc].second + ST[rightChild][rc].second));
}
int query_ST_ok(int L, int R, int year, int node = 1, int l = 0,
int r = lenBA) {
if (L <= l && r <= R) {
vector<pair<int, int> > &A = ST[node];
int l = 0, h = (int)(A.size()) - 1;
int ans;
while (l < h - 1) {
int m = (l + h) >> 1;
if (A[m].first <= year)
l = m;
else if (A[m].first > year)
h = m - 1;
}
if (A[h].first <= year)
ans = h;
else
ans = l;
int destroyed = A[(int)(A.size()) - 1].second - A[ans].second;
int total = (r - l);
return total - destroyed;
}
if (l >= R || r <= L) return 0;
int leftChild = node << 1;
int rightChild = leftChild | 1;
int mid = (l + r) >> 1;
int leftAns = query_ST_ok(L, R, year, leftChild, l, mid);
int rightAns = query_ST_ok(L, R, year, rightChild, mid, r);
return leftAns + rightAns;
}
pair<int, int> query_ST_ans_left(int L, int R, int K, int year, int node = 1,
int l = 0, int r = lenBA) {
if (l >= R || r <= L) return make_pair(0, -1);
pair<int, int> la, ra;
if (L <= l && r <= R) {
vector<pair<int, int> > &A = ST[node];
int low = 0, high = (int)(A.size()) - 1;
int ans;
while (low < high - 1) {
int mid = (low + high) >> 1;
if (A[mid].first <= year)
low = mid;
else if (A[mid].first > year)
high = mid - 1;
}
if (A[high].first <= year)
ans = high;
else
ans = low;
int destroyed = A[(int)(A.size()) - 1].second - A[ans].second;
int total = r - l;
int n = total - destroyed;
if (n < K) return make_pair(n, -1);
if (l == r - 1) return make_pair(n, l);
int lc = node << 1;
int rc = lc | 1;
int mid = (l + r) >> 1;
la = query_ST_ans_left(L, R, K, year, lc, l, mid);
if (la.second != -1) return la;
return query_ST_ans_left(L, R, K - la.first, year, rc, mid, r);
}
int lc = node << 1;
int rc = lc | 1;
int mid = (l + r) >> 1;
la = query_ST_ans_left(L, R, K, year, lc, l, mid);
if (la.second != -1) return la;
ra = query_ST_ans_left(L, R, K - la.first, year, rc, mid, r);
if (ra.second != -1) return ra;
return make_pair(la.first + ra.first, -1);
}
pair<int, int> query_ST_ans_right(int L, int R, int K, int year, int node = 1,
int l = 0, int r = lenBA) {
if (l >= R || r <= L) return make_pair(0, -1);
pair<int, int> la, ra;
if (L <= l && r <= R) {
vector<pair<int, int> > &A = ST[node];
int low = 0, high = (int)(A.size()) - 1;
int ans;
while (low < high - 1) {
int mid = (low + high) >> 1;
if (A[mid].first <= year)
low = mid;
else if (A[mid].first > year)
high = mid - 1;
}
if (A[high].first <= year)
ans = high;
else
ans = low;
int destroyed = A[(int)(A.size()) - 1].second - A[ans].second;
int total = r - l;
int n = total - destroyed;
if (n < K) return make_pair(n, -1);
if (l == r - 1) return make_pair(n, l);
int lc = node << 1;
int rc = lc | 1;
int mid = (l + r) >> 1;
ra = query_ST_ans_right(L, R, K, year, rc, mid, r);
if (ra.second != -1) return ra;
return query_ST_ans_right(L, R, K - ra.first, year, lc, l, mid);
}
int lc = node << 1;
int rc = lc | 1;
int mid = (l + r) >> 1;
ra = query_ST_ans_right(L, R, K, year, rc, mid, r);
if (ra.second != -1) return ra;
la = query_ST_ans_right(L, R, K - ra.first, year, lc, l, mid);
if (la.second != -1) return la;
return make_pair(la.first + ra.first, -1);
}
int a, b, k, y;
int query_up_ans(int u, int p, int year, int &k) {
pair<int, int> ret;
if (u == DP[u][0]) return -1;
u = DP[u][0];
while (numChain[u] != numChain[p]) {
ret = query_ST_ans_right(posInBaseArray[chainHead[numChain[u]]],
posInBaseArray[u] + 1, k, year);
if (ret.second != -1) return ret.second;
u = chainParent[numChain[u]];
k -= ret.first;
}
ret = query_ST_ans_right(posInBaseArray[p] + (p == b ? 1 : 0),
posInBaseArray[u] + 1, k, year);
if (ret.second != -1) return ret.second;
k -= ret.first;
return -1;
}
int query_down_ans(int p, int v, int year, int &k) {
pair<int, int> ret;
if (v == DP[v][0]) return -1;
v = DP[v][0];
stack<pair<int, int> > Q;
while (numChain[v] != numChain[p]) {
Q.push(make_pair(posInBaseArray[chainHead[numChain[v]]],
posInBaseArray[v] + 1));
v = chainParent[numChain[v]];
}
Q.push(make_pair(posInBaseArray[p] + 1, posInBaseArray[v] + 1));
while (!Q.empty()) {
int l = Q.top().first, r = Q.top().second;
Q.pop();
ret = query_ST_ans_left(l, r, k, year);
if (ret.second != -1) return ret.second;
k -= ret.first;
}
return -1;
}
int lca(int a, int b) {
if (level[a] > level[b]) swap(a, b);
int d = level[b] - level[a];
for (int i = 0; (1 << i) <= d; i++)
if (d & (1 << i)) b = DP[b][i];
if (a == b) return a;
int msb = 0;
for (int i = 0; DP[a][i] != DP[b][i]; i++) msb = i;
for (int i = msb; i >= 0; i--)
if (DP[a][i] != DP[b][i]) {
a = DP[a][i];
b = DP[b][i];
}
return DP[a][0];
}
void processTree() {
memset(visited, 0, sizeof(visited));
level[root] = 0;
dfs(root);
memset(visited, 0, sizeof(visited));
chainNo = 0;
lenBA = 0;
chainHead[chainNo] = root;
chainParent[chainNo] = root;
HLD(root);
build_ST();
for (int i = 1; i < LOGN; i++)
for (int j = 0; j < n; j++) DP[j][i] = DP[DP[j][i - 1]][i - 1];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int v;
scanf("%d", &v);
if (v == 0) {
root = i;
DP[root][0] = root;
} else {
tree[v - 1].push_back(i);
tree[i].push_back(v - 1);
DP[i][0] = v - 1;
}
}
processTree();
scanf("%d", &m);
for (int year = 1; year <= m; year++) {
int t;
scanf("%d", &t);
if (t == 1) {
int c;
scanf("%d", &c);
c--;
update_ST(posInBaseArray[c], 1, year);
} else {
scanf("%d %d %d %d", &a, &b, &k, &y);
a--;
b--;
int LCA = lca(a, b);
if (LCA == a) {
int ans = query_down_ans(a, b, y, k);
if (ans == -1)
printf("%d\n", ans);
else
printf("%d\n", baseArray[ans] + 1);
continue;
}
if (LCA == b) {
int ans = query_up_ans(a, b, y, k);
if (ans == -1)
printf("%d\n", ans);
else
printf("%d\n", baseArray[ans] + 1);
continue;
}
int up = query_up_ans(a, LCA, y, k);
if (up != -1) {
printf("%d\n", baseArray[up] + 1);
continue;
}
int down = query_down_ans(LCA, b, y, k);
if (down != -1) {
printf("%d\n", baseArray[down] + 1);
continue;
}
printf("%d\n", -1);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char IO;
int rd() {
int s = 0, f = 0;
while (!isdigit(IO = getchar()))
if (IO == '-') f = 1;
do s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 5011, INF = 1e9 + 10;
int n;
char s[N];
struct Node {
int opt;
long long x;
} a[N], b[N];
long long Solve(Node *s, int l, int r) {
long long t = s[l].x, res = 0;
for (int i = l + 1, iend = r; i <= iend; ++i) {
if (s[i].opt == 1)
t *= s[i].x;
else
res += t, t = s[i].x;
}
return res + t;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i += 2)
a[i / 2 + 1].opt = (s[i - 1] != '+'), a[i / 2 + 1].x = s[i] - '0';
n = n / 2 + 1;
long long ans = Solve(a, 1, n);
for (int i = 1, iend = n; i <= iend; ++i)
if (a[i].opt)
for (int j = i + 1, jend = n + 1; j <= jend; ++j)
if (a[j].opt || j == n + 1) {
long long t = Solve(a, i, j - 1);
int c = 0;
for (int k = 1, kend = i - 1; k <= kend; ++k) b[++c] = a[k];
b[++c] = (Node){1, t};
for (int k = j, kend = n; k <= kend; ++k) b[++c] = a[k];
ans = max(ans, Solve(b, 1, c));
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXPOW = 20;
const int MAXA = 1048577;
const int MAXN = 100009;
const int MAXM = 100009;
int n, m;
vector<int> q;
vector<int> a;
int dp[MAXN];
int sum[MAXM];
int getSum(int l, int r) {
l--;
if (l < 0) return sum[r];
return sum[r] - sum[l];
}
int solve(int pos) {
if (pos >= n) {
return 0;
}
if (dp[pos] == -1) {
dp[pos] = a[pos] + solve(pos + 1);
for (int i = 0; i < min(m, 100); ++i) {
if (pos + q[i] > n) {
break;
}
if (pos + q[i] + 1 <= n) {
dp[pos] =
min(dp[pos], solve(pos + q[i] + 1) + getSum(pos, pos + q[i] - 1));
}
if (pos + q[i] + 2 <= n) {
dp[pos] =
min(dp[pos], solve(pos + q[i] + 2) + getSum(pos, pos + q[i] - 1));
}
}
}
return dp[pos];
}
void gen() {
freopen("input.txt", "w", stdout);
int m = 100000;
printf("%d\n", m);
for (int i = 0; i < m; ++i) {
printf("%d ", i + 1);
}
printf("\n");
int n = 100000;
printf("%d\n", n);
for (int j = 0; j < n; ++j) {
printf("%d ", j + 1);
}
exit(0);
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &m);
q.resize(m);
for (int i = 0; i < m; ++i) {
scanf("%d", &q[i]);
}
scanf("%d", &n);
a.resize(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(q.begin(), q.end());
q.resize(unique(q.begin(), q.end()) - q.begin());
sort(a.begin(), a.end(), greater<int>());
sum[0] = a[0];
for (int i = 1; i < n; ++i) sum[i] = sum[i - 1] + a[i];
cout << solve(0) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long mod = 998244353;
const int inf = 0x3f3f3f3f;
int co[maxn];
int main() {
ios::sync_with_stdio(false);
int n, m, k, t, a, b, c, d;
cin >> a >> b >> c >> d;
cout << 2 * (b + d + 2) + 2 * (max(a, c) + 2) - 4;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void get(int &v) {
char c;
while ((c = getchar()) != EOF && isdigit(c) == 0)
;
v = c - '0';
while ((c = getchar()) != EOF && isdigit(c))
v = (v << 3) + (v << 1) + c - '0';
return;
}
int pow_mod(long long a, int x) {
int ans = 1;
while (x) {
if (x & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
x >>= 1;
}
return ans;
}
int a[200000 + 80];
int main() {
int n, i, ans = 0;
long long f = 1, tmp;
get(n);
for (i = 1; i <= n; i++) get(a[i]);
switch (n % 4) {
case 0:
for (i = 1; i <= (n >> 1); i++) {
ans = (ans + (a[(i << 1) - 1] - a[(i << 1)]) * f) % 1000000007;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i, 1000000007 - 2) %
1000000007;
}
break;
case 1:
for (i = 0; i <= (n >> 1); i++) {
ans = (ans + a[(i << 1) + 1] * f) % 1000000007;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i + 1, 1000000007 - 2) %
1000000007;
}
break;
case 2:
for (i = 1; i <= (n >> 1); i++) {
ans = (ans + (a[(i << 1) - 1] + a[(i << 1)]) * f) % 1000000007;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i, 1000000007 - 2) %
1000000007;
}
break;
case 3:
ans = a[1];
for (i = 1; i <= (n >> 1); i++) {
ans = (ans + ((a[i << 1] * f) << 1)) % 1000000007;
tmp = f;
f = f * ((n >> 1) - i) % 1000000007 * pow_mod(i, 1000000007 - 2) %
1000000007;
ans = (ans + (f - tmp) * a[(i << 1) + 1]) % 1000000007;
}
break;
}
printf("%d", (ans + 1000000007) % 1000000007);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main(void) {
printf("2000\n");
for (int i(0); i < 1000; ++i) printf("%d %d %d %d\n", i + 1, 2, i + 1, 1);
for (int i(0); i < 1000; ++i)
printf("%d %d %d %d\n", 1000 - i, 2, 1000 - i, 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a;
int k;
int main() {
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
};
cin >> a >> k;
int n = a.length();
for (int i = 0; k > 0 && i < n; i++) {
int vt = i;
for (int j = i + 1; j < n && j - i <= k; j++)
if (a[j] > a[vt]) vt = j;
if (vt != i) {
for (int j = vt - 1; j >= i; j--) swap(a[j], a[j + 1]);
k -= vt - i;
}
}
cout << a << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char bits[1000];
int main() {
int bit_number, count = 0;
cin >> bit_number;
for (int i = 0; i < bit_number; i++) {
cin >> bits[i];
}
int i = 0;
while (bits[i] == '1') {
count++;
i++;
}
cout << min(bit_number, ++count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t1 = 9, t2 = 1, t3 = 10, answer = 0;
cin >> n;
while (t3 <= n) {
answer += t1 * t2;
t1 *= 10;
t2++;
t3 *= 10;
}
answer += (n - t3 / 10 + 1) * t2;
cout << answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long sum[20], num[20];
long long k;
void init() {
long long cnt = 9;
num[1] = 9;
sum[1] = 45;
for (int i = 2; i < 20; i++) {
cnt *= 10;
num[i] = num[i - 1] + cnt * i;
sum[i] = sum[i - 1] + (num[i - 1] + i + num[i]) * cnt / 2;
if (sum[i] > 1e18) break;
}
}
int findans(long long x, int pos) {
int s[20];
int top = 0;
while (x > 0) {
s[++top] = x % 10;
x /= 10;
}
return s[top - pos + 1];
}
void solve() {
long long pos = -1;
for (int i = 1; i <= 10; i++) {
if (sum[i] >= k) {
pos = i;
break;
}
}
k -= sum[pos - 1];
int tt = 9;
for (int i = 1; i < pos; i++) {
tt *= 10;
}
long long l = 0, r = tt, ans = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
long long tot = (num[pos - 1] + mid * pos + num[pos - 1] + pos) * mid / 2;
if (tot < k) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
k -= (num[pos - 1] + ans * pos + num[pos - 1] + pos) * ans / 2;
long long cnt = 9;
if (k <= 9) {
cout << k << endl;
return;
}
k -= 9;
pos = -1;
for (long long i = 2; i <= 10; i++) {
cnt *= 10;
if (cnt * i < k) {
k -= cnt * i;
} else {
pos = i;
break;
}
}
cnt /= 9;
cnt += k / pos - 1;
if (k % pos == 0) {
cout << cnt % 10 << endl;
return;
} else {
long long inde = k % pos;
cnt++;
cout << findans(cnt, inde) << endl;
}
}
int main() {
init();
int q;
cin >> q;
while (q--) {
cin >> k;
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[12], c = 0;
cin >> n;
for (int i = 0; i < 12; i++) {
cin >> a[i];
c += a[i];
}
if (c < n)
cout << "-1" << endl;
else {
c = 0;
sort(a, a + 12);
reverse(a, a + 12);
for (int i = 0; i < 12; i++) {
if (n > 0)
c++;
else
break;
n -= a[i];
}
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long sz = 2e5 + 10;
struct node {
long long v, flow, id, dir;
};
vector<node> g[sz];
long long flow[sz];
bool dir[sz], vis[sz];
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; ++i) {
long long u, v, c;
scanf("%lld", &u), scanf("%lld", &v), scanf("%lld", &c);
g[u].push_back({v, c, i, 0});
g[v].push_back({u, c, i, 1});
flow[u] += c, flow[v] += c;
}
for (long long i = 2; i < n; i++) flow[i] /= 2;
queue<long long> q;
q.push(1);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (node &nd : g[u]) {
if (vis[nd.id]) continue;
vis[nd.id] = 1, dir[nd.id] = nd.dir;
flow[nd.v] -= nd.flow;
if (nd.v != n && flow[nd.v] == 0) q.push(nd.v);
}
}
for (long long i = 1; i <= m; ++i) printf("%d\n", (int)dir[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[5][5], x;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
a[i][j] = 0;
}
}
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cin >> x;
a[i][j] += x;
a[i - 1][j] += x;
a[i + 1][j] += x;
a[i][j - 1] += x;
a[i][j + 1] += x;
}
}
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (a[i][j] & 1) {
cout << 0;
} else {
cout << 1;
}
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
int n, q;
char A[maxn];
int m, sa[maxn], rk[maxn], ht[maxn], tp[maxn], bf[maxn], buk[maxn], lg[maxn],
st[18][maxn];
void radix_sort() {
memset(buk, 0, (m + 1) << 2);
for (int i = (1), iend = (n); i <= iend; ++i) buk[bf[i] = rk[tp[i]]]++;
for (int i = (1), iend = (m); i <= iend; ++i) buk[i] += buk[i - 1];
for (int i = (n), iend = (1); i >= iend; --i) sa[buk[bf[i]]--] = tp[i];
}
void suffix_sort() {
m = 150;
for (int i = (1), iend = (n); i <= iend; ++i) rk[i] = A[i], tp[i] = i;
radix_sort();
for (int k = 1; k <= n; k <<= 1) {
int num = 0;
for (int i = (n), iend = (n - k + 1); i >= iend; --i) tp[++num] = i;
for (int i = (1), iend = (n); i <= iend; ++i)
if (sa[i] > k) tp[++num] = sa[i] - k;
radix_sort();
swap(rk, tp), rk[sa[1]] = 1, num = 1;
for (int i = (2), iend = (n); i <= iend; ++i)
rk[sa[i]] = num +=
tp[sa[i]] != tp[sa[i - 1]] || tp[sa[i] + k] != tp[sa[i - 1] + k];
if (n == num) break;
m = num;
}
for (int i = 1, j = 0; i <= n; i++) {
if (j) j--;
while (A[i + j] == A[sa[rk[i] - 1] + j]) j++;
ht[rk[i]] = j;
}
for (int i = (2), iend = (n); i <= iend; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = (1), iend = (n); i <= iend; ++i) st[0][i] = ht[i];
for (int i = (1), iend = (17); i <= iend; ++i)
for (int j = (1), jend = (n - (1 << i) + 1); j <= jend; ++j)
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
int qmin(int l, int r) {
int k = lg[r - l + 1];
return min(st[k][l], st[k][r - (1 << k) + 1]);
}
int main() {
scanf("%d%d%s", &n, &q, A + 1);
suffix_sort();
while (q--) {
static int st[maxn], lef[maxn], rig[maxn], X[maxn], Y[maxn], V[maxn],
val[maxn];
int top = 0;
int cx, cy;
scanf("%d%d", &cx, &cy);
int sz = cx + cy;
for (int i = (1), iend = (cx); i <= iend; ++i)
scanf("%d", &X[i]), V[i] = X[i] = rk[X[i]];
for (int i = (1), iend = (cy); i <= iend; ++i)
scanf("%d", &Y[i]), V[cx + i] = Y[i] = rk[Y[i]];
sort(X + 1, X + cx + 1), sort(Y + 1, Y + cy + 1), sort(V + 1, V + sz + 1),
sz = unique(V + 1, V + sz + 1) - V - 1;
long long ans = 0;
set<int> vis;
for (int i = (1), iend = (cx); i <= iend; ++i) vis.insert(X[i]);
for (int i = (1), iend = (cy); i <= iend; ++i)
if (vis.count(Y[i])) ans += n - sa[Y[i]] + 1;
set<int> visy;
for (int i = (1), iend = (cy); i <= iend; ++i) visy.insert(Y[i]);
for (int i = (2), iend = (sz); i <= iend; ++i)
val[i] = qmin(V[i - 1] + 1, V[i]);
st[0] = 1;
for (int i = (2), iend = (sz); i <= iend; ++i) {
while (top && val[st[top]] > val[i]) top--;
lef[i] = st[top] + 1, st[++top] = i;
}
st[top = 0] = sz + 1;
for (int i = (sz), iend = (2); i >= iend; --i) {
while (top && val[st[top]] >= val[i]) top--;
rig[i] = st[top] - 1, st[++top] = i;
}
for (int i = (2), iend = (sz); i <= iend; ++i) {
long long c1 = 1ll *
(upper_bound(X + 1, X + cx + 1, V[i - 1]) -
lower_bound(X + 1, X + cx + 1, V[lef[i] - 1])) *
(upper_bound(Y + 1, Y + cy + 1, V[rig[i]]) -
lower_bound(Y + 1, Y + cy + 1, V[i]));
long long c2 = 1ll *
(upper_bound(X + 1, X + cx + 1, V[rig[i]]) -
lower_bound(X + 1, X + cx + 1, V[i])) *
(upper_bound(Y + 1, Y + cy + 1, V[i - 1]) -
lower_bound(Y + 1, Y + cy + 1, V[lef[i] - 1]));
ans += 1ll * val[i] * (c1 + c2);
}
printf("%lld\n", ans);
}
return 0;
}
| 9 |
#include <iostream>
#include <tuple>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using PP = pair<int, int>;
constexpr int maxn = 3e4 + 10;
struct Node
{
int l, r;
ull w = 0;
Node() {}
Node(int _l, int _r, ull _w) :l(_l), r(_r), w(_w) {}
};
ull Com[maxn][5];
Node fun(int x, ull k, vector<PP>& L, vector<Node>& que)
{
int l, r;
tie(l, r) = L[x];
int lb = l - 1;
int ans = -1;
while (l < r)
{
int m = (l + r) >> 1;
if (que[m].w - que[lb].w >= k)
{
ans = m;
r = m;
}
else
l = m + 1;
}
return { que[ans].l,que[ans].r,que[ans - 1].w - que[lb].w };
}
ull SC(int a, int b)
{
if (a < 0)
return 1;
ull ans = 0;
for (int i = 0; i <= b; i++)
ans += Com[a][i];
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
int T;
cin >> T;
int r[5] = { 1,1,2,6,24 };
for (int i = 0; i <= 3e4; i++)
Com[i][0] = 1;
for (int j = 1; j <= 4; j++)
{
ull sum = 1;
for (int i = 1; i <= 3e4; i++)
{
if (i == 3e4)
i = i;
if (i > j)
sum /= (ull)(i - j);
sum *= i;
if (i >= j)
Com[i][j] = sum / r[j];
}
}
while (T--)
{
int N, C, Q;
cin >> N >> C >> Q;
ll tot = SC(N - 1, C);
vector<int>P(N + 1);
for (int i = 1; i <= N; i++)
cin >> P[i];
const int que_len = 2 * N * C + 10;
vector<vector<Node>>que(5, vector<Node>(que_len));
vector<vector<PP>>L(5, vector<PP>(N + 1));
for (int c = 1; c <= C; c++)
{
int l = N * C + 2, r = N * C + 2;
que[c][r++] = { -1, -1, 1 };
L[c][N] = { l,r };
for (int i = N - 1; i >= 1; i--)
{
vector<int>t_vec;
const int ite_c = min(N - i, c);
for (int j = 1; j <= ite_c; j++)
t_vec.push_back(j);
sort(t_vec.begin(), t_vec.end(), [&](const int& a, const int& b)
{
int fa = P[i + a] - P[i];
int fb = P[i + b] - P[i];
if (fa * fb < 0)
return fa < fb;
else
return 1ll * fa * fa < 1ll * fb * fb;
});
for (auto j : t_vec)
{
Node tmp = { i, i + j, SC(N - (i + j) - 1,c - j) };
if (P[i + j] > P[i])
que[c][r++] = tmp;
else
que[c][--l] = tmp;
}
L[c][i] = { l,r };
}
for (int i = l; i < r; i++)
que[c][i].w += que[c][i - 1].w;
}
while (Q--)
{
ull n, k;
int c = C;
cin >> n >> k;
if (k > tot)
{
cout << -1 << "\n";
continue;
}
int x = 1;
while (true)
{
auto t = fun(x, k, L[c], que[c]);
x = t.r + 1;
k -= t.w;
c -= t.r - t.l;
if (t.l <= n && n <= t.r)
{
cout << P[t.r - n + t.l] << "\n";
break;
}
if (c == 0 || n < t.l || t.l == -1)
{
cout << P[n] << "\n";
break;
}
}
}
}
}
| 12 |
#include <bits/stdc++.h>
int main() {
int i, k, m, n, w = 0, t = 999999999, o = 0, len;
char a[8800];
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
if (k >= a[i] && a[i] != 0) {
w = abs((i - m) * 10);
if (w < t) {
o = t;
t = w;
w = t;
}
}
}
printf("%d ", t);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n;
string s[N];
int cnt[N][26];
bool used[26];
set<int> g[26], b[26];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i];
for (int j = 0; j < s[i].size(); ++j) {
cnt[i][s[i][j] - 'a']++;
used[s[i][j] - 'a'] = true;
if (cnt[i][s[i][j] - 'a'] > 1) {
cout << "NO";
return 0;
}
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < s[i].size() - 1; ++j) {
g[s[i][j] - 'a'].insert(s[i][j + 1] - 'a');
b[s[i][j + 1] - 'a'].insert(s[i][j] - 'a');
}
for (int i = 0; i < 26; ++i) {
if (g[i].size() > 1) {
cout << "NO";
return 0;
}
}
vector<string> res;
for (int i = 0; i < 26; ++i) {
if (used[i] && b[i].size() == 0) {
string t;
int cur = i;
while (1) {
used[cur] = false;
t += (char)('a' + cur);
if (g[cur].size() == 0)
break;
else {
if (used[*g[cur].begin()])
cur = *g[cur].begin();
else {
cout << "NO";
return 0;
}
}
}
res.push_back(t);
}
}
for (int i = 0; i < 26; ++i)
if (used[i]) {
cout << "NO";
return 0;
}
sort(res.begin(), res.end());
for (auto v : res) cout << v;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
int const N = 1e6 + 123;
int const S = 1e6;
long long n, ans;
pair<int, int> d[N][10];
bool w[N][10];
int md[N];
int findmax(int n) {
int res = 0;
while (n) {
res = max(res, n % 10);
n /= 10;
}
return res;
}
pair<int, int> f(int n, int d) {
if (!n) return make_pair(0, 0);
if (w[n][d]) return ::d[n][d];
w[n][d] = 1;
int mx = d;
if (md[n] == 0) md[n] = findmax(n);
mx = max(mx, md[n]);
pair<int, int> res;
if (n - mx < 0) {
res = make_pair(0, n);
} else {
res = f(n - mx, d);
res.first += 1;
}
::d[n][d] = res;
return res;
}
long long g(long long n) {
if (n < N) {
return f(n, 0).first;
}
long long res = 0;
int nv = n / S;
int d = findmax(nv);
pair<int, int> resp = f((int)(n % S), d);
res += resp.first;
res += 1;
n = nv * 1LL * S - d + resp.second;
res += g(n);
return res;
}
void solve() { ans = g(n); }
int main() {
scanf("%lld", &n);
solve();
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
void exgcd(long long a, long long b, long long& x, long long& y,
long long& gcd) {
if (b == 0) return x = 1, y = 0, gcd = a, void();
exgcd(b, a % b, x, y, gcd);
long long t = x;
x = y;
y = t - a / b * y;
}
long long n, m, d, x, y, cnt;
vector<long long> g[400005], b[400005];
struct node {
long long p, dis, id;
bool operator<(const node& b) const { return p < b.p; }
} a[400005];
long long solve(long long m, long long n, long long x, vector<long long> g,
vector<long long> b) {
if (g.size() == m) return -2333;
cnt = 0;
long long res = 0, dis = 1e18;
for (auto u : g) a[++cnt] = (node){u * x % m, u, cnt};
for (auto u : b) a[++cnt] = (node){u * x % m, u, cnt};
sort(a + 1, a + cnt + 1);
a[0].p = a[cnt].p - m;
a[cnt + 1].p = a[1].p + m;
for (register long long i = (1); i <= (cnt); ++i)
dis = min(dis + n * (a[i].p - a[i - 1].p), a[i].dis);
for (register long long i = (1); i <= (cnt); ++i) {
dis = min(dis + n * (a[i].p - a[i - 1].p), a[i].dis);
if (a[i].p == a[i + 1].p) continue;
if (a[i].id > g.size()) res = max(res, dis);
if (a[i].p + 1 < a[i + 1].p)
res = max(res, dis + n * (a[i + 1].p - a[i].p - 1));
}
return res;
}
signed main() {
n = read(), m = read(), exgcd(m, n, x, y, d), x = (x % n + n) % n,
y = (y % m + m) % m;
if (d > 200000) return puts("-1") & 0;
long long k = read(), t;
while (k--) t = read(), b[t % d].push_back(t / d);
k = read();
while (k--) t = read(), g[t % d].push_back(t / d);
long long res = 0;
for (register long long i = (0); i <= (d - 1); ++i) {
if (g[i].size() + b[i].size() == 0) return puts("-1") & 0;
res = max(res, i + d * max(solve(m / d, n / d, y, g[i], b[i]),
solve(n / d, m / d, x, b[i], g[i])));
}
cout << res;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, y;
long long id;
} nd[123456];
long long a, b;
bool cmp(node e, node v) { return e.x * a + e.y * b < v.x * a + v.y * b; }
long long n, d;
int main() {
cin >> n >> d >> a >> b;
for (int i = 0; i < n; ++i) {
cin >> nd[i].x >> nd[i].y;
nd[i].id = i + 1;
}
sort(nd, nd + n, cmp);
long long m = 0;
long long sum = 0;
while (m < n) {
if (sum + nd[m].x * a + nd[m].y * b <= d) {
sum += nd[m].x * a + nd[m].y * b;
++m;
} else
break;
}
cout << m << endl;
for (int i = 0; i < m; ++i) {
if (i != m - 1)
cout << nd[i].id << " ";
else
cout << nd[i].id << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Task {
int startTime;
int noOfUsedServers;
int duration;
int endTime;
vector<int> resources;
Task() { resources.clear(); }
bool operator<(const Task& t) const { return endTime > t.endTime; }
};
int main() {
int totalServers, noOfAvailServers, noOfTasks;
int servers[101];
while (scanf("%d %d", &totalServers, &noOfTasks) != EOF) {
priority_queue<Task> tasks;
for (int i = 1; i <= totalServers; i++) servers[i] = 0;
noOfAvailServers = totalServers;
for (int i = 1; i <= noOfTasks; i++) {
Task t;
scanf("%d %d %d", &t.startTime, &t.noOfUsedServers, &t.duration);
t.endTime = t.startTime + t.duration;
if (!tasks.empty()) {
while (t.startTime >= tasks.top().endTime) {
noOfAvailServers += tasks.top().noOfUsedServers;
int cnt = 0;
for (int j = tasks.top().resources.size() - 1; j >= 0; j--) {
servers[tasks.top().resources[j]] = 0;
}
tasks.pop();
if (tasks.empty()) break;
}
if (noOfAvailServers < t.noOfUsedServers) {
printf("-1\n");
continue;
}
}
int cnt = 0, sum = 0;
for (int j = 1; cnt < t.noOfUsedServers && j <= totalServers; j++) {
if (servers[j] == 0) {
sum += j;
t.resources.push_back(j);
servers[j] = 1;
cnt++;
}
}
tasks.push(t);
printf("%d\n", sum);
noOfAvailServers -= t.noOfUsedServers;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n + 2];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int tt = 100;
string s[n + 1];
for (int i = 0; i <= tt; i++) {
s[0] += 'a';
}
string str = "bcdefghijklmnopqrstuvwxy";
int k = 0;
cout << s[0] << endl;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1].substr(0, a[i]);
s[i] += str.substr(k, 1);
k++, k %= 24;
for (int j = 0; j < tt - s[1].size(); j++) s[i] += 'z';
cout << s[i] << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
set<char> cur;
for (char ch = 'a'; ch <= 'z'; ++ch) {
cur.insert(ch);
}
int n;
cin >> n;
char c;
string s;
int i = 0;
while (i + 1 < n) {
cin >> c >> s;
if (c == '.' || c == '?') {
for (char ch : s) {
cur.erase(ch);
}
} else if (c == '!') {
set<char> nxt;
for (char ch : s) {
if (cur.find(ch) != cur.end()) {
nxt.insert(ch);
}
}
cur = nxt;
}
++i;
if (cur.size() == 1) {
break;
}
}
int cnt = 0;
while (i + 1 < n) {
cin >> c >> s;
if (c == '!' || c == '?') {
++cnt;
}
++i;
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 1e6;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
if (n % 2 == 0) {
cout << "white\n1 2";
} else {
cout << "black\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
std::pair<long long, long long> a[222222];
int main() {
long long s, e;
long long i, j, r, n, m, t, tot = 1LL;
scanf("%I64d%I64d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%I64d%I64d%I64d%I64d", &t, &s, &e, &r);
e++;
while (t++ < n) {
s <<= 1LL;
e <<= 1LL;
}
if (r == 1) tot++;
a[i] = std::make_pair(s, r + 1);
a[i + m] = std::make_pair(e, -r - 1);
}
a[m + m] = std::make_pair(1LL << (n - 1LL), 2);
a[m + m + 1] = std::make_pair(1LL << n, -2);
std::sort(a, a + m + m + 2);
j = e = 0;
for (i = 0; i < m + m + 1LL; i++) {
if (a[i].second == 1) j++;
if (a[i].second == 2) tot--;
if (a[i].second == -1) j--;
if (a[i].second == -2) tot++;
if (tot == 0 && j == 0 && a[i + 1].first > a[i].first) {
e += a[i + 1].first - a[i].first;
s = a[i].first;
}
}
if (e <= 0)
puts("Game cheated!");
else if (e > 1)
puts("Data not sufficient!");
else
printf("%I64d\n", s);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, n;
cin >> m >> n;
long long qs[200005] = {0};
double s = 0;
for (int i = 1; i <= m; i++) {
long long p;
cin >> p;
qs[i] = (qs[i - 1] + p);
}
for (int i = n; i <= m; i++) s += (qs[i] - qs[i - n]);
long long r = abs(m - n) + 1;
double ans = (s / (r + .0));
printf("%.10lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, d, grid[1010][1010], NODES = 0;
vector<int> graph[1010];
int f(int rem) {
if (!rem) return 0;
return 1 + f(rem / 2);
}
void h(int u, int cur) {
if (cur == 1) {
grid[u][1] = grid[1][u] = 1;
return;
}
int v = ++NODES;
grid[u][v] = grid[v][u] = 1;
h(v, cur - 1);
}
void g(int u, int v, int rem, int cur) {
if (cur == 1) {
grid[u][1] = grid[1][u] = grid[v][1] = grid[1][v] = 1;
return;
}
int w, x;
if (rem & 1) {
w = ++NODES;
if (NODES == 1) w = ++NODES;
grid[u][w] = grid[w][u] = grid[v][w] = grid[w][v] = 1;
h(w, cur - 1);
rem--;
}
w = ++NODES;
if (NODES == 1) w = ++NODES;
x = ++NODES;
grid[u][w] = grid[w][u] = grid[u][x] = grid[x][u] = 1;
grid[v][w] = grid[w][v] = grid[v][x] = grid[x][v] = 1;
g(w, x, rem / 2, cur - 1);
}
int main() {
scanf("%d", &k);
d = f(k);
g(0, 0, k, d);
if (NODES < 2) NODES++;
printf("%d\n", NODES + 1);
for (int u = 0; u <= NODES; u++) {
for (int v = 0; v <= NODES; v++) {
if (grid[u][v])
printf("Y");
else
printf("N");
}
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
long long expo(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) res = (res * x % 1000000007) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return res;
}
using namespace std;
long long factorial(long long n) {
return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
}
void solve() {
long long n;
cin >> n;
cout << factorial(n - 1) / (n / 2) << endl;
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
{ solve(); }
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 51;
int n, m, trees[Maxn][Maxn], a, b;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> trees[i][j];
trees[i][j] += trees[i - 1][j] + trees[i][j - 1] - trees[i - 1][j - 1];
}
cin >> a >> b;
int best = n * m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i >= a && j >= b)
best = min(best, trees[i][j] - trees[i - a][j] - trees[i][j - b] +
trees[i - a][j - b]);
if (i >= b && j >= a)
best = min(best, trees[i][j] - trees[i - b][j] - trees[i][j - a] +
trees[i - b][j - a]);
}
cout << best << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x * 10) + (c ^ 48);
if (f) x = -x;
return x;
}
struct abc {
int l, r, i;
} u[400005];
vector<int> qc;
int n, m, a[400005], bl[400005], v[400005], w[400005], wt[400005], tc[400005],
ans[400005];
void up(int x, int k) {
int y = a[x];
w[v[y]] -= 1;
v[y] += k;
w[v[y]] += 1;
}
priority_queue<int, vector<int>, greater<int> > q;
bool cmp(abc a, abc b) {
if (bl[a.l] == bl[b.l])
if (bl[a.l] & 1)
return a.r < b.r;
else
return a.r > b.r;
return a.l < b.l;
}
int main() {
n = read();
int bk = sqrt(n), mc = 316;
for (int i = 1; i <= n; i++) {
a[i] = read();
tc[a[i]]++;
if (tc[a[i]] == mc) qc.push_back(a[i]);
bl[i] = (i - 1) / bk + 1;
}
m = read();
for (int i = 1; i <= m; i++) {
u[i].l = read();
u[i].r = read();
u[i].i = i;
}
sort(u + 1, u + m + 1, cmp);
int l = 1, r = 0;
for (int i = 1; i <= m; i++) {
while (l < u[i].l) up(l++, -1);
while (l > u[i].l) up(--l, 1);
while (r < u[i].r) up(++r, 1);
while (r > u[i].r) up(r--, -1);
int pr = 0, an = 0;
while (q.size()) q.pop();
for (int j = 0; j < qc.size(); j++) {
if (v[qc[j]] >= mc) {
q.push(v[qc[j]]);
}
}
for (int j = 1; j < mc; j++) {
wt[j] = w[j];
}
for (int j = 1; j < mc; j++) {
if (pr && wt[j])
if (pr + j >= mc)
q.push(pr + j), wt[j]--, an += pr + j, pr = 0;
else
wt[pr + j]++, wt[j]--, an += pr + j, pr = 0;
an += (wt[j] / 2) * 2 * j;
if (j * 2 >= mc)
for (int k = 1; k <= wt[j] / 2; k++) q.push(j * 2);
else
wt[j * 2] += wt[j] / 2;
if (wt[j] & 1) pr = j;
}
if (pr) q.push(pr);
while (q.size() > 1) {
int sa = 0;
sa += q.top();
q.pop();
sa += q.top();
q.pop();
an += sa;
q.push(sa);
}
ans[u[i].i] = an;
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long dp[1000007];
int v[1000007];
int main() {
int i, j, k, l, m, n;
long long a, b;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
if (n == 1) {
cout << 0;
return 0;
} else if (n == 2) {
cout << max(0, abs(v[0] - v[1]));
return 0;
}
int in = 1;
int dc = 1;
dp[0] = 0;
dp[1] = 0;
int prev;
for (i = 1; i < n; i++) {
if (v[i - 1] == v[i]) {
in = 1;
dc = 1;
prev = i - 1;
} else if (dc && v[i] > v[i - 1]) {
in = 1;
dc = 0;
prev = i - 1;
} else if (in && v[i] < v[i - 1]) {
in = 0;
dc = 1;
prev = i - 1;
}
a = dp[prev + 1] + abs(v[i] - v[prev + 1]);
b = dp[prev] + abs(v[i] - v[prev]);
dp[i + 1] = max(a, b);
}
cout << dp[n];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int tablero[1000][1000];
int main() {
int n, m;
cin >> n >> m;
if (n == m && n == 1) {
cout << 1 << endl;
return 0;
}
if ((n == 2 && m == 1) || (n == 1 && m == 2)) {
cout << -1 << endl;
return 0;
}
if ((n == 3 && m == 1) || (n == 1 && m == 3)) {
cout << -1 << endl;
return 0;
}
if ((n == 2 && m == 2) || (n == 2 && m == 2)) {
cout << -1 << endl;
return 0;
}
if (n == 1) {
if (m == 4) {
tablero[0][0] = 2;
tablero[0][1] = 4;
tablero[0][2] = 1;
tablero[0][3] = 3;
} else {
int t = 1;
for (int i = 0; i < m; i += 2) tablero[0][i] = t++;
for (int i = 1; i < m; i += 2) tablero[0][i] = t++;
}
} else if (m == 1) {
if (n == 4) {
tablero[0][0] = 2;
tablero[1][0] = 4;
tablero[2][0] = 1;
tablero[3][0] = 3;
} else {
int t = 1;
for (int i = 0; i < n; i += 2) tablero[i][0] = t++;
for (int i = 1; i < n; i += 2) tablero[i][0] = t++;
}
} else {
if (n == 2 && m == 3) {
tablero[0][0] = 3;
tablero[0][1] = 6;
tablero[0][2] = 2;
tablero[1][0] = 5;
tablero[1][1] = 1;
tablero[1][2] = 4;
} else if (n == 3 && m == 2) {
tablero[0][0] = 3;
tablero[1][0] = 6;
tablero[2][0] = 2;
tablero[0][1] = 5;
tablero[1][1] = 1;
tablero[2][1] = 4;
} else {
int t = 1;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++)
if ((i + j) % 2 == 0) tablero[i][j] = t++;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++)
if ((i + j) % 2 == 1) tablero[i][j] = t++;
}
}
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
cout << tablero[i][j];
if (j == m - 1)
cout << endl;
else
cout << " ";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
scanf("%d%d", &a, &b);
for (int i = 1;; i++) {
if (a < i) {
printf("Vladik");
return 0;
}
a -= i;
i++;
if (b < i) {
printf("Valera");
return 0;
}
b -= i;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100005];
int main(int argc, char const *argv[]) {
cin >> n;
memset(a, 0, sizeof(a));
long long t = 1;
for (long long i = 2; i * i <= n; i++) {
if (a[i] == 0) {
a[i] = t++;
for (long long j = i * i; j <= n; j += i) a[j] = a[i];
}
}
for (long long i = 2; i <= n; i++)
if (a[i] == 0) a[i] = t++;
for (long long i = 2; i <= n; i++) cout << a[i] << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t arr[10][10];
int64_t temp = 1;
for (int j = 0; j < 10; j++) {
for (int i = 0; i < 9; i++) {
if (j == 0) {
arr[j][i] = i + 1;
} else {
arr[j][i] = temp * (i + 1) + arr[j - 1][i];
}
}
temp = temp * 10;
}
int t;
cin >> t;
int64_t n;
while (t--) {
bool flag = 0;
cin >> n;
int count = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 9; j++) {
if (arr[i][j] <= n) {
count++;
} else {
cout << count << "\n";
flag = 1;
}
if (flag) {
break;
}
}
if (flag) {
break;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000007; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m, q;
vector<int> A[201234];
int C[201234];
void dfs(int i) {
int &res = C[i];
res = 0;
if (A[i].empty()) ++res;
int j, k;
for (k = (0); k < (A[i].size()); ++k) {
j = A[i][k];
dfs(j);
res += C[j];
}
}
int fnd(int i, int p) {
int j, k;
int res = p == 0 ? 1012345678 : 0;
if (A[i].empty()) return 0;
for (k = (0); k < (A[i].size()); ++k) {
j = A[i][k];
int a = fnd(j, !p);
if (p)
res += C[j] - a - 1;
else
minn(res, a);
}
if (p) res = C[i] - res - 1;
return res;
}
int main() {
int i, j, k;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
for (i = (0); i < (n); ++i) A[i].clear();
for (k = (0); k < (n - 1); ++k) {
scanf(
"%"
"d",
&(i));
scanf(
"%"
"d",
&(j));
--i;
--j;
A[i].push_back(j);
}
dfs(0);
printf((firstout) ? "%"
"d"
: " %"
"d",
(C[0] - fnd(0, 0))),
firstout = 0;
printf((firstout) ? "%"
"d"
: " %"
"d",
(fnd(0, 1) + 1)),
firstout = 0;
printf("\n"), firstout = 1;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128777216")
using namespace std;
const long double eps = pow(10.0, -10.0);
mt19937 rndm;
void start() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
string FILENAME = "sample";
rndm.seed(time(0));
}
int main() {
start();
long long w, l;
cin >> w >> l;
vector<long long> vals(w - 1);
for (int i = 0; i < w - 1; ++i) cin >> vals[i];
long long sum = 0, minus = 0;
for (int i = 0; i < l; ++i) sum += vals[i];
for (int i = l; i < w - 1; ++i) {
if (minus) {
long long v = min(vals[i - l], minus);
vals[i - l] -= v;
minus -= v;
}
if (vals[i - l] < vals[i]) {
vals[i] = min(vals[i], sum);
minus += min(vals[i], sum) - vals[i - l];
} else
sum -= vals[i - l] - vals[i];
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class tree {
public:
tree(const vector<int64_t>& a) : t(4 * a.size() + 1) {
build(a, 1, 0, a.size() - 1);
}
void build(const vector<int64_t>& a, int64_t v, int64_t l, int64_t r) {
if (l > r) return;
if (l == r) {
t[v].first = a[l];
t[v].second = a[l];
} else {
int64_t m = (l + r) / 2;
build(a, 2 * v, l, m);
build(a, 2 * v + 1, m + 1, r);
t[v].first = min(t[2 * v].first, t[2 * v + 1].first);
t[v].second = max(t[2 * v].second, t[2 * v + 1].second);
}
}
void update(int64_t v, int64_t tl, int64_t tr, int64_t pos, int64_t new_val) {
if (tl > tr) return;
if (tl == pos && tr == pos) {
t[v].first = new_val;
t[v].second = new_val;
} else {
int64_t tm = (tl + tr) / 2;
if (pos <= tm)
update(2 * v, tl, tm, pos, new_val);
else
update(2 * v + 1, tm + 1, tr, pos, new_val);
t[v].first = min(t[2 * v].first, t[2 * v + 1].first);
t[v].second = max(t[2 * v].second, t[2 * v + 1].second);
}
}
int64_t get_min(int64_t v, int64_t tl, int64_t tr, int64_t l, int64_t r) {
if (l > r || tl > tr) return 1000 * 1000 * 1000 * 1000ll;
if (tl == l && tr == r) {
return t[v].first;
} else {
int64_t tm = (tl + tr) / 2;
return min(get_min(2 * v, tl, tm, l, min(tm, r)),
get_min(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
}
int64_t get_max(int64_t v, int64_t tl, int64_t tr, int64_t l, int64_t r) {
if (l > r || tl > tr) return -1000 * 1000 * 1000 * 1000ll;
if (tl == l && tr == r) {
return t[v].second;
} else {
int64_t tm = (tl + tr) / 2;
return max(get_max(2 * v, tl, tm, l, min(tm, r)),
get_max(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
}
private:
vector<pair<int64_t, int64_t> > t;
};
int64_t n;
pair<int64_t, bool> get_next(pair<int64_t, bool> val) {
if (val.first == n) val.second = false;
if (val.first == 1) val.second = true;
if (val.second) ++val.first;
if (!val.second) --val.first;
if (val.first == n) val.second = false;
if (val.first == 1) val.second = true;
return val;
}
int main() {
cin >> n;
vector<int64_t> v(n);
for (int64_t i = 0; i < n; ++i) {
cin >> v[i];
}
int64_t m;
cin >> m;
vector<int64_t> q(m);
vector<int64_t> w(n + 1);
for (int64_t i = 0; i < m; ++i) {
cin >> q[i];
w[q[i]]++;
}
bool forward = true;
pair<int64_t, bool> a = {q[0], true};
if (a.first == n) a.second = false;
pair<int64_t, bool> cur = a;
int64_t sum = 0;
w[a.first]--;
for (int64_t i = 0; i < m - 1; ++i) {
pair<int64_t, bool> next = get_next(cur);
sum += abs(v[next.first - 1] - v[cur.first - 1]);
cur = next;
w[cur.first]--;
}
tree seg(w);
pair<int64_t, bool> b = cur;
set<int64_t> ans;
if (seg.get_max(1, 0, n, 0, n) == 0 && seg.get_min(1, 0, n, 0, n) == 0)
ans.insert(sum);
for (int64_t i = 0; i < 2 * n + 2 * m + 2; ++i) {
pair<int64_t, bool> next1 = get_next(a);
pair<int64_t, bool> next2 = get_next(b);
sum = sum - abs(v[next1.first - 1] - v[a.first - 1]);
sum = sum + abs(v[next2.first - 1] - v[b.first - 1]);
w[a.first]++;
w[next2.first]--;
seg.update(1, 0, n, a.first, w[a.first]);
seg.update(1, 0, n, next2.first, w[next2.first]);
if (seg.get_max(1, 0, n, 0, n) == 0 && seg.get_min(1, 0, n, 0, n) == 0)
ans.insert(sum);
a = next1;
b = next2;
}
if (ans.size() == 1) {
cout << *ans.begin() << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 260005, MAX_W = 500;
struct GRIPPER {
int m, p, r;
long long d;
} grip[MAX_N];
int x, y, n, X, Y, top;
int p[MAX_N], r[MAX_N];
int L[1000], R[1000];
long long D[1000];
bool vis[MAX_N];
bool cmp_d(GRIPPER a, GRIPPER b) { return a.d < b.d; }
bool cmp_m(GRIPPER a, GRIPPER b) { return a.m < b.m; }
void do_it() {
int st = 0, all = 1;
while (st < all) {
int P = p[st];
long long Rad = 1ll * r[st] * r[st];
st++;
for (int i = 0; i < top; i++) {
if (D[i] > Rad) {
for (int j = L[i]; j <= R[i]; ++j)
if (!vis[j] && grip[j].d <= Rad && grip[j].m <= P) {
vis[j] = 1;
p[all] = grip[j].p;
r[all] = grip[j].r;
all++;
}
break;
}
while (L[i] <= R[i] && grip[L[i]].m <= P) {
if (!vis[L[i]]) {
p[all] = grip[L[i]].p;
r[all] = grip[L[i]].r;
all++;
vis[L[i]] = 1;
}
++L[i];
}
}
}
printf("%d\n", all - 1);
return;
}
void init() {
sort(grip + 1, grip + 1 + n, cmp_d);
int i = 1;
top = 0;
while (i <= n) {
int en = i + MAX_W - 1;
if (en > n) en = n;
L[top] = i;
R[top] = en;
D[top] = grip[en].d;
sort(grip + L[top], grip + R[top] + 1, cmp_m);
top++;
i = en + 1;
}
}
void input() {
scanf("%d%d%d%d%d", &X, &Y, &p[0], &r[0], &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d%d", &x, &y, &grip[i].m, &grip[i].p, &grip[i].r);
grip[i].d = 1ll * (X - x) * (X - x) + 1ll * (Y - y) * (Y - y);
}
return;
}
int main() {
input();
init();
do_it();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
pair<int, int> diameter(int s, vector<bool> &vis) {
int h1 = 0;
int h2 = 0;
int height = 0;
int dia = 0;
vis[s] = 1;
bool leaf = 1;
for (int i = 0; i < g[s].size(); i++) {
if (vis[g[s][i]] == 0) {
leaf = 0;
pair<int, int> tt = diameter(g[s][i], vis);
dia = max(dia, tt.first);
if (tt.second > h1) {
long long temp = h1;
h1 = tt.second;
if (temp > h2) h2 = temp;
} else if (tt.second > h2) {
h2 = tt.second;
}
}
}
height = h1 + 1;
dia = max(dia, h1 + h2);
vis[s] = 0;
if (leaf == 1) {
return make_pair(0, 1);
}
return make_pair(dia, height);
}
int distance(int a, int b, vector<bool> &vis) {
queue<int> q;
q.push(a);
q.push(-1);
vis[a] = 1;
int dist = 0;
while (!q.empty()) {
int temp = q.front();
q.pop();
if (temp == b) {
break;
}
if (temp == -1) {
dist++;
if (!q.empty()) q.push(-1);
continue;
}
for (int i = 0; i < g[temp].size(); i++) {
if (vis[g[temp][i]] == 0) {
vis[g[temp][i]] = 1;
q.push(g[temp][i]);
}
}
}
return dist;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, a, b, da, db;
cin >> n >> a >> b >> da >> db;
g.clear();
g.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (db > 2 * da) {
vector<bool> vis(n + 1);
pair<int, int> dia = diameter(1, vis);
if (dia.first > 2 * da) {
vector<bool> v(n + 1);
int dist = distance(a, b, v);
if (dist > da)
cout << "Bob\n";
else
cout << "Alice\n";
} else {
cout << "Alice\n";
}
} else {
cout << "Alice\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimization("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
bool comp(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return (a.second < b.second);
}
long long int power(long long int n, long long int p) {
if (p == 0)
return 1;
else {
long long int ans = power(n, p / 2) % 1000000007;
ans = (ans * ans) % 1000000007;
if (p % 2 == 0)
return ans;
else
return ans = (ans * n) % 1000000007;
}
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int fact_of_factorial(long long int n) {
vector<long long int> cnt(n + 1, 0);
for (long long int i = 2; i <= n; i++) {
long long int k = i;
vector<pair<long long int, long long int> > res;
for (long long int j = 2; j * j <= k; j++) {
if (k % j != 0) continue;
long long int ex = 0;
while (k % j == 0) {
ex++;
k /= j;
}
cnt[j] += ex;
}
if (k != 1) cnt[k] += 1;
}
long long int ans = 1;
for (long long int i = 1; i <= n; i++) {
ans *= cnt[i] + 1;
ans %= 1000000007;
}
return ans;
}
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
{
long long int i, j, n, a, b, c, d, m, k, sum = 0, ans = 0, cnt = 0, r = 0,
e = 0;
string str, s1, om, s;
unordered_map<long long int, long long int> make_pair, mp1;
set<long long int> st;
vector<long long int> v;
cin >> n;
long long int ar[n];
for (i = 0; i < n; i++) cin >> ar[i];
sum = ar[0];
v.push_back(1);
for (i = 1; i < n; i++) {
if (ar[i] <= ar[0] / 2) {
v.push_back(i + 1);
sum += ar[i];
} else {
r += ar[i];
}
}
if (sum > r) {
cout << v.size() << "\n";
for (auto it : v) cout << it << " ";
cout << "\n";
} else {
cout << 0 << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = (int)1e9 + 7;
const int MAXN = (int)2e6 + 7;
int n, d;
int t[MAXN];
int second;
int main() {
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> t[i];
second += t[i];
}
if (second + (n - 1) * 10 > d)
puts("-1");
else
cout << (d - (second + (n - 1) * 10)) / 5 + 2 * (n - 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
int n, k;
long double a[10005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
long double lo = 0, hi = 1000;
for (int i = 0; i < 200; i++) {
long double md = (lo + hi) / 2;
long double ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] > md)
ans += ((a[i] - md) - ((a[i] - md) * (k / 100.0)));
else
ans -= (md - a[i]);
}
if (ans < 0)
hi = md;
else
lo = md;
}
cout << fixed << setprecision(6) << lo << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 0;
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
ans += (m + i) / 5 - (i / 5);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 605;
const double eps = 1e-7;
const double DINF = 1e100;
const int INF = 1000000006;
const long long LINF = 1000000000000000005ll;
int n, m, K, mod;
int source[MaxN], sink[MaxN];
long long dp[MaxN][MaxN], mat[MaxN][MaxN];
long long *a[MaxN];
bool isS[MaxN], isT[MaxN];
vector<int> edge[MaxN];
long long calc(int a, int b) {
long long &rt = dp[a][b];
if (rt != -1) return rt;
if (a == b) return 1;
rt = 0;
for (vector<int>::iterator it = edge[b].begin(); it != edge[b].end(); ++it) {
rt += calc(a, *it);
if (rt >= mod) rt -= mod;
}
return rt;
}
long long fpow(long long a, long long t, long long mod) {
long long rt = 1;
a %= mod;
for (; t; t >>= 1, a = a * a % mod)
if (t & 1) rt = rt * a % mod;
return rt;
}
int main() {
scanf("%d%d%d", &n, &m, &mod);
memset(isT, 1, sizeof(isT));
memset(isS, 1, sizeof(isS));
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
edge[v].push_back(u);
isT[u] = 0;
isS[v] = 0;
}
memset(source, -1, sizeof(source));
memset(sink, -1, sizeof(sink));
K = 0;
for (int i = 0; i < n; ++i)
if (isS[i]) source[i] = K++;
K = 0;
for (int i = 0; i < n; ++i)
if (isT[i]) sink[i] = K++;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; ++i)
if (source[i] != -1)
for (int j = 0; j < n; ++j)
if (sink[j] != -1) mat[source[i]][sink[j]] = calc(i, j);
for (int i = 0; i < K; ++i) a[i] = mat[i];
long long ans = 1;
for (int i = 0; i < K; ++i) {
int x = -1;
for (int k = i; k < K; ++k)
if (a[k][i]) {
x = k;
break;
}
if (x == -1) {
ans = 0;
break;
}
if (i != x) {
ans = mod - ans;
swap(a[i], a[x]);
}
ans = ans * a[i][i] % mod;
long long inv = fpow(a[i][i], mod - 2, mod);
for (int j = 0; j < K; ++j) a[i][j] = a[i][j] * inv % mod;
for (int j = i + 1; j < K; ++j) {
if (!a[j][i]) continue;
long long t = a[j][i];
for (int k = i; k < K; ++k) {
a[j][k] = a[j][k] - a[i][k] * t;
a[j][k] %= mod;
if (a[j][k] < 0) a[j][k] += mod;
}
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool G1[1005][1005], G2[1005][1005];
int n, X1[10005], Y1[10005], X2[10005], Y2[10005];
int read() {
char c = getchar();
int ans = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
ans = (ans << 1) + (ans << 3) + (c ^ 48), c = getchar();
return ans;
}
void solve1() {
for (register int i = 1, j; i < n;) {
if (G1[0][i]) {
i++;
continue;
}
j = i;
while (!G1[0][j]) j++;
for (register int k = i; k < j; k++)
if (G1[k][i - 1] && G1[k][j]) {
G1[i - 1][j] = G1[j][i - 1] = 0;
G1[0][k] = G1[k][0] = 1;
X1[++X1[0]] = i - 1, Y1[++Y1[0]] = j;
break;
}
}
return;
}
void solve2() {
for (register int i = 1, j; i < n;) {
if (G2[0][i]) {
i++;
continue;
}
j = i;
while (!G2[0][j]) j++;
for (register int k = i; k < j; k++)
if (G2[k][i - 1] && G2[k][j]) {
G2[i - 1][j] = G2[j][i - 1] = 0;
G2[0][k] = G2[k][0] = 1;
X2[++X2[0]] = 0, Y2[++Y2[0]] = k;
break;
}
}
return;
}
int main() {
n = read();
for (register int i = 0; i < n; i++)
G1[i][(i + 1) % n] = G2[i][(i + 1) % n] = G1[(i + 1) % n][i] =
G2[(i + 1) % n][i] = 1;
for (register int i = 1, u, v; i <= n - 3; i++) {
u = read() - 1, v = read() - 1;
G1[u][v] = G1[v][u] = 1;
}
for (register int i = 1, u, v; i <= n - 3; i++) {
u = read() - 1, v = read() - 1;
G2[u][v] = G2[v][u] = 1;
}
solve1();
solve2();
printf("%d\n", X1[0] + X2[0]);
for (register int i = 1; i <= X1[0]; i++)
printf("%d %d\n", X1[i] + 1, Y1[i] + 1);
for (register int i = X2[0]; i >= 1; i--)
printf("%d %d\n", X2[i] + 1, Y2[i] + 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e3 + 5;
int a[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
int num1 = n, num2 = n * 2;
for (int i = 0; i < k; i++) {
int te = min(num1, a[i] >> 2);
num1 -= te;
a[i] -= te << 2;
}
num2 += num1;
for (int i = 0; i < k; i++) {
int te = min(num2, a[i] >> 1);
num2 -= te;
a[i] -= te << 1;
}
int sum = num1 + num2;
for (int i = 0; i < k; i++) sum -= a[i];
printf("%s\n", sum >= 0 ? "YES" : "NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct dummie {
int x, y, z;
dummie() {}
dummie(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
bool operator<(const dummie b) const { return true; }
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int N, K, L, R, Sk, Skt, Sa, resto, n;
cin >> N >> K >> L >> R >> Sa >> Sk;
resto = Sk % K;
for (int i = 0; i < K; i++) {
if (i) cout << " ";
n = Sk / K + ((resto > 0) ? 1 : 0);
resto--;
cout << n;
}
N -= K;
if (N) {
resto = (Sa - Sk) % N;
for (int i = 1; i <= N; i++) {
if (i) cout << " ";
n = (Sa - Sk) / N + ((resto > 0) ? 1 : 0);
resto--;
cout << n;
}
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long hcf(long long x, long long y) {
if (x == 0) return y;
return hcf(y % x, x);
}
signed main() {
long long a, b, c, d, x1, y1, x3, y3, m, n;
long double k = 0, p = 0;
cin >> a >> b >> c >> d;
n = hcf(a, b);
m = hcf(c, d);
c /= m;
d /= m;
a /= n;
b /= n;
if ((a * 1.0) * (d * 1.0) / (c * 1.0) <= (b * 1.0)) {
k = (a * 1.0) * ((a * 1.0) * (d * 1.0) / (c * 1.0));
x1 = b * c - a * d;
y1 = b * c;
}
if ((b * 1.0) * (c * 1.0) / (d * 1.0) <= (a * 1.0)) {
p = (b * 1.0) * ((b * 1.0) * (c * 1.0) / (d * 1.0));
x3 = a * d - c * b;
y3 = a * d;
}
if (k >= p) {
m = hcf(x1, y1);
x1 /= m;
y1 /= m;
cout << x1 << "/" << y1;
} else {
m = hcf(x3, y3);
x3 /= m;
y3 /= m;
cout << x3 << "/" << y3;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
cout << -a[1] << " " << a[0] << " ";
for (long long int i = 2; i < n; i++) {
if (i % 2 == 0)
cout << -a[i + 1] << " ";
else
cout << a[i - 1] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, bool> f;
int n, m;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
long long sum = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += (long long)x;
f[sum] = true;
}
int res = 0;
sum = 0;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
sum += x;
if (f[sum]) res++;
}
cout << res;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int GCD(long long int a, long long int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
void solve() {
long long int n, m;
cin >> n >> m;
int vsize = n + m;
vector<long long int> v1[vsize];
vector<long long int> v2[vsize];
long long int num;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> num;
v1[i + j].push_back(num);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> num;
v2[i + j].push_back(num);
}
}
for (int i = 0; i < vsize; i++) {
sort(v1[i].begin(), v1[i].end());
sort(v2[i].begin(), v2[i].end());
}
for (int i = 0; i < vsize; i++) {
if (v1[i] != v2[i]) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() { solve(); }
| 3 |
#include <bits/stdc++.h>
const int maxx = 2e5 + 7;
const int maxn = 1e9 + 7;
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
long long n, h, l, r;
int dp[2005][2005], a[2006];
int check(int op) {
if (op <= r && op >= l)
return 1;
else
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> h >> l >> r;
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < h; j++) {
if (dp[i - 1][(j - a[i] + h) % h] < 0 &&
dp[i - 1][(j - a[i] + 1 + h) % h] < 0)
continue;
dp[i][j] = max(dp[i - 1][(j - a[i] + h) % h],
dp[i - 1][(j - a[i] + 1 + h) % h]) +
check(j);
}
}
int ans = 0;
for (int i = 0; i < h; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int match[2005];
int visited[2005];
vector<int> adj[2005];
vector<pair<int, int>> factors[105];
int cookie;
int dfs(int x) {
if (visited[x] == cookie) return 0;
visited[x] = cookie;
for (int y : adj[x]) {
if (match[y] == -1 || dfs(match[y])) {
match[y] = x;
return 1;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, m;
cin >> n >> m;
int size[2] = {};
for (int i = 1; i <= n; ++i) {
int num;
cin >> num;
for (int j = 2; j * j <= num; ++j) {
while (num % j == 0) {
factors[i].push_back({j, size[i % 2]++});
num /= j;
}
}
if (num > 1) {
factors[i].push_back({num, size[i % 2]++});
}
}
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
if (l % 2) swap(l, r);
for (auto [p1, i1] : factors[l]) {
for (auto [p2, i2] : factors[r]) {
if (p1 == p2) {
adj[i1].push_back(i2);
}
}
}
}
int sol = 0;
memset(match, -1, sizeof match);
for (int i = 0; i < size[0]; ++i) {
cookie++;
sol += dfs(i);
}
cout << sol << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, h;
cin >> n >> d >> h;
if (d <= 2 * h) {
if (n == 2) {
cout << 1 << " " << 2 << endl;
} else if (d >= 2) {
int num = 1;
vector<vector<int>> v(n + 3);
int aux = h;
while (aux--) {
v[num].push_back(num + 1);
num++;
}
num++;
aux = d - h;
if (aux > 0) {
v[1].push_back(num);
aux--;
num++;
}
while (aux--) {
v[num - 1].push_back(num);
num++;
}
int dif = n - num + 1;
int extra = 1;
if (h > 1) {
extra = 2;
}
while (dif--) {
v[extra].push_back(num);
num++;
}
for (int i = 1; i <= n; i++) {
if (!(v[i].empty())) {
for (int j = 0; j < v[i].size(); j++) {
cout << i << " " << v[i][j] << endl;
}
}
}
} else {
cout << -1;
}
} else {
cout << -1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 51, K = 5001, MOD = 1e9 + 7;
int n, k, a, b, dp1[2][N][N][201], dp2[2][N][N][201], C[N][N];
void build() {
C[0][0] = 1;
for (int i = 1; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
}
}
inline int mul(int a, int b) {
return (int)(((long long)a * (long long)b) % MOD);
}
pair<int, int> calc(int c, int x, int y, int ss) {
int x2 = a - x, y2 = b - y;
if (x == 0 && y == 0) return make_pair(0, 1);
if (ss == 200) return make_pair(1e9, 0);
int &r1 = dp1[c][x][y][ss];
int &r2 = dp2[c][x][y][ss];
if (r1 != -1) return make_pair(r1, r2);
r1 = 1e9;
r2 = 0;
if (c == 0) {
for (int i = 0; i <= x; i++) {
for (int j = 0; j <= y; j++) {
if (!i && !j) continue;
if (i * 50 + j * 100 <= k) {
pair<int, int> res = calc(c ^ 1, x - i, y - j, ss + 1);
res.second = mul(res.second % MOD, mul(C[x][i], C[y][j]));
if (res.first + 1 < r1)
r1 = res.first + 1, r2 = res.second;
else if (res.first + 1 == r1)
r2 = (r2 + res.second) % MOD;
}
}
}
} else {
for (int i = 0; i <= x2; i++) {
for (int j = 0; j <= y2; j++) {
if (!i && !j) continue;
if (i * 50 + j * 100 <= k) {
pair<int, int> res = calc(c ^ 1, x + i, y + j, ss + 1);
res.second = mul(res.second % MOD, mul(C[x2][i], C[y2][j]));
if (res.first + 1 < r1)
r1 = res.first + 1, r2 = res.second;
else if (res.first + 1 == r1)
r2 = (r2 + res.second) % MOD;
}
}
}
}
return make_pair(r1, r2);
}
int main() {
std::ios::sync_with_stdio(false);
build();
scanf("%d%d", &n, &k);
a = 0, b = 0;
for (int i = 0, x; i < n; i++) {
scanf("%d", &x);
if (x == 50)
a++;
else
b++;
}
memset(dp1, -1, sizeof(dp1));
memset(dp2, -1, sizeof(dp2));
pair<int, int> ans = calc(0, a, b, 0);
if (ans.first >= 1e9)
puts("-1\n0");
else
printf("%d\n%d\n", ans.first, ans.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isbad(char c) {
return !(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
}
int main() {
string str;
cin >> str;
int count = 0;
for (int i = 0; i < str.length(); ++i) {
if (isbad(str[i]))
count++;
else
count = 0;
if (count == 3)
if (str[i] == str[i - 1] && str[i] == str[i - 2])
count--;
else {
cout << " ";
count = 1;
}
cout << str[i];
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pqs priority_queue<int,vi,greater<int> >
#define mod 1000000007
#define int long long
#define pb push_back
#define inf 1e18
#define sp(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(t) int t; cin>>t; while(t--)
#define mp make_pair
#define endl "\n"
#define pqb priority_queue<int>
#define ceil(a , b) ((a / b) + (a%b && 1))
#define rep(i,a,b) for(int i=a;i<(int)b;i++)
#define repr(i,a,b) for(int i=a;i>=(int)b;i--)
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define all(v) v.begin(), v.end()
#define ff first
#define ss second
template<typename... T> void pn(T... args) { ((cout << args << " "), ...); cout<<"\n"; }
template<typename... T> void ps(T... args) { ((cout << args << " "), ...); cout<<""; }
// void start()
// {
// ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
// }
int power(int a, int b,int P=mod) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % P)
if (b & 1)
res = 1ll * res * a % P;
return res;
}
set<int>st;
vector<int> arr;
void solver(int l,int r)
{
int sum=0;
for(int i=l; i<r+1; i++) sum+=arr[i];
st.insert(sum);
if(r<=l)return;
int pos=-1;
int mid=(arr[l]+arr[r])/2;
for(int i=l; i<r+1; i++)
{
if(arr[i]<=mid) pos=i;
else break;
}
if(pos==-1||pos==r) return;
// int pos=lower_bound(all(arr),mid)-arr.begin();
solver(l,pos);
solver(pos+1,r);
}
void solve()
{
int n,m;
cin>>n>>m;
arr=vector<int>(n);
for(int i=0; i<n; i++)
{
cin>>arr[i];
}
sort(all(arr));
st.clear();
solver(0,n-1);
while(m--)
{
int a;
cin>>a;
if(st.count(a)) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
}
int32_t main()
{
fastio;
w(t)
{
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
void redirectIO() {
ios::sync_with_stdio(false);
cin.tie(0);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long la, ra, ta;
long long lb, rb, tb;
int main() {
redirectIO();
cin >> la >> ra >> ta;
cin >> lb >> rb >> tb;
long long g = gcd(ta, tb);
long long pa = ra - la + 1;
long long pb = rb - lb + 1;
if (lb < la) {
swap(lb, la);
swap(pa, pb);
swap(ta, tb);
}
long long offs = lb - la;
offs %= g;
long long answer = 0;
long long bEnd = offs + pb;
long long aEnd = pa;
if (aEnd > offs) {
answer = max(answer, min(aEnd, bEnd) - offs);
}
offs -= g;
swap(lb, la);
swap(pa, pb);
swap(ta, tb);
offs = -offs;
bEnd = offs + pb;
aEnd = pa;
if (aEnd > offs) {
answer = max(answer, min(aEnd, bEnd) - offs);
}
cout << answer << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d, n, m, b[200005];
int mn[200005 << 2];
long long ans;
struct node {
int x;
long long p;
bool operator<(const node &a) const { return x < a.x; }
} a[200005];
int check(int x, int y) { return a[x].p < a[y].p ? x : y; }
void build(int l, int r, int rt) {
if (l == r) {
mn[rt] = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
mn[rt] = check(mn[rt << 1], mn[rt << 1 | 1]);
}
int get_mn(int l, int r, int rt, int L, int R) {
if (L == l && R == r) return mn[rt];
int mid = (l + r) >> 1;
if (R <= mid)
return get_mn(l, mid, rt << 1, L, R);
else if (L > mid)
return get_mn(mid + 1, r, rt << 1 | 1, L, R);
else
return check(get_mn(l, mid, rt << 1, L, mid),
get_mn(mid + 1, r, rt << 1 | 1, mid + 1, R));
}
int main() {
cin >> d >> n >> m;
for (int i = 1; i <= m; i++) scanf("%d%I64d", &a[i].x, &a[i].p);
sort(a + 1, a + m + 1);
a[++m].x = d;
a[0].p = 0x3f3f3f3f;
build(1, m, 1);
for (int i = 1; i <= m; i++) b[i] = a[i].x;
int now = n, i = 0, j = 1, t, k;
while (i < m) {
t = upper_bound(b + 1, b + m + 1, a[i].x + n) - b - 1;
if (t == i) {
puts("-1");
return 0;
}
t = upper_bound(b + 1, b + m + 1, a[i].x + now) - b - 1;
k = (t > i ? get_mn(1, m, 1, i + 1, t) : 0);
if (a[k].p <= a[i].p) {
now -= (a[k].x - a[i].x);
i = k;
} else {
t++;
while (t <= m && a[t].x - a[i].x <= n) {
if (a[t].p <= a[i].p) {
ans = (ans + (a[t].x - a[i].x - now) * a[i].p);
now = 0;
i = t;
break;
}
t++;
}
if (a[t].x - a[i].x > n) {
t = upper_bound(b + 1, b + m + 1, a[i].x + n) - b - 1;
k = get_mn(1, m, 1, i + 1, t);
ans = (ans + (n - now) * a[i].p);
now = (n - (a[k].x - a[i].x));
i = k;
}
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (b != d)
cout << b << " " << d << endl;
else if (a != d)
cout << a << " " << d << endl;
else if (b != c)
cout << b << " " << c << endl;
else if (a != c)
cout << a << " " << c << endl;
else
cout << a + 1 << " " << d - 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10, inf = 1e9 + 1;
unordered_map<string, long long> mp;
vector<long long> G[maxn], R[maxn], t;
long long a[maxn], r[maxn], l[maxn], c, sccid[maxn];
pair<long long, long long> scc[maxn], dp[maxn];
bool v[maxn];
string lower(const string &s) {
string ret = "";
for (long long i = 0; i < s.length(); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z')
ret += s[i] + 32;
else
ret += s[i];
}
return ret;
}
long long find(string s) {
s = lower(s);
if (mp.find(s) == mp.end()) {
mp[s] = mp.size();
l[mp[s]] = (long long)s.size();
for (long long i = 0; i < s.size(); ++i)
if (s[i] == 'r') ++r[mp[s]];
}
return mp[s];
}
void add_edge(long long u, long long v) {
G[u].push_back(v);
R[v].push_back(u);
}
void dfs(long long now) {
v[now] = true;
for (long long u : G[now])
if (!v[u]) dfs(u);
t.push_back(now);
}
void rdfs(long long now) {
v[now] = true;
scc[c] = min(scc[c], make_pair(r[now], l[now]));
sccid[now] = c;
for (long long u : R[now])
if (!v[u]) rdfs(u);
}
pair<long long, long long> go(long long now) {
if (dp[now] != make_pair(0ll, 0ll)) return dp[now];
dp[now] = scc[now];
for (long long u : R[now]) {
pair<long long, long long> p = go(u);
dp[now] = min(dp[now], p);
}
return dp[now];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
string s;
cin >> s;
a[i] = find(s);
}
long long n;
cin >> n;
while (n--) {
string a, b;
cin >> a >> b;
long long u = find(a), v = find(b);
add_edge(u, v);
}
for (long long i = 1; i <= mp.size(); ++i)
if (!v[i]) dfs(i);
reverse(t.begin(), t.end());
memset(v, false, sizeof(v));
fill(scc, scc + maxn, make_pair(inf, inf));
for (long long u : t)
if (!v[u]) ++c, rdfs(u);
for (long long i = 0; i < maxn; ++i) R[i].clear();
for (long long i = 1; i <= mp.size(); ++i) {
for (long long u : G[i]) {
if (sccid[u] != sccid[i]) R[sccid[i]].push_back(sccid[u]);
}
}
long long rnow = 0, lnow = 0;
for (long long i = 0; i < m; ++i) {
pair<long long, long long> p = go(sccid[a[i]]);
rnow += p.first;
lnow += p.second;
}
cout << rnow << ' ' << lnow << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
const long long LINF = (long long)1E18;
const long double PI = acos(-1.0);
const long double EPS = 1E-9;
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? abs(a) : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
inline T mod(T a, T b) {
a %= b;
if (a < 0) a += b;
return a;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline T gmax(T a, T b) {
return (a > b ? a : b);
}
template <typename T>
inline T gmin(T a, T b) {
return (a < b ? a : b);
}
template <typename T>
inline string toString(T x) {
ostringstream oss;
oss << x;
return oss.str();
}
inline long long toInt(const string& st) {
istringstream iss(st);
long long x;
iss >> x;
return x;
}
inline long double toDouble(const string& st) {
istringstream iss(st);
long double x;
iss >> x;
return x;
}
inline string toLower(string st) {
for (int i = 0; i < (((int)(st).size())); i++) st[i] = tolower(st[i]);
return st;
}
inline string toUpper(string st) {
for (int i = 0; i < (((int)(st).size())); i++) st[i] = toupper(st[i]);
return st;
}
bool LOCAL = false, OUTPUT = true;
const char DEBUG_PARAM[] = "__LOCAL_TESTING";
const char IN[] = "input.txt";
const char OUT[] = "output.txt";
inline void init();
inline void run();
int ntest = 0, test;
int main(int argc, char* argv[]) {
if (argc > 1 && strcmp(argv[1], DEBUG_PARAM) == 0) {
LOCAL = true;
freopen(IN, "r", stdin);
}
init();
if (ntest == 0) {
cerr << "ntest = ?" << endl;
return 0;
}
for (test = 1; test <= ntest; ++test) {
run();
}
return 0;
}
inline void stop() { ntest = test - 1; }
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
inline void init() {
OUTPUT = true;
ntest = 1;
}
int k, l;
int num = 0;
inline void run() {
cin >> k >> l;
while (l % k == 0) {
l /= k;
num++;
}
if (l != 1 || num == 0) {
cout << "NO";
return;
}
cout << "YES" << endl << num - 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 29;
const long long LINF = 1ll << 61;
inline long long getnum() {
register long long r = 0;
register bool ng = 0;
register char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') ng = 1, c = getchar();
while (c != ' ' && c != '\n') r = r * 10 + c - '0', c = getchar();
if (ng) r = -r;
return r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline void putsp() { putchar(' '); }
inline void putendl() { putchar('\n'); }
inline char mygetchar() {
register char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
int X, n, a[22][22], b[22][22], suf[22];
bool visx[22], visy[22];
int ans, mx[22], my[22], lx[22], ly[22], slk[22], tc[22][22];
bool dfs(int x) {
visx[x] = 1;
for (int y = 1; y <= n; y++) {
if (lx[x] + ly[y] > tc[x][y]) {
slk[y] = min(slk[y], lx[x] + ly[y] - tc[x][y]);
} else if (!visy[y]) {
visy[y] = 1;
if (my[y] == -1 || dfs(my[y])) {
mx[x] = y;
my[y] = x;
return true;
}
}
}
return false;
}
void go(int x) {
for (int i = 1; i <= n; i++) slk[i] = INF;
memset(visx, 0, sizeof(visx));
memset(visy, 0, sizeof(visy));
while (!dfs(x)) {
int d = INF * 2;
for (int i = 1; i <= n; i++)
if (!visy[i]) d = min(d, slk[i]);
if (d == INF * 2) {
puts("WTF!");
exit(1);
}
for (int i = 1; i <= n; i++)
if (visx[i]) lx[i] -= d, visx[i] = 0;
for (int i = 1; i <= n; i++)
if (visy[i]) ly[i] += d, visy[i] = 0;
for (int i = 1; i <= n; i++) slk[i] = INF;
}
}
void calc(int cnta, int cntb) {
int tans = 0;
for (int i = 1; i < X; i++) tans += tc[i][mx[i]];
if (clock() > 1500) {
cout << ans << endl;
exit(0);
}
if (tans + suf[X] <= ans) return;
if (X > n) {
ans = tans;
return;
}
if (cnta < n / 2 && cntb < n / 2) {
int tlx[22], tly[22], tmx[22], tmy[22];
for (int i = 1; i <= n; i++)
tlx[i] = lx[i], tly[i] = ly[i], tmx[i] = mx[i], tmy[i] = my[i];
for (int i = 1; i <= n; i++) tc[X][i] = a[X][i];
go(X);
X++;
calc(cnta + 1, cntb);
X--;
for (int i = 1; i <= n; i++)
lx[i] = tlx[i], ly[i] = tly[i], mx[i] = tmx[i], my[i] = tmy[i];
for (int i = 1; i <= n; i++) tc[X][i] = b[X][i];
go(X);
X++;
calc(cnta, cntb + 1);
X--;
} else if (cnta < n / 2) {
for (int i = 1; i <= n; i++) tc[X][i] = a[X][i];
go(X);
X++;
calc(cnta + 1, cntb);
X--;
} else if (cntb < n / 2) {
for (int i = 1; i <= n; i++) tc[X][i] = b[X][i];
go(X);
X++;
calc(cnta, cntb + 1);
X--;
}
}
int main() {
n = getnum();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
a[i][j] = getnum();
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
b[i][j] = getnum();
}
}
for (int i = n; i >= 1; i--) {
suf[i] = max(*max_element(a[i] + 1, a[i] + 1 + n),
*max_element(b[i] + 1, b[i] + 1 + n));
suf[i] += suf[i + 1];
}
for (int i = 1; i <= n; i++) lx[i] = INF;
memset(mx, -1, sizeof(mx));
memset(my, -1, sizeof(my));
X = 1;
calc(0, 0);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 50;
const int maxm = 100000 + 100;
const long long unit = 1LL;
const int INF = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const double inf = 1e15;
const double pi = acos(-1.0);
const long long mod = 1000000007LL;
inline long long read() {
long long x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
long long n, k, l;
long long d[maxn];
vector<long long> safe;
int main() {
int T = read();
while (T--) {
n = read(), k = read(), l = read();
for (long long i = 1; i <= n; ++i) d[i] = read();
bool ok = true;
safe.clear();
safe.push_back(0);
for (long long i = 1; i <= n; ++i) {
if (d[i] > l) {
ok = false;
break;
}
if (d[i] + k <= l) safe.push_back(i);
}
safe.push_back(n + 1);
for (long long i = 1; i < safe.size(); ++i) {
long long tide = k;
bool down = true;
for (long long j = safe[i - 1] + 1; j < safe[i]; ++j) {
tide += down ? -1 : 1;
if (!down) {
if (tide + d[j] > l) {
ok = false;
break;
}
} else
tide -= max(0LL, tide + d[j] - l);
if (!tide) down = false;
}
if (!ok) break;
}
if (!ok)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[105][105], ans[105], temp[105];
int book[105];
int main() {
int n, l, a, b;
char c, *p;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
l = strlen(s[i]);
for (int j = 0; j < l; j++) {
if (isupper(s[i][j])) s[i][j] = tolower(s[i][j]);
}
}
scanf("%s\n", ans);
strcpy(temp, ans);
l = strlen(ans);
for (int i = 0; i < l; i++)
if (isupper(temp[i])) temp[i] = tolower(temp[i]);
for (int i = 0; i < n; i++) {
p = strstr(temp, s[i]);
a = 1;
while (p != NULL) {
l = strlen(s[i]);
for (int j = p - temp; j < p - temp + l; j++) book[j] = 1;
p = strstr(temp + a, s[i]);
a++;
}
}
l = strlen(ans);
scanf("%c", &c);
if (isupper(c))
a = c - 'A';
else
a = c - 'a';
for (int i = 0; i < l; i++) {
if (book[i] == 1) {
if (isupper(ans[i]))
b = ans[i] - 'A';
else
b = ans[i] - 'a';
if (a != b) {
if (isupper(ans[i]))
ans[i] = toupper(c);
else
ans[i] = tolower(c);
} else {
if (c == 'A' || c == 'a') {
if (isupper(ans[i]))
ans[i] = 'B';
else
ans[i] = 'b';
} else {
if (isupper(ans[i]))
ans[i] = 'A';
else
ans[i] = 'a';
}
}
}
}
printf("%s", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > v(100000);
vector<bool> used(100000, false);
int color[100000], k, last;
bool ok;
void dfs(int start) {
used[start] = true;
last = start;
k++;
for (int i = 0; i < v[start].size(); ++i) {
if (!used[v[start][i]]) {
dfs(v[start][i]);
}
}
}
void dfs1(int start) {
color[start] = 1;
for (int i = 0; i < v[start].size(); ++i) {
int to = v[start][i];
if (!color[to]) {
dfs1(to);
} else if (color[to] == 1) {
ok = true;
return;
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
v[x - 1].push_back(y - 1);
v[y - 1].push_back(x - 1);
}
vector<int> v1, v2, v3;
for (int i = 0; i < n; ++i) {
if (!v[i].empty()) {
if (v[i].size() == 1) {
v1.push_back(i);
} else if (v[i].size() == 2) {
v2.push_back(i);
} else if (v[i].size() == n - 1) {
v3.push_back(i);
}
} else {
cout << "unknown topology" << endl;
return 0;
}
}
if (v1.size() == 2 && v2.size() == n - 2) {
dfs(v1.front());
if (last == v1.back() && k == n) {
cout << "bus topology" << endl;
} else {
cout << "unknown topology" << endl;
}
} else if (v2.size() == n) {
dfs1(v2.front());
if (ok) {
cout << "ring topology" << endl;
} else {
cout << "unknown topology" << endl;
}
} else if (v3.size() == 1 && v1.size() == n - 1) {
dfs(v3.front());
if (k == n) {
cout << "star topology" << endl;
} else {
cout << "unknown topology" << endl;
}
} else {
cout << "unknown topology" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int x, t, a, b, da, db;
cin >> x >> t >> a >> b >> da >> db;
if (x == a || x == b || x == 0) {
cout << "YES";
return 0;
}
int tmp;
for (int i = (int)0; i < (int)t; i++) {
tmp = b;
for (int j = (int)0; j < (int)t; j++) {
if (a == x || tmp == x || a + tmp == x) {
cout << "YES";
return 0;
}
tmp = tmp - db;
}
a = a - da;
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[10000000 + 5];
int main() {
memset(a, 0, sizeof(a));
char c;
int b;
int sum = 0, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
getchar();
scanf("%c %d", &c, &b);
if (c == '+') {
sum++;
a[b]++;
} else {
if (a[b] == 0)
ans++;
else {
sum--;
a[b]--;
}
}
ans = max(ans, sum);
}
printf("%d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long candy(long long k, long long n) {
long long ctr = 0;
while (n > 0) {
if (n < k) {
ctr += n;
n = 0;
} else {
n = n - k;
ctr += k;
if (n >= 10) n = n - (n / 10);
}
}
return ctr;
}
int main() {
long long n;
cin >> n;
long long lo = 1, hi = n;
long long ans;
while (lo <= hi) {
long long mid = lo + (hi - lo) / 2;
long long caneat = candy(mid, n);
if (2 * caneat >= n) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x[2005], y[2005];
int cnt[2005];
int s[2005];
int t[2005];
int ans = 1e9;
int all = 0;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i];
y[i] = x[i];
}
sort(y + 1, y + 1 + n);
int tot = unique(y + 1, y + n + 1) - y - 1;
for (int i = 1; i <= n; i++) {
x[i] = lower_bound(y + 1, y + tot + 1, x[i]) - y;
s[x[i]]++;
if (s[x[i]] == 2) {
all++;
}
}
if (all == 0) {
cout << 0 << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
int nsum = all;
for (int j = 1; j <= n; j++) {
t[j] = s[j];
}
for (int j = i; j <= n; j++) {
t[x[j]]--;
if (t[x[j]] == 1) {
nsum--;
}
if (nsum == 0) {
ans = min(ans, j - i + 1);
break;
}
}
}
if (ans == 1e9) {
ans = 0;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> S;
struct Node {
int x, y;
} C[2012];
char s[2012][2012];
int N, M, cnt;
long long Ans, Cnt;
inline bool cmp1(Node A, Node B) {
return A.x < B.x || (A.x == B.x && A.y < B.y);
}
inline bool cmp2(Node A, Node B) {
return A.y < B.y || (A.y == B.y && A.x < B.x);
}
int main() {
scanf("%d%d ", &N, &M);
for (long long i = 1; i <= N; ++i) {
gets(s[i] + 1);
for (long long j = 1; j <= M; ++j)
if (s[i][j] == 'X') {
C[++cnt].x = i, C[cnt].y = j;
Ans -= M * ((i - 1) * i / 2 + (N - i) * (N - i + 1) / 2) +
N * ((j - 1) * j / 2 + (M - j) * (M - j + 1) / 2);
Ans += 2 * ((i - 1) * (N - i) + (j - 1) * (M - j));
for (int k = 1; k < cnt; ++k)
Ans += abs(C[k].x - C[cnt].x) + abs(C[k].y - C[cnt].y);
} else
++Cnt;
}
for (long long i = 1; i <= N; ++i)
for (long long j = 1; j <= M; ++j) {
Ans += (j - 1) * j / 2;
Ans += M * (i - 1) * i / 2;
Ans += (i - 1) * ((j - 1) * j / 2 + (M - j + 1) * (M - j) / 2);
}
sort(C + 1, C + 1 + cnt, cmp1);
S.push_back(1);
for (int i = 2; i <= cnt; ++i) {
int fuck = i;
while (S.size() && (C[S.back()].x != C[i].x - 1 || C[S.back()].y > C[i].y))
S.pop_back();
S.push_back(i);
for (vector<int>::iterator j = S.begin(); *j != i; ++j) {
Ans += 2 * (C[*j].y - 1) * (M - C[S.back()].y);
}
}
S.erase(S.begin(), S.end());
S.push_back(1);
for (int i = 2; i <= cnt; ++i) {
while (S.size() && (C[S.back()].x != C[i].x - 1 || C[S.back()].y < C[i].y))
S.pop_back();
S.push_back(i);
for (vector<int>::iterator j = S.begin(); *j != i; ++j) {
Ans += 2 * (M - C[*j].y) * (C[S.back()].y - 1);
}
}
S.erase(S.begin(), S.end());
sort(C + 1, C + 1 + cnt, cmp2);
S.push_back(1);
for (int i = 2; i <= cnt; ++i) {
while (S.size() && (C[S.back()].y != C[i].y - 1 || C[S.back()].x > C[i].x))
S.pop_back();
S.push_back(i);
for (vector<int>::iterator j = S.begin(); *j != i; ++j) {
Ans += 2 * (C[*j].x - 1) * (N - C[S.back()].x);
}
}
S.erase(S.begin(), S.end());
S.push_back(1);
for (int i = 2; i <= cnt; ++i) {
while (S.size() && (C[S.back()].y != C[i].y - 1 || C[S.back()].x < C[i].x))
S.pop_back();
S.push_back(i);
for (vector<int>::iterator j = S.begin(); *j != i; ++j) {
Ans += 2 * (N - C[*j].x) * (C[S.back()].x - 1);
}
}
S.erase(S.begin(), S.end());
printf("%.10f",
(double)(((long double)(Ans * 2)) / ((long double)(Cnt * Cnt))));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
while (scanf("%lld", &n) != EOF) {
int k = 0;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) {
a[i] /= 2;
}
while (a[i] % 3 == 0) {
a[i] /= 3;
}
}
for (int i = 0; i < n; i++) {
if (a[i] != a[0]) {
cout << "No" << endl;
k = 1;
break;
}
}
if (!k) {
cout << "Yes" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long pp = 3e5;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
template <typename T>
inline void read(T& x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
putchar(' ');
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
long long n, m, k;
long long a[pp], kt[pp], trc[pp];
pair<int, int> M[pp];
vector<int> V[pp];
string S;
set<long long> Set;
bool ss(int u, int v) { return M[u] < M[v]; }
void dowork(int x) {
m = 0;
read(n);
for (int i = 1; i <= n; ++i) {
int u;
read(u);
if (M[u].second != x + 1) {
M[u] = {0, x + 1};
a[++m] = u;
}
++M[u].first;
}
sort(a + 1, a + m + 1, ss);
long ans = 0;
for (int i = n; i >= 1; --i)
if (M[a[m]].first >= i) {
ans += i;
--m;
}
writeln(ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
int n1;
read(n1);
while (n1--) dowork(n1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[2020][2020], b[2020][2020];
const int LIM = 3, BLIM = 15;
int minx, miny, maxx, maxy, cn;
void dfs(int x, int y) {
if (!b[x][y]) return;
if (x < minx || (x == minx && y < miny)) minx = x, miny = y;
if (x > maxx || (x == maxx && y > maxy)) maxx = x, maxy = y;
b[x][y] = 0;
cn++;
dfs(x - 1, y);
dfs(x + 1, y);
dfs(x, y - 1);
dfs(x, y + 1);
}
void lemon() {
int n;
scanf("%d", &n);
for (int i = (LIM); i <= (n + LIM - 1); i++)
for (int j = (LIM); j <= (n + LIM - 1); j++) scanf("%d", &a[i][j]);
for (int i = (LIM); i <= (n - LIM + 1); i++)
for (int j = (LIM); j <= (n - LIM + 1); j++)
for (int k = (i - LIM + 1); k <= (i + LIM - 1); k++)
for (int L = (j - LIM + 1); L <= (j + LIM - 1); L++)
if (a[k][L]) b[i - LIM + 1][j - LIM + 1]++;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (b[i][j] >= BLIM)
b[i][j] = 1;
else
b[i][j] = 0;
int circle = 0, square = 0;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (b[i][j]) {
minx = miny = 1000000000;
maxx = maxy = -1000000000;
cn = 0;
dfs(i, j);
double dis =
sqrt((maxx - minx) * (maxx - minx) + (maxy - miny) * (maxy - miny));
double square_area = dis * dis / 2;
double circle_area = dis * dis / 4 * 3.14159;
if (circle_area < 65 && square_area < 85) continue;
if (abs(cn - circle_area) < abs(cn - square_area))
circle++;
else
square++;
}
cout << circle << " " << square << endl;
}
int main() {
ios::sync_with_stdio(true);
lemon();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, dc, i;
cin >> n >> dc;
vector<int> a(n, 0), x(n, 0), y(n, 0);
for (i = 1; i < n - 1; i++) cin >> a[i];
vector<vector<pair<int, int> > > g(n);
for (i = 0; i < n; i++) {
cin >> x[i] >> y[i];
for (int j = 0; j < i; j++) {
g[j].push_back(make_pair(i, dc * (abs(x[i] - x[j]) + abs(y[i] - y[j]))));
g[i].push_back(make_pair(j, dc * (abs(x[i] - x[j]) + abs(y[i] - y[j]))));
}
}
int m = 0;
int s = 0;
vector<int> d(n, 1000000000), p(n);
d[s] = 0;
vector<char> u(n);
for (int i = 0; i < n; ++i) {
int v = -1;
for (int j = 0; j < n; ++j)
if (!u[j] && (v == -1 || d[j] < d[v])) v = j;
if (d[v] == 1000000000) break;
u[v] = true;
for (size_t j = 0; j < g[v].size(); ++j) {
int to = g[v][j].first, len = g[v][j].second;
if (d[v] + len - a[v] < d[to]) {
d[to] = d[v] + len - a[v];
p[to] = v;
}
}
}
cout << d[n - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10e5 + 3;
int a[N], b[N];
int main() {
int maxa, maxb;
int n, m, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> b[i];
}
maxa = a[0];
maxb = b[0];
for (int i = 1; i < n; i++) {
if (a[i] > maxa) {
maxa = a[i];
}
}
for (int i = 1; i < m; i++) {
if (b[i] > maxb) {
maxb = b[i];
}
}
cout << maxa << " " << maxb;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int po(long long int a, long long int b) {
if (b == 0) {
return 1;
}
long long int t = po(a, b / 2);
if (b % 2) {
return mul(t, mul(t, a));
} else {
return mul(t, t);
}
}
long long int m[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i <= n; i++) {
m[i] = 0;
}
long long int ma = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
ma = max(ma, m[a[i]]);
}
long long int x = 0;
for (long long int i = 0; i <= n; i++) {
if (m[i] == ma) {
x++;
}
}
long long int out = (n - x);
out = (out) / (ma - 1);
out--;
cout << out << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20009, M = 109;
vector<int> to[N];
int stk[N], match[N], L[N], R[N], idx[N], f[N][M], g[N][M], mn[M], mx[M];
char str[N];
int n, len, m, opt, lp, rp, tot, top, lim;
void merge(int x, int y) {
for (int i = 0; i <= lim; i++) mx[i] = -1000000, mn[i] = 1000000;
for (int l = 0; l <= lim; l++)
for (int r = 0; r + l <= lim; r++) {
if (opt) {
mn[l + r] = min(mn[l + r], g[x][l] + g[y][r]);
if (l + r + 1 <= lim)
mn[l + r + 1] = min(mn[l + r + 1], g[x][l] - f[y][r]);
mx[l + r] = max(mx[l + r], f[x][l] + f[y][r]);
if (l + r + 1 <= lim)
mx[l + r + 1] = max(mx[l + r + 1], f[x][l] - g[y][r]);
} else {
mn[l + r] = min(mn[l + r], g[x][l] - f[y][r]);
if (l + r + 1 <= lim)
mn[l + r + 1] = min(mn[l + r + 1], g[x][l] + g[y][r]);
mx[l + r] = max(mx[l + r], f[x][l] - g[y][r]);
if (l + r + 1 <= lim)
mx[l + r + 1] = max(mx[l + r + 1], f[x][l] + f[y][r]);
}
}
memcpy(f[x], mx, sizeof f[x]);
memcpy(g[x], mn, sizeof g[x]);
}
void dp(int x) {
for (int i = 0; i <= lim; i++) f[x][i] = -1000000, g[x][i] = 1000000;
if (L[x] == R[x]) {
f[x][0] = g[x][0] = str[L[x]] - '0';
return;
}
bool flag = 0;
for (int i = L[x] + 1; i <= R[x]; i = match[i] + 2) {
int w = idx[i];
dp(w);
if (!flag) {
memcpy(f[x], f[w], sizeof f[x]);
memcpy(g[x], g[w], sizeof g[x]);
flag = 1;
continue;
}
merge(x, w);
}
}
int main() {
scanf("%s", str + 1);
str[0] = '(';
len = strlen(str);
str[len++] = ')';
for (int i = 0; i < len; i++) {
if (str[i] == '(') {
idx[i] = ++tot;
stk[++top] = i;
}
if (str[i] == ')') {
match[stk[top]] = i;
match[i] = stk[top];
idx[i] = idx[stk[top]];
L[idx[i]] = stk[top];
R[idx[i]] = i;
top--;
}
if (str[i] >= '0' && str[i] <= '9') {
match[i] = i;
idx[i] = ++tot;
L[tot] = R[tot] = i;
}
}
scanf("%d%d", &lp, &rp);
opt = lp > rp;
lim = opt ? rp : lp;
dp(1);
cout << f[1][lim] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp1;
map<long long, long long> mp2;
int main() {
long long i, j, k, l, m, n;
while (cin >> n) {
mp1.clear();
mp2.clear();
for (i = 1, j = n; i <= n, j >= 1; i++, j--) {
cin >> m;
if (!mp1[m]) {
mp1[m] = i;
}
if (!mp2[m]) {
mp2[m] = j;
}
}
cin >> m;
long long s1, s2;
s1 = s2 = 0;
for (i = 0; i < m; i++) {
cin >> l;
s1 += mp1[l];
s2 += mp2[l];
}
cout << s1 << " " << s2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a[200005], b[200005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) b[i] = (a[i] == a[i - 1]) ? b[i - 1] : (i - 1);
while (m--) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
if (a[y] != v)
printf("%d\n", y);
else if (b[y] >= x)
printf("%d\n", b[y]);
else
puts("-1");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn];
int b[maxn * 400];
int c[maxn];
int book[maxn * 100];
vector<int> edg[maxn];
int num, d, sg;
void dfs(int x, int e) {
d = max(e, d);
for (int i = 0; i < (int)edg[x].size(); i++) {
dfs(edg[x][i], e + 1);
}
}
void dfs2(int x, int e) {
if (e % 2 == d % 2) {
num++;
sg ^= a[x];
c[x] = 1;
}
for (int i = 0; i < (int)edg[x].size(); i++) {
dfs2(edg[x][i], e + 1);
}
return;
}
int main() {
int n, i, j;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int x;
for (i = 2; i <= n; i++) {
scanf("%d", &x);
edg[x].push_back(i);
}
dfs(1, 1);
dfs2(1, 1);
long long ans = 0;
if (sg == 0) {
ans += (long long)(n - num) * (long long)(n - num - 1) / 2LL +
(long long)num * (long long)(num - 1LL) / 2LL;
}
for (i = 1; i <= n; i++) {
if (c[i]) {
b[sg ^ a[i]]++;
}
}
long long sum = 0;
for (i = 1; i <= n; i++) {
if (c[i] == 0) {
ans += b[a[i]];
}
}
cout << ans + sum / 2 << endl;
}
| 7 |
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#define maxn 300005
#define ll long long
using namespace std;
int n,i,j,k,a[maxn],fa[maxn],p[maxn],b[maxn];
int em,e[maxn],nx[maxn],ls[maxn];
void insert(int x,int y){
em++; e[em]=y; nx[em]=ls[x]; ls[x]=em;
}
int L[maxn],R[maxn],dep[maxn];
vector<int> E[maxn];
int cmp(int i,int j){return L[i]<L[j];}
void dfs(int x){
L[x]=R[x]=a[x];
for(int i=ls[x];i;i=nx[i]) {
dep[e[i]]=dep[x]+1,dfs(e[i]),E[x].push_back(e[i]);
L[x]=min(L[x],L[e[i]]),R[x]=max(R[x],R[e[i]]);
}
sort(E[x].begin(),E[x].end(),cmp);
for(int i=1;i<E[x].size();i++) if (L[E[x][i]]<R[E[x][i-1]])
printf("NO\n"),exit(0);
}
int dfn[maxn],dfn0[maxn];
void dfs2(int x){
dfn[x]=++dfn[0];
for(int i=0;i<E[x].size();i++)
dfs2(E[x][i]);
dfn0[x]=++dfn0[0];
}
int now;
void dfs3(int x,int p){
if (a[x]>now){
if (a[x]<p)
printf("NO\n"),exit(0);
p=a[x];
}
for(int i=0;i<E[x].size();i++)
dfs3(E[x][i],p);
}
int main(){
scanf("%d",&n);
for(i=1;i<=n;i++) scanf("%d",&a[i]),p[a[i]]=i;
for(i=1;i<n;i++){
scanf("%d%d",&j,&k);
fa[k]=j,insert(j,k);
}
dfs(1);
dfs2(1);
ll ans=0;
for(now=1;now<=n;now++){
int x=p[now],tp=0; ans+=dep[x];
for(i=ls[x];i;i=nx[i]) if (a[e[i]]>a[x]) tp=1;
if (tp) break;
if (dfn0[x]!=now) printf("NO\n"),exit(0);
}
dfs3(1,0);
printf("YES\n");
printf("%lld\n",ans);
for(i=1;i<=n;i++) printf("%d ",dfn[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int j, last = -1, n;
char s[100100], i;
int main() {
scanf("%s", &s);
n = strlen(s);
for (i = 'z'; i >= 'a'; i--) {
for (j = last + 1; j < n; j++)
if (s[j] == i) {
putchar(i);
last = j;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1003;
int n;
int mat[maxn];
int main() {
scanf("%d", &n);
int id = 0, mx = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &mat[i]);
if (mx < mat[i]) {
mx = mat[i];
id = i;
}
}
printf("%d ", id + 1);
int ans = 0;
bool flag = false;
for (int i = 0; i < n; i++) {
if ((mat[i] != mx && mat[i] > ans) || (flag && (mat[i] == mx))) {
ans = mat[i];
} else if (mat[i] == mx)
flag = true;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int INF = 1e9 + 100;
const long long LINF = 1e18 + 100;
int n, k;
vector<int> adj[100100];
int h[100100];
int sttime[100100], fntime[100100], timer;
int lpar[30][100100];
void dfs(int v) {
sttime[v] = timer++;
for (int u : adj[v]) {
if (u == lpar[0][v]) continue;
lpar[0][u] = v;
h[u] = h[v] + 1;
dfs(u);
}
fntime[v] = timer;
}
int getpar(int v, int x) {
for (int i = (0); i < (30); i++)
if (x >> i & 1) v = lpar[i][v];
return v;
}
int getlca(int u, int v) {
if (h[u] > h[v]) swap(u, v);
v = getpar(v, h[v] - h[u]);
if (u == v) return u;
for (int i = 30 - 1; i >= 0; i--) {
if (lpar[i][v] != lpar[i][u]) {
v = lpar[i][v];
u = lpar[i][u];
}
}
return lpar[0][u];
}
struct cmp {
bool operator()(int x, int y) { return sttime[x] < sttime[y]; }
};
int size;
set<int, cmp> s;
inline int getdist(int x, int y) { return h[x] + h[y] - 2 * h[getlca(x, y)]; }
int getdif(int v) {
;
;
int nxt, prv;
auto it = s.upper_bound(v);
int lca = getlca(*s.begin(), *s.rbegin());
if (it == s.end())
nxt = lca;
else
nxt = *it;
if (it == s.begin())
prv = lca;
else {
it--;
prv = *it;
}
return (getdist(v, prv) + getdist(v, nxt) - getdist(prv, nxt)) / 2;
}
void add(int v) {
size += getdif(v);
s.insert(v);
}
void rem(int v) {
s.erase(v);
size -= getdif(v);
}
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = (0); i < (n - 1); i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1);
for (int i = (1); i < (30); i++)
for (int j = (1); j < (n + 1); j++)
lpar[i][j] = lpar[i - 1][lpar[i - 1][j]];
s.insert(1);
size = 1;
int r = 1;
int ans = 0;
for (int l = (1); l < (n + 1); l++) {
while (r < n && size <= k) add(++r);
ans = max(ans, r - l + (size <= k));
if (l < n) rem(l);
}
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, flag[30];
long long sum[400010 << 2], a[400010];
void update(int dep, int now, int l, int r, int p, long long v) {
if (l == r) {
sum[now] = v;
return;
}
int mid = (l + r) / 2;
if (mid >= p) {
if (flag[dep])
update(dep - 1, now << 1 | 1, mid + 1, r, p - l + mid + 1, v);
else
update(dep - 1, now << 1, l, mid, p, v);
} else {
if (flag[dep])
update(dep - 1, now << 1, l, mid, p - mid - 1 + l, v);
else
update(dep - 1, now << 1 | 1, mid + 1, r, p, v);
}
sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
long long query(int dep, int now, int l, int r, int L, int R) {
if (l >= L && r <= R) return sum[now];
int mid = (l + r) / 2;
long long res = 0;
if (flag[dep]) {
if (mid >= L)
res += query(dep - 1, now << 1 | 1, mid + 1, r, L - l + mid + 1,
min(R, mid) - l + mid + 1);
if (mid < R)
res += query(dep - 1, now << 1, l, mid, max(L, mid + 1) - mid - 1 + l,
R - mid - 1 + l);
} else {
if (mid >= L) res += query(dep - 1, now << 1, l, mid, L, min(R, mid));
if (mid < R)
res += query(dep - 1, now << 1 | 1, mid + 1, r, max(L, mid + 1), R);
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= (1 << n); i++)
scanf("%lld", &a[i]), update(n, 1, 1, (1 << n), i, a[i]);
while (m--) {
int op, x, y;
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%d", &y);
update(n, 1, 1, (1 << n), x, y);
} else if (op == 2)
for (int i = x; i >= 0; i--) flag[i] ^= 1;
else if (op == 3)
flag[x + 1] ^= 1;
else {
scanf("%d", &y);
printf("%lld\n", query(n, 1, 1, (1 << n), x, y));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[555][555];
int vis[555][555];
int go[555][555][4];
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
char ans[3333333];
int cnt;
int n;
inline char to(int i) {
if (i == 0)
return 'R';
else if (i == 1)
return 'D';
else if (i == 2)
return 'U';
else
return 'L';
}
inline bool in(int x) { return x >= 1 && x <= n; }
void bfs(int x, int y) {
queue<pair<int, int> > Q;
Q.push(make_pair(x, y));
vis[x][y] = 1;
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
Q.pop();
for (int d = 0; d < 4; ++d) {
int xx = x + dx[d];
int yy = y + dy[d];
int last = 0, i = 0;
while (in(xx) && in(yy) && vis[xx][yy] == 0) {
++i;
if (a[xx][yy] == 1) last = i;
xx += dx[d];
yy += dy[d];
}
xx = x;
yy = y;
for (int i = 1; i <= last; ++i) {
xx += dx[d];
yy += dy[d];
Q.push(make_pair(xx, yy));
vis[xx][yy] = 1;
go[xx - dx[d]][yy - dy[d]][d] = 1;
}
}
}
}
void dfs(int x, int y) {
if (a[x][y] == 0) ans[cnt++] = '1';
for (int d = 0; d < 4; ++d) {
if (go[x][y][d]) {
ans[cnt++] = to(d);
dfs(x + dx[d], y + dy[d]);
ans[cnt++] = to(3 - d);
}
}
ans[cnt++] = '2';
}
int main() {
int x0, y0;
scanf("%d%d%d", &n, &x0, &y0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &a[i][j]);
bfs(x0, y0);
bool ok = true;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (a[i][j] == 1 && vis[i][j] == 0) {
ok = false;
break;
}
}
}
if (ok) {
puts("YES");
cnt = 0;
dfs(x0, y0);
ans[cnt] = '\0';
puts(ans);
} else {
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, a[200010], b[200010], c[200010], s[200010];
bool cal(int k) {
memset(s, 0, sizeof s);
int ok = 0;
for (int i = 1; i <= cnt + k; ++i) s[a[i]]++;
for (int i = 1; i <= m; ++i)
if (s[i] >= b[i]) ok++;
if (ok == m) return 1;
for (int i = 1; i <= n - cnt - k + 1; ++i) {
s[a[i]]--;
if (s[a[i]] == b[a[i]] - 1) ok--;
s[a[i + cnt + k]]++;
if (s[a[i + cnt + k]] == b[a[i + cnt + k]]) ok++;
if (ok == m) return 1;
}
return 0;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> b[i], cnt += b[i];
int l = 0, r = n - cnt + 1, mid;
while (l < r) {
mid = (l + r) >> 1;
if (cal(mid))
r = mid;
else
l = mid + 1;
}
if (l == n - cnt + 1)
cout << -1 << endl;
else
cout << l << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num;
cin >> num;
string s;
cin >> s;
string res;
char lst0 = 'a', lst1 = 'a';
for (int i = 0; i < num; i++) {
if (s[i] >= lst0) {
res = res + '0';
lst0 = s[i];
} else if (s[i] >= lst1) {
res = res + '1';
lst1 = s[i];
} else {
cout << "NO" << endl;
return 0;
}
}
cout << "YES"
<< "\n"
<< res << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t;
cin >> t;
while (t > 0) {
cin >> a >> b;
int c = a ^ b;
std::cout << c << std::endl;
t--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e3 + 3, BIG = 1e9 + 7, MOD = 1e9 + 7, P = 'z' - 'a' + 1,
K = 3;
long long solve(vector<long long> a, long long n, long long d, long long b,
long long all_n) {
long long have = 0, j = 0, ans = 0;
for (long long i = 0; i < n; ++i) {
while (j < all_n && j <= i + d * (i + 1)) {
have += a[j];
++j;
}
if (b <= have)
have -= b;
else {
++ans;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, d, b;
cin >> n >> d >> b;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
vector<long long> a2(n);
long long frst = (n / 2 + n % 2) * b;
for (long long i = 0; i < n; ++i) {
if (frst >= a[i]) {
a2[i] = a[i];
a[i] -= a2[i];
frst -= a2[i];
} else {
a2[i] = frst;
a[i] -= frst;
frst = 0;
}
if (frst == 0) break;
}
reverse(a.begin(), a.end());
cout << max(solve(a2, n / 2 + n % 2, d, b, n), solve(a, n / 2, d, b, n));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void prime(int a, vector<int> &v) {
for (long long int i = 2; i * i <= a; i++) {
if (a % i == 0) v.push_back(i);
while (a % i == 0) {
a = a / i;
}
}
if (a > 1) v.push_back(a);
}
long long int mod;
long long int expmod(long long int a, long long int b) {
if (b == 1) return a;
if (b == 0) return 1;
long long int m1 = expmod(a, b / 2) % mod;
if (b % 2) return ((m1 * m1) % mod * a % mod) % mod;
return (m1 * m1) % mod;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int dp[200001][2];
int t;
int comp(int a[], int i, int j) {
if (i >= t) return 0;
if (dp[i][j] == -1) {
if (j % 2 == 0) {
if (i == t - 1)
dp[i][j] = comp(a, i + 1, 1) + a[i];
else
dp[i][j] =
min(comp(a, i + 2, 1) + a[i] + a[i + 1], comp(a, i + 1, 1) + a[i]);
} else {
if (i == t - 1)
dp[i][j] = comp(a, i + 1, 0);
else
dp[i][j] = min(comp(a, i + 1, 0), comp(a, i + 2, 0));
}
}
return dp[i][j];
}
int main() {
int w;
cin >> w;
while (w--) {
int n;
cin >> n;
int a[n];
t = n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
int r = comp(a, 0, 0);
cout << r;
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 1e15;
const int N = 300010;
int n, m, sz[N], fg[N], hd[N], a[N], b[N], cnt, o, lg[N], bin[25];
ll dis[N], f[N][21];
stack<int> s;
struct Edge {
int v, nt, w;
} E[N << 1];
char gc() {
static char *p1, *p2, s[1000000];
if (p1 == p2) p2 = (p1 = s) + fread(s, 1, 1000000, stdin);
return (p1 == p2) ? EOF : *p1++;
}
int rd() {
int x = 0;
char c = gc();
while (c < '0' || c > '9') c = gc();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = gc();
return x;
}
void adde(int u, int v, int w) {
E[o] = (Edge){v, hd[u], w};
hd[u] = o++;
}
void adde2(int u, int v, int w) {
adde(u, v, w);
adde(v, u, w);
}
bool dfs(int u, int fa) {
sz[u] = 1;
for (int i = hd[u]; i; i = E[i].nt) {
int v = E[i].v, w = E[i].w;
if (v == fa) continue;
dis[v] = dis[u] + w;
if (dfs(v, u)) return true;
fg[u] |= fg[v];
if (!fg[v]) sz[u] += sz[v], b[u] = w;
}
fg[u] |= (u == n);
if (fg[u]) s.push(u);
if (fg[u] && sz[u] > 2) return true;
return false;
}
ll query(int x, int y) {
if (x > y) return -inf;
int k = lg[y - x + 1];
return max(f[x][k], f[y - bin[k] + 1][k]);
}
int main() {
n = rd();
m = rd();
o = 1;
for (int i = 1, u, v, w; i < n; i++) {
u = rd(), v = rd(), w = rd();
adde2(u, v, w);
}
if (dfs(1, 0)) {
for (int i = 1, x; i <= m; i++) {
x = rd();
printf("%I64d\n", dis[n]);
}
return 0;
}
while (!s.empty()) {
a[++cnt] = s.top();
s.pop();
}
for (int i = 1; i <= cnt; i++) f[i][0] = dis[a[i]] + b[a[i]];
for (int i = 2; i <= cnt; i++) lg[i] = lg[i >> 1] + 1;
for (int i = bin[0] = 1; i <= 20; i++) bin[i] = bin[i - 1] << 1;
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= cnt; j++) {
if (bin[i] + j - 1 > cnt) break;
f[j][i] = max(f[j][i - 1], f[j + bin[i - 1]][i - 1]);
}
ll mx = -inf;
for (int i = 2; i <= cnt; i++) {
mx = max(mx, b[a[i]] - dis[a[i]] +
query(1, i - 1 - (sz[a[i]] == 1 && sz[a[i - 1]] == 1)));
}
mx += dis[n];
for (int i = 1, x; i <= m; i++) {
x = rd();
printf("%I64d\n", min(mx + x, dis[n]));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
vector<char> a;
cin >> s;
a.push_back(s[0]);
for (int i = 1; i < s.length() - 2; i += 2) {
if (s[i] == s[i + 1]) {
a.push_back(s[i]);
}
}
a.push_back(s[s.length() - 1]);
for (int i = 0; i < a.size(); i++) {
cout << a[i];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, a, b, c, s = 0, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d %d", &a, &b, &c);
if (a + b + c > 1) s++;
}
printf("%d", s);
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.