solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n = 0;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
cout << "1 1" << endl;
long long v0d = n - (v[0] % n);
cout << v0d << endl;
v[0] += v0d;
if (n == 1) {
cout << "1 1" << endl << -v[0] << endl;
cout << "1 1" << endl << 0 << endl;
} else {
cout << 2 << " " << n << endl;
for (long long i = 1; i < n; i++) {
long long mod = v[i] % n;
long long d = (mod) * (n - 1);
cout << d << " ";
v[i] += d;
}
cout << endl << 1 << " " << n << endl;
for (long long i = 0; i < n; i++) {
cout << -v[i] << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 200010;
const int INF = 2147483600;
int N, M;
vector<int> vec[MAXN + 1];
bool inq[MAXN + 1], vis[MAXN + 1];
int deg[MAXN + 1];
int Node[MAXN << 1], Next[MAXN << 1], Root[MAXN + 1], cnt;
inline void insert(int u, int v) {
Node[++cnt] = v;
Next[cnt] = Root[u];
Root[u] = cnt;
}
inline void dfs(int k) {
inq[k] = 1, vis[k] = 1;
for (int x = Root[k]; x; x = Next[x]) {
int v = Node[x];
if (!inq[v]) vec[k].push_back(v), ++deg[v];
if (!vis[v]) dfs(v);
}
inq[k] = 0;
}
queue<int> que;
int main() {
N = read(), M = read();
for (int i = 1; i <= M; i++) {
int u = read(), v = read();
insert(u, v);
}
for (int i = 1; i <= N; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= N; i++)
if (!deg[i]) que.push(i);
while (que.size() > 1) {
int u = que.front();
que.pop();
int v = que.front();
que.pop();
int d;
printf("? %d %d\n", u, v);
fflush(stdout);
scanf("%d", &d);
if (!d) swap(u, v);
que.push(u);
for (int i = 0, sz = vec[v].size(); i < sz; i++) {
int to = vec[v][i];
--deg[to];
if (!deg[to]) que.push(to);
}
}
printf("! %d\n", que.front());
fflush(stdout);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int MAXN = 5050;
const int MAXE = 1e6;
int n, m;
int v[N];
int good[N][2];
int sz[N];
int d[N][50];
int cnt[N][50];
int no[N][50];
int edge_cnt, src, snk, node_cnt, que_sz;
int head[MAXN], work[MAXN], to[MAXE], cap[MAXE], nxt[MAXE];
int que[MAXN], dis[MAXN];
void add_edge(int f, int t, int c) {
nxt[edge_cnt] = head[f];
head[f] = edge_cnt;
to[edge_cnt] = t;
cap[edge_cnt] = c;
edge_cnt++;
}
void add_bi_edge(int f, int t, int c) {
add_edge(f, t, c);
add_edge(t, f, 0);
}
bool bfs() {
que_sz = 0;
que[que_sz++] = src;
memset(dis, -1, sizeof dis);
dis[src] = 0;
while (que_sz) {
int u = que[--que_sz];
for (int i = head[u]; i != -1; i = nxt[i]) {
int v = to[i];
if (cap[i] <= 0 || dis[v] != -1) continue;
dis[v] = dis[u] + 1;
que[que_sz++] = v;
if (v == snk) return 1;
}
}
return 0;
}
int dfs(int u, int flow) {
if (!flow) return 0;
if (u == snk) return flow;
for (int &i = work[u]; i != -1; i = nxt[i]) {
if (dis[to[i]] != dis[u] + 1) continue;
int f = dfs(to[i], min(flow, cap[i]));
if (f) {
cap[i] -= f;
cap[i ^ 1] += f;
return f;
}
}
return 0;
}
int solve() {
int ret = 0, flow = 0;
while (bfs()) {
memcpy(work, head, sizeof head);
while (flow = dfs(src, MAXE)) ret += flow;
}
return ret;
}
int main() {
memset(head, -1, sizeof head);
scanf("%d%d", &n, &m);
src = n;
snk = n + 1;
node_cnt = n + 2;
for (int i = 0; i < int(n); i++) scanf("%d", &v[i]);
for (int i = 0; i < int(m); i++)
for (int j = 0; j < int(2); j++) {
int x;
scanf("%d", &x);
good[i][j] = --x;
}
for (int i = 0; i < int(n); i++) {
int k = 2, tmp = v[i], c = 0;
while (k * k <= tmp) {
if (tmp % k == 0) {
d[i][sz[i]] = k;
while (tmp % k == 0) {
c++;
tmp /= k;
}
cnt[i][sz[i]] = c;
sz[i]++;
}
k++;
}
if (tmp != 1) {
d[i][sz[i]] = tmp;
cnt[i][sz[i]] = 1;
sz[i]++;
}
}
for (int i = 0; i < int(n); i++) {
if (i % 2 == 0)
add_bi_edge(src, i, MAXE);
else
add_bi_edge(i, snk, MAXE);
}
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(sz[i]); j++) {
no[i][j] = node_cnt;
if (i % 2 == 0)
add_bi_edge(i, node_cnt, cnt[i][j]);
else
add_bi_edge(node_cnt, i, cnt[i][j]);
node_cnt++;
}
}
for (int k = 0; k < int(m); k++) {
if (good[k][0] % 2 == 1) swap(good[k][0], good[k][1]);
int i = good[k][0], j = good[k][1];
int ii = 0, jj = 0;
while (ii < sz[i] && jj < sz[j]) {
if (d[i][ii] == d[j][jj])
add_bi_edge(no[i][ii++], no[j][jj++], MAXE);
else if (d[i][ii] < d[j][jj])
ii++;
else
jj++;
}
}
printf("%d\n", solve());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int palindrome[17] = {0, 70, 140, 210, 280, 350, 601, 671, 741,
811, 881, 951, 1202, 1272, 1342, 1412, 1440};
int h, m, ans, temp;
scanf("%d:%d", &h, &m);
temp = 60 * h + m;
for (int i = 0; i <= 16; i++) {
ans = palindrome[i] - temp;
if (ans >= 0) break;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long lnf = 0x3f3f3f3f3f3f3f3f;
const double dnf = 1e18;
const int mod = 1000000007;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int maxn = 2000100;
const int maxm = 100100;
const int up = 100000;
int n, k, m;
long long dp[1100][110][2];
long long x[1100], ten[1100];
long long dfs(int pos, int mo, int flag) {
if (pos > n) return flag;
if (dp[pos][mo][flag] != -1) return dp[pos][mo][flag];
long long ans = 0;
for (int i = x[pos]; i <= 9; i++)
ans += dfs(pos + 1, (mo + i * ten[pos]) % k,
flag || ((mo + i * ten[pos]) % k == 0 && i));
return dp[pos][mo][flag] = ans % m;
}
long long get(int n) {
ten[1] = 1;
for (int i = 2; i <= n; i++) ten[i] = ten[i - 1] * 10 % k;
x[n] = 1;
return dfs(1, 0, 0);
}
int main(void) {
cin >> n >> k >> m;
memset(dp, -1, sizeof(dp));
cout << get(n) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m;
int bits[100];
map<long long, int> logTwo;
int main() {
for (int i = 0; i <= 60; i++) {
long long a = pow(2, i);
logTwo[a] = i;
}
cin >> t;
while (t--) {
memset(bits, 0, sizeof(bits));
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a;
cin >> a;
int loog = logTwo[a];
bits[loog]++;
}
bitset<60> foo(n);
int counter = 0;
for (int i = 0; i < foo.size(); i++) {
bool done = 1;
if (foo.test(i)) {
done = 0;
long long a = pow(2, i);
for (int j = i; j >= 0; j--) {
long long b = pow(2, j);
long long div = a / b;
a = a - min(div * b, bits[j] * b);
}
if (a == 0) {
a = pow(2, i);
for (int j = i; j >= 0; j--) {
long long b = pow(2, j);
long long div = a / b;
a = a - min(div * b, bits[j] * b);
bits[j] -= min(bits[j], (int)div);
}
foo[i] = 0;
done = 1;
continue;
}
a = pow(2, i);
int j;
for (j = i; j <= 60; j++) {
if (bits[j] == 0) {
bits[j]++;
counter++;
} else {
bits[j]--;
foo[i] = 0;
done = 1;
break;
}
}
}
if (!done) {
counter = -1;
cout << -1 << endl;
break;
}
}
if (counter != -1) cout << counter << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans[2000100][5], n, mod[5];
long long count(long long x, long long mod3) {
if (x == n) {
if (!mod3)
return 1;
else
return 0;
}
if (ans[x][mod3] == -1) {
long long val = 0;
long long tmp = 1e9 + 7;
for (int i = 0; i < 3; i++) {
if (mod[i]) val = (val + mod[i] * count(x + 1, (mod3 + i) % 3)) % tmp;
}
ans[x][mod3] = val;
}
return ans[x][mod3];
}
int main() {
memset(ans, -1, sizeof(ans));
long long l, r;
cin >> n >> l >> r;
for (int i = 0; i < 3; i++) {
mod[i] = (r - l + 1) / 3;
}
for (int i = 0; i < (r - l + 1) % 3; i++) {
long long tmp = l + i;
mod[tmp % 3]++;
}
long long tmp = 1e9 + 7;
long long ans = count(0, 0) % tmp;
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int lowBit(long long int n) {
for (long long int i = 0; i < 30; i++) {
long long int p = 1 << i;
if (n & p) return 1 << i;
}
}
int32_t main() {
long long int n, k;
cin >> n >> k;
long long int kk = k;
long long int y = k;
long long int half = n / 2;
long long int nn = n;
nn--;
long long int tmp = (nn * (nn + 1)) / 2;
if (n == 1) {
cout << 0 << endl;
return 0;
}
if (k == half)
cout << tmp << endl;
else if (k > half) {
long long int z = n - k;
if (z & 1)
cout << tmp << endl;
else
cout << tmp << endl;
} else if (k < half) {
long long int sm = 0;
for (long long int i = n; i > y; i--) {
if (k) {
sm += (i - 1);
k--;
} else {
sm += kk;
}
}
for (long long int j = y; j >= 2; j--) sm += (j - 1);
cout << sm << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int S = 1005, D = 55, K = 10;
const long long mod = 1000000007ll;
int fail[S * D], ch[S * D][K], trans[S * D][K], tot = 0;
bool vis[S * D];
int newnode() {
int x = ++tot;
fail[x] = 0, vis[x] = false;
for (int i = 0; i < K; i++) ch[x][i] = trans[x][i] = 0;
return x;
}
queue<int> q;
void get_trans() {
q.push(0);
for (int i = 0; i < K; i++) trans[0][i] = ch[0][i];
while (!q.empty()) {
int u = q.front();
for (int i = 0; i < K; i++) {
int v = ch[u][i];
if (!v) continue;
fail[v] = ~fail[u] ? trans[fail[u]][i] : 0;
for (int j = 0; j < K; j++) {
if (ch[v][j])
trans[v][j] = ch[v][j];
else if (~fail[v])
trans[v][j] = trans[fail[v]][j];
else
trans[v][j] = 0;
}
q.push(v);
}
q.pop();
}
}
long long f[D][S * D][2][2];
int len = 0, d = 0;
char str[S], l[S], r[S];
long long calc(char s[S]) {
for (int i = 0; i <= tot; i++) {
f[0][i][0][0] = f[0][i][0][1] = f[0][i][1][0] = f[0][i][1][1] = 0ll;
}
f[0][0][1][0] = 1ll;
for (int i = 0; i < d; i++) {
for (int j = 0; j <= tot; j++) {
f[i + 1][j][0][0] = f[i + 1][j][0][1] = 0ll;
f[i + 1][j][1][0] = f[i + 1][j][1][1] = 0ll;
}
int digit = s[i] - '0';
for (int j = 0; j <= tot; j++) {
for (int a = 0; a <= 1; a++) {
for (int b = 0; b <= 1; b++) {
for (int k = 0; k < K; k++) {
if (a && k > digit) continue;
long long &val =
f[i + 1][trans[j][k]][a & (k == digit)][b | vis[trans[j][k]]];
val = (val + f[i][j][a][b]) % mod;
}
}
}
}
}
long long res = 0ll;
for (int i = 0; i <= tot; i++)
res = (res + f[d][i][0][1] + f[d][i][1][1]) % mod;
return res;
}
int main() {
scanf("%s", str), len = strlen(str);
scanf("%s%s", l, r), d = strlen(l);
fail[0] = -1, vis[0] = false;
for (int i = 0; i < K; i++) trans[0][i] = ch[0][i] = 0;
for (int i = 0; i <= len - d / 2; i++) {
int now = 0;
for (int j = 0; j < d / 2; j++) {
if (!ch[now][str[i + j] - '0']) ch[now][str[i + j] - '0'] = newnode();
now = ch[now][str[i + j] - '0'];
}
vis[now] = true;
}
get_trans();
for (int i = d - 1; i >= 0; i--) {
l[i]--;
if (l[i] < '0')
l[i] += 10;
else
break;
}
printf("%lld\n", (calc(r) - calc(l) + mod) % mod);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> c(n + 1);
int x, curr_ptr = 1;
for (int i = 1; i <= n; i++) {
cin >> x;
c[x] = i;
}
for (int i = 0; i < n; i++) {
cin >> x;
if (curr_ptr == n + 1)
cout << 0 << " ";
else {
if (c[x] < curr_ptr)
cout << 0 << " ";
else {
cout << c[x] - curr_ptr + 1 << " ";
curr_ptr = c[x] + 1;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 110;
long long n, k, h, A, a[N], p[N], cnt, son[N][2], op[N], de[N];
long long win[N], t[N];
unordered_map<long long, long long> mp;
inline void add(long long &a, long long b) {
a = ((a + b >= 998244353) ? a + b - 998244353 : a + b);
}
inline void del(long long &a, long long b) {
a = ((a - b < 0) ? a - b + 998244353 : a - b);
}
inline void mul(long long &a, long long b) { a = a * b % 998244353; }
inline long long m_pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) mul(ans, a);
b >>= 1;
mul(a, a);
}
return ans;
}
inline void ckmin(long long &a, long long b) { a = ((a < b) ? a : b); }
inline void ckmax(long long &a, long long b) { a = ((a > b) ? a : b); }
inline long long read() {
long long f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
void build() {
long long pos = 1;
cnt = n;
for (long long i = 1; i < n; i++) {
cnt++;
son[cnt][0] = pos;
son[cnt][1] = pos + 1;
pos += 2;
}
}
void dfs(long long x) {
if (x <= n) return;
de[son[x][0]] = de[x] + 1;
de[son[x][1]] = de[x] + 1;
dfs(son[x][0]);
dfs(son[x][1]);
}
void dfs1(long long x) {
if (x <= n) {
win[x] = x;
return;
}
dfs1(son[x][0]);
dfs1(son[x][1]);
win[x] = win[son[x][op[x]]];
a[win[son[x][op[x] ^ 1]]] = (1 << de[x]);
}
signed main() {
k = read();
A = read();
h = read() * m_pow(A, 998244353 - 2) % 998244353;
if (k == 1) {
if ((1 + 2 * A) % 998244353 == h)
printf("1 2\n");
else if ((2 + A) % 998244353 == h)
printf("2 1\n");
else
printf("-1\n");
return 0;
}
long long w = 0;
p[w++] = 0;
for (long long i = 0; i <= k - 2; i++) {
for (long long j = 1; j <= (1 << i); j++) p[w++] = (1 << i);
}
long long full = (1 << w) - 1;
for (long long mask = 0; mask <= full; mask++) {
long long sum = 0;
for (long long i = 0; i < w; i++) {
if ((mask >> i) & 1)
add(sum, m_pow(A, (1 << (k - 1))));
else
add(sum, m_pow(A, p[i]));
}
mp[sum] = mask;
}
n = (1 << (k - 1));
build();
dfs(cnt);
full = (1 << (n - 1)) - 1;
for (long long mask = 0; mask <= full; mask++) {
for (long long i = 0; i < n - 1; i++) op[i + n + 1] = ((mask >> i) & 1);
dfs1(cnt);
a[win[cnt]] = 0;
long long sum = 0;
for (long long i = 1; i <= n; i++) {
long long now = m_pow(A, a[i]) + m_pow(A, (1 << (k - 1)));
now %= 998244353;
mul(now, 2 * i);
add(sum, now);
}
del(sum, h);
if (mp.count(sum)) {
long long s = mp[sum];
for (long long i = 0; i < w; i++)
if (!((s >> i) & 1)) t[p[i]]++;
for (long long i = 1; i <= n; i++) {
if (t[a[i]] > 0)
printf("%lld %lld ", a[i] + 1, (1ll << (k - 1)) + 1), t[a[i]]--;
else
printf("%lld %lld ", (1ll << (k - 1)) + 1, a[i] + 1);
}
printf("\n");
return 0;
}
}
printf("-1\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
const int MAXNUM = 100000;
int n;
int max_x[MAXNUM + 1];
int max_y;
int w[MAXN];
int res[MAXN][2];
int lookup(int t) {
int p = 0, q = max_y;
while (p < q) {
int y = (p + q) / 2;
if (y - max_x[y] < t)
p = y + 1;
else
q = y;
}
if (p > q) return -1;
if (p - max_x[p] != t) return -1;
if (p < max_y && max_x[p] == max_x[p + 1]) return -1;
return p;
}
int main() {
for (int i = 0; i <= MAXNUM; i++) max_x[i] = -1;
max_y = -1;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x > max_x[y]) max_x[y] = x;
if (y > max_y) max_y = y;
}
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = n - 1; i >= 0; i--) {
int y = lookup(w[i]);
if (y == -1) {
cout << "NO" << endl;
return 0;
}
res[i][0] = max_x[y]--;
res[i][1] = y;
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << res[i][0] << " " << res[i][1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
int a[N];
int main() {
int n, t, ans, best, i, l;
double minn, p;
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
ans = 1;
for (i = 1, l = 0; i < n; i++) {
if (a[i] != a[i - 1]) {
if (ans >= 2) a[l++] = a[i - 1];
if (ans >= 4) a[l++] = a[i - 1];
ans = 1;
} else
ans++;
}
if (ans >= 2) a[l++] = a[n - 1];
if (ans >= 4) a[l++] = a[n - 1];
minn = (a[0] + a[1]) * (a[0] + a[1]) / (double)(a[0] * a[1]);
best = 0;
for (i = 1; i < l - 1; i++) {
p = (a[i] + a[i + 1]) * (a[i] + a[i + 1]) / (double)(a[i] * a[i + 1]);
if (p < minn) {
minn = p;
best = i;
}
}
cout << a[best] << " " << a[best] << " " << a[best + 1] << " "
<< a[best + 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a;
cin >> n >> a;
int c1 = 0, c2 = 0, c3 = 0, c4 = 0, ans = -1;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (a[i] == 'b')
c1++;
else if (a[i] == 'r')
c2++;
} else if (i % 2 == 1) {
if (a[i] == 'r')
c3++;
else if (a[i] = 'b')
c4++;
}
}
int ans2;
ans = max(c3, c1);
ans2 = max(c4, c2);
ans = min(ans, ans2);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265359;
const long long int Maxi = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, i, j, l, k = 0, p = 0, s = 0, t = 1, x, y, z, r, c;
long long a[100005] = {0};
map<string, string> mp;
cin >> n >> m;
string s1, s2;
while (n--) {
cin >> s1 >> s2;
mp[s2] = s1;
}
while (m--) {
cin >> s1 >> s2;
char s3[100];
i = 0;
while (i < 100) s3[i] = '\0', i++;
for (i = 0; i < s2.size() - 1; i++) s3[i] = s2[i];
cout << s1 << " " << s2 << " #" << mp[s3] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 12;
const int MAXR = 1;
const int MAXC = 1;
const int MAXBITS = 64;
const int INF = (int)1e9;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
priority_queue<int, vector<int>, greater<int>> q1;
priority_queue<int, vector<int>, less<int>> q2;
void l() { ; }
int arr[MAXN];
string s;
bool c1() {
for (int i = 0; i < 12; ++i) {
if (s[i] == 'X') return true;
}
return false;
}
bool c2() {
for (int i = 0; i < 6; ++i) {
int idx = i;
bool ans = true;
for (int j = 0; j < 2; ++j) {
if (s[idx] != 'X') {
ans = false;
break;
}
idx += 6;
}
if (ans) {
return true;
}
}
return false;
}
bool c3() {
for (int i = 0; i < 4; ++i) {
int idx = i;
bool ans = true;
for (int j = 0; j < 3; ++j) {
if (s[idx] != 'X') {
ans = false;
break;
}
idx += 4;
}
if (ans) {
return true;
}
}
return false;
}
bool c4() {
for (int i = 0; i < 3; ++i) {
int idx = i;
bool ans = true;
for (int j = 0; j < 4; ++j) {
if (s[idx] != 'X') {
ans = false;
break;
}
idx += 3;
}
if (ans) {
return true;
}
}
return false;
}
bool c6() {
for (int i = 0; i < 2; ++i) {
int idx = i;
bool ans = true;
for (int j = 0; j < 6; ++j) {
if (s[idx] != 'X') {
ans = false;
break;
}
idx += 2;
}
if (ans) {
return true;
}
}
return false;
}
bool c12() {
for (int i = 0; i < 12; ++i) {
if (s[i] != 'X') return false;
}
return true;
}
void printAns() {
l();
;
bool isp1, isp2, isp3, isp4, isp6, isp12;
isp1 = isp2 = isp3 = isp4 = isp6 = isp12 = false;
int cnt = 0;
isp1 = c1();
isp2 = c2();
isp3 = c3();
isp4 = c4();
isp6 = c6();
isp12 = c12();
if (isp1) cnt++;
if (isp2) cnt++;
if (isp3) cnt++;
if (isp4) cnt++;
if (isp6) cnt++;
if (isp12) cnt++;
cout << cnt << " ";
if (isp1) {
cout << "1x12"
<< " ";
}
if (isp2) {
cout << "2x6"
<< " ";
}
if (isp3) {
cout << "3x4"
<< " ";
}
if (isp4) {
cout << "4x3"
<< " ";
}
if (isp6) {
cout << "6x2"
<< " ";
}
if (isp12) {
cout << "12x1"
<< " ";
}
cout << "\n";
l();
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> s;
printAns();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod2 = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
map<int, int> m;
for (long long i = 0; i < n; i++) ++m[a[i]];
vector<int> v;
for (auto it = m.begin(); it != m.end(); ++it) v.push_back(it->second);
sort(v.begin(), v.end(), greater<int>());
int count = v[0];
int i = 1;
int ans = count;
int x = count;
while (--count && i < v.size()) {
x = (v[i] > count) ? count : v[i];
count = x;
ans += x;
++i;
}
cout << ans << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long A[2], B[2], C[2];
int check(long long p, long long q) {
long long a, b, c;
a = (-C[0] * p - C[1] * q);
b = (-C[1] * p + C[0] * q);
c = (C[0] * C[0] + C[1] * C[1]);
return (a % c == 0 && b % c == 0);
}
int check2() {
if (A[0] == B[0] && A[1] == B[1]) return 1;
if ((-1 * A[1]) == B[0] && A[0] == B[1]) return 1;
if ((-1 * A[0]) == B[0] && (-1 * A[1]) == B[1]) return 1;
if (A[1] == B[0] && (-1 * A[0]) == B[1]) return 1;
return 0;
}
int main(void) {
int i, T, j, m, n;
for (i = 0; i < 2; i++) scanf("%I64d", &A[i]);
for (i = 0; i < 2; i++) scanf("%I64d", &B[i]);
for (i = 0; i < 2; i++) scanf("%I64d", &C[i]);
if (C[0] == 0 && C[1] == 0) {
if (check2())
printf("YES\n");
else
printf("NO\n");
} else if (check(B[0] - A[0], B[1] - A[1]) ||
check(B[0] - A[1], B[1] + A[0]) ||
check(B[0] + A[0], B[1] + A[1]) || check(B[0] + A[1], B[1] - A[0]))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, l, r;
long long S, sum, cnt, cur, ans;
struct point {
long long x, y;
} a[1000005 << 1], pre[1000005 << 1];
point operator-(const point a, const point b) {
return (point){a.x - b.x, a.y - b.y};
}
point operator+(const point a, const point b) {
return (point){a.x + b.x, a.y + b.y};
}
point operator*(const int a, const point b) {
return (point){(long long)a * b.x, (long long)a * b.y};
}
point operator*(const long long a, const point b) {
return (point){(long long)a * b.x, (long long)a * b.y};
}
inline long long add(long long x, long long y) {
return x + y < 1000000007 ? x + y : x + y - 1000000007;
}
inline long long cross(point a, point b) { return abs(a.x * b.y - a.y * b.x); }
inline int read() {
int ans = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
ans = (ans << 1) + (ans << 3) + (c ^ 48), c = getchar();
return ans * f;
}
int main() {
n = read();
for (int i = 0; i < n; ++i) a[i].x = read(), a[i].y = read();
for (int i = 2; i < n; ++i) S += cross(a[i - 1] - a[0], a[i] - a[0]);
pre[0] = a[0];
for (int i = 1; i < n; ++i) pre[i] = pre[i - 1] + a[i];
for (int i = n; i < n * 2; ++i) pre[i] = pre[i - 1] + (a[i] = a[i % n]);
r = 1;
while (l < n) {
r = max(r, l + 1);
while ((cross(a[r + 1] - a[l], a[r] - a[l]) + cur) <= S / 2)
cur += cross(a[r + 1] - a[l], a[r] - a[l]),
sum = add(sum, cur % 1000000007), cnt++, r++;
ans = add(ans, S % 1000000007 * cnt % 1000000007);
ans = add(ans, 1000000007 - sum * 2ll % 1000000007);
point tmp = pre[r] - pre[l] - (r - l) * a[l], tt = a[l + 1] - a[l];
tmp.x %= 1000000007, tmp.y %= 1000000007;
if (cnt)
sum = add(sum, 1000000007 - ((tmp.x * tt.y - tmp.y * tt.x) % 1000000007 +
1000000007) %
1000000007);
if (cnt) cur -= cross(a[r] - a[l], a[l + 1] - a[l]);
if (cnt) cnt--;
l++;
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
set<char> save;
string frase;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
getline(cin, frase);
for (int i = 0; i < frase.size(); ++i)
if (isalpha(frase[i])) save.insert(frase[i]);
cout << save.size() << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[333][333], f[2][333][333], l[666], r[666];
int main() {
int z = 0;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", a[i] + j);
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) f[0][j][k] = -1000111222;
f[0][0][0] = a[0][0];
for (int i = 0; i <= n * 2 - 2; i++) {
l[i] = i < n ? 0 : i - n + 1;
r[i] = i < n ? i : n - 1;
}
for (int i = 0; i <= n * 2 - 3; i++) {
z ^= 1;
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) f[z][j][k] = -1000111222;
for (int j = l[i]; j <= r[i]; j++)
for (int k = j; k <= r[i]; k++)
if (f[1 - z][j][k] > -1000111222)
for (int jj = j; jj <= j + 1; jj++)
if (jj >= l[i + 1] && jj <= r[i + 1])
for (int kk = k; kk <= k + 1; kk++)
if (kk >= l[i + 1] && kk <= r[i + 1]) {
int add = a[jj][i + 1 - jj] + a[kk][i + 1 - kk];
if (jj == kk) add /= 2;
f[z][jj][kk] = max(f[z][jj][kk], f[1 - z][j][k] + add);
}
}
cout << f[z][n - 1][n - 1] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool same_char();
bool can_swap();
string s1, s2;
int main() {
cin >> s1 >> s2;
bool possible = true;
if (s1 != s2) {
possible = same_char();
if (possible) {
possible = can_swap();
}
}
if (possible) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
bool same_char() {
if (s1.length() != s2.length()) {
return false;
}
int arr1[26]{0};
int arr2[26]{0};
for (int i = 0; i < s1.length(); i++) {
arr1[s1[i] - 97]++;
arr2[s1[i] - 97]++;
}
for (int i = 0; i < 26; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
bool can_swap() {
for (int i = 0; i < s1.length(); i++) {
if (s1[i] != s2[i]) {
for (int j = i + 1; j < s1.length(); j++) {
if (s2[j] == s1[i] && s1[j] == s2[i]) {
char temp = s2[j];
s2[j] = s2[i];
s2[i] = temp;
break;
}
}
break;
}
}
if (s1 == s2) {
return true;
}
return false;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct ddt {
int pos;
vector<int> attempts;
int sum;
ddt(int pos_) {
pos = pos_;
sum = 0;
}
};
int main() {
int n, A, B;
cin >> n >> A >> B;
vector<int> a(n);
for (auto& i : a) {
cin >> i;
++i;
}
int ans = 1e9;
vector<int> res;
queue<ddt> q;
q.push({1});
while (!q.empty()) {
ddt x = q.front();
q.pop();
if (x.pos == n - 1) {
if (ans > x.sum) {
ans = x.sum;
res = x.attempts;
}
continue;
}
int hits = a[x.pos - 1];
if (!x.attempts.empty()) {
hits -= x.attempts.back() * A;
}
if (x.attempts.size() > 1) {
hits -= x.attempts[x.attempts.size() - 2] * B;
}
int from = max(0, int((hits + B - 1) / B));
if (x.pos == n - 2) {
from = max(from, int((a.back() + B - 1) / B));
}
int to = from + max(0, (a[x.pos] - A * from + A - 1) / A);
for (int i = from; i <= to; ++i) {
ddt t = x;
++t.pos;
t.attempts.push_back(i);
t.sum += i;
q.push(t);
}
}
cout << ans << endl;
for (int i = 0; i < res.size(); ++i) {
for (int j = 0; j < res[i]; ++j) {
cout << 2 + i << " ";
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ans = 1e9, sum1, sum2, mx1, mx2;
char ch[10];
pair<int, int> a[20];
int dp[1 << 16][260], sum[1 << 16][2], b[20];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s%d%d", ch, &a[i].first, &a[i].second);
sum1 += a[i].first, sum2 += a[i].second;
b[i] = (ch[0] == 'B');
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if ((i >> j) & 1) {
if (b[j] == 0)
sum[i][0]++;
else
sum[i][1]++;
}
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < 240; j++) {
if (dp[i][j] == -1) continue;
for (int k = 0; k < n; k++) {
if ((i >> k) & 1) continue;
int tmp3 = (i | (1 << k));
int tmp1 = min(sum[i][0], a[k].first),
tmp2 = min(sum[i][1], a[k].second);
dp[tmp3][j + tmp1] = max(dp[tmp3][j + tmp1], dp[i][j] + tmp2);
}
}
}
int now = (1 << n) - 1;
for (int i = 0; i < 240; i++) {
if (dp[now][i] == -1) continue;
ans = min(ans, max(sum1 - i, sum2 - dp[now][i]) + n);
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int MOD = 1e9 + 7;
inline int in() {
int x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '0') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
int n, m;
int c[MAXN][102], a[MAXN];
int add[102][MAXN];
void init() {
c[0][0] = 1;
c[1][0] = c[1][1] = 1;
for (int i = 2; i <= 100000; i++) {
c[i][0] = 1;
for (int j = 1; j <= 100; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
}
void solve(int k) {
for (int i = 1; i <= n; i++)
(add[k][i] += (add[k][i - 1] + add[k + 1][i]) % MOD) %= MOD;
}
int main() {
n = in(), m = in();
for (int i = 1; i <= n; i++) a[i] = in();
init();
for (int i = 1; i <= m; i++) {
int l = in(), r = in(), x = in();
(add[x][l] += 1) %= MOD;
for (int j = x; j >= 0; j--)
(add[x - j][r + 1] += (MOD - c[r - l + 1 + j - 1][j])) %= MOD;
}
for (int i = 100; i >= 0; i--) {
solve(i);
}
for (int i = 1; i <= n; i++) (a[i] += add[0][i]) %= MOD;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
int vals[5];
int solve(int n) {
for (int i = 0; i < (int)(5); i++) {
if (n + i < 5 && vals[n + i]) {
vals[n + i]--;
return n + i;
}
if (n - i >= 0 && vals[n - i]) {
vals[n - i]--;
return n - i;
}
}
return -1;
}
int main() {
string arr[] = {"S", "M", "L", "XL", "XXL"};
for (int i = 0; i < (int)(5); i++) cin >> vals[i];
int n;
cin >> n;
string s;
for (int i = 0; i < (int)(n); i++) {
cin >> s;
int curr = -1;
for (int k = 0; k < (int)(5); k++)
if (s == arr[k]) {
curr = k;
break;
}
cout << arr[solve(curr)] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vv = vector<vector<T>>;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
vector<string> s_p_l_i_t(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void e_r_r(vector<string>::iterator it) {}
template <typename T, typename... Args>
void e_r_r(vector<string>::iterator it, T a, Args... args) {
if (*it == " 1" || *it == "1")
cerr << endl;
else
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
e_r_r(++it, args...);
}
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
string s;
cin >> s;
int n = s.size();
vector<int> last(200);
for (int(i) = 0; (i) < (n); ++(i)) last[s[i]] = i;
stack<char> st;
string re;
int ind = 0;
for (int(c) = 'a'; (c) < ('z' + 1); ++(c)) {
while (st.size() && st.top() <= c) re += st.top(), st.pop();
for (int(i) = ind; (i) < (last[c] + 1); ++(i)) {
if (s[i] == c) {
re += c;
} else {
st.push(s[i]);
}
}
MX(ind, last[c] + 1);
}
while (st.size()) re += st.top(), st.pop();
cout << re << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100006;
const int MOD = 1000000007;
char S[N], W[N];
int n, cnt;
long long calMax() {
long long res = 1;
for (int i = 0; i < n; i++) {
if (S[i] != '?' && W[i] != '?') {
if (S[i] >= W[i])
res *= 1;
else
return 0;
continue;
}
if (S[i] != '?')
res = (res * (S[i] - '0' + 1)) % MOD;
else if (W[i] != '?')
res = (res * ('9' - W[i] + 1)) % MOD;
else
res = (res * 55) % MOD;
}
return res;
}
long long calMin() {
long long res = 1;
for (int i = 0; i < n; i++) {
if (S[i] != '?' && W[i] != '?') {
if (S[i] <= W[i])
res *= 1;
else
return 0;
continue;
}
if (S[i] != '?')
res = res * ('9' - S[i] + 1) % MOD;
else if (W[i] != '?')
res = res * (W[i] - '0' + 1) % MOD;
else
res = res * 55 % MOD;
}
return res;
}
long long calEqu() {
long long res = 1;
for (int i = 0; i < n; i++) {
if (S[i] != '?' || W[i] != '?') {
if (S[i] != '?' && W[i] != '?' && S[i] != W[i]) return 0;
continue;
}
res = res * 10 % MOD;
}
return res;
}
int main() {
scanf("%d", &n);
scanf("%s%s", S, W);
cnt = 0;
for (int i = 0; i < n; i++) {
if (S[i] == '?') cnt++;
if (W[i] == '?') cnt++;
}
long long ans = 1;
for (int i = 0; i < cnt; i++) ans = (ans * 10) % MOD;
long long res1 = calMax(), res2 = calMin(), res3 = calEqu();
printf("%I64d\n", (ans - res1 - res2 + res3 + MOD + MOD) % MOD);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, l1, l2, result, element;
cin >> t;
for (int i = 0; i < t; i++) {
int a[1000], b[1000];
result = 0;
cin >> l1 >> l2;
for (int j = 0; j < l1; j++) {
cin >> a[j];
}
for (int k = 0; k < l2; k++) {
cin >> b[k];
}
for (int x = 0; x < l2; x++) {
for (int m = 0; m < l1; m++) {
if (a[m] == b[x]) {
result = 1;
element = a[m];
break;
}
}
if (result == 1) {
break;
}
}
if (result == 1) {
cout << "YES" << endl;
cout << "1"
<< " " << element << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d;
int m, p, q;
while (scanf("%d%d%d%d%d", &n, &a, &b, &c, &d) != EOF) {
long long cnt = 0;
for (int i = 1; i <= n; i++) {
m = i + b - c;
p = i + a - d;
q = m + a - d;
if (m >= 1 && m <= n && p >= 1 && p <= n && q >= 1 && q <= n) cnt++;
}
printf("%I64d\n", cnt * n);
}
return 0;
}
| 3 |
///...................SUBHASHIS MOLLICK...................///
///.....DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING....///
///.............ISLAMIC UNIVERSITY,BANGLADESH.............///
///....................SESSION-(14-15)....................///
#include<bits/stdc++.h>
using namespace std;
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#define sf(a) scanf("%d",&a)
#define sf2(a,b) scanf("%d %d",&a,&b)
#define sf3(a,b,c) scanf("%d %d %d",&a,&b,&c)
#define pf(a) printf("%d",a)
#define pf2(a,b) printf("%d %d",a,b)
#define pf3(a,b,c) printf("%d %d %d",a,b,c)
#define sfl(a) scanf("%lld",&a)
#define sfl2(a,b) scanf("%lld %lld",&a,&b)
#define sfl3(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define pfl(a) printf("%lld",a)
#define pfl2(a,b) printf("%lld %lld",a,b)
#define pfl3(a,b,c) printf("%lld %lld %lld",a,b,c)
#define nl printf("\n")
#define timesave ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define ll long long
#define pb push_back
#define MPI map<int,int>mp;
#define fr(i,n) for(i=0;i<n;i++)
#define fr1(i,n) for(i=1;i<=n;i++)
#define frl(i,a,b) for(i=a;i<=b;i++)
#define tz 100000
#define clr0(a) memset(a,0,sizeof(a))
#define clr1(a) memset(a,-1,sizeof(a))
#define space " "
#define yesp cout<<"YES"<<endl;
#define nop cout<<"NO"<<endl;
/*primes in range 1 - n
1 - 100(1e2) -> 25 pimes
1 - 1000(1e3) -> 168 primes
1 - 10000(1e4) -> 1229 primes
1 - 100000(1e5) -> 9592 primes
1 - 1000000(1e6) -> 78498 primes
1 - 10000000(1e7) -> 664579 primes
large primes ->
104729 1299709 15485863 179424673 2147483647 32416190071 112272535095293 48112959837082048697
*/
//freopen("Input.txt","r",stdin);
//freopen("Output.txt","w",stdout);
//const int fx[]={+1,-1,+0,+0};
//const int fy[]={+0,+0,+1,-1};
//const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
//const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
//const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
//const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
int main()
{
timesave;
//freopen("Input.txt","r",stdin);
//freopen("Output.txt","w",stdout);
int ts=1;
cin>>ts;
while(ts--)
{
ll n,k;
string s;
cin>>n>>k>>s;
int flag=0;
for(int i=0,j=n-1; i<k; i++,j--)
{
if(s[i]!=s[j])
flag=1;
if(i+1==j)
flag=1;
}
if(flag)
cout<<"NO"<<endl;
else
cout<<"YES"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[26];
vector<long long> occ[26];
map<long long, long long> m;
long long pref[100003];
int main() {
string s;
long long i;
for (i = 0; i < 26; i++) cin >> a[i];
cin >> s;
for (i = 0; i < s.size(); i++) occ[s[i] - 'a'].push_back(i);
for (i = 0; i < s.size(); i++)
if (i == 0)
pref[i] = a[s[i] - 'a'];
else
pref[i] = pref[i - 1] + a[s[i] - 'a'];
long long ans = 0;
for (i = 0; i < 26; i++) {
m.clear();
if (!occ[i].empty()) m[pref[occ[i][0]]]++;
for (long long j = 1; j < occ[i].size(); j++) {
long long in = occ[i][j];
ans += m[pref[in - 1]];
m[pref[in]]++;
if (in == occ[i][j - 1] + 1) ans--;
}
}
for (i = 1; i < s.size(); i++)
if (s[i] == s[i - 1]) ans++;
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x, p;
vector<int> v;
int main() {
cin >> n;
v.clear();
v.resize(n);
if (n == 1) {
cin >> x;
if (x == 1) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
return 0;
}
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i] == 1) {
ans++;
if (p == 1) {
ans++;
p = 0;
}
if (i < n - 1) {
if (v[i + 1] == 0) p = 1;
}
} else {
if (i < n - 1) {
if (v[i + 1] == 0) {
p = 0;
}
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD2 = 998244353;
void solve() {
long long n, s;
cin >> n >> s;
if (s < 2 * n)
cout << "NO";
else {
cout << "YES"
<< "\n";
for (long long i = 0; i < n - 1; i++) {
cout << 1 << " ";
}
cout << s - (n - 1) << "\n";
cout << n;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
{
solve();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
double PI = 4 * atan(1);
vector<int> nodes[200000];
vector<int> par[200000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, t, k;
cin >> n >> t >> k;
int cur = 1, curk = n - t;
nodes[0].push_back(cur++);
for (int i = 1; i < t + 1; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
nodes[i].push_back(cur++);
par[i].push_back(nodes[i - 1][0]);
}
}
if (curk < k) {
cout << -1;
return 0;
}
for (int i = 1; i < t + 1; i++) {
bool flag = 0;
for (int j = 1; j < min(nodes[i].size(), nodes[i - 1].size()); j++) {
if (curk == k) {
flag = 1;
break;
}
par[i][j] = nodes[i - 1][j];
curk--;
}
if (flag == 1) break;
}
if (curk != k) {
cout << -1;
return 0;
}
cout << n << "\n";
for (int i = 1; i < t + 1; i++) {
for (int j = 0; j < nodes[i].size(); j++)
cout << nodes[i][j] << " " << par[i][j] << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, bool> vis;
map<int, vector<int>> AdjList;
vector<int> Route;
int n, e, u, v;
void CreatingAdjListGraph() {
cin >> e;
for (int i = 0; i < e; ++i) {
cin >> u >> v;
AdjList[u].push_back(v);
AdjList[v].push_back(u);
}
}
void DFSRec(int root) {
Route.push_back(root);
vis[root] = 1;
for (auto v : AdjList[root]) {
if (!vis[v]) DFSRec(v);
}
}
void FindingOneDegreenNode() {
for (auto i : AdjList) {
if (i.second.size() == 1) DFSRec(i.first);
}
}
void Output() {
for (int i = 1; i < Route.size(); ++i) {
cout << Route[i - 1] << " ";
}
cout << endl;
}
int main() {
CreatingAdjListGraph();
FindingOneDegreenNode();
Output();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[11][100005];
int comps[400005], lt[11][400005], rt[11][400005];
pair<int, int> par[3][1000001];
pair<int, int> par_find(pair<int, int> xp) {
return par[xp.second][xp.first] == xp
? xp
: par[xp.second][xp.first] = par_find(par[xp.second][xp.first]);
}
void build(int idx, int lo, int hi) {
if (lo == hi) {
for (int i = 1; i <= n; ++i) {
if (a[i][lo] != a[i - 1][lo])
lt[i][idx] = rt[i][idx] = ++comps[idx];
else
lt[i][idx] = rt[i][idx] = comps[idx];
}
return;
}
int mid = (lo + hi) / 2;
build(2 * idx, lo, mid);
build(2 * idx + 1, mid + 1, hi);
comps[idx] = comps[2 * idx] + comps[2 * idx + 1];
set<pair<int, int> > merged;
for (int i = 1; i <= n; ++i) {
int c1 = rt[i][2 * idx], c2 = lt[i][2 * idx + 1];
if (a[i][mid] != a[i][mid + 1]) continue;
if (merged.find(make_pair(c1, 1LL)) != merged.end()) {
if (merged.find(make_pair(c2, 2LL)) != merged.end()) {
pair<int, int> p1 = par_find(make_pair(c1, 1LL));
pair<int, int> p2 = par_find(make_pair(c2, 2LL));
par[p2.second][p2.first] = p1;
} else {
merged.insert(make_pair(c2, 2LL));
par[2][c2] = par_find(make_pair(c1, 1LL));
}
} else {
merged.insert(make_pair(c1, 1LL));
par[1][c1] = make_pair(c1, 1LL);
if (merged.find(make_pair(c2, 2LL)) != merged.end()) {
pair<int, int> p1 = par_find(make_pair(c1, 1LL));
pair<int, int> p2 = par_find(make_pair(c2, 2LL));
par[p2.second][p2.first] = p1;
} else {
merged.insert(make_pair(c2, 2LL));
par[2][c2] = par_find(make_pair(c1, 1LL));
}
}
}
comps[idx] -= merged.size();
vector<pair<int, int> > skipped;
for (pair<int, int> xp : merged) {
if (par[xp.second][xp.first] == xp)
comps[idx]++;
else
skipped.push_back(make_pair(xp.second, xp.first));
}
sort(skipped.begin(), skipped.end());
for (int i = 1; i <= n; ++i) {
int val = lt[i][2 * idx];
pair<int, int> pf = make_pair(val, 1LL);
if (merged.find(pf) != merged.end()) pf = par_find(make_pair(val, 1LL));
int ps = lower_bound(skipped.begin(), skipped.end(),
make_pair(pf.second, pf.first)) -
skipped.begin();
if (skipped.empty()) ps = 0;
if (pf.second == 1)
lt[i][idx] = pf.first - ps;
else
lt[i][idx] = pf.first - ps + comps[2 * idx];
val = rt[i][2 * idx + 1];
pf = make_pair(val, 2LL);
if (merged.find(pf) != merged.end()) pf = par_find(make_pair(val, 2LL));
ps = lower_bound(skipped.begin(), skipped.end(),
make_pair(pf.second, pf.first)) -
skipped.begin();
if (skipped.empty()) ps = 0;
if (pf.second == 1)
rt[i][idx] = pf.first - ps;
else
rt[i][idx] = pf.first - ps + comps[2 * idx];
}
}
struct node {
int ff;
int lt[11], rt[11];
node(int v1) { ff = v1; }
};
node query(int idx, int lo, int hi, int st, int en) {
if (lo == st && hi == en) {
node ret = node(comps[idx]);
for (int i = 1; i <= n; ++i) ret.lt[i] = lt[i][idx], ret.rt[i] = rt[i][idx];
return ret;
}
int mid = (lo + hi) / 2;
if (en <= mid)
return query(2 * idx, lo, mid, st, en);
else if (st > mid)
return query(2 * idx + 1, mid + 1, hi, st, en);
node q1 = query(2 * idx, lo, mid, st, mid);
node q2 = query(2 * idx + 1, mid + 1, hi, mid + 1, en);
node ret = node(q1.ff + q2.ff);
set<pair<int, int> > merged;
for (int i = 1; i <= n; ++i) {
int c1 = q1.rt[i], c2 = q2.lt[i];
if (a[i][mid] != a[i][mid + 1]) continue;
if (merged.find(make_pair(c1, 1LL)) != merged.end()) {
if (merged.find(make_pair(c2, 2LL)) != merged.end()) {
pair<int, int> p1 = par_find(make_pair(c1, 1LL));
pair<int, int> p2 = par_find(make_pair(c2, 2LL));
par[p2.second][p2.first] = p1;
} else {
merged.insert(make_pair(c2, 2LL));
par[2][c2] = par_find(make_pair(c1, 1LL));
}
} else {
merged.insert(make_pair(c1, 1LL));
par[1][c1] = make_pair(c1, 1LL);
if (merged.find(make_pair(c2, 2LL)) != merged.end()) {
pair<int, int> p1 = par_find(make_pair(c1, 1LL));
pair<int, int> p2 = par_find(make_pair(c2, 2LL));
par[p2.second][p2.first] = p1;
} else {
merged.insert(make_pair(c2, 2LL));
par[2][c2] = par_find(make_pair(c1, 1LL));
}
}
}
ret.ff -= merged.size();
vector<pair<int, int> > skipped;
for (pair<int, int> xp : merged) {
if (par[xp.second][xp.first] == xp)
ret.ff++;
else
skipped.push_back(make_pair(xp.second, xp.first));
}
sort(skipped.begin(), skipped.end());
for (int i = 1; i <= n; ++i) {
int val = q1.lt[i];
pair<int, int> pf = make_pair(val, 1LL);
if (merged.find(pf) != merged.end()) pf = par_find(make_pair(val, 1LL));
int ps = lower_bound(skipped.begin(), skipped.end(),
make_pair(pf.second, pf.first)) -
skipped.begin();
if (skipped.empty()) ps = 0;
if (pf.second == 1)
ret.lt[i] = pf.first - ps;
else
ret.lt[i] = pf.first - ps + q1.ff;
val = q2.rt[i];
pf = make_pair(val, 2LL);
if (merged.find(pf) != merged.end()) pf = par_find(make_pair(val, 2LL));
ps = lower_bound(skipped.begin(), skipped.end(),
make_pair(pf.second, pf.first)) -
skipped.begin();
if (skipped.empty()) ps = 0;
if (pf.second == 1)
ret.rt[i] = pf.first - ps;
else
ret.rt[i] = pf.first - ps + q1.ff;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
build(1, 1, m);
while (q--) {
int l, r;
cin >> l >> r;
cout << query(1, 1, m, l, r).ff << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long a[110];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
long long su = 0;
long long ma = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
su += a[i];
if (a[i] > ma) ma = a[i];
}
if (ma == su - ma) {
printf("HL\n");
} else if (ma > su - ma) {
printf("T\n");
} else {
if (su & 1)
printf("T\n");
else
printf("HL\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int a[maxn], b[maxn], t[maxn];
int m, n, c;
int main() {
while (scanf("%d %d %d", &n, &m, &c) != EOF) {
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
t[0] = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
t[i] = t[i - 1] + b[i];
}
for (int i = 1; i <= m; ++i) {
int L = max(1, i - (n - m));
a[i] = (a[i] + t[i] - t[L - 1]) % c;
}
for (int i = m + 1; i <= n; ++i) {
int L = max(1, m - n + i);
a[i] = (a[i] + t[m] - t[L - 1]) % c;
}
for (int i = 1; i < n; ++i) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int x = 0, w = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') w = -1, c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
return x * w;
}
const int N = 400005;
int n, m, cc, c[N], hd[N], f[N], a[N], fa[N], s[N], sz[N], ch[N][2], tp[N];
long long sq[N], ans[N];
vector<pair<int, int> > g[N];
struct E {
int v, nxt;
} e[N * 2];
inline void add(int u, int v) {
e[++cc] = (E){v, hd[u]};
hd[u] = cc;
e[++cc] = (E){u, hd[v]};
hd[v] = cc;
}
void dfs(int x, int p) {
f[x] = p;
for (int i = hd[x], y; i; i = e[i].nxt)
if ((y = e[i].v) != p) dfs(y, x);
}
inline long long sqr(int x) { return 1ll * x * x; }
inline int S(int x) { return s[x] + sz[x]; }
inline int wh(int x) { return ch[fa[x]][1] == x; }
inline int isrt(int x) { return ch[fa[x]][0] != x && ch[fa[x]][1] != x; }
inline void up(int x) {
s[x] = S(ch[x][0]) + S(ch[x][1]) + 1;
tp[x] = ch[x][0] ? tp[ch[x][0]] : x;
}
inline void rot(int x) {
int y = fa[x], z = fa[y], w = wh(x), t = ch[x][w ^ 1];
if (!isrt(y)) ch[z][wh(y)] = x;
fa[x] = z;
if (t) fa[t] = y;
ch[y][w] = t;
fa[y] = x;
ch[x][w ^ 1] = y;
up(y);
up(x);
}
inline void splay(int x) {
for (int y; !isrt(x); rot(x))
if (!isrt(y = fa[x])) rot(wh(x) ^ wh(y) ? x : y);
}
inline void access(int x) {
for (int y = 0; x; x = fa[y = x])
splay(x), sz[x] += S(ch[x][1]) - S(y),
sq[x] += sqr(S(ch[x][1])) - sqr(S(y)), ch[x][1] = y, up(x);
}
inline long long qry(int x) {
splay(x);
return sq[x] + sqr(S(ch[x][1]));
}
inline void mkrt(int x) {
access(x);
splay(x);
}
inline long long link(int x) {
a[x] = 0;
int y = f[x];
mkrt(x);
mkrt(y);
int t = tp[y];
long long res = -qry(x) - qry(t);
splay(y);
fa[x] = y;
sz[y] += S(x);
sq[y] += sqr(S(x));
res += qry(t);
return res;
}
inline long long cut(int x) {
a[x] = 1;
int y = f[x];
access(x);
splay(y);
int t = tp[y];
long long res = -qry(t);
splay(y);
fa[x] = 0;
ch[y][1] = 0;
up(y);
res += qry(x) + qry(t);
return res;
}
int main() {
n = rd();
m = rd();
a[n + 1] = 1;
for (int i = (1); i <= (n); ++i)
c[i] = rd(), g[c[i]].push_back(make_pair(i, 0));
for (int i = (1); i <= (n - 1); ++i) add(rd(), rd());
dfs(1, n + 1);
for (int i = (1); i <= (m); ++i) {
int x = rd(), v = rd();
g[c[x]].push_back(make_pair(x, i));
g[c[x] = v].push_back(make_pair(x, i));
}
for (int i = (1); i <= (n); ++i) up(i);
for (int i = (1); i <= (n); ++i) link(i);
for (int i = (1); i <= (n); ++i) {
ans[0] += 1ll * n * n;
for (int j = 0; j < g[i].size(); ++j) {
int x = g[i][j].first;
ans[g[i][j].second] += a[x] ? link(x) : cut(x);
}
for (int j = 0; j < g[i].size(); ++j)
if (a[g[i][j].first]) link(g[i][j].first);
}
for (int i = (1); i <= (m); ++i) ans[i] += ans[i - 1];
for (int i = (0); i <= (m); ++i) printf("%lld\n", 1ll * n * n * n - ans[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int INF = 1e9;
const double EPS = 1e-8;
struct node {
int num, id, add;
bool operator<(const node &a) const {
return num > a.num || (num == a.num && id < a.id);
}
} a[105];
int pre[105];
int n;
int ok(int i, int j) {
node x = a[i], y = a[j], xx = x, yy = y;
xx.num = x.num + x.add, yy.num = y.num + y.add;
if (x < y && yy < xx) return 1;
if (y < x && xx < yy) return 1;
if (x < y && y < xx && xx < yy) return 2;
if (y < x && x < yy && yy < xx) return 2;
if (x < y && yy < x && xx < yy) return 2;
if (y < x && xx < y && yy < xx) return 2;
return 0;
}
int main() {
int ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].num >> a[i].add;
a[i].id = i;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans += ok(i, j);
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimization("O3")
using namespace std;
int main() {
;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int N;
cin >> N;
long long int arr[N];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
if (N == 1 || N == 2) {
cout << N << "\n";
return 0;
}
long long int ans = 2, cnt = 0;
for (int i = 2; i < N; i++) {
if (arr[i - 1] + arr[i - 2] == arr[i]) {
cnt++;
} else if (cnt > 0) {
ans = max(ans, cnt + 2);
cnt = 0;
}
}
if (cnt > 0) ans = max(ans, cnt + 2);
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, q;
int ar[N + 2], ls[N + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
vector<int> v;
cin >> q;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int p, x;
cin >> p >> x;
ar[p] = x;
ls[p] = v.size();
} else {
int x;
cin >> x;
v.push_back(x);
}
}
for (int i = v.size() - 2; i >= 0; i--) {
v[i] = max(v[i + 1], v[i]);
}
v.push_back(0);
for (int i = 1; i <= n; i++) {
cout << max(ar[i], v[ls[i]]) << ' ';
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
scanf("%d %d %d %d %d %d", &e, &f, &a, &b, &c, &d);
if (a > c) swap(a, c);
if (b > d) swap(b, d);
if ((d - b) >= 5 || (c - a) >= 5)
printf("Second\n");
else {
if ((d - b) == 4 && (c - a) == 4)
printf("Second\n");
else if (max(d - b, c - a) == 4 && min(d - b, c - a) == 3)
printf("Second\n");
else
printf("First\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long mxi = 100005;
vector<long long> dp[mxi];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
;
long long n;
cin >> n;
long long ar[n];
long long cnt[33];
for (int i = 1; i <= n; i++) {
cin >> ar[i];
long long j = 1;
while (ar[i] > 0) {
dp[j].push_back(ar[i] % 10);
j++;
ar[i] /= 10;
}
cnt[j - 1]++;
}
long long pre[mxi];
pre[0] = 1;
for (int i = 1; i <= 100; i++) {
pre[i] = pre[i - 1] * 10;
pre[i] %= mod;
}
long long ans = 0;
for (int i = 1; i <= 32; i++) {
long long k = dp[i].size();
for (auto itr : dp[i]) {
ans += itr % mod * k % mod * pre[2 * (i - 1)] % mod;
ans %= mod;
ans += itr % mod * k % mod * pre[2 * (i - 1) + 1] % mod;
ans %= mod;
}
for (int j = i - 1; j >= 1; j--) {
for (auto itr : dp[i]) {
ans += (2 * itr) % mod * cnt[j] % mod * pre[i + j - 1] % mod;
ans %= mod;
}
}
}
cout << (ans % mod + mod) % mod << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string keyb = "qwertyuiopasdfghjkl;zxcvbnm,./";
map<char, int> m;
int main() {
for (int i = 0; i < keyb.size(); i++) {
m[keyb[i]] = i;
}
char ori;
string in;
cin >> ori;
cin >> in;
if (ori == 'R') {
for (int i = 0; i < in.size(); i++) {
cout << keyb[m[in[i]] - 1];
}
cout << "\n";
} else {
for (int i = 0; i < in.size(); i++) {
cout << keyb[m[in[i]] + 1];
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int m[112345], p[112345];
int main() {
int n;
cin >> n;
int mn = 105, ans = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
mn = min(mn, y);
ans += mn * x;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int g[2048];
int num[2048];
void un(int a, int b);
int Find(int x);
int main() {
int n, like, dislike, a, b, grp;
while (cin >> n) {
grp = 0;
for (int i = 1; i <= n; i++) {
g[i] = i;
num[i] = 1;
}
cin >> like;
for (int i = 0; i < like; i++) {
cin >> a >> b;
un(a, b);
}
cin >> dislike;
for (int i = 0; i < dislike; i++) {
cin >> a >> b;
a = Find(a);
b = Find(b);
if (a == b) num[a] = 0;
}
for (int i = 1; i <= n; i++) {
grp = max(grp, num[i]);
}
cout << grp << endl;
}
return 0;
}
void un(int a, int b) {
a = Find(a);
b = Find(b);
if (a != b) {
if (num[a] > num[b]) {
g[b] = a;
num[a] += num[b];
num[b] = 0;
} else {
g[a] = b;
num[b] += num[a];
num[a] = 0;
}
}
}
int Find(int x) { return x == g[x] ? x : g[x] = Find(g[x]); }
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> v[105];
int a[105][105];
int n, m;
long long f(int low, int high, int k) {
long long ans = 0;
for (int i = 0; i < n; i++) {
int idx = a[i][k];
if (v[i][idx].first >= low && v[i][idx].second <= high) ans++;
}
return ans * ans;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
while (k--) {
int l, r;
cin >> l >> r;
l--;
r--;
v[i].push_back({l, r});
for (int j = l; j <= r; j++) a[i][j] = v[i].size() - 1;
}
}
vector<vector<long long>> dp(m, vector<long long>(m, 0));
for (int i = 0; i < m; i++) {
dp[i][i] = f(i, i, i);
}
for (int len = 2; len <= m; len++) {
for (int i = 0; i < m - len + 1; i++) {
int j = i + len - 1;
dp[i][j] = 0;
for (int k = i; k <= j; k++) {
long long tmp = f(i, j, k);
if (i < k) tmp += dp[i][k - 1];
if (k < j) tmp += dp[k + 1][j];
dp[i][j] = max(dp[i][j], tmp);
}
}
}
cout << dp[0][m - 1] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline int readInt() {
int x;
scanf("%d", &x);
return x;
}
map<string, int> msi;
map<string, string> mss;
set<string> ss;
int main() {
int n, q;
scanf("%d", &n);
for (int i = 0; i < (int)n; ++i) {
char _str[9];
scanf("%s", _str);
auto str = string(_str);
ss.clear();
for (int i = 0; i < (int)str.length(); ++i)
for (int j = 1; j < (int)str.length() - i + 1; ++j)
ss.insert(str.substr(i, j));
for (auto s : ss) {
msi[s]++;
mss[s] = str;
}
}
scanf("%d", &n);
for (int i = 0; i < (int)n; ++i) {
char _str[9];
scanf("%s", _str);
auto str = string(_str);
if (msi[str] == 0)
printf("0 -\n");
else
printf("%d %s\n", msi[str], mss[str].c_str());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long powmod(long long base, long long exp, long long MOD) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % MOD;
base = (base * base) % MOD;
exp /= 2;
}
return (res % MOD);
}
const long long N = 200001;
vector<long long> a(N), b(N), p(N);
long long i, j, ans;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = 0;
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
p[b[i]] = i;
}
if (p[1]) {
for (i = 2; p[i] == p[1] + i - 1; i++)
;
if (p[i - 1] == n) {
for (j = i; j <= n && p[j] <= j - i; j++)
;
if (j > n) {
cout << n - i + 1;
exit(0);
}
}
}
for (long long i = 1; i <= n; i++) ans = max(ans, p[i] - i + 1 + n);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 150000 + 10;
struct TREE {
int l, r;
double maxsub;
double maxprefix, maxsuffix;
double sum;
} tree[4 * M];
int a[M];
int p[M];
double E[M];
void build(int isize, int l, int r, int node) {
tree[node].l = l;
tree[node].r = r;
if (l == r) {
tree[node].maxprefix = E[l];
tree[node].maxsuffix = E[l];
tree[node].maxsub = E[l];
tree[node].sum = E[l];
return;
} else {
int mid = (l + r) / 2;
build(isize, l, mid, 2 * node);
build(isize, mid + 1, r, 2 * node + 1);
tree[node].sum = tree[2 * node].sum + tree[2 * node + 1].sum;
tree[node].maxprefix =
max(tree[2 * node].maxprefix,
tree[2 * node].sum + tree[2 * node + 1].maxprefix);
tree[node].maxsuffix =
max(tree[2 * node + 1].maxsuffix,
tree[2 * node + 1].sum + tree[2 * node].maxsuffix);
tree[node].maxsub = max(tree[2 * node].maxsub, tree[2 * node + 1].maxsub);
tree[node].maxsub =
max(tree[node].maxsub,
tree[2 * node].maxsuffix + tree[2 * node + 1].maxprefix);
return;
}
}
TREE query(int node, int l, int r) {
if (tree[node].l == l && tree[node].r == r) {
return tree[node];
} else {
int mid = (tree[node].l + tree[node].r) / 2;
if (r <= mid) {
return query(2 * node, l, r);
} else {
if (l >= mid + 1) {
return query(2 * node + 1, l, r);
} else {
TREE tree1 = query(2 * node, l, mid);
TREE tree2 = query(2 * node + 1, mid + 1, r);
TREE tree3;
tree3.maxprefix = max(tree1.maxprefix, tree1.sum + tree2.maxprefix);
tree3.maxsuffix = max(tree2.maxsuffix, tree2.sum + tree1.maxsuffix);
tree3.maxsub = max(tree1.maxsub, tree2.maxsub);
tree3.maxsub = max(tree3.maxsub, tree1.maxsuffix + tree2.maxprefix);
tree3.sum = tree1.sum + tree2.sum;
return tree3;
}
}
}
}
int main() {
time_t t_start, t_end;
t_start = clock();
int n, m, c;
cin >> n >> m >> c;
int isize = 1;
while (isize * 2 <= n) {
isize *= 2;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n - 1; i++) {
cin >> p[i];
}
for (int i = 1; i <= n - 1; i++) {
E[i] = (a[i + 1] - a[i]) / 2.0 - 1.0 * p[i] / 100 * c;
}
build(isize, 1, n - 1, 1);
double ans = 0;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
TREE tree1 = query(1, l, r - 1);
if (tree1.maxsub > 0) {
ans += tree1.maxsub;
}
}
printf("%.10f\n", ans);
t_end = clock();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans = 0;
int main() {
cin >> n >> k;
long long i = 1;
while (n >= 2 && i <= k) {
ans = ans + (n - 1) * 2 - 1;
n = n - 2;
i++;
}
cout << ans;
return 0;
}
| 2 |
//Bismillahir Rahmanir Raheem
#include<bits/stdc++.h>
#define ll long long int
#define pb push_back
#define eb emplace_back
#define vl vector<ll>
#define pa pair<ll,ll>
#define mod 1000000007
#define maxN 1000000
#define dekhao(tc,ans) cout<<"Case "<<tc<<": "<<ans<<"\n"
const double pi=acos(-1.0);
using namespace std;
void solve()
{
ll n;
cin>>n;
vector<ll>a,b;
for(ll i=0;i<(2*n);i++)
{
ll x;
cin>>x;
a.pb(x);
b.pb(i+1);
}
if(a==b)
{
cout<<0<<endl;
return;
}
ll ans=-1,c1=0;
for(ll i=0;i<=(2*n);i++)
{
if(a==b)
{
ans=i;
break;
}
if(i%2==0)
{
for(ll j=0;j<2*n;j+=2)
{
swap(b[j],b[j+1]);
}
}
else
{
for(ll k=0;k<n;k++)
{
swap(b[k],b[k+n]);
}
}
}
sort(b.begin(),b.end());
for(ll i=0;i<=(2*n);i++)
{
if(a==b)
{
if(ans==-1)
{
ans=i;
}
else
{
ans=min(ans,(i));
}
break;
}
if(i%2!=0)
{
for(ll j=0;j<2*n;j+=2)
{
swap(b[j],b[j+1]);
}
}
else
{
for(ll k=0;k<n;k++)
{
swap(b[k],b[k+n]);
}
}
}
cout<<ans<<endl;
}
int main()
{
#ifdef FILE_IO
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
/*int t;
cin>>t;
int tc=1;
while(t--)
{
solve();
tc++;
}
*/solve();
return 0;
} | 2 |
#include <bits/stdc++.h>
int T, fl, cur, res, x[5], y[5], p[5], c[5], rx[5], ry[5], d[5];
struct value {
int val;
bool has;
inline void reset() { has = 0; }
inline void set(int x) {
if (has) {
if (val != x) fl = 0;
} else {
val = x, has = 1;
}
}
} vx, vy, kx, ky, k;
inline int calc(int a, int b, int c, int d) {
return std::max(std::abs(a - b), std::abs(c - d));
}
int main() {
for (scanf("%d", &T); T--;) {
res = -1;
for (int k = 1; k <= 4; k++) scanf("%d%d", &x[k], &y[k]), p[k] = k;
do {
for (int sta = 0; sta < 16; sta++) {
fl = 1;
vx.reset(), vy.reset(), kx.reset(), ky.reset(), k.reset();
for (int i = 1; i <= 4; i++) c[i] = (sta >> (i - 1)) & 1;
c[1] ? vx.set(x[p[1]]) : vy.set(y[p[1]]);
c[2] ? vx.set(x[p[2]]) : ky.set(y[p[2]]);
c[3] ? kx.set(x[p[3]]) : vy.set(y[p[3]]);
c[4] ? kx.set(x[p[4]]) : ky.set(y[p[4]]);
if (!fl) continue;
if (vx.has && kx.has) k.set(kx.val - vx.val);
if (vy.has && ky.has) k.set(ky.val - vy.val);
if (!fl) continue;
if (kx.has) vx.set(kx.val - k.val);
if (ky.has) vy.set(ky.val - k.val);
if (!fl) continue;
if (!vx.has) {
d[1] = x[p[1]], d[2] = x[p[2]], d[3] = x[p[3]] - k.val,
d[4] = x[p[4]] - k.val;
std::sort(d + 1, d + 5), vx.set((d[1] + d[4]) / 2);
}
if (!vy.has) {
d[1] = y[p[1]], d[2] = y[p[3]], d[3] = y[p[2]] - k.val,
d[4] = y[p[4]] - k.val;
std::sort(d + 1, d + 5), vy.set((d[1] + d[4]) / 2);
}
if (!fl) continue;
kx.set(vx.val + k.val), ky.set(vy.val + k.val);
cur = -1;
cur = std::max(cur, calc(x[p[1]], vx.val, y[p[1]], vy.val));
cur = std::max(cur, calc(x[p[2]], vx.val, y[p[2]], ky.val));
cur = std::max(cur, calc(x[p[3]], kx.val, y[p[3]], vy.val));
cur = std::max(cur, calc(x[p[4]], kx.val, y[p[4]], ky.val));
if (cur < res || res == -1) {
res = cur;
rx[p[1]] = vx.val, ry[p[1]] = vy.val;
rx[p[2]] = vx.val, ry[p[2]] = ky.val;
rx[p[3]] = kx.val, ry[p[3]] = vy.val;
rx[p[4]] = kx.val, ry[p[4]] = ky.val;
}
}
} while (std::next_permutation(p + 1, p + 5));
printf("%d\n", res);
if (~res)
printf("%d %d\n%d %d\n%d %d\n%d %d\n", rx[1], ry[1], rx[2], ry[2], rx[3],
ry[3], rx[4], ry[4]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, j, s = 1, m = 1;
scanf("%d", &t);
int a[t];
for (i = 0; i < t; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i < t; i++) {
if (a[i] > a[i - 1]) {
s++;
if (s > m) m = s;
} else {
s = 1;
}
}
printf("%d", m);
}
| 0 |
#include <bits/stdc++.h>
static const bool debug = 0;
using ll = long long;
int INF_int = 2147483647;
ll INF_ll = 9223372036854775807;
using namespace std;
int main() {
if (!debug) {
std::ios::sync_with_stdio(false);
cin.tie(0);
};
int n;
cin >> n;
if (n > 5) {
cout << "1 2\n2 3\n2 4\n3 5\n3 6\n";
if (n % 2 == 1) {
cout << "3 7\n";
for (int(i) = (7); (i) < (n); ++i) cout << i << ' ' << i + 1 << '\n';
} else {
for (int(i) = (6); (i) < (n); ++i) cout << i << ' ' << i + 1 << '\n';
}
} else
cout << "-1\n";
for (int(i) = (1); (i) < (n); ++i) cout << i << ' ' << i + 1 << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
void print(ll x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes" << endl;
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No" << endl;
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static random_device rd;
static mt19937_64 gen(rd());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
using uint = unsigned;
using ull = unsigned long long;
const uint mod = 998244353;
struct mint {
uint v;
mint(ll vv = 0) { s(vv % mod + mod); }
mint& s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
mint operator-() const { return mint() - *this; }
mint& operator+=(const mint& rhs) { return s(v + rhs.v); }
mint& operator-=(const mint& rhs) { return s(v + mod - rhs.v); }
mint& operator*=(const mint& rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
mint& operator/=(const mint& rhs) { return *this *= rhs.inv(); }
mint operator+(const mint& rhs) const { return mint(*this) += rhs; }
mint operator-(const mint& rhs) const { return mint(*this) -= rhs; }
mint operator*(const mint& rhs) const { return mint(*this) *= rhs; }
mint operator/(const mint& rhs) const { return mint(*this) /= rhs; }
mint pow(ll n) const {
mint res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
mint inv() const { return pow(mod - 2); }
friend ostream& operator<<(ostream& os, const mint& m) { return os << m.v; }
bool operator<(const mint& r) const { return v < r.v; }
bool operator==(const mint& r) const { return v == r.v; }
};
const ll vmax = (1 << 21) + 10;
mint fact[vmax], finv[vmax], invs[vmax];
void initfact() {
fact[0] = 1;
for (ll i = ll(1); i < ll(vmax); i++) {
fact[i] = fact[i - 1] * i;
}
finv[vmax - 1] = fact[vmax - 1].inv();
for (ll i = vmax - 2; i >= 0; i--) {
finv[i] = finv[i + 1] * (i + 1);
}
for (ll i = vmax - 1; i >= 1; i--) {
invs[i] = finv[i] * fact[i - 1];
}
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
initfact();
ll n, k;
cin >> n >> k;
vi h = readvi(n);
ll first = 0, second = 0;
for (ll i = ll(0); i < ll(n); i++) {
if (h[i] == h[(i + 1) % n])
first++;
else
second++;
}
mint ans = 0;
vc<mint> p(second + 1);
p[0] = 1;
for (ll i = ll(0); i < ll(second); i++) p[i + 1] = p[i] * (k - 2);
for (ll i = 0; i * 2 <= second; i++) {
mint w = finv[i] * finv[i] * finv[second - i * 2] * fact[second];
w *= p[second - i * 2];
ans += w;
}
ans *= mint(k).pow(first);
ans = (mint(k).pow(n) - ans) / 2;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, m;
bool vis[1000009];
vector<int> ans, g[1000009];
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
}
for (i = 1; i <= n; i++)
if (!vis[i]) {
for (j = 0; j < g[i].size(); j++)
if (g[i][j] > i) vis[g[i][j]] = 1;
}
for (i = n; i >= 1; i--)
if (!vis[i]) {
ans.push_back(i);
for (j = 0; j < g[i].size(); j++) vis[g[i][j]] = 1;
}
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const int N = 100000 + 10;
const long long MOD = 1000000000 + 7;
const long long INF = 1000000010;
const long long LOG = 17;
int n, sz[N], fen[2][N], L[N], R[N], st[N], ft[N], Time, par[N], ans[N];
bool tak[N];
vector<pair<pair<int, int>, int>> Qjad[N], Qsub[N];
vector<int> Valst[N], Valsz[N], G[N];
inline void add(int ind, int id, int x) {
for (; id < N; id += (id & (-id))) fen[ind][id] += x;
}
inline int get(int ind, int id) {
int res = 0;
for (; id > 0; id -= (id & (-id))) res += fen[ind][id];
return res;
}
void DFS(int v, int p = 0) {
sz[v] = 1;
st[v] = ++Time;
for (auto u : G[v]) {
par[u] = v;
DFS(u, v);
sz[v] += sz[u];
}
Valst[st[v]].push_back(v);
Valsz[sz[v]].push_back(v);
ft[v] = Time;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
int root = 0;
for (int i = 1; i <= n; i++) {
int v, u;
cin >> v >> u;
if (v == 0) {
root = u;
continue;
}
G[v].push_back(u);
}
DFS(root);
for (int i = 1; i <= n; i++) L[i] = 0, R[i] = n - 1;
for (int tmp = 0; tmp < LOG; tmp++) {
for (int i = 0; i < N; i++)
Qjad[i].clear(), Qsub[i].clear(), ans[i] = 0, tak[i] = 0,
fen[0][i] = fen[1][i] = 0;
for (int i = 1; i <= n; i++) {
if (i == root && G[i].size() == 1) {
L[i] = (R[i] + L[i]) >> 1;
tak[i] = 1;
}
if (R[i] == L[i] + 1) {
tak[i] = 1;
continue;
}
int md = (R[i] + L[i]) >> 1;
if (G[i].size() == 0) {
L[i] = md;
tak[i] = 1;
continue;
}
int cnt = 0;
int v = i;
for (auto u : G[v]) {
if (sz[u] > md) cnt++;
}
if (n - sz[v] > md) cnt++;
if (cnt > 1) {
L[i] = md;
tak[i] = 1;
continue;
}
int mn = INF, mx = G[v][0];
for (auto u : G[v]) {
if (sz[u] > sz[mx]) mx = u;
mn = min(mn, sz[u]);
}
if (i != root) mn = min(mn, n - sz[v]);
if (n - sz[v] > sz[mx]) {
if (n - sz[v] <= md) {
R[i] = md;
tak[i] = 1;
continue;
}
int l = n - sz[v] - md;
int r = md - mn;
if (r < l) {
L[i] = md;
tak[i] = 1;
continue;
}
Qjad[l - 1].push_back({{par[v], 1}, v});
Qjad[r].push_back({{par[v], -1}, v});
Qsub[n].push_back({{l - 1, -1}, v});
Qsub[n].push_back({{r, 1}, v});
Qsub[st[v] - 1].push_back({{l - 1, -1}, v});
Qsub[st[v] - 1].push_back({{r, +1}, v});
Qsub[ft[v]].push_back({{l - 1, +1}, v});
Qsub[ft[v]].push_back({{r, -1}, v});
r += sz[v];
l += sz[v];
r = min(N - 1, r);
l = min(N - 1, l);
Qjad[l - 1].push_back({{par[v], -1}, v});
Qjad[r].push_back({{par[v], 1}, v});
if (sz[root] >= l && sz[root] <= r) ans[v]--;
continue;
}
if (sz[mx] <= md) {
R[i] = md;
tak[i] = 1;
continue;
}
int l = sz[mx] - md;
int r = md - mn;
if (r < l) {
L[i] = md;
tak[i] = 1;
continue;
}
Qsub[st[mx] - 1].push_back({{l - 1, 1}, v});
Qsub[st[mx] - 1].push_back({{r, -1}, v});
Qsub[ft[mx]].push_back({{l - 1, -1}, v});
Qsub[ft[mx]].push_back({{r, 1}, v});
if (sz[mx] >= l && sz[mx] <= r) ans[v]--;
}
for (int i = 0; i < N; i++) {
for (auto u : Valst[i]) add(1, sz[u], 1);
for (auto u : Valsz[i]) add(0, st[u], 1), add(0, ft[u] + 1, -1);
for (auto u : Qjad[i])
ans[u.second] += u.first.second * get(0, st[u.first.first]);
for (auto u : Qsub[i])
ans[u.second] += u.first.second * get(1, u.first.first);
}
for (int i = 1; i <= n; i++) {
if (tak[i] == 1) continue;
int md = (L[i] + R[i]) >> 1;
if (ans[i] > 0)
R[i] = md;
else
L[i] = md;
}
}
for (int i = 1; i <= n; i++) {
cout << R[i] << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x1, y1, x2, y2;
;
cin >> n;
cout << "YES\n";
for (long long i = 0; i < n; i++) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 % 2 == 0 && y1 % 2 == 0) cout << "1\n";
if (x1 % 2 == 0 && y1 % 2 != 0) cout << "2\n";
if (x1 % 2 != 0 && y1 % 2 == 0) cout << "3\n";
if (x1 % 2 != 0 && y1 % 2 != 0) cout << "4\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t;
int a, b, c, d;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (b >= a) {
printf("%d\n", b);
continue;
}
if (d >= c) {
printf("-1\n");
continue;
}
a -= b;
d = c - d;
int t = a / d + (a % d != 0);
cout << b + 1ll * t * c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
const int MAXN = 1123456;
long long n, m, k;
long long s[MAXN];
long long ult[MAXN];
int main() {
scanf("%lld", &n);
long long ans = 0;
memset(ult, 0, sizeof(ult));
for (int a = 1; a <= n; a++) {
scanf("%lld", s + a);
ans += 2 * ((n - a + 1) * (a - ult[s[a]]) - 1) + 1;
ult[s[a]] = a;
}
printf("%.10f\n", ((double)ans) / (n * n));
;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void pencilcase(long long a, long long b, long long c, long long d,
long long k) {
if (k <= 1) {
cout << -1 << endl;
return;
}
long long pen;
long long pencil;
if (a % c > 0) {
pen = (a / c) + 1;
} else {
pen = (a / c);
}
if (b % d > 0) {
pencil = (b / d) + 1;
} else {
pencil = b / d;
}
if (pen + pencil <= k) {
cout << (k - pencil) << " " << pencil << endl;
} else {
cout << -1 << endl;
}
}
int main() {
long long t;
cin >> t;
for (long long i = 0; i < t; i++) {
long long a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
pencilcase(a, b, c, d, k);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int tot, toz, nm[11];
long long ans, tom = 1, mul[20];
vector<pair<int, int> > num;
void dfs(int x) {
for (int i = 1; i <= num[x].second; i++) {
tot++;
tom *= i;
if (!num[x].first) toz = i;
if (x == num.size() - 1) {
ans += mul[tot] * (tot - toz) / tom / tot;
continue;
}
dfs(x + 1);
tot -= num[x + 1].second;
tom /= mul[num[x + 1].second];
}
}
int main() {
string n;
cin >> n;
for (int i = 0; i < n.size(); i++) nm[n[i] - '0']++;
for (int i = 0; i < 10; i++)
if (nm[i]) num.push_back(make_pair(i, nm[i]));
mul[1] = 1;
for (int i = 2; i < 20; i++) mul[i] = mul[i - 1] * i;
dfs(0);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
int x, y, m = 0;
cin >> n;
for (int i = 1; i <= n / 2; i++) {
a = i;
b = n - i;
while (a != b) {
if (a > b) {
a = a - b;
} else {
b = b - a;
}
}
if ((a == 1) && (i < (n - i)) &&
((i / (n - i) + 0, 1 * (i % (n - i))) > m)) {
x = i;
y = n - i;
}
}
cout << x << " " << y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300;
int n, m, k, t;
vector<int> v;
void ubaci(int x) {
int lim = v.size();
vector<int> res;
for (int i = 0; i < x - 1; i++) res.push_back(v[i]);
res.push_back(0);
for (int i = x - 1; i < lim; i++) res.push_back(v[i]);
v = res;
}
int nadi(vector<int> vv) {
for (int i = 0; i < vv.size(); i++) {
if (vv[i] == 1) return i + 1;
}
return -1;
}
void razdvoji(int ind) {
vector<int> a, b;
for (int i = 0; i < v.size(); i++) {
if (i < ind)
a.push_back(v[i]);
else
b.push_back(v[i]);
}
if (nadi(a) != -1)
v = a;
else
v = b;
}
int main() {
cin >> n >> k >> m >> t;
for (int i = 1; i <= n; i++) {
v.push_back(i == k);
}
for (int i = 0; i < t; i++) {
int tip, ind;
cin >> tip >> ind;
if (tip == 1) {
ubaci(ind);
} else {
razdvoji(ind);
}
cout << v.size() << " " << nadi(v) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dfs(int *graph, int n) {
int maxDepth = 0, tmp, i, j;
for (i = 1; i <= n; i++) {
tmp = 1, j = i;
while (graph[j] != -1) {
tmp++;
j = graph[j];
}
maxDepth = maxDepth > tmp ? maxDepth : tmp;
}
return maxDepth;
}
int main() {
int n, manager[2002];
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", manager + i);
cout << dfs(manager, n) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int p = 1e9 + 7;
int n, k, suf[N], pre[N], fac[N];
void read(int &x) {
int flg = 1;
x = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') flg = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x *= flg;
}
int pow(int x, int y) {
long long a = x, ret = 1;
for (; y; y >>= 1, a = a * a % p)
if (y & 1) ret = ret * a % p;
return ret;
}
int main() {
read(n), read(k);
suf[k + 3] = pre[0] = fac[0] = 1;
for (int i = 1; i <= k + 2; ++i) pre[i] = 1ll * pre[i - 1] * (n - i) % p;
for (int i = k + 2; i >= 1; --i) suf[i] = 1ll * suf[i + 1] * (n - i) % p;
for (int i = 1; i <= k + 2; ++i) fac[i] = 1ll * fac[i - 1] * i % p;
int y = 0, f, s, ans = 0;
for (int i = 1; i <= k + 2; ++i) {
y = (1ll * y + pow(i, k)) % p;
s = 1ll * pre[i - 1] * suf[i + 1] % p;
f = 1ll * fac[i - 1] * ((k - i) & 1 ? -1ll : 1ll) * fac[k + 2 - i] % p;
ans = (1ll * ans + 1ll * y * s % p * pow(f, p - 2) % p) % p;
}
printf("%d\n", (ans + p) % p);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int maxn = 18;
const int maxm = 110;
const int maxmask = (1 << maxn) - 1;
const int infi = 1e9 + 7;
const long long infl = 1e18;
const long double eps = 1e-10;
const long long mod = 1e9 + 7;
int ar[100500];
long long dp[2010][2010];
int main() {
int n, h;
cin >> n >> h;
for (int i = 1; i <= n; ++i) {
cin >> ar[i];
}
for (int i = 1; i <= n; ++i) {
if (ar[i] > h) {
cout << 0;
return 0;
}
}
dp[1][0] = 1;
for (int i = 1; i <= n; ++i) {
long long h1 = h - ar[i];
dp[i + 1][h1] += dp[i][h1];
if (h1) {
dp[i + 1][h1 - 1] += dp[i][h1 - 1] * (h1 - 1);
dp[i + 1][h1] += dp[i][h1 - 1];
dp[i + 1][h1 - 1] += dp[i][h1 - 1];
dp[i + 1][h1 - 1] += dp[i][h1] * h1;
dp[i + 1][h1 - 1] %= mod;
}
dp[i + 1][h - ar[i]] %= mod;
}
cout << dp[n + 1][0];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
int main() {
string x, y;
cin >> x >> y;
string z = y;
string t = y;
for (int i = (0); i < (x.size()); ++i) {
t[i] = min(x[i], z[i]);
}
if (z == t) {
cout << z;
} else {
cout << -1;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n > 36)
cout << "-1";
else {
if (n % 2 == 1) {
cout << "9";
n--;
}
for (int i = 0; i < n / 2; i++) {
cout << "8";
}
}
}
| 2 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int N = 100050, M = 105;
struct Matrix {
int a[M][M];
Matrix operator*(const Matrix& b) const {
Matrix c;
int i, j, k;
for (i = 0; i < M; i++)
for (j = 0; j < M; j++) c.a[i][j] = 0;
for (i = 0; i < M; i++)
for (j = 0; j < M; j++)
for (k = 0; k < M; k++)
c.a[i][j] = (c.a[i][j] + (1ll * a[i][k] * b.a[k][j] % mod)) % mod;
return c;
}
} ans, tmp;
int b[N * 10];
int sol;
int main() {
int n, l, m, i, u, j;
scanf("%i%i%i", &n, &l, &m);
for (i = 0; i < n; i++) scanf("%i", &u), ans.a[0][u % m]++;
for (i = 0; i < n; i++) scanf("%i", &b[i]), b[i] %= m;
for (j = 0; j < m; j++)
for (i = 0; i < n; i++) tmp.a[(m + j - b[i]) % m][j]++;
l -= 2;
for (; l; tmp = tmp * tmp, l >>= 1)
if (l & 1) ans = ans * tmp;
for (i = 0; i < n; i++)
scanf("%i", &u), u %= m,
sol = ((long long)sol + ans.a[0][(2 * m - u - b[i]) % m]) % mod;
printf("%i\n", sol);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int g[1010];
int mark[2010];
int save[1010];
int bin[1100];
int num[1100];
int find(int x) {
if (x == bin[x]) return x;
return bin[x] = find(bin[x]);
}
int main() {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%d", &g[i]);
}
for (int i = 0; i <= n; i++) {
num[i] = 1;
bin[i] = i;
}
int flag = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (g[i] != 0) {
int a = find(i);
int b = find(g[i]);
bin[a] = b;
num[b] = num[a] + num[b];
num[a] = 0;
}
}
for (int i = 1; i <= n; i++) {
if (bin[i] == i && find(x) != i) {
save[cnt++] = num[i];
}
}
memset(mark, 0, sizeof(mark));
mark[0] = 1;
for (int i = 0; i < cnt; i++) {
for (int j = 1000; j >= 0; j--) {
if (mark[j] == 1) {
mark[j + save[i]] = 1;
}
}
}
int sum = 0;
while (g[x]) {
sum++;
x = g[x];
}
for (int i = 0; i <= n; i++)
if (mark[i] == 1) printf("%d\n", sum + i + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
map<int, int> used;
for (int c = 0; c < (n); c++) {
int x, y, total = 0;
cin >> x >> y;
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) {
int start = c - y, end = c - 1;
total++;
if (start <= end && used.find(i) != used.end() && used[i] >= start &&
used[i] <= end) {
total--;
}
used[i] = c;
}
int k = x / i;
if (x % k == 0 && k != i) {
int start = c - y, end = c - 1;
total++;
if (start <= end && used.find(k) != used.end() && used[k] >= start &&
used[k] <= end) {
total--;
}
used[k] = c;
}
}
cout << total << "\n";
;
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
void scf(int &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
void scf(int &x, int &y) {
scf(x);
return scf(y);
}
void scf(int &x, int &y, int &z) {
scf(x);
scf(y);
return scf(z);
}
const int N = 1e5 + 100;
const long long MOD = 1e9 + 7;
int n;
long long pow25[N], pow26[N], fac[N], inv[N], inv26[N];
struct query {
int l, n, id;
long long ans;
query() {}
query(int L, int N, int ID) {
l = L;
n = N;
id = ID;
}
bool operator<(const query &a) const { return l == a.l ? n < a.n : l < a.l; }
} qry[N];
inline long long kiss_me(long long a, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ret;
}
inline long long INV(long long x) { return kiss_me(x, MOD - 2); }
inline long long C(int n, int m) {
return n < m ? 0 : fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
void init() {
pow25[0] = pow26[0] = fac[0] = inv[0] = inv26[0] = 1ll;
for (int i = (1); i <= (N - 1); i++)
pow25[i] = pow25[i - 1] * 25ll % MOD, pow26[i] = pow26[i - 1] * 26ll % MOD,
fac[i] = fac[i - 1] * (long long)i % MOD, inv26[i] = INV(pow26[i]),
inv[i] = INV(fac[i]);
int m, l;
scf(m);
char str[N];
scanf("%s", str);
l = (int)strlen(str);
while (m--) {
int op;
scf(op);
if (op == 2) {
int x;
scf(x);
qry[n] = query(l, x, n);
n++;
} else {
scanf("%s", str);
l = (int)strlen(str);
}
}
sort(qry, qry + n);
return;
}
inline bool cmp(const query &a, const query &b) { return a.id < b.id; }
void solve() {
int lst;
long long cur;
for (int i = 0; i < (n); i++) {
if (!i || qry[i].l != qry[i - 1].l) lst = qry[i].l, cur = 0;
while (lst <= qry[i].n)
cur = (cur + pow25[lst - qry[i].l] * inv26[lst] % MOD *
C(lst - 1, qry[i].l - 1) % MOD) %
MOD,
lst++;
qry[i].ans = cur * pow26[qry[i].n] % MOD;
}
sort(qry, qry + n, cmp);
for (int i = 0; i < (n); i++) printf("%I64d\n", qry[i].ans);
return;
}
int main() {
init();
solve();
return 0;
}
| 8 |
// 及时当勉励，岁月不待人！
//当前状态 : attempted
//#include<bits/stdc++.h>;
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<map>
#include<stack>
#include<vector>
#include<cmath>
#include<string>
#include<iomanip>
#define MP make_pair
#define fuck() int t;cin>>t;while(t--)
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
inline int read(){int ret = 0, sgn = 1;char ch = getchar();while(ch < '0' || ch > '9'){if(ch == '-')sgn = -1;ch = getchar();} while (ch >= '0' && ch <= '9'){ret = ret*10 + ch - '0';ch = getchar();}return ret*sgn;}
struct MN{int a;int b;};
//结构体
//全局变量
const int maxn=1005;
//函数
int main()
{
std::ios::sync_with_stdio(false);std::cin.tie(0);
//freopen("d:\\desk\\in.txt","r",stdin);
//freopen("d:\\desk\\out.txt","w",stdout);
fuck(){
int n;cin>>n;
if(n==1){
cout<<0<<endl;
}else if(n==2){
cout<<1<<endl;
}else if(n==3){
cout<<2<<endl;
}else if(n%2==0){
cout<<2<<endl;
}else{
cout<<3<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int &e : a) cin >> e;
bool ok = true;
for (int i = 0; i < n - 1; i++) {
if (a[i] + 1 < a[i + 1]) {
ok = false;
break;
}
}
cout << ((ok) ? "YES" : "NO") << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const double Pi = acos(-1.0);
const int INF = 1000000000;
const int MAX = 250007;
const int MAX2 = 2000000;
const int BASE = 10;
const int ST = 1000000007;
const int CNT = 100;
int p[MAX];
int t[MAX];
bool Comp(pair<int, int> a, pair<int, int> b) {
return 1LL * a.first * b.second > 1LL * a.second * b.first;
}
bool Eq(pair<int, int> a, pair<int, int> b) {
return 1LL * a.first * b.second == 1LL * a.second * b.first;
}
int main() {
int n;
cin >> n;
for (int i = (0); i < (n); ++i) {
scanf("%d", &p[i]);
}
long long T = 0;
for (int i = (0); i < (n); ++i) {
scanf("%d", &t[i]);
T += t[i];
}
vector<pair<int, int> > A;
for (int i = (0); i < (n); ++i) {
A.push_back(make_pair(p[i], t[i]));
}
sort(A.begin(), A.end(), Comp);
double L = 0;
double R = 1;
for (int it = (0); it < (47); ++it) {
double X = (L + R) / 2;
int pos = 0;
long long time = 0;
vector<pair<int, pair<double, double> > > Q;
while (pos < n) {
int add = 1;
while (pos + add < n && Eq(A[pos + add], A[pos])) ++add;
long long sum = 0;
for (int i = (pos); i < (pos + add); ++i) {
sum += A[i].second;
}
for (int i = (pos); i < (pos + add); ++i) {
double mn = A[i].first * (1.0 - X * (time + sum) / T);
double mx = A[i].first * (1.0 - X * (time + A[i].second) / T);
Q.push_back(make_pair(A[i].first, make_pair(mn, mx)));
}
time += sum;
pos += add;
}
sort(Q.begin(), Q.end());
bool ok = 1;
double Mx = -1;
pos = 0;
while (pos < n) {
if (!ok) break;
int add = 1;
while (pos + add < n && Q[pos + add].first == Q[pos].first) ++add;
for (int i = (pos); i < (pos + add); ++i) {
if (Q[i].second.first < Mx) {
ok = 0;
break;
}
}
for (int i = (pos); i < (pos + add); ++i) {
Mx = max(Mx, Q[i].second.second);
}
pos += add;
}
if (ok) {
L = X;
} else {
R = X;
}
}
printf("%.10f\n", L);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, ans[200100], st = 1, i;
double s[200100], sum = 0;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%lf", &s[i]);
sum += s[i];
}
for (i = 1; i <= n; i++)
if ((sum - s[i]) / (n - 1) == s[i]) ans[st++] = i;
if (st != 1) {
printf("%d\n", st - 1);
for (i = 1; i < st - 1; i++) printf("%d ", ans[i]);
printf("%d\n", ans[st - 1]);
} else
printf("0\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100020;
char s[MAXN];
struct XYZ {
int x, y, z;
} xyz[MAXN];
int main() {
scanf("%s", s);
int len = strlen(s);
int x = 0, y = 0, z = 0;
xyz[0].x = x;
xyz[0].y = y;
xyz[0].z = z;
for (int i = 1; i <= len; ++i) {
if (s[i - 1] == 'x')
++x;
else if (s[i - 1] == 'y')
++y;
else if (s[i - 1] == 'z')
++z;
xyz[i].x = x;
xyz[i].y = y;
xyz[i].z = z;
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int l, r, a[3];
scanf("%d%d", &l, &r);
if (r - l < 2) {
printf("YES\n");
continue;
}
a[0] = xyz[r].x - xyz[l - 1].x;
a[1] = xyz[r].y - xyz[l - 1].y;
a[2] = xyz[r].z - xyz[l - 1].z;
sort(a, a + 3);
if (a[2] - a[0] <= 1) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[200005];
int deep[200005];
int f[200005];
int b[200005][21];
int kk[200005];
int flag, k;
void dfs(int u, int fu) {
f[u] = fu;
b[u][0] = fu;
for (int i = 1; i <= 20; i++) b[u][i] = b[b[u][i - 1]][i - 1];
deep[u] = deep[fu] + 1;
for (int i = 0; i < (int)a[u].size(); i++)
if (a[u][i] != fu) dfs(a[u][i], u);
}
int dfs1(int v, int u) {
int c = deep[v] - 1;
for (int i = 20; i >= 0; i--) {
if (deep[b[u][i]] >= c) u = b[u][i];
}
if (f[v] == u)
return 1;
else
return 0;
}
int cmp(int x, int y) { return deep[x] > deep[y]; }
int main() {
int n, m, u, v;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
dfs(1, 0);
while (m--) {
flag = 1;
scanf("%d", &k);
for (int i = 1; i <= k; i++) scanf("%d", &kk[i]);
sort(kk + 1, kk + 1 + k, cmp);
for (int i = 2; i <= k; i++) {
if (!dfs1(kk[i], kk[1])) {
flag = 0;
break;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int levo[5002][5002], mg[5003][5003], a[5003];
int main() {
ios::sync_with_stdio(false);
int n, m, res = 0, i, j, k, x;
string s;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> s;
for (j = 1; j <= m; j++) mg[i][j] = s[j - 1] - '0';
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
levo[i][j] = levo[i][j - 1] + 1;
if (mg[i][j] == 0) levo[i][j] = 0;
}
}
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) {
a[j] = levo[j][i];
}
sort(a + 1, a + n + 1);
for (j = 1; j <= n; j++) res = max(res, (n - j + 1) * a[j]);
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, r[501000], _[501000][20], Max[501000][20];
int MAX(int a, int b) { return a + r[a] > b + r[b] ? a : b; }
long long Ans;
int Query(int a, int b) {
if (b >= 2 * n) b = 2 * n - 1;
int l(b - a + 1), k;
for (k = 0; (1 << k + 1) <= l; k++)
;
return MAX(Max[a][k], Max[b - (1 << k) + 1][k]);
}
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", r + i);
for (i = 0; i < n; i++) r[i + n] = r[n - i - 1];
for (i = 0; i < n; i++) r[i] = r[i + n];
memset(Max, -1, sizeof Max);
for (i = 0; i < 2 * n; i++) Max[i][0] = i;
for (k = 1; k < 20; k++)
for (i = 0; i + (1 << k) - 1 < 2 * n; i++)
Max[i][k] = MAX(Max[i][k - 1], Max[i + (1 << k - 1)][k - 1]);
for (i = 0; i < 2 * n; i++) _[i][0] = Query(i, i + r[i]);
for (k = 1; k < 20; k++)
for (i = 0; i < 2 * n; i++) _[i][k] = _[_[i][k - 1]][k - 1];
for (i = 0; i < n; i++) {
j = i;
Ans++;
if (i + r[i] < i + n - 1) {
for (k = 19; k >= 0; k--)
if (_[j][k] + r[_[j][k]] < i + n - 1) {
j = _[j][k];
Ans += 1 << k;
}
Ans++;
}
}
printf("%I64d\n", Ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, p, id, ix, iy;
int a[500000];
int b[500000];
long long int isum;
void print() {
for (int j = 0; j < id; j++) {
isum += b[j] * 1ll;
}
printf("%lld\n", isum);
}
void is_calculatein(int i) {
if (i < 0 || i >= n) return;
if (i == 0) {
if (a[i] > a[i + 1]) isum -= a[i];
} else if (i == n - 1) {
if (a[i - 1] <= a[i]) isum -= a[i];
} else {
if (a[i] <= a[i + 1] && a[i - 1] >= a[i]) {
isum += a[i];
} else if (a[i] >= a[i + 1] && a[i] >= a[i - 1]) {
isum -= a[i];
}
}
}
void is_sum(int i) {
if (i < 0 || i >= n) return;
if (i == 0) {
if (a[i] > a[i + 1]) isum += a[i];
} else if (i == n - 1) {
if (a[i - 1] <= a[i]) isum += a[i];
} else {
if (a[i] <= a[i + 1] && a[i - 1] >= a[i]) {
isum -= a[i];
} else if (a[i] >= a[i + 1] && a[i] >= a[i - 1]) {
isum += a[i];
}
}
}
int main() {
scanf("%d", &t);
for (int i = 0; i < t; i++) {
id = 0;
isum = 0;
scanf("%d %d", &n, &p);
for (int j = 0; j < n; j++) {
scanf("%d", &a[j]);
}
if (n == 1) {
printf("%d\n", a[0]);
for (int k = 0; k < p; k++) {
scanf("%d %d", &ix, &iy);
printf("%d\n", a[0]);
}
} else {
if (a[0] > a[1]) {
b[id++] = a[0];
}
for (int k = 1; k < n - 1; k++) {
if (a[k] >= a[k + 1] && a[k - 1] <= a[k]) {
b[id++] = a[k];
} else if (a[k] <= a[k + 1] && a[k - 1] >= a[k]) {
b[id++] = -a[k];
}
}
if (a[n - 2] <= a[n - 1]) {
b[id++] = a[n - 1];
}
print();
for (int j = 0; j < p; j++) {
scanf("%d %d", &ix, &iy);
ix--;
iy--;
if (iy - ix < 3) {
for (int j = ix - 1; j <= iy + 1; j++) {
is_calculatein(j);
}
} else {
for (int j = -1; j <= 1; j++) {
is_calculatein(ix + j);
is_calculatein(iy + j);
}
}
int c = a[ix];
a[ix] = a[iy];
a[iy] = c;
if (iy - ix < 3) {
for (int j = ix - 1; j <= iy + 1; j++) {
is_sum(j);
}
} else {
for (int j = -1; j <= 1; j++) {
is_sum(ix + j);
is_sum(iy + j);
}
}
printf("%lld\n", isum);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int a[1100000], s[1100000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int n, k;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << 1 << " " << a[1] << endl;
return 0;
}
sort(a + 1, a + n + 1);
for (long long int i = 1; i <= n; i++) {
s[i] = s[i - 1] + a[i];
}
long long int ans1 = 0, ans2 = 0;
long long int p = 1;
for (long long int i = 1; i <= n; i++) {
while ((a[i] * (i - p)) - (s[i - 1] - s[p - 1]) > k) {
p++;
}
if (i - p > ans1) {
ans1 = i - p;
ans2 = a[i];
}
}
ans1++;
cout << ans1 << " " << ans2 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 2005;
int n, m;
bitset<2005> a[MAXN];
int w[MAXN][MAXN];
int parent[MAXN];
vector<int> who[MAXN];
vector<int> g[MAXN];
int findset(int v) {
if (v == parent[v]) {
return v;
}
return parent[v] = findset(parent[v]);
}
int col[MAXN];
int uk = 0;
int dfs(int u, int pr = -1) {
int cnt = 1;
for (auto h : g[u]) {
if (h == pr || col[h] != uk) {
continue;
}
cnt += dfs(h, u);
}
return cnt;
}
bool check(vector<int> x) {
uk++;
for (auto y : x) {
col[y] = uk;
}
return dfs(x[0]) == (int)(x).size();
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
a[i].reset();
parent[i] = i;
g[i].clear();
}
for (int i = 0; i < m; i++) {
string s;
cin >> s;
who[i].clear();
for (int j = 0; j < n; j++) {
if (s[j] == '1') {
who[i].push_back(j);
a[j][i] = 1;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
w[i][j] = (a[i] & a[j]).count();
}
}
vector<pair<int, pair<int, int> > > st;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
st.push_back({w[i][j], make_pair(i, j)});
}
}
sort((st).begin(), (st).end());
reverse((st).begin(), (st).end());
vector<pair<int, int> > sts;
for (auto x : st) {
int ta = x.second.first;
int tb = x.second.second;
if (findset(ta) != findset(tb)) {
parent[findset(ta)] = findset(tb);
sts.push_back(make_pair(ta, tb));
g[ta].push_back(tb);
g[tb].push_back(ta);
}
}
bool bad = false;
for (int i = 0; i < m; i++) {
if (!check(who[i])) {
bad = true;
break;
}
}
if (bad) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (auto x : sts) {
cout << x.first + 1 << ' ' << x.second + 1 << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 12 |
#include <bits/stdc++.h>
int l;
int h;
int s;
int main() {
int n, x;
scanf("%d %d", &n, &x);
int e;
for (int i = 0; i < n; ++i) {
scanf("%d ", &e);
if (e < x) {
++l;
} else if (e == x) {
++s;
}
}
h = n - l - s;
int half = (n + 1) / 2;
if (l < half) {
if (s + l >= half) {
printf("0\n");
return 0;
} else {
if (s) {
printf("%d\n", h - l - s);
} else {
printf("%d\n", h - l);
}
return 0;
}
} else {
if (s) {
printf("%d\n", l - h - s + 1);
} else {
printf("%d\n", l - h + 1);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
int mat = (n * (n - 1)) / 2;
int c2 = 0;
int in;
for (int i = 0; i < n; i++)
if (s[i] == '2') {
c2++;
in = i;
}
int d = (n * n) - n + c2 - (c2 * c2);
if (c2 == 1 || c2 == 2)
cout << "NO"
<< "\n";
else {
cout << "YES"
<< "\n";
char m[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (s[i] == '1' || s[j] == '1')
m[i][j] = '=';
else {
if (i > j)
m[i][j] = '+';
else
m[i][j] = '-';
}
if (i == j) m[i][j] = 'X';
}
}
for (int i = 0; i < n; i++) {
if (m[in][i] == '+') {
swap(m[in][i], m[i][in]);
break;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << m[i][j];
}
cout << "\n";
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, l[300], c[300];
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
unordered_map<int, int> um;
for (int i = 0; i < n; i++)
if (um.find(l[i]) == um.end())
um.emplace(l[i], c[i]);
else
um[l[i]] = min(um[l[i]], c[i]);
for (int i = 0; i < n; i++) {
for (auto elem : um) {
int g = gcd(elem.first, l[i]);
if (um.find(g) != um.end())
um[g] = min(um[g], elem.second + c[i]);
else
um.emplace(g, elem.second + c[i]);
}
}
cout << (um[1] ?: -1) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long const mod = pow(2, 32);
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return (((a % mod) * (b % mod)) % mod + mod) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long power(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long modInv(long long x) { return power(x, mod - 2, mod) % mod; }
long long ans = 0;
long long a, b, c, d;
void simpleSieve(long long limit, vector<long long> &prime, long long n) {
bool mark[limit + 1];
memset(mark, true, sizeof(mark));
for (long long p = 2; p * p < limit; p++) {
if (mark[p] == true) {
for (int i = p * 2; i < limit; i += p) mark[i] = false;
}
}
for (int p = 2; p < limit; p++) {
if (mark[p] == true) {
prime.push_back(p);
long long co = 0;
long long z = p;
while (z <= n) {
co = add(co, n / z);
z = z * p;
}
long long first = add(add(mul(a, mul(p, mul(p, p))), mul(b, mul(p, p))),
add(mul(c, p), d));
ans = add(ans, mul(first, co));
}
}
}
void segmentedSieve(long long n) {
long long limit = floor(sqrt(n)) + 1;
vector<long long> prime;
simpleSieve(limit, prime, n - 1);
long long low = limit;
long long high = 2 * limit;
while (low < n) {
if (high >= n) high = n;
bool mark[limit + 1];
memset(mark, true, sizeof(mark));
for (long long i = 0; i < prime.size(); i++) {
long long loLim = floor(low / prime[i]) * prime[i];
if (loLim < low) loLim += prime[i];
for (int j = loLim; j < high; j += prime[i]) mark[j - low] = false;
}
long long n2 = n - 1;
for (long long i = low; i < high; i++)
if (mark[i - low] == true) {
long long p = i;
long long co = 0;
long long z = p;
while (z <= n2) {
co = add(co, n2 / z);
z = z * p;
}
long long first = add(add(mul(a, mul(p, mul(p, p))), mul(b, mul(p, p))),
add(mul(c, p), d));
ans = add(ans, mul(first, co));
}
low = low + limit;
high = high + limit;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n >> a >> b >> c >> d;
segmentedSieve(n + 1);
cout << ans << endl;
return 0;
}
| 8 |
#include <cstdlib>
#include <cstdarg>
#include <cassert>
#include <cctype> // tolower
#include <ctime>
#include <cmath>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <stdexcept>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <vector>
#include <string>
#include <limits>
#include <utility>
#include <numeric>
#include <iterator>
#include <algorithm>
#include <functional>
/*
* g++ -g -std=c++11 -DBUG -D_GLIBCXX_DEBUG -Wall -Wfatal-errors -o cforce{,.cpp}
* g++ -g -DBUG -D_GLIBCXX_DEBUG -Wall -Wfatal-errors -o cforce{,.cpp}
*
* TODO:
* C++ dataframe
* stl11 -> c++11 standard template lib in c++98
* overload >> for map and set, using (insert) iterator
* chmod:: consider an algorithm stable to int64 overflow
* shortest path algorithm
* shortest path in a tree
* maximum network flow
* partial idx/iter sort
* a prime number generator which traverses prime numbers w/ ++
* a divisor generator which traverses divisors efficiently
* Apply1st ?!
* Apply2nd and bind2nd ?!
* count_if ( a.begin(), a.end(), a.second < x )
* Arbitrary-precision arithmetic / Big Integer / Fraction - rational num
* tuple class --> cplusplus.com/reference/tuple
* get<1>, get<2>, bind2nd ( foo ( get<2> pair ), val )
* isin( const T & val, first, last )
* fuinction composition in c++
* blogea.bureau14.fr/index.php/2012/11/function-composition-in-c11/
* cpp-next.com/archive/2010/11/expressive-c-fun-with-function-composition/
* TimeWrapper -- accumulate time of a function call
* stackoverflow.com/questions/879408
* hash map -- possible hash value & obj % some_big_prime [ b272 ]
* lower level can be a simple map to resolve hash collisions
* add explicit everywhere necessary
* bloom filters
* heap -> how to update values in place / increase-key or decrease-key ... IterHeap ?!
* median maintaince --> max_heap / min_heap
* prim's min spaning tree alg. O ( m log n ) using heap contianing V - X vertices
* kruskal algorithm minimum cost spanning tree with union find data structure
* unique_ptr
* hufman codes
* simple arithmatic tests
* longest common subsequence using seq. alignment type algorithm
* longest common substring ( consequative subsequeance )
* Graham scan; en.wikipedia.org/wiki/Graham_scan
*/
/*
* @recepies
* ----------------------------------------------
* odd / even
* transform ( x.begin(), x.end(), x.begin(), bind2nd( modulus<int>(), 2 ));
* count_if ( x.begin(), x.end(), bind2nd( modulus < int > (), 2));
* Apply2nd
* max_element ( m.begin(), m.end(), Apply2nd < string, int , less < int > > )
* sort ( a.begin(), a.end(), Apply2nd < char, int , greater< int > > )
* count_if ( m.begin(), m.end(), Apply2nd < string, int, modulus < int > > )
* accumulate ( m.begin(), m.end(), 0.0, Apply2nd < int, double, plus < double > > )
* accumulate ( m.begin( ), m.end( ), pair < int, double> ( 0 , 0.0 ) , operator+ < int, double > )
* abs_diff
* adjacent_difference ( a.begin(), a.end(), adj_diff.begin( ), abs_diff < int > ( ) )
* accumulate ( a.begin(), a.end(), 0, abs_diff < int > ( ) )
* erase
* a.erase ( remove_if ( a.begin( ), a.end( ), bind2nd ( less < int >( ), 0 ) ), a.end( ) )
* a.erase ( remove ( a.begin( ), a.end( ), b.begin( ), b.end( ) ), a.end ( ) )
* binding
* bind2nd ( mem_fun_ref (& ClassName::m_func ), arg ) // binds the argument of the object
* iterator generators
* generate_n ( back_inserter ( a ), n, rand ); // calls push_back
* generate_n ( inserter( a, a.begin( ) + 5 ), 10, RandInt( 0 , 100 ) ) // calls insert
* copy ( foo.begin( ), foo.end( ), insert_iterator < std::list < double > > ( bar, bar.begin( ) + 5 ))
* copy ( a.begin( ), a.end( ), ostream_iterator < double > ( cout, ", " ))
* accumulate ( m.begin( ), m.end( ), pair < int, double> ( 0 , 0.0 ) , operator+ < int, double > )
* transform (numbers.begin(), numbers.end(), lengths.begin(), mem_fun_ref(&string::length));
*/
/*
* @good read
* ----------------------------------------------
* [ partial ] template specialization
* cprogramming.com/tutorial/template_specialization.html
* function composition
* cpp-next.com/archive/2010/11/expressive-c-fun-with-function-composition
*/
/*
* @prob set
* ----------------------------------------------
* purification --> c330
*/
/*
* @limits
* ----------------------------------------------
* int 31 2.14e+09
* long int 31 2.14e+09
* unsigned 32 4.29e+09
* long unsigned 32 4.29e+09
* size_t 32 4.29e+09
* long long int 63 9.22e+18
* long long unsigned 64 1.84e+19
*/
/*
* issues
* ----------------------------------------------
* stackoverflow.com/questions/10281809
* mem_fun -> func_obj ( pointer to instance, origanal argument )
* bind1st ( mem_fun ( & ClassName::m_func ), this ) // binds obj of the class
* bind1st takes 'const T &' as the first argument
*/
/*
* typedef / define
* ----------------------------------------------
*/
typedef long long int int64;
typedef unsigned long long int uint64;
#define DOUBLE_INF std::numeric_limits< double >::infinity()
#define DOUBLE_NAN std::numeric_limits< double >::quiet_NaN()
#define DECLARE( X ) \
typedef shared_ptr < X > X ## _shared_ptr; \
typedef const shared_ptr < X > X ## _const_shared_ptr;
#ifdef BUG
#define DEBUG(var) { std::cout << #var << ": " << (var) << std::endl; }
#define EXPECT(expr) if ( ! (expr) ) std::cerr << "Assertion " \
<< #expr " failed at " << __FILE__ << ":" << __LINE__ << std::endl;
#else
#define DEBUG(var)
#define EXPECT(expr)
#endif
#define DBG(v) std::copy( v.begin(), v.end(), std::ostream_iterator < typeof( *v.begin() )> ( std::cout, " " ) )
/*
* http://rootdirectory.de/wiki/SSTR()
* usage:
* SSTR( "x^2: " << x*x )
*/
#define SSTR( val ) dynamic_cast< std::ostringstream & >( std::ostringstream() << std::dec << val ).str()
/* https://www.quora.com/C++-programming-language/What-are-some-cool-C++-tricks */
// template <typename T, size_t N>
// char (&ArraySizeHelper(T (&array)[N]))[N];
// #define arraysize(array) (sizeof(ArraySizeHelper(array)))
/*
* forward decleration
* ----------------------------------------------
*/
class ScopeTimer;
/*
* functional utils
* ----------------------------------------------
*/
template < typename T >
struct abs_diff : std::binary_function < T, T, T >
{
typedef T value_type;
inline value_type operator( ) ( const value_type & x, const value_type & y ) const
{
return std::abs( x - y );
}
};
// template < class InputIterator, class T >
// class isin : public std::binary_function < InputIterator, InputIterator, bool >
// {
// public:
// typedef T value_type;
//
// isin ( const InputIterator & first, const InputIterator & last ):
// m_first ( first ), m_last ( last ) { }
//
// bool operator ( ) ( const value_type & val ) const
// {
// return std::find ( m_first, m_last, val ) != m_last;
// }
// private:
// const InputIterator m_first, m_last;
// }
template < typename value_type, typename cont_type >
class isin : public std::unary_function < value_type, bool >
{
public:
isin( const cont_type & vals ): m_vals ( vals ) { };
bool operator ( ) ( const value_type & x ) const
{
return std::find ( m_vals.begin( ), m_vals.end( ), x ) != m_vals.end( );
}
private:
const cont_type m_vals;
};
/*
* max_element, min_element, count_if ... on the 2nd element
* eg: max_element ( m.begin(), m.end(), Apply2nd < string, int , less < int > > )
*/
template < class T1, class T2, class BinaryOperation >
class Apply2nd : std::binary_function < typename std::pair < T1, T2 >,
typename std::pair < T1, T2 >,
typename BinaryOperation::result_type >
{
public:
typedef T1 first_type;
typedef T2 second_type;
typedef typename BinaryOperation::result_type result_type;
typedef typename std::pair < first_type, second_type > value_type;
inline result_type operator( ) ( const value_type & x, const value_type & y ) const
{
return binary_op ( x.second , y.second );
}
private:
BinaryOperation binary_op;
};
/*
* algo utils
* ----------------------------------------------
*/
/**
* count the number of inversions in a permutation; i.e. how many
* times two adjacent elements need to be swaped to sort the list;
* 3 5 2 4 1 --> 7
*/
template < class InputIterator >
typename std::iterator_traits<InputIterator>::difference_type
count_inv ( InputIterator first, InputIterator last )
{
typedef typename std::iterator_traits<InputIterator>::difference_type difference_type;
typedef typename std::iterator_traits<InputIterator>::value_type value_type;
std::list < value_type > l; /* list of sorted values */
difference_type cnt = 0;
for ( difference_type n = 0; first != last; ++first, ++n )
{
/* count how many elements larger than *first appear before *first */
typename std::list < value_type >::iterator iter = l.begin( );
cnt += n;
for ( ; iter != l.end( ) && * iter <= * first; ++ iter, -- cnt )
;
l.insert( iter, * first );
}
return cnt;
}
template < class ForwardIterator, class T >
inline void fill_inc_seq ( ForwardIterator first, ForwardIterator last, T val )
{
for ( ; first != last; ++first, ++val )
* first = val;
}
template <class ForwardIterator, class InputIterator >
ForwardIterator remove ( ForwardIterator first, ForwardIterator last, InputIterator begin, InputIterator end )
{
ForwardIterator result = first;
for ( ; first != last; ++ first )
if ( find ( begin, end, *first ) == end )
{
*result = *first;
++result;
}
return result;
}
/* stackoverflow.com/questions/1577475 */
template < class RAIter, class Compare >
class ArgSortComp
{
public:
ArgSortComp ( const RAIter & first, Compare comp ): m_first ( first ), m_comp( comp ) { }
inline bool operator() ( const size_t & i, const size_t & j ) const
{
return m_comp ( m_first[ i ] , m_first[ j ] );
}
private:
const RAIter & m_first;
const Compare m_comp;
};
/*!
* usage:
* vector < size_t > idx;
* argsort ( a.begin( ), a.end( ), idx, less < Type > ( ) );
*/
template < class RAIter, class Compare >
void argsort ( const RAIter & first, const RAIter & last, std::vector < size_t > & idx, Compare comp )
{
const size_t n = last - first;
idx.resize ( n );
for ( size_t j = 0; j < n; ++ j )
idx[ j ] = j ;
std::sort ( idx.begin( ), idx.end( ), ArgSortComp< RAIter, Compare > ( first, comp ) );
}
template < class RAIter, class Compare >
class IterSortComp
{
public:
IterSortComp ( Compare comp ): m_comp ( comp ) { }
inline bool operator( ) ( const RAIter & i, const RAIter & j ) const
{
return m_comp ( * i, * j );
}
private:
const Compare m_comp;
};
/*!
* usage:
* vector < list < Type >::const_iterator > idx;
* itersort ( a.begin( ), a.end( ), idx, less < Type > ( ) );
*/
template <class INIter, class RAIter, class Compare>
void itersort ( INIter first, INIter last, std::vector < RAIter > & idx, Compare comp )
{
/* alternatively: stackoverflow.com/questions/4307271 */
idx.resize ( std::distance ( first, last ) );
for ( typename std::vector < RAIter >::iterator j = idx.begin( ); first != last; ++ j, ++ first )
* j = first;
std::sort ( idx.begin( ), idx.end( ), IterSortComp< RAIter, Compare > (comp ) );
}
/*
* string utils
* ----------------------------------------------
*/
inline void erase ( std::string & str, const char & ch )
{
std::binder2nd < std::equal_to < char > > isch ( std::equal_to < char > ( ), ch );
std::string::iterator iter = std::remove_if ( str.begin(), str.end(), isch );
str.erase ( iter, str.end() );
}
inline void erase ( std::string & str, const std::string & chrs )
{
isin < char, std::string > isin_chrs ( chrs );
std::string::iterator iter = std::remove_if ( str.begin(), str.end(), isin_chrs );
str.erase ( iter, str.end() );
}
template < typename value_type>
inline std::string val2str ( const value_type & x )
{
std::ostringstream sout ( std::ios_base::out );
sout << x;
return sout.str();
}
template < typename value_type>
inline value_type str2val ( const std::string & str )
{
std::istringstream iss ( str, std::ios_base::in );
value_type val;
iss >> val;
return val;
}
std::vector< std::string > tokenize ( const std::string & str, const char & sep )
{
/*!
* outputs empty tokens and assumes str does not start with sep
* corner cases:
* empty string, one char string,
* string starting/ending with sep, all sep, end with two sep
*/
std::vector < std::string > res;
std::string::const_iterator follow = str.begin( ),
lead = str.begin( );
while ( true )
{
while ( lead != str.end() && * lead != sep )
++ lead;
res.push_back ( std::string( follow, lead ) );
if ( lead != str.end ( ) )
follow = 1 + lead ++ ;
else
break;
}
return res;
}
/*!
* chunk a string into strings of size [ at most ] k
*/
void chunk ( const std::string::const_iterator first,
const std::string::const_iterator last,
const size_t k,
const bool right_to_left,
std::list < std::string > & str_list )
{
str_list.clear( );
if ( right_to_left )
/* chunk from the end of the string */
for ( std::string::const_iterator i, j = last; j != first; j = i )
{
i = first + k < j ? j - k : first;
str_list.push_back ( std::string ( i, j ) );
}
else
/* chunk from the begining of the string */
for ( std::string::const_iterator i = first, j; i != last; i = j )
{
j = i + k < last ? i + k : last;
str_list.push_back ( std::string ( i, j ) );
}
}
/*!
* next lexicographically smallest string
* within char set a..z
*/
std::string & operator++( std::string & s )
{
/* find the first char from right less than 'z' */
std::string::reverse_iterator j = find_if( s.rbegin( ), s.rend( ),
std::bind2nd( std::less < char > ( ), 'z' ));
if ( j != s.rend( ))
{
++ *j;
std::fill( s.rbegin( ), j, 'a' );
}
else
s.assign( s.length( ) + 1, 'a' );
return s;
}
/*!
* getline ( cin, str )
* requires ctrl-D
* cin >> str; does not pass after space char
*/
/*
* number utils
* ----------------------------------------------
*/
class BigInteger
{
#if ULONG_MAX <= 1 << 32
typedef long long unsigned val_type;
#else
typedef long unsigned val_type;
#endif
const static int WSIZE = 32;
const static val_type BASE = 1LL << WSIZE;
public:
private:
std::list < val_type > val; /* val[ 0 ] is most significant */
bool pos; /* true if sign is positive */
};
/**
* greatest common divisor - Euclid's alg.
*/
template < typename value_type > inline
value_type gcd ( value_type a, value_type b )
{
return ! b ? a : gcd( b, a % b );
// if ( a < 0 ) a = -a ;
// if ( b < 0 ) b = -b ;
// if ( a < b ) std::swap ( a, b );
/* corner case: one of the values is zero */
// if ( ! b ) return a;
// for ( value_type r = a % b; r ; r = a % b )
// {
// a = b;
// b = r;
// }
// return b;
}
/**
* prime factorization
*/
template < class T >
void prime_factors( T n, std::map < T, size_t > & fac )
{
for ( T k = 2; n > 1; ++ k )
if ( ! ( n % k ) )
{
size_t & ref = fac[ k ];
while ( ! ( n % k ) )
{
++ ref;
n /= k;
}
}
}
/* abs diff - safe for unsigned types */
template < class T >
inline T absdiff( T a, T b )
{
return a < b ? b - a : a - b;
}
namespace
{
template < class T >
std::pair < T, T > __extgcd ( const T & x0, const T & y0,
const T & x1, const T & y1,
const T & r0, const T & r1 )
{
const T q = r0 / r1;
const T r2 = r0 % r1;
if ( ! ( r1 % r2 ) )
return std::make_pair < T, T > ( x0 - q * x1, y0 - q * y1 );
const T x2 = x0 - q * x1;
const T y2 = y0 - q * y1;
return __extgcd ( x1, y1, x2, y2, r1, r2 );
}
}
/**
* extended euclidean algorithm: a x + b y = gcd( a, b)
* en.wikipedia.org/wiki/Extended_Euclidean_algorithm
*/
template < class value_type > inline
std::pair < value_type, value_type > extgcd ( value_type a, value_type b )
{
return a % b
? __extgcd < value_type > ( 1, 0, 0, 1, a, b )
: std::make_pair < value_type, value_type > ( 0, 1 );
}
/**
* modular multiplicative inverse
* en.wikipedia.org/wiki/Modular_multiplicative_inverse
*/
template < class value_type > inline
value_type modinv ( value_type a, value_type m )
{
const std::pair < value_type, value_type > coef ( extgcd( a, m ) );
/* a needs to be coprime to the modulus, or the inverse won't exist */
if ( a * coef.first + m * coef.second != 1 )
throw std::runtime_error ( val2str( a ) + " is not coprime to " + val2str( m ));
/* return a pos num between 1 & m-1 */
return ( m + coef.first % m ) % m;
}
inline bool isnan ( const double & a )
{
return ! ( a == a );
}
template < typename value_type >
inline value_type mini ( int n, ... )
{
va_list vl;
va_start (vl, n);
value_type res = va_arg ( vl, value_type );
for ( int i = 1; i < n; ++i ) {
const value_type val = va_arg ( vl, value_type );
res = std::min ( res, val );
}
va_end( vl );
return res;
}
template < typename value_type >
inline value_type maxi ( int n, ... )
{
va_list vl;
va_start (vl, n);
value_type res = va_arg ( vl, value_type );
for ( int i = 1; i < n; ++i ) {
const value_type val = va_arg ( vl, value_type );
res = std::max ( res, val );
}
va_end( vl );
return res;
}
// XXX look this up how is this implemented
template < class T >
inline int sign ( const T & x )
{
if ( x == T() )
return 0;
else if ( x < T() )
return -1;
else
return 1;
}
/*
* change moduluos from n to m
*/
std::string chmod ( std::string num, const unsigned n, const unsigned m )
{
const char * digit = "0123456789abcdefghijklmnopqrstuvwxyz";
std::transform ( num.begin(), num.end(), num.begin(), tolower );
isin < char, std::string > is_alpha_num ( digit );
assert ( find_if ( num.begin( ), num.end( ), std::not1 ( is_alpha_num ) ) == num.end( ));
unsigned long long int val ( 0 );
if ( n == 10U )
{
std::istringstream iss ( num, std::ios_base::in );
iss >> val;
}
else
for ( std::string::const_iterator iter = num.begin( ); iter != num.end( ); ++ iter )
val = val * n + ( 'a' <= *iter ? *iter - 'a' + 10U : *iter - '0');
if ( m == 10U )
{
std::ostringstream sout ( std::ios_base::out );
sout << val;
return sout.str ( );
}
else
{
std::string res;
for ( ; val ; val /= m )
res.push_back( digit [ val % m ] );
return res.length( ) ? std::string( res.rbegin( ), res.rend( )) : "0";
}
}
template < class value_type > /* a^n mod m */
value_type powmod ( value_type a, const value_type & n, const value_type & m )
{
if ( a == 1 || ! n )
return m != 1 ? 1 : 0;
value_type res = 1;
for ( value_type k = 1; k <= n; a = a * a % m, k = k << 1 )
if ( k & n )
res = ( res * a ) % m;
return res;
}
/*
* Fermat pseudoprime test
* www.math.umbc.edu/~campbell/Computers/Python/numbthy.py
* NOTE: since return type is bool, and powmod may break for ints,
* the argument is always casted to long long
*/
inline bool is_pseudo_prime ( const long long & a )
{
/* all the primes less than 1000 ( 168 primes )*/
const long long p [ ] = { 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,
79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,
163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,
241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,
337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,
431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,
521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,
617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,
719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,
823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,
929,937,941,947,953,967,971,977,983,991,997 };
const size_t n = sizeof( p ) / sizeof ( p[ 0 ] );
if ( a < p[ n - 1 ] + 1)
return std::binary_search ( p, p + n , a );
if ( std::find_if ( p, p + n, std::not1 ( std::bind1st ( std::modulus< long long >( ), a ))) != p + n )
return false;
const size_t k = a < 9006401LL ? 3 :
a < 10403641LL ? 4 :
a < 42702661LL ? 5 :
a < 1112103541LL ? 6 : 7;
for ( size_t j = 0; j < k; ++ j )
if ( powmod ( p[ j ], a - 1, a ) != 1 )
return false;
return true;
}
/*
* returns a sorted vector of all primes less than or equal to n
* maximum adj diff of all primes less than 1e5 is 72 ( 114 for 1e6 )
*/
template < typename value_type >
std::vector < value_type > get_primes ( const value_type n )
{
#ifdef BUG
ScopeTimer scope_timer ( "std::vector < value_type > get_primes ( const value_type n )" );
#endif
typedef typename std::vector < value_type >::iterator iterator;
std::vector < value_type > primes;
for ( value_type k = 2 ; k <= n; ++ k )
if ( is_pseudo_prime ( k ) )
{
const value_type sqrt_k = 1 + static_cast < value_type > ( sqrt ( k + 1 ) );
iterator iend = upper_bound ( primes.begin( ), primes.end( ), sqrt_k );
if ( find_if ( primes.begin( ), iend, std::not1 ( std::bind1st ( std::modulus< value_type >( ), k ) ) ) != iend )
continue;
primes.push_back ( k );
}
return primes;
}
template < class T >
inline std::list < std::pair < T, size_t > > get_prime_fact ( T a )
{
std::list < std::pair < T, size_t > > fac;
for ( T k = 2; a > 1; ++ k )
if ( ! ( a % k ) ) // no need to check if k is prime
{
size_t m = 0;
for ( ; ! ( a % k ) ; ++m, a/= k )
;
fac.push_back ( std::pair < T, size_t > ( k, m ) );
}
return fac;
}
template < class T >
T n_choose_k ( T n, T k )
{
if ( k > n )
return 0;
const T lb = std::min ( k, n - k ) + 1;
const T ub = n - lb + 1;
T res = 1, j = 2;
while ( n > ub && j < lb)
{
res *= n--;
while ( j < lb and ! (res % j) )
res /= j++;
}
while ( n > ub )
res *= n--;
return res;
}
/**
* median calculator, using two heaps
*/
template < class InputIter >
inline std::pair < typename InputIter::value_type, typename InputIter::value_type >
median ( InputIter first, InputIter last )
{
typedef typename InputIter::value_type value_type;
typedef std::pair< value_type, value_type > result_type;
/*
* max_heap:
* - the lower half of the elements
* - the biggest of such elements is on the top
*/
std::vector < value_type > max_heap, min_heap;
/*
* comp argument to heap algorithm should provide
* 'strict weak ordering'; in particular
* std::not2 ( std::less < value_type > )
* does not have such a strict weak ordering;
*/
std::less < value_type > max_heap_comp;
std::greater < value_type > min_heap_comp;
if ( first == last ) /* corner case: empty vector */
throw std::runtime_error ( "median of an empty vector is undefined!" );
InputIter iter = first;
max_heap.push_back ( * iter );
for ( ++iter ; iter != last; ++ iter )
if ( * iter < max_heap.front() )
{
max_heap.push_back ( * iter );
std::push_heap ( max_heap.begin(), max_heap.end(), max_heap_comp );
if ( min_heap.size() + 1 < max_heap.size() )
{
/* max_heap has got too large */
min_heap.push_back( max_heap.front() );
std::push_heap( min_heap.begin(), min_heap.end(), min_heap_comp );
std::pop_heap( max_heap.begin(), max_heap.end(), max_heap_comp );
max_heap.pop_back();
}
}
else
{
min_heap.push_back ( * iter );
std::push_heap ( min_heap.begin(), min_heap.end(), min_heap_comp );
if ( max_heap.size() + 1 < min_heap.size() )
{
/* min_heap has got too large */
max_heap.push_back( min_heap.front() );
std::push_heap( max_heap.begin(), max_heap.end(), max_heap_comp );
std::pop_heap( min_heap.begin(), min_heap.end(), min_heap_comp );
min_heap.pop_back();
}
}
DEBUG( max_heap );
DEBUG( min_heap );
return min_heap.empty( ) /* corner case: ++first = last */
? result_type ( *first, *first )
: result_type ( max_heap.size() < min_heap.size() ? min_heap.front() : max_heap.front(),
min_heap.size() < max_heap.size() ? max_heap.front() : min_heap.front() );
}
/*
* geometry util
* ----------------------------------------------
*/
struct xyPoint
{
double x, y;
xyPoint ( const double & a = .0, const double & b = .0 ): x ( a ), y( b ) { };
};
struct xyCircle
{
xyPoint center;
double radius;
};
std::ostream & operator<< ( std::ostream & out, const xyPoint & p )
{
out << '(' << p.x << ", " << p.y << ')';
return out;
}
std::istream & operator>> ( std::istream & ist, xyPoint & p )
{
ist >> p.x >> p.y;
return ist;
}
std::ostream & operator<< ( std::ostream & out, const xyCircle & o )
{
out << "{(" << o.center.x << ", " << o.center.y << ") " << o.radius << '}';
return out;
}
std::istream & operator>> ( std::istream & ist, xyCircle & o )
{
ist >> o.center.x >> o.center.y >> o.radius;
return ist;
}
inline double cartesian_dist ( const xyPoint & a, const xyPoint & b )
{
const double d = a.x - b.x;
const double e = a.y - b.y;
return std::sqrt ( d * d + e * e );
}
class xyLine
{
public:
xyLine ( const xyPoint & , const xyPoint & );
xyLine ( const double slope, const double intercept );
/*
* 'signed' orthogonal distance; the sign is useful
* to compare which side of the line the point is
*/
inline double orth_dist ( const xyPoint & ) const;
private:
double m_slope;
double m_intercept;
double m_normfac; /* normalization factor for orth_dist calc */
bool m_vertical; /* if the line is verticcal */
double m_xcross; /* x axis cross point for vertical line */
};
xyLine::xyLine ( const xyPoint & a, const xyPoint & b )
{
if ( a.x == b.x ) /* vertical line */
{
m_vertical = true;
m_xcross = a.x;
m_intercept = DOUBLE_NAN;
m_slope = DOUBLE_INF;
m_normfac = DOUBLE_NAN;
}
else
{
m_vertical = false;
m_xcross = DOUBLE_NAN;
m_slope = ( b.y - a.y ) / ( b.x - a.x );
m_intercept = a.y - m_slope * a.x;
m_normfac = std::sqrt ( m_slope * m_slope + 1.0 );
}
}
xyLine::xyLine ( const double slope, const double intercept ):
m_slope ( slope ), m_intercept ( intercept )
{
m_vertical = false;
m_xcross = DOUBLE_NAN;
m_normfac = std::sqrt ( m_slope * m_slope + 1.0 );
}
double xyLine::orth_dist ( const xyPoint & o ) const /* 'signed' orthogonal distance */
{
if ( m_vertical )
return o.x - m_xcross;
else
return ( m_slope * o.x - o.y + m_intercept ) / m_normfac;
}
inline double triangle_area ( const xyPoint & a, const xyPoint & b, const xyPoint & c )
{
const xyLine l ( a, b );
const double h = std::abs ( l.orth_dist ( c ) );
const double e = cartesian_dist ( a, b );
return h * e;
}
/*
* operator<< overrides
* ----------------------------------------------
*/
namespace
{
/* helper function to output containers */
template < typename T >
std::ostream & __output ( std::ostream & out, const T & a )
{
typedef typename T::const_iterator const_iterator;
out << "{ ";
// does not work for 'pair' value type
// std::copy ( a.begin( ), a.end( ), std::ostream_iterator < typename T::value_type > ( std::cout, ", " ));
for ( const_iterator iter = a.begin(); iter != a.end(); ++ iter )
out << ( iter != a.begin( ) ? ", " : "" ) << *iter ;
return out << " }";
}
}
template < typename key_type, typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::pair < key_type, value_type > & p)
{
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template < typename key_type, typename value_type, typename comp >
std::ostream & operator<< ( std::ostream & out, const std::map < key_type, value_type, comp > & m )
{
return __output ( out, m );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::set < value_type > & s )
{
return __output ( out, s );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::vector < value_type > & a )
{
return __output ( out, a );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::list < value_type > & a )
{
return __output ( out, a );
}
template < typename value_type >
std::ostream & operator<< ( std::ostream & out, const std::vector < std::vector < value_type > > & a )
{
typedef typename std::vector < std::vector < value_type > >::const_iterator const_iterator;
for ( const_iterator iter = a.begin( ); iter != a.end( ); ++ iter )
out << '\n' << *iter ;
return out;
}
/*
* operator>> overrides
* ----------------------------------------------
*/
template < typename key_type, typename value_type >
std::istream & operator>> ( std::istream & in, std::pair < key_type, value_type > & p)
{
in >> p.first >> p.second;
return in;
}
template < typename value_type >
std::istream & operator>> ( std::istream & in, std::vector < value_type > & a )
{
typedef typename std::vector < value_type >::iterator iterator;
if ( ! a.size( ) )
{
size_t n;
in >> n;
a.resize( n );
}
for ( iterator iter = a.begin(); iter != a.end(); ++ iter )
in >> * iter;
return in;
}
/*
* readin quick utilities
* ----------------------------------------------
*/
// template < typename value_type >
// inline void readin ( std::vector < value_type > & a, size_t n = 0, std::istream & in = std::cin )
// {
// // if ( ! n ) std::cin >> n;
// if ( ! n ) in >> n ;
// a.resize ( n );
// // std::cin >> a;
// in >> a;
// }
// XXX consider removing
// template < typename key_type, typename value_type >
// inline void readin (std::vector < std::pair < key_type , value_type > > & a, size_t n = 0 )
// {
// if ( !n ) std::cin >> n;
// a.resize( n );
// std::cin >> a;
// }
/*
* pair utility
* ----------------------------------------------
*/
/*
* accumulate ( m.begin( ), m.end( ), pair < int, double> ( 0 , 0.0 ) , operator+ < int, double > );
* stackoverflow.com/questions/18640152
*/
template < typename T1, typename T2 >
inline std::pair < T1, T2 > operator+ ( const std::pair < T1, T2 > & a, const std::pair < T1, T2 > & b )
{
return std::make_pair < T1, T2 > ( a.first + b.first, a.second + b.second );
}
template < typename T1, typename T2 >
inline std::pair < T1, T2 > operator- ( const std::pair < T1, T2 > & a, const std::pair < T1, T2 > & b )
{
return std::make_pair < T1, T2 > ( a.first - b.first, a.second - b.second );
}
// template < class T1, class T2, class BinaryOperation >
// class Apply2nd : std::binary_function < typename std::pair < T1, T2 >,
// typename std::pair < T1, T2 >,
// typename BinaryOperation::result_type >
namespace
{
/*!
* helper template to do the work
*/
template < size_t J, class T1, class T2 >
struct Get;
template < class T1, class T2 >
struct Get < 0, T1, T2 >
{
typedef typename std::pair < T1, T2 >::first_type result_type;
static result_type & elm ( std::pair < T1, T2 > & pr ) { return pr.first; }
static const result_type & elm ( const std::pair < T1, T2 > & pr ) { return pr.first; }
};
template < class T1, class T2 >
struct Get < 1, T1, T2 >
{
typedef typename std::pair < T1, T2 >::second_type result_type;
static result_type & elm ( std::pair < T1, T2 > & pr ) { return pr.second; }
static const result_type & elm ( const std::pair < T1, T2 > & pr ) { return pr.second; }
};
}
template < size_t J, class T1, class T2 >
typename Get< J, T1, T2 >::result_type & get ( std::pair< T1, T2 > & pr )
{
return Get < J, T1, T2 >::elm( pr );
}
template < size_t J, class T1, class T2 >
const typename Get< J, T1, T2 >::result_type & get ( const std::pair< T1, T2 > & pr )
{
return Get < J, T1, T2 >::elm( pr );
}
/*
* graph utils
* ----------------------------------------------
*/
/*
* Dijkstra :: single-source shortest path problem for
* a graph with non-negative edge path costs, producing
* a shortest path tree
* en.wikipedia.org/wiki/Dijkstra's_algorithm
*/
template < typename DistType >
void Dijekstra ( const size_t & source,
const std::vector < std::list < size_t > > & adj, // adjacency list
const std::vector < std::vector < DistType > > & edge_len, // pair-wise distance for adjacent nodes
std::vector < DistType > & dist, // distance from the source
std::vector < size_t > prev ) // previous node in the shortest path tree
{
// TODO
}
// TODO http://en.wikipedia.org/wiki/Shortest_path_problem
// TODO Graph class, Weighted graph, ...
/*
* maximum cardinality matching in a bipartite graph
* G = G1 ∪ G2 ∪ {NIL}
* where G1 and G2 are partition of graph and NIL is a special null vertex
* https://en.wikipedia.org/wiki/Hopcroft-Karp_algorithm
*/
class HopcroftKarp
{
public:
HopcroftKarp ( const std::vector < std::list < size_t > > & adj,
const std::vector < bool > & tag );
size_t get_npair ( ) { return npair; };
std::map < size_t, size_t > get_map ( );
private:
bool mf_breadth_first_search ( ); // breadth first search from unpaired nodes in G1
bool mf_depth_first_search ( const size_t v ); // dfs w/ toggeling augmenting paths
const std::vector < std::list < size_t > > & m_adj; // adjacency list for each node
const std::vector < bool > & m_tag; // binary tag distinguishing partitions
size_t npair;
const size_t NIL; // special null vertex
const size_t INF; // practically infinity distance
std::vector < size_t > m_g1; // set of nodes with tag = true
std::vector < size_t > m_dist; // dist from unpaired vertices in G1
std::vector < size_t > m_pair;
};
std::map < size_t, size_t > HopcroftKarp::get_map ( )
{
std::map < size_t, size_t > m;
for ( size_t j = 0; j < m_pair.size( ); ++ j )
if ( m_pair[ j ] != NIL && m_tag[ j ])
m[ j ] = m_pair[ j ];
return m;
}
HopcroftKarp::HopcroftKarp ( const std::vector < std::list < size_t > > & adj,
const std::vector < bool > & tag ):
m_adj ( adj ),
m_tag ( tag ),
npair ( 0 ),
NIL ( adj.size( )),
INF ( adj.size( ) + 1 ),
m_dist ( std::vector < size_t > ( adj.size( ) + 1, INF)),
m_pair ( std::vector < size_t > ( adj.size( ), NIL )) // initially everything is paired with nil
{
assert ( m_adj.size() == m_tag.size() );
for ( size_t j = 0; j < tag.size( ); ++ j )
if ( tag[ j ] )
m_g1.push_back ( j );
while ( mf_breadth_first_search ( ) )
for ( std::vector < size_t >::const_iterator v = m_g1.begin( ); v != m_g1.end( ); ++ v )
if ( m_pair[ *v ] == NIL && mf_depth_first_search ( *v ) )
++ npair;
}
bool HopcroftKarp::mf_breadth_first_search( )
{
/* only nodes from g1 are queued */
std::queue < size_t > bfs_queue;
/* initialize queue with all unpaired nodes from g1 */
for ( std::vector < size_t >::const_iterator v = m_g1.begin( ); v != m_g1.end( ); ++v )
if ( m_pair[ *v ] == NIL )
{
m_dist[ *v ] = 0;
bfs_queue.push ( *v );
}
else
m_dist[ *v ] = INF;
m_dist[ NIL ] = INF;
/* find all the shortest augmenting paths to node nil */
while ( ! bfs_queue.empty() )
{
const size_t v = bfs_queue.front( );
bfs_queue.pop ( );
if ( m_dist[ v ] < m_dist[ NIL ] )
for ( std::list < size_t >::const_iterator u = m_adj[ v ].begin( ); u != m_adj[ v ].end( ); ++ u )
if ( m_dist[ m_pair[ * u ] ] == INF )
{
m_dist[ m_pair[ * u ] ] = m_dist[ v ] + 1;
bfs_queue.push ( m_pair[ * u ] );
}
}
return m_dist[ NIL ] != INF;
}
bool HopcroftKarp::mf_depth_first_search( const size_t v )
{
if ( v == NIL )
return true;
else
{
for ( std::list < size_t >::const_iterator u = m_adj[ v ].begin( ); u != m_adj[ v ].end( ); ++ u )
if ( m_dist[ m_pair[ *u ] ] == m_dist[ v ] + 1 && mf_depth_first_search( m_pair[ *u ] ))
{
/*
* there is an augmenting path to nil from m_pair[ *u ]
* and hence there is an augmenting path from v to u and
* u to to nil; therefore v and u can be paired together
*/
m_pair [ *u ] = v;
m_pair [ v ] = *u;
return true;
}
m_dist[ v ] = INF;
return false;
}
}
/*
* data-structure utility
* ----------------------------------------------
*/
template < class T, class Comp = std::less< T > >
class Heap /* less< T > --> max-heap */
{
typedef T value_type;
typedef typename std::vector < value_type >::size_type size_type;
public:
/*
* stackoverflow.com/questions/10387751
* possible work-around: a memebr pointer to m_val
*
* TODO: static/friend heapify ( val, & heap ) XXX O( n ) ?!
*/
Heap ( ): m_val ( std::vector < value_type > ( ) ) , m_comp ( Comp( ) ){ }
template < class InputIter >
Heap ( InputIter first, InputIter last ):
m_val ( std::vector < value_type > ( ) ) , m_comp( Comp( ) )
{
for ( ; first != last ; ++ first )
m_val.push_back ( * first );
std::make_heap( m_val.begin( ), m_val.end( ), m_comp );
}
/*!
* to avoid destroying heap property, front( )
* should always return a 'const' reference
*/
inline const value_type & front( ) const { return m_val.front( ); }
inline bool empty( ) const { return m_val.empty( ); }
inline size_type size( ) const { return m_val.size( ); }
inline void push ( const value_type & a )
{
m_val.push_back( a );
std::push_heap( m_val.begin( ), m_val.end( ), m_comp );
}
inline void pop( )
{
std::pop_heap ( m_val.begin( ), m_val.end( ), m_comp );
m_val.pop_back( );
}
// inline void swap( Heap< T, Comp> & other ) { m_val.swap( other.m_val ) };
// void sort( ) { std::sort_heap ( m_val.begin( ), m_val.end( ), m_comp ); }
// template < class X, class Y >
// friend std::ostream & operator<<( std::ostream & out, const Heap < X, Y> & heap );
private:
std::vector < value_type > m_val;
const Comp m_comp;
};
/*
* boost.org/doc/libs/1_54_0/libs/smart_ptr/shared_ptr.htm
*/
template < class Type >
class shared_ptr
{
typedef Type value_type;
public:
explicit shared_ptr ( value_type * p = NULL ) : ptr ( p ), count ( new size_t ( 1U ) ) { }
shared_ptr ( const shared_ptr < value_type > & sp ): ptr ( sp.ptr ), count ( sp.count ) { ++ * count; }
~ shared_ptr ( ) { release( ); }
bool operator== ( const shared_ptr < value_type > & sp ) { return ptr == sp.ptr; }
bool operator!= ( const shared_ptr < value_type > & sp ) { return ptr != sp.ptr; }
shared_ptr < value_type > & operator= ( const shared_ptr < value_type > & sp )
{
if ( this != & sp && ptr != sp.ptr )
{
release( );
ptr = sp.ptr;
count = sp.count;
++ * count;
}
return * this;
}
value_type * operator-> ( ) { return ptr ; }
value_type & operator* ( ) { return *ptr ; }
const value_type * operator-> ( ) const { return ptr ; }
const value_type & operator* ( ) const { return *ptr; }
void swap ( shared_ptr < value_type > & sp )
{
if ( this != &sp && ptr != sp.ptr )
{
std::swap ( ptr, sp.ptr );
std::swap ( count, sp.count );
}
}
private:
void release ( )
{
/* stackoverflow.com/questions/615355 */
-- * count;
if ( ! * count )
{
delete count;
delete ptr;
count = NULL;
ptr = NULL;
}
}
value_type * ptr;
size_t * count;
};
/*!
* union find data structure with
* - lazy unions
* - union by rank
* - path compression
*/
class UnionFind
{
public:
UnionFind( const size_t n ):
parent ( std::vector < size_t > ( n ) ), /* initialize each node as its own */
rank ( std::vector < size_t > ( n, 0 )) /* parent and set all the ranks to 0 */
{
for ( size_t j = 0; j < n; ++ j )
parent[ j ] = j ;
}
inline size_t find( const size_t s )
{
/*
* perform path compresion and add shortcut
* if parent[ s ] is not a root node
*/
const size_t p = parent[ s ];
return parent[ p ] == p ? p : parent[ s ] = find( p ) ;
}
inline void lazy_union ( size_t i, size_t j )
{
/* unions should be done on root nodes */
i = find( i );
j = find( j );
if ( i != j )
{
if ( rank [ i ] < rank[ j ] )
parent[ i ] = j;
else
{
parent[ j ] = i;
rank[ i ] += rank[ i ] == rank[ j ];
}
}
}
private:
std::vector < size_t > parent;
std::vector < size_t > rank;
};
// TODO XXX
// template < class NumType >
// unsigned num_hash_func ( const NumType & a )
// {
// // XXX what will happen in case of overflow?
// return static_cast < unsigned > ( a % 9973 ) % 9973 ;
// }
/*
* XXX: HashMap: map< Key, T > data [ 9973 ]
* data [ num_hash_func ( key ) ][ key ]
*/
/*
* testing util
* ----------------------------------------------
*/
// TODO add a preprocessor which automatically includes the funciton name, or __line__
// and disables if not in debug mode
/* prints the life length of the object when it goes out of scope */
class ScopeTimer
{
public:
ScopeTimer ( const std::string & msg = "" ): tic ( clock ( )), m_msg( msg ) { };
~ ScopeTimer ( )
{
const clock_t toc = clock();
const uint64 dt = 1000L * ( toc - tic ) / CLOCKS_PER_SEC;
const uint64 mil = dt % 1000L;
const uint64 sec = ( dt / 1000L ) % 60L;
const uint64 min = ( dt / 60000L ) % 60L;
const uint64 hrs = ( dt / 3600000L );
std::cout << '\n' << m_msg << "\n\telapsed time: ";
if ( hrs ) std::cout << hrs << " hrs, ";
if ( min ) std::cout << min << " min, ";
if ( sec ) std::cout << sec << " sec, ";
std::cout << mil << " mil-sec\n";
}
private:
typedef unsigned long long int uint64;
const clock_t tic;
const std::string m_msg;
};
class RandInt
{
public:
RandInt ( int a = 0, int b = 100 ): m ( a ), f ( static_cast < double > ( b - a ) / RAND_MAX ) { }
inline int operator() ( ) { return m + std::ceil ( f * rand( ) ); }
private:
const int m;
const double f;
};
class RandDouble
{
public:
RandDouble ( double a = 0.0, double b = 1.0 ): m ( a ), f ( ( b - a ) / RAND_MAX ) { }
inline double operator() ( ) { return m + f * rand( ); }
private:
const double m, f;
};
class Noisy
{
public:
Noisy ( std::string str ): msg ( str )
{
std::cout << " Noisy ( " << msg << " )\t@ " << this << std::endl;
}
~Noisy ( )
{
std::cout << "~Noisy ( " << msg << " )\t@ " << this << std::endl;
}
void beep ( )
{
std::cout << " beep ( " << msg << " )\t@ " << this << std::endl;
}
void beep ( ) const
{
std::cout << " const beep ( " << msg << " )\t@ " << this << std::endl;
}
private:
const std::string msg;
};
DECLARE ( Noisy );
/*
* ----------------------------------------------
* ----------------------------------------------
*/
/*
* -- @@@ -------------------------------------------------
*/
using namespace std;
// struct Comp
// {
// // bool operator() ( const pair < int, int > & x, const pair < int, int > & y )
// // {
// // return abs( x.first ) + abs( x.second ) < abs( y.first ) + abs( y.second );
// // }
//
// // bool operator( ) ( const xyCircle & a, const xyCircle & b )
// // {
// // return a.radius < b.radius;
// // }
// //
// bool operator( ) ( const pair < size_t, size_t > & pr, const size_t & x )
// {
// return pr.second < x;
// }
// };
void probA()
{
vector <size_t> a;
cin >> a;
sort( a.begin(), a.end() );
copy ( a.begin( ), a.end( ), ostream_iterator < size_t > ( cout, " " ));
}
size_t probB( )
{
size_t n;
string str;
cin >> n >> str;
// const size_t n = str.size();
const size_t INF = n + 2;
vector < size_t > ldist( n ), rdist( n);
rdist[ 0 ] = str[ 0 ] == 'R' ? 0 : INF;
for ( size_t j = 1; j < n; ++ j )
switch ( str[ j ] )
{
case 'R':
rdist[ j ] = 0;
break;
case 'L':
rdist[ j ] = INF;
break;
case '.':
rdist[ j ] = 1 + rdist[ j - 1 ];
break;
}
ldist[ n - 1 ] = str[ n - 1 ] == 'L' ? 0 : INF;
for ( size_t j = n - 1; j > 0; -- j )
switch ( str[ j - 1] )
{
case 'L':
ldist[ j - 1] = 0;
break;
case 'R':
ldist[ j - 1] = INF;
break;
case '.':
ldist[ j - 1] = 1 + ldist[ j ];
break;
}
DEBUG( ldist );
DEBUG( rdist );
size_t cnt = 0;
for ( size_t j = 0; j < n; ++ j )
if ( ( INF <= ldist[j] && INF <= rdist[j] ) || ldist[ j ] == rdist[ j ] )
++ cnt;
return cnt;
}
int main ( const int argc, char * argv [ ])
{
cout << probB();
// c79( );
// cout << c343( );
// cout << setprecision( 10 )
return EXIT_SUCCESS;
}
/**
* " mislav.uniqpath.com/2011/12/vim-revisited/
* set encoding=utf-8
* %s/\(.\{60,70\}\) /\1\r/gc
* %s/ / /gc
* %s/10\([0-9]\{1,2\}\)/10^\1/gc
*/
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int n, m;
int a[N], b[N];
int q[33];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
int j = 0;
while (a[i]) {
if (a[i] % 2 == 1) ++q[j];
a[i] /= 2;
++j;
}
}
for (int i = 1; i <= m; ++i) cin >> b[i];
sort(b + 1, b + m + 1);
for (int i = 1; i <= m; ++i) {
if (q[b[i]])
--q[b[i]];
else {
int k = -1;
for (int j = b[i]; j < 33; ++j) {
if (q[j]) {
k = j;
break;
}
}
if (k == -1) {
cout << i - 1 << endl;
return 0;
}
q[k]--;
for (int j = k - 1; j >= b[i]; --j) {
q[j] = 1;
}
}
}
cout << m << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using u64 = uint64_t;
using u32 = uint32_t;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vpi = vector<pi>;
static constexpr int INF = (int)1e9 + 5;
static constexpr ll INFL = (ll)1e18 + 5;
static mt19937 rng((u32)chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
set<u32> s;
for (int i = 0; i < (n); ++i) {
string w;
cin >> w;
bitset<26> b;
for (auto& c : w) b[c - 'a'] = true;
s.emplace(b.to_ulong());
}
cout << ((int)(s).size()) << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
long long int x, y;
cin >> x >> y;
long long int sum = 0;
if (y % 10 == 0) {
sum = 0;
} else if (y % 5 == 0) {
long long int w = x / y;
long long int t = w % 10;
w = w / 10;
sum = w * 25;
for (long long int i = 1; i <= t; i++) {
sum = sum + (y * i) % 10;
}
} else if (y % 2 == 0) {
long long int w = x / y;
long long int t = w % 10;
w = w / 10;
sum = w * 40;
for (long long int i = 1; i <= t; i++) {
sum = sum + (y * i) % 10;
}
} else {
long long int w = x / y;
long long int t = w % 10;
w = w / 10;
sum = w * 45;
for (long long int i = 1; i <= t; i++) {
sum = sum + (y * i) % 10;
}
}
cout << sum << endl;
}
}
| 2 |
#include <bits/stdc++.h>
const long double PI = atan2(0, -1);
using namespace std;
const int N = 100;
vector<int> a(N + 1);
int main() {
int n, m;
cin >> n >> m;
if (m == 0) {
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a.rbegin(), a.rend());
long long s = 0;
int k = 0;
for (auto vec : a) {
s += vec;
k++;
if (s >= m) break;
}
printf("%d", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int n, m, x, y;
char ch;
int DP[MAXN][MAXN][28][2];
vector<vector<pair<int, int> > > v;
int dp(int i, int j, int prev, bool ok) {
int &ret = DP[i][j][prev][ok];
if (~ret) return ret;
ret = 0;
if (!ok) {
for (auto k : v[i])
if (k.first >= prev) ret |= (!dp(k.second, j, k.first, 1));
} else
for (auto k : v[j])
if (k.first >= prev) ret |= (!dp(i, k.second, k.first, 0));
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n >> m;
v.resize(n + 1);
while (m--) {
cin >> x >> y >> ch;
v[x].push_back({(int)ch - 'a', y});
}
memset(DP, -1, sizeof DP);
for (int i = 1; i <= n; ++i, cout << endl)
for (int j = 1; j <= n; ++j)
if (dp(i, j, 0, 0))
cout << "A";
else
cout << "B";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int n, m, head[maxn + 1], link[maxn * 2 + 1], adj[maxn * 2 + 1];
bool visit[maxn + 1];
int bfs(int s) {
memset(visit, false, sizeof(visit));
queue<int> q;
q.push(s);
int p;
visit[s] = true;
do {
p = q.front();
q.pop();
int i = head[p];
while (i != 0) {
if (!visit[adj[i]]) {
q.push(adj[i]);
visit[adj[i]] = true;
}
i = link[i];
}
} while (!q.empty());
return p;
}
int dis(int x, int y) {
if (x == y) return 0;
int i = head[x];
visit[x] = true;
int res = m + 1;
while (i != 0) {
if (!visit[adj[i]]) res = min(res, dis(adj[i], y) + 1);
i = link[i];
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
link[i * 2 - 1] = head[x];
adj[i * 2 - 1] = y;
head[x] = i * 2 - 1;
link[i * 2] = head[y];
adj[i * 2] = x;
head[y] = i * 2;
}
int u = bfs(1);
int v = bfs(u);
memset(visit, false, sizeof(visit));
cout << dis(u, v);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
namespace input {
template <class T>
void re(complex<T>& x);
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
void re(long double& x) {
string t;
re(t);
x = stold(t);
}
template <class T, class... Ts>
void re(T& t, Ts&... ts) {
re(t);
re(ts...);
}
template <class T>
void re(complex<T>& x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = (0); i < ((int)a.size()); ++i) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = (0); i < (SZ); ++i) re(a[i]);
}
} // namespace input
using namespace input;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(long long x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(long double x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template <class T>
void pr(const complex<T>& x) {
cout << x;
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T>
void pr(const T& x);
template <class T, class... Ts>
void pr(const T& t, const Ts&... ts) {
pr(t);
pr(ts...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void pr(const T& x) {
pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
void ps() { pr("\n"); }
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(" ");
ps(ts...);
}
void pc() { pr("]\n"); }
template <class T, class... Ts>
void pc(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pr(", ");
pc(ts...);
}
} // namespace output
using namespace output;
namespace io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
cin.sync_with_stdio(0);
cin.tie(0);
if ((int)second.size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace io
using namespace io;
typedef decay<decltype(MOD)>::type T;
struct mi {
T val;
explicit operator T() const { return val; }
mi() { val = 0; }
mi(const long long& v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0) val += MOD;
}
friend void pr(const mi& a) { pr(a.val); }
friend void re(mi& a) {
long long x;
re(x);
a = mi(x);
}
friend bool operator==(const mi& a, const mi& b) { return a.val == b.val; }
friend bool operator!=(const mi& a, const mi& b) { return !(a == b); }
friend bool operator<(const mi& a, const mi& b) { return a.val < b.val; }
mi operator-() const { return mi(-val); }
mi& operator+=(const mi& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
mi& operator-=(const mi& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
mi& operator*=(const mi& m) {
val = (long long)val * m.val % MOD;
return *this;
}
friend mi pow(mi a, long long p) {
mi ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mi inv(const mi& a) {
assert(a != 0);
return pow(a, MOD - 2);
}
mi& operator/=(const mi& m) { return (*this) *= inv(m); }
friend mi operator+(mi a, const mi& b) { return a += b; }
friend mi operator-(mi a, const mi& b) { return a -= b; }
friend mi operator*(mi a, const mi& b) { return a *= b; }
friend mi operator/(mi a, const mi& b) { return a /= b; }
};
template <int SZ>
struct Dinic {
typedef long long F;
struct Edge {
int to, rev;
F flow, cap;
};
int N, second, t;
vector<Edge> adj[SZ];
typename vector<Edge>::iterator cur[SZ];
void addEdge(int u, int v, F cap) {
assert(cap >= 0);
Edge a{v, (int)adj[v].size(), 0, cap}, b{u, (int)adj[u].size(), 0, 0};
adj[u].push_back(a), adj[v].push_back(b);
}
int level[SZ];
bool bfs() {
for (int i = (0); i < (N); ++i) level[i] = -1, cur[i] = begin(adj[i]);
queue<int> q({second});
level[second] = 0;
while ((int)q.size()) {
int u = q.front();
q.pop();
for (auto& e : adj[u])
if (level[e.to] < 0 && e.flow < e.cap)
q.push(e.to), level[e.to] = level[u] + 1;
}
return level[t] >= 0;
}
F sendFlow(int v, F flow) {
if (v == t) return flow;
for (; cur[v] != end(adj[v]); cur[v]++) {
Edge& e = *cur[v];
if (level[e.to] != level[v] + 1 || e.flow == e.cap) continue;
auto df = sendFlow(e.to, min(flow, e.cap - e.flow));
if (df) {
e.flow += df;
adj[e.to][e.rev].flow -= df;
return df;
}
}
return 0;
}
F maxFlow(int _N, int _s, int _t) {
N = _N, second = _s, t = _t;
if (second == t) return -1;
F tot = 0;
while (bfs())
while (auto df = sendFlow(second, numeric_limits<F>::max())) tot += df;
return tot;
}
};
Dinic<205> D;
int n, m, t;
int tot;
bool adj[201][201];
int ldeg[201], rdeg[201], ans[201][201];
int ret = 0;
vector<pair<int, int> > ed;
void ae(int x, int y, int l, int r, bool flag) {
if (flag) ret += r - l;
D.addEdge(n + m + 1, y, r);
D.addEdge(y, x, r - l);
D.addEdge(x, n + m + 2, r);
tot += r;
}
void solve() {
for (int i = (0); i < (t); ++i) {
D = Dinic<205>();
tot = 0;
for (int a = (1); a < (n + 1); ++a) ldeg[a] = 0;
for (int b = (1); b < (m + 1); ++b) rdeg[b] = 0;
for (int a = (1); a < (n + 1); ++a)
for (int b = (1); b < (m + 1); ++b)
if (adj[a][b]) {
ldeg[a]++, rdeg[b]++;
D.addEdge(a, n + b, 1);
}
for (int a = (1); a < (n + 1); ++a)
ae(0, a, ldeg[a] / (t - i), (ldeg[a] + t - i - 1) / (t - i), i == 0);
for (int b = (1); b < (m + 1); ++b)
ae(n + b, 0, rdeg[b] / (t - i), (rdeg[b] + t - i - 1) / (t - i), i == 0);
assert(D.maxFlow(n + m + 3, n + m + 1, n + m + 2) == tot);
for (int a = (1); a < (n + 1); ++a)
for (auto& t : D.adj[a])
if (n + 1 <= t.to && t.to <= n + m && t.flow) {
adj[a][t.to - n] = 0;
ans[a][t.to - n] = i + 1;
}
}
for (auto& t : ed) ps(ans[t.first][t.second]);
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int z;
re(n, z, t);
m = n;
vector<int> w(n);
re(w);
for (int i = (0); i < (z); ++i) {
int a, b;
re(a, b);
ed.push_back({a, b});
adj[a][b] = 1;
}
solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, a, x, b, y;
cin >> n >> a >> x >> b >> y;
a--, x--, b--, y--;
while (true) {
if (a == b) {
cout << "YES\n";
return 0;
}
if (a == x || b == y) {
break;
}
a = (a + 1) % n;
b = (b - 1 + n) % n;
}
cout << "NO\n";
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.