solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, max;
int num[100001];
int f[100001] = {0};
cin >> n;
for (int i = 1; i < n + 1; ++i) {
cin >> num[i];
}
for (int i = 1; i < n + 1; ++i) {
f[num[i]] = f[num[i] - 1] + 1;
}
max = 0;
for (int i = 1; i < n + 1; ++i) {
if (f[i] > max) {
max = f[i];
}
}
cout << n - max << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, k, start = 0, i;
string s;
cin >> n >> k >> s;
while (start < n && s[start] == '0') {
start++;
}
for (i = start; i < n; i++) {
if (s[i] == '0') {
swap(s[i], s[i - min(i - start, k)]);
k -= i - start;
if (k <= 0) {
break;
}
start++;
}
}
cout << s << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, r;
cin >> a >> b >> r;
if (a < 2 * r || b < 2 * r)
cout << "Second" << endl;
else
cout << "First" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long v[102];
long long D;
long long pathLength(long long v1, long long time, long long v2) {
long long res = 0;
v[0] = v1;
v[time - 1] = v2;
for (int(i) = (1); (i) < (time - 1); ++(i))
v[i] = min(v[i - 1] + D, v[time - 1] + D * ((time - 1) - i));
for (int(i) = (0); (i) < (time); ++(i)) res += v[i];
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long v1, v2, t, d;
cin >> v1 >> v2 >> t >> d;
D = d;
cout << pathLength(v1, t, v2) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 8 + 2;
int n, m, ans = 1000, fl;
vector<long long> vec;
vector<long long> sec[max_n];
vector<int> child[max_n];
void get(int ind) {
if (ind >= n) {
int ret = fl + bool(fl > 1);
for (int i = 0; i < n; i++) {
ret += child[i].size();
long long t = sec[i].size(), x = 1;
for (int j : child[i]) {
x *= vec[j];
t -= sec[j].size();
if (x > vec[i]) return;
}
if (vec[i] % x) return;
ret += t;
}
ans = min(ans, ret - m);
return;
}
for (int i = -1; i < ind; i++) {
if (i == -1) fl++;
if (i != -1) child[i].push_back(ind);
get(ind + 1);
if (i != -1) child[i].pop_back();
if (i == -1) fl--;
}
}
int main() {
scanf("%d", &n);
vec.resize(n);
for (int i = 0; i < n; i++) scanf("%I64d", &vec[i]);
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
long long temp = vec[i];
for (long long j = 2; temp != 1; j++) {
if (j * j > temp) {
sec[i].push_back(temp);
break;
}
while (temp % j == 0) {
temp /= j;
sec[i].push_back(j);
}
}
if (sec[i].size() == 1) m++;
}
get(0);
printf("%d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 7010;
int dp[maxn][2];
int vis[maxn][2];
int out_deg[maxn][2];
vector<int> a[2];
int n;
void f(int i, int j, int v) {
if (vis[i][j]) return;
vis[i][j] = 1;
dp[i][j] = v;
if (v == -1)
for (int x : a[1 - j]) {
int tmp = (i - x + n) % n;
if (tmp == 0) continue;
f(tmp, 1 - j, 1);
}
else
for (int x : a[1 - j]) {
int tmp = (i - x + n) % n;
if (tmp == 0) continue;
if (--out_deg[tmp][1 - j] == 0) f(tmp, 1 - j, -1);
}
}
int main() {
string ss[] = {"Lose", "Loop", "Win"};
scanf("%d", &n);
for (int j = 0; j < 2; j++) {
int k, v;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%d", &v);
a[j].push_back(v);
}
for (int i = 1; i < n; i++) out_deg[i][j] = k;
}
f(0, 0, -1);
f(0, 1, -1);
for (int j = 0; j < 2; j++) {
for (int i = 1; i < n; i++) cout << ss[dp[i][j] + 1] << " ";
cout << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int code[300];
vector<int> ft[11][11][4];
void update(int mul, int rem, char c, int idx, int val) {
while (idx < ft[mul][rem][code[c]].size()) {
ft[mul][rem][code[c]][idx] += val;
idx += idx & (-idx);
}
}
void update(int idx, char c, int val) {
for (int i = 1; i <= 10; i++) {
update(i, idx % i, c, (idx + i) / i, val);
}
}
int query(int mul, int rem, char c, int idx) {
int res = 0;
while (idx) {
res += ft[mul][rem][code[c]][idx];
idx -= idx & (-idx);
}
return res;
}
int query(int mul, int rem, char c, int kir, int kan) {
if (kan < kir)
return 0;
else
return query(mul, rem, c, kan) - query(mul, rem, c, kir - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
n = s.length();
s = " " + s;
code['A'] = 0;
code['G'] = 1;
code['C'] = 2;
code['T'] = 3;
for (int i = 1; i <= 10; i++) {
for (int j = 0; j < i; j++) {
for (int k = 0; k < 4; k++) ft[i][j][k].assign(150000 / i, 0);
}
}
for (int i = 1; i <= n; i++) update(i, s[i], 1);
int q;
cin >> q;
while (q--) {
int tipe;
cin >> tipe;
if (tipe == 1) {
int idx;
char c;
cin >> idx >> c;
update(idx, s[idx], -1);
s[idx] = c;
update(idx, s[idx], 1);
} else {
int l, r;
cin >> l >> r;
string t;
cin >> t;
int mul = t.size();
int res = 0;
for (int i = 0; i < t.size(); i++) {
res += query(mul, (l + i) % mul, t[i], (l + i + mul) / mul,
(r - ((l + i) % mul) + mul) / mul);
}
cout << res << "\n";
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
double r, a, b, c, d;
cin >> r >> a >> b >> c >> d;
c = c - a;
d = d - b;
r *= 2;
double dis = sqrt(c * c + d * d);
cout << ceil(dis / r);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, n, m, t, mi, c;
map<long long, long long> x;
vector<long long> a;
vector<long long> b;
cin >> t;
while (t--) {
c = 0, mi = 0;
cin >> n;
map<long long, long long> x;
for (i = 0; i < n; i++) {
cin >> m;
x[m]++;
a.push_back(m);
if (x[m] == 1) b.push_back(m);
}
for (i = 0; i < n; i++) {
if (x[a[i]] > mi) mi = x[a[i]];
}
c = b.size() - 1;
if (n == 1)
cout << 0 << endl;
else if (c == n || mi == n)
cout << 1 << endl;
else if (mi > c) {
if (mi - c == 1)
cout << c << endl;
else
cout << c + 1 << endl;
} else if (mi == c)
cout << mi << endl;
else
cout << mi << endl;
a.clear();
b.clear();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 300 + 10, MOD = 1000 * 1000 * 1000 + 7;
long long pre[maxn], a[maxn], nex[maxn], dp[100010][maxn], n, ccc;
vector<long long> coins;
vector<vector<long long> > tree;
bool Do(long long v, vector<long long> &T) {
ccc++;
if (T.size() > n) return false;
long long temp = 0;
if (!T.empty()) temp = coins[coins.size() - 1];
temp += a[v];
coins.push_back(temp);
T.push_back(v);
if (nex[v] != -1) return Do(nex[v], T);
return true;
}
long long CC(long long t, long long v) {
long long i, j, ans;
long long temp;
ans = 0;
if (v >= coins.size()) return 0;
if (dp[t][v] != -2) return dp[t][v];
if (t - coins[v] == 0) return 1 + CC(t, v + 1);
if (t - coins[v] > 0) ans = (ans + CC(t - coins[v], v)) % MOD;
ans = (ans + CC(t, v + 1)) % MOD;
return dp[t][v] = ans;
}
int main() {
long long q, t, i, b, c, j;
vector<long long> T;
cin >> n >> q >> t;
for (i = 0; i < n; i++) cin >> a[i];
memset(pre, -1, sizeof pre);
memset(nex, -1, sizeof nex);
for (i = 0; i < q; i++) {
cin >> b >> c;
nex[b - 1] = c - 1;
pre[c - 1] = b - 1;
}
ccc = 0;
for (i = 0; i < n; i++)
if (pre[i] == -1) {
T.clear();
if (!Do(i, T)) {
cout << 0 << endl;
return 0;
}
tree.push_back(T);
}
if (ccc != n) {
cout << 0 << endl;
return 0;
}
for (i = 0; i < 100005; i++)
for (j = 0; j < maxn; j++) dp[i][j] = -2;
long long init;
init = 0ll;
for (i = 0; i < tree.size(); i++) {
for (j = 0; j < tree[i].size(); j++) {
init += (a[tree[i][j]] * 1ll * ((long long)tree[i].size() - j - 1));
}
}
t -= init;
if (t < 0)
cout << 0 << endl;
else
cout << (!t ? 1 : CC(t, 0)) << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> v;
vector<long long> res;
long long num[1000 * 1000];
void solve() {
long long n, k;
scanf("%lld %lld", &n, &k);
for (int i = 0; i < n * k; i++) scanf("%lld", &num[i]);
sort(num, num + n * k);
long long sum = 0, idx = (long long)ceil(n / 2.0) - 1;
for (int i = 0; i < k; i++) sum += num[k * idx + i * (n - idx)];
printf("%lld\n", sum);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int c[1000][1000];
int main(void) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j];
long long int scol[1001], srow[1001];
for (int i = 0; i < n; i++) {
srow[i] = 0;
for (int j = 0; j < m; j++) srow[i] += c[i][j];
}
for (int i = 0; i < m; i++) {
scol[i] = 0;
for (int j = 0; j < n; j++) scol[i] += c[j][i];
}
int bx, by;
long long int BX = LLONG_MAX, BY = LLONG_MAX;
for (int i = 0; i <= n; i++) {
long long int v = 0;
for (int j = 0; j < n; j++) {
long long int d = (j * 4 + 2 - i * 4);
v += srow[j] * d * d;
}
if (v < BX) BX = v, bx = i;
}
for (int j = 0; j <= m; j++) {
long long int v = 0;
for (int i = 0; i < m; i++) {
long long int d = (i * 4 + 2 - j * 4);
v += scol[i] * d * d;
}
if (v < BY) BY = v, by = j;
}
cout << (BX + BY) << endl;
cout << bx << " " << by << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[1001], f[200][100][2];
int main() {
int n;
cin >> n;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
f[i][j][0] = 1000;
f[i][j][1] = 1000;
}
}
f[0][0][0] = f[0][0][1] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 0; j <= i; j++) {
if (a[i] % 2 == 0)
f[i][j + 1][0] = min(f[i - 1][j][0], f[i - 1][j][1] + 1);
if (a[i] == 0 || a[i] % 2 == 1)
f[i][j][1] = min(f[i - 1][j][1], f[i - 1][j][0] + 1);
}
}
cout << min(f[n][n / 2][0], f[n][n / 2][1]) << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N], b[N];
int n, m, K;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int ans = 0;
for (int k = 0; k <= 26; ++k) {
int mod = 1 << (k + 1);
for (int i = 1; i <= n; ++i) {
b[i] = a[i] % mod;
}
int tmp = 0;
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; ++i) {
int l, r;
l = lower_bound(b + 1, b + 1 + n, (1 << k) - b[i]) - b;
r = lower_bound(b + 1, b + 1 + n, (1 << (k + 1)) - b[i]) - b - 1;
tmp += r - l + 1;
l = lower_bound(b + 1, b + 1 + n, (1 << (k + 1)) + (1 << k) - b[i]) - b;
r = lower_bound(b + 1, b + 1 + n, (1 << (k + 2)) - 1 - b[i]) - b - 1;
tmp += r - l + 1;
if ((b[i] + b[i]) & (1 << k)) {
tmp--;
}
}
if ((tmp / 2) & 1) ans += 1 << k;
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
const long long maxn = 1e6 + 10;
using namespace std;
long long arr[maxn];
long long ans = 0, a, b, f, k;
int main() {
cin >> a >> b >> f >> k;
long long n = k + 1, ff = 1;
long long k1 = 2 * f, k2 = 2 * (a - f);
arr[1] = k1 / 2, ff = 1 - ff;
for (int i = 2; i < n; i++) {
if (ff) {
arr[i] = k1;
ff = 1 - ff;
} else {
arr[i] = k2;
ff = 1 - ff;
}
}
if (ff)
arr[n] = k1 / 2;
else
arr[n] = k2 / 2;
long long t = b;
int flag = 1;
for (int i = 1; i <= n; i++) {
if (t < arr[i]) {
t = b - arr[i];
ans++;
} else
t = t - arr[i];
if (t < 0) {
flag = 0;
break;
}
}
if (flag)
cout << ans;
else
cout << "-1";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, q = 0;
cin >> n;
long long arr[200001];
arr[0] = 0;
for (int i = 1; i < n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
q = min(arr[i], q);
}
q = 1 - q;
unordered_map<int, int> mymap;
for (int i = 0; i < n; i++) {
arr[i] += q;
if (mymap[arr[i]] > 0) {
cout << -1;
return 0;
}
mymap[arr[i]] = 1;
if (arr[i] > n) {
cout << -1;
return 0;
}
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
}
| 7 |
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
int n;
int L[700], R[700];
int dp[700][700];
int rec(int i, int j) {
if (i > j) return 1;
if (dp[i][j] != -1) return dp[i][j];
int ans = 0, lim = j - i;
for (int k = 0; k <= lim; k++)
if (L[i] <= 2 * k + 1 && 2 * k + 1 <= R[i])
ans |= (rec(i + 1, i + k) & rec(i + k + 1, j));
return dp[i][j] = ans;
}
void trace(int i, int j) {
if (i > j) return;
int ans = 0, lim = j - i;
for (int k = 0; k <= lim; k++)
if (L[i] <= 2 * k + 1 && 2 * k + 1 <= R[i]) {
ans = (rec(i + 1, i + k) & rec(i + k + 1, j));
if (ans) {
cout << "(";
trace(i + 1, i + k);
cout << ")";
trace(i + k + 1, j);
break;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> L[i] >> R[i];
memset(dp, -1, sizeof(dp));
int ans = rec(1, n);
if (!ans)
cout << "IMPOSSIBLE" << endl;
else
trace(1, n);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int M = 4200000;
namespace io {
const int L = (1 << 21) + 1;
char ibuf[L], *iS, *iT, obuf[L], *oS = obuf, *oT = obuf + L - 1, c, st[65];
int f, tp;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void read(int &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
inline void print(int x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) putc(st[tp--]);
}
inline void read(long long &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
inline void print(long long x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) st[++tp] = x % 10 + '0', x /= 10;
while (tp) putc(st[tp--]);
}
inline void read(char *s, int &l) {
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < 33; c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
for (l = 0; c > 32;
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
s[l++] = c;
s[l] = '\0';
}
inline void read(char *s) {
int l;
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < 33; c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
for (l = 0; c > 32;
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
s[l++] = c;
s[l] = '\0';
}
inline void print(char *s) {
for (int l = 0; s[l] != '\0'; ++l) putc(s[l]);
}
}; // namespace io
using io::print;
using io::putc;
using io::read;
struct edge {
int fr, to, nx;
} e[M];
int n, m;
int cnt = 2;
int h[M] = {0};
void add(int u, int v) {
e[cnt].fr = u;
e[cnt].nx = h[u];
e[cnt].to = v;
h[u] = cnt++;
}
int dgree[M] = {0};
int im;
bool vir(int x) { return x > im; }
int eula[M];
int tp = 0;
vector<int> ans;
bool vsp[M];
bool vse[M];
void dfs(int u, int p) {
vsp[u] = 1;
for (int &i = h[u]; i; i = e[i].nx) {
if (vse[i] || vse[i ^ 1]) continue;
vse[i] = 1;
dfs(e[i].to, i);
}
eula[tp++] = p;
}
bool del[M];
void solve(int x) {
tp = 0;
dfs(x, 0);
--tp;
for (int i = (0); i <= (tp); ++i) del[i] = 0;
for (int i = 1; i < tp; i += 2) {
int a = eula[i - 1], b = eula[i], c = eula[(i + 1) % tp];
if (b > im)
del[i] = 1;
else {
if (a > im)
del[i - 1] = 1;
else if (c > im)
del[(i + 1) % tp] = 1;
else
del[i] = 1;
}
}
for (int i = (0); i <= (tp - 1); ++i)
if (!del[i] && eula[i] <= im) {
ans.push_back(eula[i]);
}
}
int main() {
read(n);
read(m);
int u, v;
for (int i = (1); i <= (m); ++i) {
read(u);
read(v);
add(u, v);
add(v, u);
++dgree[u];
++dgree[v];
}
im = cnt - 1;
for (int i = (1); i <= (n); ++i)
if (dgree[i] & 1) {
add(i, 0);
add(0, i);
}
for (int i = (1); i <= (n); ++i)
if (!vsp[i]) solve(i);
print((int)ans.size());
putc('\n');
for (int i : ans) {
print(e[i].fr);
putc(' ');
print(e[i].to);
putc('\n');
}
io::flush();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2505;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long fact(long long n) {
long long ret = 1;
for (int i = 1; i <= n; i++) ret *= i;
return ret;
}
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
return 0;
}
long double getDistance(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int dsu[N], edges[N], sz[N], grid[N][N], n;
vector<pair<int, pair<int, int> > > v;
int getPar(int a) { return a == dsu[a] ? a : dsu[a] = getPar(dsu[a]); }
void merge(int a, int b) {
a = getPar(a);
b = getPar(b);
if (a == b) {
edges[a]++;
return;
}
sz[a] += sz[b];
edges[a] += edges[b] + 1;
dsu[b] = a;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &grid[i][j]);
for (int i = 0; i < n; i++) {
dsu[i] = i;
sz[i] = 1;
for (int j = 0; j < n; j++) {
if (grid[i][j] != grid[j][i] || grid[i][i] != 0) {
printf("NOT MAGIC");
return 0;
}
if (i < j)
v.push_back(
pair<int, pair<int, int> >(grid[i][j], pair<int, int>(i, j)));
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size();) {
int cur = i;
while (v[cur].first == v[i].first && cur < v.size()) {
merge(v[cur].second.first, v[cur].second.second);
cur++;
}
for (int j = i; j < cur; j++) {
int node = v[j].second.first;
node = getPar(node);
if (sz[node] * (sz[node] - 1) != edges[node] * 2) {
printf("NOT MAGIC");
return 0;
}
}
i = cur;
}
printf("MAGIC");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout.precision(12);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<int> a(n);
vector<int> ar(1025);
for (long long i = 0; i < n; i++) {
cin >> a[i];
ar[a[i]] = 1;
}
int an = -1;
for (int i = 1; i < 1024; i++) {
int f = 1;
for (int j = 0; j < n; j++) {
int x = a[j] ^ i;
if (ar[x] == 0) {
f = 0;
break;
}
}
if (f) {
an = i;
break;
}
}
cout << an << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:256000000")
using namespace std;
const int N = 1000500, M = 200500, INF = 1000 * 1000 * 1000 + 7;
const long double eps = 1e-9;
bool a[N];
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcd(long long a, long long b) { return a / gcd(a, b) * b; }
bool solve() {
int n;
if (scanf("%d", &n) != 1) return false;
long long ans = 1;
int to = min(100, n);
for (int i = 0; i < to; i++) {
for (int j = 0; j < to; j++) {
for (int k = 0; k < to; k++) {
ans = max(ans, lcd(n - i, lcd(n - j, n - k)));
}
}
}
cout << ans << endl;
return true;
}
int main() {
a[0] = true;
a[1] = true;
for (int i = 0; i < N; i++) {
if (a[i]) continue;
for (int j = i + i; j < N; j += i) a[j] = true;
}
while (solve())
;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * (b / (gcd(a, b))); }
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline long long toLL(string s) {
long long v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
using namespace std;
string mains;
int n;
unordered_map<long long, string> ma;
bool seen[10000 + 1];
bool memo[10000 + 1];
vector<string> ans;
const int A = 1e4 + 100, BASE = 1e6 + 3, MOD = 98765431;
int m;
inline bool solve(int s) {
if (s == n) return 1;
if (seen[s] == 1) return memo[s];
seen[s] = 1;
bool c = 0;
long long hash = 0;
for (int i = s; i < n; i++) {
hash = hash * BASE + mains[i];
if (ma.find(hash) != ma.end()) {
c |= solve(i + 1);
}
}
return memo[s] = c;
}
inline void trace(int s) {
if (s == n) return;
long long hash = 0;
for (int i = s; i < n; i++) {
hash = hash * BASE + mains[i];
if (ma.count(hash)) {
if (solve(i + 1) == 1) {
ans.push_back(ma[hash]);
trace(i + 1);
return;
}
}
}
return;
}
int main() {
std::ios_base::sync_with_stdio(false);
memset(seen, 0, sizeof(seen));
memset(memo, 0, sizeof(memo));
cin >> n;
cin >> mains;
string sub;
string ne = "";
cin >> m;
for (int i = 0; i < (int)m; i++) {
cin >> sub;
string ne = "";
int sz = (int)(sub.size());
for (int j = 0; j < (int)sz; j++) ne = ne + sub[j];
long long hash = 0;
for (int j = 0; j < (int)sz; j++) ne[j] = tolower(ne[j]);
for (int j = 0; j < sz; j++) hash = hash * BASE + ne[j];
ma[hash] = sub;
}
reverse(mains.begin(), mains.end());
solve(0);
trace(0);
int sz = ((int)((ans).size()));
for (int i = sz - 1; i >= 0; i--) cout << ans[i] << " ";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print2dvector(vector<vector<T> > v) {
cout << "A 2d vector:" << endl;
int a = v.size();
int b = v[0].size();
if (a <= 15 && b <= 15) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
cout << setw(4) << v[i][j];
}
cout << endl;
}
}
if (a > 15 && b > 15) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
cout << setw(4) << v[i][j];
}
cout << " "
<< ". . ." << setw(4) << v[i][b - 3] << setw(4) << v[i][b - 2]
<< setw(4) << v[i][b - 1] << endl;
}
for (int i = 0; i < 15; i++) {
cout << setw(4) << '.';
}
cout << endl;
for (int i = a - 3; i < a; i++) {
for (int j = 0; j < 9; j++) {
cout << setw(4) << v[i][j];
}
cout << " "
<< ". . ." << setw(4) << v[i][b - 3] << setw(4) << v[i][b - 2]
<< setw(4) << v[i][b - 1] << endl;
}
}
if (a > 15) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < b; j++) {
cout << setw(4) << v[i][j];
}
cout << endl;
}
for (int i = 0; i < b; i++) {
cout << setw(4) << '.';
}
cout << endl;
for (int i = a - 3; i < a; i++) {
for (int j = 0; j < b; j++) {
cout << setw(4) << v[i][j];
}
cout << endl;
}
}
if (b > 15) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < 9; j++) {
cout << setw(4) << v[i][j];
}
cout << " "
<< ". . ." << setw(4) << v[i][b - 3] << setw(4) << v[i][b - 2]
<< setw(4) << v[i][b - 1] << endl;
}
}
}
template <typename T>
void printvector(vector<T> v) {
cout << "A 1d vector:" << endl;
int a = v.size();
if (a <= 15) {
for (int i = 0; i < a; i++) {
cout << setw(4) << v[i];
}
} else {
for (int i = 0; i < 9; i++) {
cout << setw(4) << v[i];
}
cout << " "
<< ". . ." << setw(4) << v[a - 3] << setw(4) << v[a - 2] << setw(4)
<< v[a - 1];
}
cout << endl;
}
long long p(long long n, long long m) {
long long ans = 1;
for (int i = 0; i < m; i++) {
ans *= n;
}
return ans;
}
long long sum(long long a) {
stringstream ss;
ss << a;
string s = ss.str();
long long ans = 0;
for (int i = 0; i < s.size(); i++) {
ans += s[i] - '0';
}
return ans;
}
int main() {
long long a, b, c;
cin >> a >> b >> c;
vector<int> solutions;
for (long long i = 1; i <= 100; i++) {
long long x = b * p(i, a) + c;
if (sum(x) == i && 0 < x && x < 1000000000) {
solutions.push_back(x);
}
}
cout << solutions.size() << endl;
if (solutions.size() != 0) {
for (int i = 0; i < solutions.size() - 1; i++) {
cout << solutions[i] << " ";
}
cout << solutions[solutions.size() - 1] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000555;
long long a[maxn * 2];
int main() {
long long n;
int k, pos = 0, tot = 0;
cin >> n >> k;
while (n) {
if (n & 1) a[maxn + pos]++, tot++;
n >>= 1;
pos++;
}
if (tot > k) {
cout << "No" << endl;
return 0;
}
for (int i = 2 * maxn - 1; i > (0); --i) {
if (!a[i]) continue;
if (tot + a[i] > k) break;
int can_chg = min((k - tot) * 1LL, a[i]);
tot = tot + can_chg;
a[i - 1] += 2 * can_chg;
a[i] -= can_chg;
}
int left = k - tot, min_pos;
for (int i = 0; i < (maxn * 2); ++i)
if (a[i]) {
min_pos = i;
break;
}
cout << "Yes" << endl;
vector<int> ans;
for (int i = 2 * maxn - 1; i > (0); --i) {
for (int j = 0; j < (a[i]); ++j) ans.push_back(i - maxn);
}
for (int i = 0; i < ((int)ans.size() - 1); ++i) printf("%d ", ans[i]);
if (!left) {
printf("%d\n", ans.back());
} else {
int kk = 1;
while (left > 0) {
left--;
printf("%d ", ans.back() - kk);
kk++;
}
printf("%d\n", ans.back() - kk + 1);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[5];
int main() {
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
cout << a[1] - a[0] + a[2] - a[1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x, y, d;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * (b / (gcd(a, b))); }
int lowestbit(int n) {
int idx = (log2(n & -n));
return 1 << idx;
}
bool colinear(int x1, int y1, int x2, int y2, int x3, int y3) {
return (((x3 - x1) * (y2 - y1)) - ((x2 - x1) * (y3 - y1))) == 0;
}
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();
}
void extendedEuclid(int a, int b, int &d, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
d = a;
return;
}
extendedEuclid(b, a % b, d, x, y);
int x1 = y;
int y1 = x - (a / b) * y;
x = x1;
y = y1;
}
int getModInv(int a, int n) {
int d, x, y;
extendedEuclid(a, n, d, x, y);
return (x + n) % n;
}
vector<int> primes;
vector<long long> ans;
int N, K;
long long mod = 1073741824;
void sieve() {
long long N = 1000000;
bool p[N + 1];
memset(p, true, sizeof(p));
for (long long i = 4; i <= N; i += 2) p[i] = false;
p[1] = false;
p[0] = false;
for (long long i = 3; i <= N; i += 2) {
if (p[i]) {
for (long long j = i * 2; j <= N; j += i) {
p[j] = false;
}
}
}
for (int i = 1; i <= (int)N; i++)
if (p[i]) primes.push_back(i);
}
int main() {
scanf("%d%d", &N, &K);
if (N == 1 && K == 0) {
cout << "1"
<< "\n";
return 0;
}
if ((N == 1 && K == 1) || K == 0 || (N == 1 && K != 1)) {
cout << "-1"
<< "\n";
return 0;
}
int pairs = N / 2;
if (pairs > K) {
cout << "-1"
<< "\n";
return 0;
}
int curr = K - (pairs - 1);
long long num1, num2;
num1 = curr;
num2 = curr * 2;
ans.push_back(curr);
ans.push_back(curr * 2);
int qq = pairs;
pairs--;
int q = 2;
while (pairs--) {
if (q == num1 - 1 || q == num1) q += 2;
if (q == num2 - 1 || q == num2) q += 2;
ans.push_back(q);
ans.push_back(q + 1);
q += 2;
}
if (qq * 2 < N) {
while (q == num1 || q == num2) q++;
ans.push_back(q);
}
for (int k = 0; k < ((int)((ans).size())); k++) cout << ans[k] << " ";
cout << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> line(n);
for (long long& i : line) cin >> i;
set<long long> av;
for (long long i = 1; i <= 2 * n; i++) av.insert(i);
for (long long i : line) av.erase(i);
vector<long long> ans(2 * n);
for (long long i = 0; i < n; i++) {
ans[2 * i] = line[i];
auto it = av.lower_bound(line[i]);
if (it == av.end()) {
cout << -1 << endl;
return;
}
ans[2 * i + 1] = *it;
av.erase(it);
}
for (long long i : ans) cout << i << " ";
cout << endl;
}
signed main() {
long long q = 1;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
int x, sum2 = 0;
char s1 = '(', s2 = ')';
string temp;
for (int i = 0; i < t; i++) {
cin >> n;
string sum[2 * n];
if (n == 1) {
cout << s1 << s2 << endl;
} else if (n > 1) {
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
sum[i] = s1;
}
for (int i = n; i < 2 * n; i++) {
sum[i] = s2;
}
}
do {
for (int i = 0; i < 2 * n; i++) {
cout << sum[i];
}
sum2 += 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = n; j < 2 * n; j++) {
temp = sum[i];
sum[i] = sum[j];
sum[j] = temp;
break;
}
}
cout << endl;
} while (sum2 < n);
}
sum2 = 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, p;
int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
double dp[500][500];
int main() {
n = read(), k = read(), p = read();
double p1 = 1.0 * p / 100, p2 = 1.0 - p1;
for (int i = 0; i <= k; ++i) {
for (int j = n + i; (j & 1) == 0; j >>= 1) {
dp[0][i] += 1.0;
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j <= k; ++j) {
if (j != 0) dp[i + 1][j - 1] += p2 * dp[i][j];
if (j * 2 <= k) dp[i + 1][j * 2] += p1 * (dp[i][j] + 1);
}
}
printf("%.10lf", dp[k][0]);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long int cnt[1001][1001] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
cin >> n >> m;
if (n > m) {
cout << 0 << endl;
return 0;
}
long long int a[n];
long long int x[1001] = {};
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int ans = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans = (ans * (abs(a[j] - a[i]))) % m;
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
vector<vector<pair<int, int> > > arv;
long long s, soma;
int ans = 0;
bool vis[100005];
int dist[100005];
struct comp {
bool operator()(pair<int, int> a, pair<int, int> b) const {
return ((long long)a.first * a.second) - (a.first / 2 * a.second) >
((long long)b.first * b.second) - (b.first / 2 * b.second);
}
};
multiset<pair<int, int>, comp> jafoi;
int dfs2(int x, int papi = -1) {
int cont = 0;
if (((int)arv[x].size()) == 1 and x != 1) {
return dist[x] = 1;
}
for (auto f : arv[x]) {
if (f.first != papi) cont += dfs2(f.first, x);
}
return dist[x] = cont;
}
void dfs(int x) {
vis[x] = true;
for (auto f : arv[x]) {
if (vis[f.first]) {
soma += (long long)f.second * dist[x];
jafoi.insert({f.second, dist[x]});
break;
}
}
for (auto f : arv[x]) {
if (!vis[f.first]) {
dfs(f.first);
}
}
}
void solve() {
int n;
ans = 0;
cin >> n >> s;
arv.assign(n + 1, {});
jafoi.clear();
soma = 0;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
arv[u].push_back({v, w});
arv[v].push_back({u, w});
}
memset(vis, false, sizeof(vis));
memset(dist, -1, sizeof(dist));
dist[1] = 0;
dfs2(1);
dfs(1);
while (soma > s) {
ans++;
soma -= (long long)jafoi.begin()->first * jafoi.begin()->second;
soma += (long long)(jafoi.begin()->first / 2) * jafoi.begin()->second;
jafoi.insert({jafoi.begin()->first / 2, jafoi.begin()->second});
jafoi.erase(jafoi.begin());
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int N = 121000;
int n, a, b, c, d, f[N];
double len[N];
struct node {
double l, r;
} stars[N];
inline int cmp(const void* a, const void* b) {
node *A = (node*)a, *B = (node*)b;
if (fabs(A->l - B->l) < eps) {
return A->r < B->r ? -1 : 1;
}
return A->l < B->l ? -1 : 1;
}
double geti(int x, int y, int a, int b) {
if (a == 0) return y;
if (b == 0) return x;
double K = (double)a / b, B = y - K * x, A = -B / K;
if (A < 0) return A;
return B;
}
int main() {
scanf("%d %d/%d %d/%d", &n, &a, &b, &c, &d);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
stars[i].l = geti(-x, y, a, -b);
stars[i].r = -geti(-x, y, c, -d);
}
qsort(stars + 1, n, sizeof stars[0], cmp);
for (int i = 1; i <= n; i++) len[i] = 1e90;
stars[n + 1].l = stars[n].l + 1;
len[0] = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (stars[i].l <= eps || stars[i].r <= eps) continue;
int left = 0, right = n;
while (right - left > 1) {
int mid = (left + right) >> 1;
if (len[mid] < stars[i].r)
left = mid;
else
right = mid - 1;
}
if (len[right] < stars[i].r) left = right;
f[i] = left + 1;
if (fabs(stars[i].l - stars[i + 1].l) > eps) {
int j = i;
while (j > 0 && (fabs(stars[j].l - stars[i].l) < eps)) {
if (len[f[j]] > stars[j].r) len[f[j]] = stars[j].r;
j--;
}
}
if (f[i] > ans) ans = f[i];
}
printf("%d\n", ans);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e7 + 5;
int vis[maxn];
int main() {
long long n, m;
cin >> n >> m;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += min(i * i, m) * 2;
}
for (long long i = 1; i <= n; i++) {
for (long long j = i - 1; j >= 0; j--) {
if (i * i - j * j > m) break;
if (vis[i - j])
ans--;
else
vis[i - j] = 1;
if (vis[i + j])
ans--;
else
vis[i + j] = 1;
}
}
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], b[100005], st[100005], top;
int main() {
memset(b, -1, sizeof(b));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
st[++top] = i;
while (a[i - 1] != a[i]) {
b[st[top]] = a[i - 1];
a[i - 1]++;
top--;
}
}
for (int i = 1; i <= n; i++) {
if (b[i] == -1)
printf("100001 ");
else
printf("%d ", b[i]);
}
printf("\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a;
int main() {
scanf("%lld", &a);
long long now = 100000000000000000ll % a, P = 0;
for (int i = 1; i <= 9; i++) P = (P + (now * i % a)) % a;
now = 0;
for (int i = 1; i <= 18; i++) now = (now + P) % a;
now = (now + 1) % a;
long long l = 1, r = 1000000000000000000ll;
l += a - now;
r += a - now;
printf("%lld %lld", l, r);
return 0;
}
| 17 |
#include <iostream>
#include <vector>
#include <set>
#include <climits>
#include <string>
#include <algorithm>
#include <math.h>
#include <map>
#include <unordered_map>
#include <queue>
#include <iomanip>
#include <stack>
#include <bitset>
#include <stdio.h>
using namespace std;
typedef long long ll;
//#define int long long
#define vi vector<int>
#define vii vector<vector<int> >
#define vl vector<ll>
#define vpi vector<pair<int, int> >
#define M 1000000007
#define pi pair<int, int>
#define M_P 3.14159265358979323846
template <class T>
T expo(T base, T exp, T mod)
{
T res = 1;
base = base % mod;
while (exp > 0)
{
if (exp & 1)
res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
void input(vi &arr)
{
for (int i = 0; i < arr.size(); i++)
cin >> arr[i];
}
void output(vi &arr)
{
for (int i = 0; i < arr.size(); i++)
cout << arr[i] << " ";
cout << endl;
}
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
void print(vector<vector<char> > arr, int n, int m)
{
cout << "yes" << endl;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
cout << arr[i][j];
}
cout << endl;
}
}
bool check(int x, int d)
{
int sum = (x * (x + 1)) / 2;
if (sum < d)
return false;
return sum % 2 == d % 2;
}
int cal(int src, vector<int> arr[], vector<int> &dp)
{
if (dp[src] != -1)
return dp[src];
int ans = 0;
for (int x : arr[src])
{
ans = max(cal(x, arr, dp) + 1, ans);
}
return dp[src] = ans;
}
int mi = INT_MAX;
int m2 = INT_MIN;
void mak(int sum, int n, int m)
{
if (n == 0 && m == 0)
{
mi = min(mi, sum);
m2 = max(m2, sum);
return;
}
if (n == 0)
return;
for (int d = 9; d >= 0; d--)
{
if (m - d >= 0)
{
int t = sum * 10 + d;
mak(t, n - 1, m - d);
}
}
}
void solve()
{
int n;cin>>n;
vector<int>arr(n);
input(arr);
vector<int>ans;
ans.push_back(0);
int last = 0;
for(int i = 1;i<n;i++)
{
int k = (arr[i-1]^last);
int p = arr[i];
int j = 0;
int num = 0;
while(k > 0)
{
int d = k&1;
int d2 = p&1;
if(d != d2)
{
if(d == 1)
{
int mask = (1<<j);
num = num | mask;
}
}
j++;
k = k >> 1;
p = p >> 1;
}
last = num;
ans.push_back(num);
}
output(ans);
}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--)
{
solve();
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int t = 1;
while (t--) {
long long int n, i, sum = 0, y = 0, ans = 0;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (i = 0; i < n - 1; i++) {
y += a[i];
if (y == sum - y) {
ans++;
}
}
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs"
<< "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
using namespace std;
int gcd(int a, int b) {
if (!a || !b) return max(a, b);
return gcd(max(a, b) % min(a, b), min(a, b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
for (int k = 2; k <= 1000; k++) {
int a = n - (k + 1);
int b = k;
int c = 1;
if (a < 0 || b < 0 || c < 0) continue;
if (a == b || b == c || a == c) continue;
if (gcd(a, b) != c) continue;
cout << a << " " << b << " " << c << '\n';
break;
}
}
}
| 1 |
#include <bits/stdc++.h>
const long long MXN = 1e5 + 1;
const long long MNN = 1e3 + 1;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long long OO = 1e9 + 500;
using namespace std;
int n, k, ans, pa[MXN], push_back[MXN];
string s;
bool check(int l, int r) {
if (min(pa[r] - pa[l - 1], push_back[r] - push_back[l - 1]) <= k) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
;
cin >> n >> k >> s;
s = '#' + s;
for (int i = 1; i <= n; i++) {
pa[i] = pa[i - 1] + (s[i] == 'a' ? 1 : 0);
push_back[i] = push_back[i - 1] + (s[i] == 'b' ? 1 : 0);
}
for (int i = 1; i <= n; i++) {
if (s[i - 1] != s[i]) {
int l = i, r = n;
while (r - l > 1) {
int m = (r + l) / 2;
if (check(i, m) == 1) {
l = m;
} else {
r = m;
}
}
int x = (check(i, r) == 1 ? r : l) - i + 1;
ans = max(ans, x);
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int A[105][105], n, m;
void rotate() {
for (int i = 0; i < n; i++)
for (int j = i + 1; j < m; j++) {
swap(A[i][j], A[j][i]);
}
}
bool check() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (A[i][j]) return true;
return false;
}
int main() {
int R[105], t;
bool done = true, swapped = false;
pair<int, int> C[105];
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> A[i][j];
if (n > m) {
swapped = true;
swap(n, m);
rotate();
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
t = A[i][j];
if (t) done = false;
if (j == 0)
R[i] = t;
else
R[i] = min(R[i], t);
if (i == 0)
C[j] = pair<int, int>(t, t);
else
C[j] = pair<int, int>(max(C[j].first, t), min(C[j].second, t));
}
int mxr = 0;
bool row = false;
vector<string> ans;
if (!done)
for (int i = 0; i < n; i++)
if (R[i]) {
row = true;
string tmp = swapped ? "col " : "row ";
tmp += to_string(i + 1);
for (int k = 0; k < R[i]; k++) {
for (int j = 0; j < m; j++) A[i][j]--;
ans.push_back(tmp);
}
mxr = max(mxr, R[i]);
}
if (!done)
for (int j = 0; j < m; j++) {
int c = row ? C[j].first - mxr : C[j].second;
if (c) {
string tmp = swapped ? "row " : "col ";
tmp += to_string(j + 1);
for (int k = 0; k < c; k++) {
for (int i = 0; i < n; i++) A[i][j]--;
ans.push_back(tmp);
}
}
}
if (check() || (!ans.size() && !done))
cout << -1 << endl;
else if (done)
cout << 0 << endl;
else {
cout << ans.size() << endl;
for (string s : ans) cout << s << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x, temp;
int odd, even;
int main() {
while (scanf("%d %d", &n, &k) != EOF) {
odd = even = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (x & 1) odd++;
}
even = n - odd;
if (n == k) {
if (odd & 1)
printf("Stannis\n");
else
printf("Daenerys\n");
} else {
temp = n - k;
if (temp & 1) {
if (odd <= temp / 2)
printf("Daenerys\n");
else if (even <= temp / 2)
if (k & 1)
printf("Stannis\n");
else
printf("Daenerys\n");
else
printf("Stannis\n");
} else {
if (even <= temp / 2)
if (k & 1)
printf("Stannis\n");
else
printf("Daenerys\n");
else
printf("Daenerys\n");
}
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long modexpo(long long x, long long y) {
if (y == 0) return 1;
if (y % 2) {
long long viky = modexpo(x, y / 2);
return (((x * viky) % 1000000007) * viky) % 1000000007;
} else {
long long viky = modexpo(x, y / 2);
return (viky * viky) % 1000000007;
}
}
long long fact[100111];
long long ncr(long long n, long long r) {
long long p = (fact[r] * fact[n - r]) % 1000000007;
return (fact[n] * modexpo(p, 1000000007 - 2)) % 1000000007;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t, i, j, k, l, m, n, p, q, r, s = 0, a, b, c, d, ans = 0, x, y;
cin >> n;
vector<pair<long long, long long> > V(n);
for (i = 0; i < n; i++) {
cin >> a >> b;
V[i] = make_pair(a, b);
}
sort(V.begin(), V.end());
long long now = V[0].second;
q = now;
ans = 0;
long long p1 = 0;
if (n == 1) {
cout << V[0].first + V[0].second << " " << V[0].second << endl;
return 0;
}
for (i = 1; i < n; i++) {
ans = max(q, ans);
p = V[i].first - V[i - 1].first;
now -= p;
now = max(0ll, now);
now += V[i].second;
ans = max(now, ans);
if (i == n - 1) {
p1 = now + V[i].first;
}
}
cout << p1 << " " << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, t;
node() {}
node(int l1, int r1, int t1) : l(l1), r(r1), t(t1) {}
};
inline bool operator<(const node &x, const node &y) { return x.l < y.l; }
struct hhhh {
int l, r, t, id;
} h[500010];
set<node> st;
long long S[100010], M[100010], R[100010], ans[100010], c[100010];
int g[100010], n, m, tt;
inline int rd() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x;
}
inline void print(long long x) {
static char s[233];
if (!x) {
putchar('0');
putchar('\n');
return;
}
int tot = 0;
for (; x; x /= 10) s[++tot] = x % 10 + '0';
for (; tot; tot--) putchar(s[tot]);
putchar('\n');
}
inline long long min(const long long &x, const long long &y) {
return (x < y) ? x : y;
}
inline long long max(const long long &x, const long long &y) {
return (x > y) ? x : y;
}
inline set<node>::iterator split(int x) {
set<node>::iterator it = st.upper_bound(node(x, 0, 0));
it--;
if (x == (*it).l) return it;
node hh = *it;
st.erase(hh);
st.insert(node(hh.l, x - 1, hh.t));
return st.insert(node(x, hh.r, hh.t)).first;
}
inline void pre_gao(int l, int r, int t, int id) {
for (int i = l; i <= r; i++) ans[id] += min(S[i] + R[i] * t, M[i]);
}
inline bool cmp(const hhhh &x, const hhhh &y) { return x.t < y.t; }
inline bool cmp1(const int &x, const int &y) {
if (!R[x]) return false;
if (!R[y]) return true;
return (M[x] / R[x] + 1) < (M[y] / R[y] + 1);
}
long long sum[400010], s[400010], tag[400010];
inline void gao(const int &o, const long long &hh) {
sum[o] += s[o] * hh;
tag[o] += hh;
}
inline void pushdown(const int &o) {
if (!tag[o]) return;
gao(o << 1, tag[o]);
gao(o << 1 | 1, tag[o]);
tag[o] = 0;
}
inline void build(int o, int l, int r) {
sum[o] = tag[o] = 0;
if (l == r) {
s[o] = R[l];
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
s[o] = s[o << 1] + s[o << 1 | 1];
}
inline void del(int o, int l, int r, int x) {
if (l == r) {
s[o] = sum[o] = 0;
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (x <= mid)
del(o << 1, l, mid, x);
else
del(o << 1 | 1, mid + 1, r, x);
sum[o] = sum[o << 1] + sum[o << 1 | 1];
s[o] = s[o << 1] + s[o << 1 | 1];
}
inline long long query(int o, int l, int r, int x, int y) {
if (l >= x && r <= y) return sum[o];
pushdown(o);
int mid = (l + r) >> 1;
long long res = 0;
if (x <= mid) res += query(o << 1, l, mid, x, y);
if (y > mid) res += query(o << 1 | 1, mid + 1, r, x, y);
return res;
}
inline void add(int x, long long y) {
for (; x <= n; x += ((x) & (-(x)))) c[x] += y;
}
inline long long query(int x) {
long long res = 0;
for (; x; x -= ((x) & (-(x)))) res += c[x];
return res;
}
int main() {
n = rd();
for (int i = 1; i <= n; i++) S[i] = rd(), M[i] = rd(), R[i] = rd();
for (int i = 1; i <= n; i++) st.insert(node(i, i, 0));
m = rd();
for (int i = 1; i <= m; i++) {
int t = rd(), l = rd(), r = rd();
if (r < n) split(r + 1);
for (set<node>::iterator it = split(l); it != st.end() && it->l <= r;
st.erase(it++)) {
if (it->t == 0)
pre_gao(it->l, it->r, t, i);
else
h[++tt] = (hhhh){it->l, it->r, t - it->t, i};
}
st.insert(node(l, r, t));
}
sort(h + 1, h + tt + 1, cmp);
for (int i = 1; i <= n; i++) g[i] = i;
sort(g + 1, g + n + 1, cmp1);
build(1, 1, n);
int now = 1;
for (int i = 1; i <= tt; i++) {
for (; now <= n && R[g[now]] && M[g[now]] / R[g[now]] + 1 <= h[i].t;
now++) {
del(1, 1, n, g[now]);
add(g[now], M[g[now]]);
}
gao(1, h[i].t - h[i - 1].t);
ans[h[i].id] +=
query(1, 1, n, h[i].l, h[i].r) + query(h[i].r) - query(h[i].l - 1);
}
for (int i = 1; i <= m; i++) print(ans[i]);
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int lazy[4 * N];
int tree[4 * N];
void prop(int start, int end, int pos) {
if (lazy[pos] == 0) return;
tree[pos] += lazy[pos];
if (start != end) {
lazy[2 * pos + 1] += lazy[pos];
lazy[2 * pos + 2] += lazy[pos];
}
lazy[pos] = 0;
}
int update(int start, int end, int ustart, int uend, int val, int pos) {
prop(start, end, pos);
if (ustart > end or uend < start) return tree[pos];
if (start >= ustart and end <= uend) {
lazy[pos] += val;
prop(start, end, pos);
return tree[pos];
}
int mid = (start + end) / 2;
int left = update(start, mid, ustart, uend, val, 2 * pos + 1);
int right = update(mid + 1, end, ustart, uend, val, 2 * pos + 2);
return tree[pos] = max(left, right);
}
int solve(int start, int end, int pos) {
if (tree[pos] + lazy[pos] <= 0) return -1;
while (start != end) {
prop(start, end, pos);
int mid = (start + end) / 2;
int l = 2 * pos + 1, r = 2 * pos + 2;
if (tree[r] + lazy[r] > 0) {
pos = 2 * pos + 2;
start = mid + 1;
} else {
pos = 2 * pos + 1;
end = mid;
}
}
return start;
}
int v[N];
int main() {
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int p, t;
scanf("%d %d", &p, &t);
p--;
if (t == 0) {
update(0, m - 1, 0, p, -1, 0);
} else {
scanf("%d", &v[p]);
update(0, m - 1, 0, p, 1, 0);
}
int idx = solve(0, m - 1, 0);
if (idx == -1)
printf("-1\n");
else
printf("%d\n", v[idx]);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100001], s, ans, i;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < n; i++) {
if (s <= a[i]) ans++, s += a[i];
}
cout << ans;
return 0;
}
| 5 |
//表
#include<bits/stdc++.h>
using namespace std;
int p[2005][2005];
int ans[2005];
/*void ran(int i,int v,int x,int y)
{
// cout<<i<<" "<<v<<" "<<x<<" "<<y<<endl;
if(i<0)
{
return ;
}
if(i==0)
{
p[x+100][y+100]++;
return ;
}
else if(v==0)
{
int t=rand()%2;
int b=rand()%2;
// cout<<t<<" "<<b<<endl;
if(t%2==0)
{
if(b%2==0)
return ran(i-1,2,x,y-1);
else return ran(i-1,2,x,y+1);
}
else
{
if(b%2==0)
return ran(i-1,1,x-1,y);
else return ran(i-1,1,x+1,y);
}
}
else if(v==1)
{
int t=rand()%2;
if(t%2==0)
{
return ran(i-1,2,x,y-1);
}
else
{
return ran(i-1,2, x, y+1);
}
}
else if(v==2)
{
int t=rand()%2;
if(t%2==0)
{
return ran(i-1,1,x-1,y);
}
else
{
return ran(i-1,1, x+1, y);
}
}
}*/
int main()
{
/* for(int i=1;i<=100;i++)
{
for(int j=0;j<=100000;j++)
{
//cout<<j<<endl;
ran(i,0,0,0);
}
for(int j=0;j<=305;j++)
{
for(int k=0;k<=305;k++)
{
if(p[j][k]!=0)
{
//if(i==2)
//cout<<j-100<<" "<<k-100<<endl;
ans[i]++;
p[j][k]=0;
}
}
}
cout<<ans[i]<<" "<<i<<endl;
}*/
int cnt=2;
for(int i=1;i<=505;i++)
{
ans[i*2]=cnt*cnt;
cnt++;
}
int from=0;
cnt=4;
for(int i=1;i<=1005;i++)
{
if(i%2==0)continue;
ans[i]=from+cnt;
cnt=cnt+4;
from=ans[i];
// cout<<ans[i]<<" "<<i<<endl;
}
int v;
cin>>v;
cout<<ans[v]<<endl;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int __n = 1e3 + 5, mod = 1e9 + 7, INF = 0x3f3f3f3f;
template <typename T>
inline void read(T &__result) {
T x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
__result = x * f;
}
string a, b;
int n;
vector<int> v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
cin >> n;
cin >> a >> b;
v.clear();
int len = a.length(), pos[__n];
for (int i = len - 1, p1 = 0, p2 = len - 1; i >= 0; i--) {
pos[i] = p1++;
i--;
if (i >= 0) pos[i] = p2--;
}
int change = 0;
bool flag = 0;
for (int i = len - 1; i >= 0; i--) {
if ((a[pos[i]] == b[i] && change % 2 == 0) ||
(a[pos[i]] != b[i] && change % 2 == 1)) {
v.push_back((1));
v.push_back((i + 1));
change++;
} else {
v.push_back((i + 1));
change++;
}
}
cout << v.size();
for (auto i : v) {
cout << ' ' << i;
}
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> arr[1001];
int ok[8];
int main() {
ios_base::sync_with_stdio(0);
int n, top, botton;
cin >> n >> top;
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
botton = 7 - top;
for (int i = 0; i < n; i++) {
ok[arr[i].first] = arr[i].first;
ok[7 - arr[i].first] = 7 - arr[i].first;
ok[arr[i].second] = arr[i].second;
ok[7 - arr[i].second] = 7 - arr[i].second;
if (ok[botton] == 0) {
botton = 7 - botton;
} else {
cout << "NO";
return 0;
}
fill(ok, ok + 8, 0);
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
int dp[1 << 10][1 << 7][2][2];
int pw[1 << 10];
int main() {
int n, k, m;
cin >> n >> k >> m;
dp[0][0][0][0] = 1 % m;
pw[0] = 1 % k;
for (int i = 1; i < 1 << 10; ++i) pw[i] = pw[i - 1] * 10 % k;
for (int i = 0; i < n; ++i) {
for (int r = 0; r < k; ++r) {
for (int j = 0; j < 2; ++j) {
for (int jj = 0; jj < 2; ++jj) {
for (int d = 0; d <= 9; ++d) {
if (d == 0 && i == n - 1) continue;
int rr = (r + pw[i] * d) % k;
int too = (d > 0) | jj;
int to = too & (rr == 0) | j;
dp[i + 1][rr][to][too] += dp[i][r][j][jj];
if (dp[i + 1][rr][to][too] >= m) dp[i + 1][rr][to][too] -= m;
}
}
}
}
}
int res = 0;
for (int i = 0; i < k; ++i) {
res += dp[n][i][1][1];
if (res >= m) res -= m;
}
cout << res << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin >> n >> k;
long long one = 1;
long long res = 0;
long long max_v = log2(n);
if ((one << max_v) > n) max_v--;
if (k == 1)
cout << n;
else {
for (int i = max_v; i >= 0; i--) {
res += one << (max_v - i);
}
cout << res;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long energy;
;
long long pref;
long long suff;
long long dist;
};
vector<node> st;
vector<int> d;
vector<int> h;
node combine(node left, node right, int m) {
if (left.energy == 0) {
return right;
} else if (right.energy == 0) {
return left;
}
node ans;
ans.energy =
max(max(left.energy, right.energy), left.suff + right.pref + d[m]);
ans.pref = max(left.pref, left.dist + d[m] + right.pref);
ans.suff = max(left.suff + d[m] + right.dist, right.suff);
ans.dist = left.dist + d[m] + right.dist;
return ans;
}
void build(int vi, int vl, int vr) {
if (vl == vr) {
st[vi].energy = 2 * h[vl];
st[vi].dist = 0;
st[vi].pref = 2 * h[vl];
st[vi].suff = 2 * h[vr];
0;
return;
}
int vm = (vl + vr) / 2;
build(vi * 2, vl, vm);
build(vi * 2 + 1, vm + 1, vr);
st[vi] = combine(st[vi * 2], st[vi * 2 + 1], vm);
0;
}
node getmax(int vi, int vl, int vr, int l, int r) {
if (vl > r || vr < l || r < l) {
node ans;
ans.energy = 0;
ans.pref = 0;
ans.suff = 0;
ans.dist = 0;
return ans;
}
if (vl == l && vr == r) {
0;
return st[vi];
}
int vm = (vl + vr) / 2;
node nl = getmax(vi * 2, vl, vm, l, min(r, vm));
node nr = getmax(vi * 2 + 1, vm + 1, vr, max(l, vm + 1), r);
node ans = combine(nl, nr, vm);
0;
return ans;
}
void solve() {
int n, m;
cin >> n >> m;
d.resize(2 * n);
h.resize(2 * n);
for (int i = 0; i < n; ++i) {
cin >> d[i];
d[n + i] = d[i];
}
for (int i = 0; i < n; ++i) {
cin >> h[i];
h[n + i] = h[i];
}
int base = 1;
while (base < 2 * n) {
base *= 2;
}
0;
st.resize(base * 2);
build(1, 0, 2 * n - 1);
for (int i = 0; i < base * 2; ++i) {
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
node ans;
if (b < a) {
ans = getmax(1, 0, 2 * n - 1, b + 1, a - 1);
} else {
ans = getmax(1, 0, 2 * n - 1, b + 1, a + n - 1);
}
0;
cout << ans.energy << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
vector<pair<int, int>> a;
int x, y;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
a.push_back(make_pair(x, y));
}
sort(a.begin(), a.end());
int count = 0;
int pos = 0;
for (int i = n - 2; i >= 0; --i) {
if (a[i].first != a[n - 1].first) {
pos = i;
break;
}
}
int flag3 = 0, flag4 = 0;
int flag = 0, flag1 = 0;
for (int k = 0; k < n; ++k) {
flag3 = 0, flag4 = 0;
for (int i = 0; i < n; ++i) {
if (a[k].first > a[i].first && a[k].second == a[i].second)
flag3 = 1;
else if (a[k].first < a[i].first && a[k].second == a[i].second)
flag4 = 1;
if (flag3 == 1 && flag4 == 1) break;
}
if (flag3 == 1 && flag4 == 1) {
flag = 0, flag1 = 0;
for (int j = 0; j < n; ++j) {
if (a[k].first == a[j].first && a[k].second > a[j].second &&
flag == 0)
flag = 1;
else if (a[k].first == a[j].first && a[k].second < a[j].second &&
flag1 == 0)
flag1 = 1;
if (flag == 1 && flag1 == 1) break;
}
if (flag == 1 && flag1 == 1) count++;
}
}
cout << count;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> d(15);
multiset<long long int> s;
int flag = 0;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (x < 2048) {
s.insert(x);
} else if (x == 2048) {
flag = 1;
}
}
if (flag)
cout << "YES" << endl;
else {
int found = 0;
while (s.size()) {
auto it = s.begin();
long long int fv = *it;
it++;
long long int sv = *it;
if (fv == sv) {
long long int adder = 2 * (fv);
s.erase(s.begin());
s.erase(s.begin());
s.insert(adder);
if (adder == 2048) {
found = 1;
break;
}
} else {
s.erase(s.begin());
}
}
if (found)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
int main() {
int tc = 1;
cin >> tc;
while (tc--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, j, k, n, m;
scanf("%d", &n);
int foo = 0, bar = 0, baz = 0, quz = 1;
int pur;
for (i = 0; i < n; i++) {
scanf("%d", &pur);
foo = foo + pur;
bar = bar + 1;
if (max(foo * quz, bar * baz) == foo * quz) {
baz = foo;
quz = bar;
}
}
printf("%f\n", double(baz) / double(quz));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<long long>> grid;
long long number = 1;
long long k;
void In() {
cin >> n;
grid.resize(n, vector<long long>(n, 0));
}
bool IsColored(int i, int j) { return i % 2 == 0; }
void PrintCoordinate(pair<int, int>& curr_coordinate) {
cout << curr_coordinate.first + 1 << ' ' << curr_coordinate.second + 1
<< '\n';
}
void AnswerQuerry() {
int total_queries = 2 * n - 1;
cin >> k;
pair<int, int> curr_coordinate = {0, 0};
PrintCoordinate(curr_coordinate);
for (int i = 1; i < total_queries - 1; i++, k /= 2) {
if (k % 2 == 1) {
if (IsColored(curr_coordinate.first + 1, curr_coordinate.second))
curr_coordinate.first++;
else
curr_coordinate.second++;
} else {
if (IsColored(curr_coordinate.first + 1, curr_coordinate.second))
curr_coordinate.second++;
else
curr_coordinate.first++;
}
PrintCoordinate(curr_coordinate);
}
curr_coordinate = {n - 1, n - 1};
PrintCoordinate(curr_coordinate);
cout.flush();
}
void Solve() {
for (int diagonal = 1; diagonal < 2 * n - 2; diagonal++, number *= 2)
for (int i = 0; i < n; i++) {
int j = diagonal - i;
if (j >= 0 && j <= n - 1)
if (IsColored(i, j)) grid[i][j] = number;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << grid[i][j] << ' ';
cout << endl;
}
int q;
cin >> q;
while (q--) AnswerQuerry();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
In();
Solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pi;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<int> vi;
int mod = 998244353;
void solve(){
int n; cin >> n;
vector<int>A(n), dp(n+1), l(n+1), r(n+1), f(n+1),maxCnt(n+2);
for (int i = 0 ;i < n; i++){
cin >> A[i];
if (!l[A[i]]) l[A[i]] = i+1;
r[A[i]] = i+1;
}
for (int i = n - 1; i >= 0; i--){
f[A[i]]++;
maxCnt[i] = max(maxCnt[i+1], f[A[i]]);
}
int ans = n;
for (int i = 1; i <= n; i++){
dp[i] = dp[i-1];
if (r[A[i-1]] == i){
dp[i] = max(dp[i], dp[l[A[i-1]]] + f[A[i-1]]);
}
ans = min(ans, n - maxCnt[i] - dp[i]);
}
cout << ans << "\n";
}
int main(){
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
ll t = 1;
//cin >> t;
while(t--){
solve();
}
return 0;
}
//120 50 100 100 70000
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int x;
vector<long long int> v;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
vector<long long int>::iterator it;
vector<long long int>::iterator it2;
vector<long long int>::iterator it4;
vector<long long int> v2;
long long int l = 0;
long long int r = 0;
for (it2 = v.begin(); it2 != v.end(); it2++) {
if (!v2.empty()) {
if ((*it2) < 0) {
it4 = find(v2.begin(), v2.end(), (*it2));
if (it4 == v2.end()) {
v2.push_back(*it2);
}
}
}
if ((*it2) == 0) {
l++;
}
if (v2.empty() && (*it2) < 0) {
v2.push_back(*it2);
}
}
vector<int>::iterator it3;
long long int sum = 0;
for (it = v2.begin(); it != v2.end(); it++) {
long long int c = count(v.begin(), v.end(), abs(*it));
long long int d = count(v.begin(), v.end(), *it);
sum = sum + c * d;
}
long long int f = ((l) * (l - 1)) / 2;
cout << sum + f << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int ss = s.size(), vk = 0, cnt;
for (int i = 0; i < ss - 1; i++)
if (s[i] == 'V' && s[i + 1] == 'K') vk++;
for (int i = 0; i < ss; i++) {
if (s[i] == 'V')
s[i] = 'K';
else
s[i] = 'V';
cnt = 0;
for (int j = 0; j < ss - 1; j++)
if (s[j] == 'V' && s[j + 1] == 'K') cnt++;
vk = max(vk, cnt);
if (s[i] == 'V')
s[i] = 'K';
else
s[i] = 'V';
}
cout << vk;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
#define IOS ios::sync_with_stdio(0); cin.tie(0);
#define endl '\n'
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define sz(v) (int)(v).size()
#define mk make_pair
#define F first
#define S second
#define debug(a) cout << #a << " = " << a << endl;
//#define int long long
const int INF = 1000000009;
const ll MOD = 1000000007LL;
int n;
int a[100009];
char ans[100009];
signed main() { IOS
cin >> n;
for (int i = 1; i <= n; ++ i) cin >> a[i];
string s; cin >> s;
if (s == "+-" || s == "-+") s = "+";
if (sz(s) == 1) {
for (int i = 1; i <= n - 1; ++ i) ans[i] = s[0];
}
else if (s == "*-" || s == "-*") {
for (int i = 1; i <= n - 1; ++ i) ans[i] = '*';
for (int i = 1; i <= n; ++ i) {
if (a[i] == 0) {
ans[i - 1] = '-';
break;
}
}
}
else s = "InuiTokoKawaii";
vector<int> dp(n + 1), dp_prev(n + 1);
auto Solve = [&](int l, int r) -> void {
while (a[l] == 1) l ++;
while (a[r] == 1) r --;
if (r <= l) return;
int res = 1;
for (int i = l; i <= r; ++ i) {
res *= a[i];
if (res >= 2 * (r - l + 1)) {
for (int j = l; j <= r - 1; ++ j) ans[j] = '*';
return;
}
}
for (int i = l; i <= r; ++ i) {
dp[i] = 0;
dp_prev[i] = -1;
}
dp[l - 1] = 0;
for (int i = l; i <= r; ++ i) {
if (a[i] == 1) {
dp[i] = dp[i - 1] + a[i];
dp_prev[i] = i - 1;
continue;
}
int res = a[i];
for (int j = i - 1; j >= l - 1; -- j) {
if (dp[i] <= dp[j] + res) {
dp[i] = dp[j] + res;
dp_prev[i] = j;
}
res *= a[j];
}
}
for (int i = r; i >= l; i = dp_prev[i]) {
for (int j = dp_prev[i] + 1; j < i; ++ j)
ans[j] = '*';
}
};
if (s == "InuiTokoKawaii") {
for (int i = 1; i <= n - 1; ++ i) ans[i] = '+';
for (int i = 1, j = 1; i <= n; i = j) {
if (j <= n && a[j] == 0) {
++ j;
continue;
}
while (j <= n && a[j] != 0) ++ j;
Solve(i, j - 1);
}
}
for (int i = 1; i <= n; ++ i) {
cout << a[i];
if (i != n) cout << ans[i];
}
} | 19 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec;
inline long long gcd(long long a, long long b) {
return a % b ? gcd(b, a % b) : b;
}
inline long long calc(long long a, long long b) {
long long Max = 0;
for (int i = 0; i < vec.size(); ++i) {
long long t = vec[i];
if (a % t) continue;
Max = max(Max, b / t * t);
}
return Max;
}
int main() {
long long a, b, c;
cin >> a >> b;
c = a;
for (long long i = 2; i <= c; ++i) {
if (i * i > c) break;
if (c % i == 0) {
vec.push_back(i);
while (c % i == 0) c /= i;
}
}
if (c > 1) vec.push_back(c);
long long ans = 0;
while (b) {
long long g = gcd(a, b);
a /= g, b /= g;
long long nxt = calc(a, b);
ans += b - nxt;
b = nxt;
}
cout << ans;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
const int N = 3e5 + 5;
int n, del[N];
int st[N], top, ok[N];
struct node {
double l, r;
int id;
} s[N];
bool cmp(const node &a, const node &b) {
return a.l == b.l ? a.r > b.r : a.l > b.l;
}
double cacl(node a, node b) {
return a.l * b.l * (b.r - a.r) / ((b.l - a.l) * a.r * b.r);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
s[i].l = read();
s[i].r = read();
s[i].id = i;
}
sort(s + 1, s + n + 1, cmp);
double maxn = -1e9;
for (int i = 1; i <= n; i++) {
if (s[i].r <= maxn)
del[i] = 1;
else
maxn = s[i].r;
}
st[++top] = 1;
for (int i = 2; i <= n; i++) {
if (del[i]) continue;
while (top > 1 && cacl(s[i], s[st[top]]) < cacl(s[st[top - 1]], s[st[top]]))
top--;
st[++top] = i;
}
for (int i = 1; i <= top; i++) {
ok[s[st[i]].id] = 1;
int p = st[i] + 1;
while (p <= n && s[p].l == s[st[i]].l && s[p].r == s[st[i]].r)
ok[s[p].id] = 1, p++;
}
for (int i = 1; i <= n; i++)
if (ok[i]) printf("%d ", i);
putchar('\n');
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, i;
scanf("%I64d", &t);
long long int a[100011] = {0}, cnt[100011] = {0};
long long int dp[100011] = {0};
long long int max1 = 0;
for (int i = 0; i < t; ++i) {
scanf("%I64d", &a[i]);
cnt[a[i]]++;
if (a[i] > max1) {
max1 = a[i];
}
}
dp[0] = 0;
dp[1] = cnt[1];
for (i = 2; i <= max1; ++i) {
dp[i] = max(dp[i - 1], dp[i - 2] + cnt[i] * i);
}
printf("%I64d\n", dp[i - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void SieveOfEratosthenes(long long n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
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;
}
void print(vector<long long> a) {
for (long long i = 0; i < a.size(); i++) cout << a[i] << " ";
cout << "\n";
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
bool cmp(long long a, long long b) { return a > b; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = 0, p = 1, l = 0;
long long g = n;
set<long long> s;
bool f = true, f1 = false;
for (long long i = 2; i < g; i++) {
if (n % i == 0) {
f1 = true;
long long c = 0;
p = p * i;
long long k = n;
while (n % i == 0) {
n /= i;
c++;
}
long long j = 2;
long long h = 1;
while (j < c) {
j = j * 2;
h++;
}
if (j != c) f = false;
l = max(l, h);
if (c == 1)
s.insert(0);
else
s.insert(h);
}
}
if (s.size() > 1 || *s.begin() != l || !f) ans++;
ans += l;
if (!f1) ans = 0, p = g;
if (p == g) ans = 0;
cout << p << " " << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long power(long x, long n) {
if (n == 0) return 1;
if (n == 1) return x;
long n2 = n / 2;
long long po = power(x, n2);
if (n % 2) return po * po * x;
return po * po;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
class CFindMaximum {
public:
void solve(std::istream &cin, std::ostream &cout) {
int n, i, ans = 0, ans2 = 0, sum = 0;
cin >> n;
vector<int> v(n), V(n);
for (i = 0; i < n; i++) cin >> v[i];
string s;
cin >> s;
V[0] = v[0];
for (i = 1; i < n; i++) V[i] += V[i - 1] + v[i];
for (i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
if (i > 0) ans = max(ans, sum + V[i - 1]);
sum += v[i];
ans = max(ans, sum);
}
}
cout << ans << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
CFindMaximum solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m;
scanf("%d:%d", &h, &m);
for (int i = 0;; i++) {
if (h / 10 == m % 10 && h % 10 == m / 10) {
printf("%d\n", i);
return 0;
}
m++;
m %= 60;
if (m == 0) {
h++;
h %= 24;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, k;
std::cin >> n >> k;
std::vector<int> a(n);
for (auto& now : a) {
std::cin >> now;
}
if (k == 1) {
std::cout << *std::min_element(a.begin(), a.end()) << '\n';
} else if (k >= 3) {
std::cout << *std::max_element(a.begin(), a.end()) << '\n';
} else {
int max = *std::max_element(a.begin(), a.end());
if (a[0] == max || a[a.size() - 1] == max) {
std::cout << max << '\n';
} else {
std::cout << std::max(a[0], a[a.size() - 1]) << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
char BUF[1 << 22], *ST, *EN;
template <class T>
void read(T &x) {
int f = 0;
x = 0;
char ch = (ST == EN && (ST = BUF, EN = BUF + fread(BUF, 1, 1 << 21, stdin),
ST == EN)
? EOF
: *ST++);
for (; !isdigit(ch);
ch = (ST == EN && (ST = BUF, EN = BUF + fread(BUF, 1, 1 << 21, stdin),
ST == EN)
? EOF
: *ST++))
f |= (ch == '-');
for (; isdigit(ch);
ch = (ST == EN && (ST = BUF, EN = BUF + fread(BUF, 1, 1 << 21, stdin),
ST == EN)
? EOF
: *ST++))
x = x * 10 + ch - '0';
if (f) x = -x;
}
const int N = 65;
const int mod = 1e9 + 7;
int a[N], f[N][10], mx;
long long m;
inline const void add(int &x, const int y) {
x = (x + y >= mod ? x + y - mod : x + y);
}
int main() {
int T;
read(T);
while (T--) {
read(m);
for (int i = 0; i < 64; i++) {
a[i] = (m >> i & 1);
if (a[i]) mx = i;
}
memset(f, 0, sizeof f);
f[mx + 1][0] = 1;
for (int i = mx; i >= 0; i--) {
for (int j = 0; j <= 7; j++) {
if (!f[i + 1][j]) continue;
int now = j * 2 + a[i];
if (now <= 7)
add(f[i][0], f[i + 1][j]);
else
add(f[i][now - 7], f[i + 1][j]);
if (now < 7) add(f[i][now + 1], mod - f[i + 1][j]);
}
for (int j = 1; j <= 7; j++) add(f[i][j], f[i][j - 1]);
}
printf("%d\n", f[0][0]);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, h;
cin >> n >> h;
int f[n], width = 0;
for (int i = 0; i < n; ++i) {
cin >> f[i];
if (f[i] <= h) {
width++;
} else {
width += 2;
}
}
cout << width << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INFI = (1LL << 31) - 10;
const long long INFL = (1LL << 62);
const double eps = 1e-10;
const long double pi = acos(-1.0);
const int MAXN = 102;
int main() {
int n, k;
double x0, y0, ep;
scanf("%d%d%lf", &n, &k, &ep);
scanf("%lf%lf", &x0, &y0);
ep /= 1000.0;
double dist[MAXN];
for (int i = 1; i <= n; i++) {
double x1, y1;
scanf("%lf%lf", &x1, &y1);
dist[i] = sqrt(pow(x0 - x1, 2.0) + pow(y0 - y1, 2.0));
}
double lo = 0, hi = *max_element(dist + 1, dist + n + 1);
while (lo + eps < hi) {
double mid = (lo + hi) / 2;
double dp[MAXN][MAXN] = {};
double p[MAXN] = {};
for (int i = 1; i <= n; i++) {
if (dist[i] <= mid) {
p[i] = 1;
} else {
p[i] = exp(1 - dist[i] * dist[i] / mid / mid);
}
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = dp[i - 1][0] * (1 - p[i]);
dp[i][i] = dp[i - 1][i - 1] * p[i];
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++) {
dp[i][j] = dp[i - 1][j - 1] * p[i] + dp[i - 1][j] * (1.0 - p[i]);
}
}
double risk = 0;
for (int i = 0; i < k; i++) {
risk += dp[n][i];
}
if (risk < ep + eps) {
hi = mid;
} else {
lo = mid;
}
}
printf("%0.20lf", lo);
return 0;
}
| 13 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const int maxn = 2005;
int n, m, ans[maxn << 2];
char s[maxn], t[maxn];
inline void shift(int x) {
reverse(s, s + n);
if (x < n) reverse(s + x, s + n);
ans[++m] = x;
}
int main() {
scanf("%d%s%s", &n, s, t);
for (int i = n - 1; ~i; --i) {
int j = n - i - 1;
while (j < n && s[j] != t[i]) ++j;
if (j == n) {
puts("-1");
return 0;
}
shift(n), shift(j), shift(1);
}
printf("%d\n", m);
for (int i = 1; i <= m; ++i) printf("%d%c", ans[i], i == m ? '\n' : ' ');
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
bool fastsort(int x, int y) { return x > y; }
int cmp_str(int x, string s1) {
int ans;
string s;
while (x > 0) {
ans = x % 10;
x /= 10;
s += (ans + 48);
}
if (s == s1) {
return 1;
}
return 0;
}
int to_int(int x, string s) {
int p = 1;
for (int i = s.size() - 1; i >= 0; i--) {
x += (s[i] - 48) * p;
p *= 10;
}
return x;
}
vector<int> v;
set<int> se;
string s, s1;
pair<int, int> pa;
long long a, b[100001], c, ans, cnt, x1, y2, x2, d[100001];
int main() {
cin >> a;
for (int i = 1; i <= a; i++) {
cin >> b[i];
if (b[i] != 0) {
se.insert(b[i]);
}
}
cout << se.size();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class CPattern {
public:
void solve(std::istream& in, std::ostream& out) {
long long n;
in >> n;
vector<string> arr;
for (long long i = 0; i < n; i++) {
string s;
in >> s;
arr.emplace_back(s);
}
long long m = arr[0].length();
for (long long j = 0; j < m; j++) {
char c = '?';
bool ok = true;
for (long long i = 0; i < n; i++) {
if (arr[i][j] == '?') continue;
if (c == '?')
c = arr[i][j];
else if (c != arr[i][j])
ok = false;
}
if (c == '?') c = 'a';
if (ok)
out << c;
else
out << '?';
}
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CPattern solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int>> mp;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
if (arr[arr[arr[i]]] == i) {
cout << "YES" << endl;
exit(0);
}
}
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0', c = getchar();
return x * f;
}
long long sp[N], c[N], w[N], flag[N];
namespace tarjan {
vector<int> g[N];
int dfn[N], low[N], gcnt, ln, fa[N];
stack<int> s;
void tarjan(int x, int f) {
dfn[x] = low[x] = ++gcnt;
s.push(x);
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (f == to) continue;
if (!dfn[to]) {
tarjan(to, x);
low[x] = min(low[x], low[to]);
} else
low[x] = min(low[x], dfn[to]);
}
if (dfn[x] == low[x]) {
++ln;
while (1) {
int cur = s.top();
s.pop();
fa[cur] = ln;
w[ln] += c[cur];
flag[ln] |= sp[cur];
if (cur == x) break;
}
}
}
} // namespace tarjan
struct Edge {
int u, v;
int w;
} e[N];
vector<pair<int, int> > g[N];
long long dp[N];
void dfs1(int x, int fa) {
for (pair<int, int> now : g[x]) {
int to = now.first;
if (fa == to) continue;
dfs1(to, x);
flag[x] |= flag[to];
}
}
void dfs2(int x, int fa) {
dp[x] = w[x];
for (pair<int, int> now : g[x]) {
int to = now.first;
if (fa == to) continue;
dfs2(to, x);
if (flag[to] == 0)
dp[x] += dp[to];
else if (dp[to] - now.second > 0)
dp[x] += dp[to] - now.second;
}
}
void dfs3(int x, int fa) {
for (pair<int, int> now : g[x]) {
int to = now.first, w = now.second;
if (fa == to) continue;
if (flag[to] == 1)
dp[to] += std::max(0ll, dp[x] - max(0ll, dp[to] - w) - w);
else
dp[to] = dp[x];
dfs3(to, x);
}
}
int main() {
int n = read(), m = read(), k = read();
for (int i = 1; i <= k; i++) {
int x = read();
sp[x] = 1;
}
for (int i = 1; i <= n; i++) c[i] = read();
for (int i = 1; i <= m; i++) e[i].w = read();
for (int i = 1; i <= m; i++) {
e[i].u = read(), e[i].v = read();
tarjan::g[e[i].u].push_back(e[i].v);
tarjan::g[e[i].v].push_back(e[i].u);
}
tarjan::tarjan(1, 0);
for (int i = 1; i <= m; i++) {
int u = tarjan::fa[e[i].u], v = tarjan::fa[e[i].v], w = e[i].w;
if (u != v) {
g[u].push_back(make_pair(v, w));
g[v].push_back(make_pair(u, w));
}
}
int rt = 1;
for (int i = 1; i <= tarjan::ln; i++)
if (flag[i]) rt = i;
dfs1(rt, 0);
dfs2(rt, 0);
dfs3(rt, 0);
for (int i = 1; i <= n; i++) printf("%lld ", dp[tarjan::fa[i]]);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 7;
const int N = (int)1e7 + 7;
char c[105][105];
int main() {
int n, m, x, y;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
}
}
int mni, mnj, mxi, mxj, ans = 0;
mni = mnj = inf;
mxi = mxj = -inf;
int bl = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] == 'B') {
mni = min(mni, i);
mnj = min(mnj, j);
mxi = max(mxi, i);
mxj = max(mxj, j);
bl++;
}
}
}
if (bl == 0) {
cout << 1;
return 0;
}
int raz = max(mxi - mni + 1, mxj - mnj + 1);
if (mni == inf) {
raz = 1;
}
if (raz > n || raz > m) {
puts("-1");
} else {
cout << raz * raz - bl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, v, h, maxh, maxv;
long long three[100010];
pair<long long, long long> ans;
void dfs(long long m, long long t, long long r) {
if (m == 0) {
ans = max(ans, make_pair(t, r));
return;
}
long long Do = upper_bound(three + 1, three + 100002, m) - three;
Do--;
dfs(m - three[Do], t + 1, r + three[Do]);
if (Do > 1) dfs(three[Do] - 1 - three[Do - 1], t + 1, r + three[Do - 1]);
}
int main() {
cin >> m;
for (long long i = 1; i <= 100001; i++) {
three[i] = i * i * i;
}
dfs(m, 0, 0);
printf("%lld %lld\n", ans.first, ans.second);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[10001];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
long long Sol = 0;
for (int i = 1; i <= n; i++) Sol += 1LL * G[i].size() * (G[i].size() - 1) / 2;
cout << Sol;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
const double PI = acos(-1.0);
template <class T>
inline T _abs(T n) {
return ((n) < 0 ? -(n) : (n));
}
template <class T>
inline T _max(T a, T b) {
return (!((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _min(T a, T b) {
return (((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _swap(T &a, T &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
int cnt[100004], n;
long long dp[100004];
long long call(int in) {
if (in <= 0) return 0;
if (in == 1) return cnt[1];
if (dp[in] != -1) return dp[in];
long long s1, s2;
s1 = s2 = -INF;
s1 = call(in - 1);
s2 = call(in - 2) + (long long)cnt[in] * (long long)in;
return dp[in] = max(s1, s2);
}
int main() {
while (~scanf("%d", &n)) {
int a[n];
memset(cnt, 0, sizeof(cnt));
memset(dp, -1, sizeof(dp));
long long maxy = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
maxy = max(maxy, (long long)a[i]);
cnt[a[i]]++;
}
printf("%I64d\n", call(maxy));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ar[] = {0, 0, 1, -1};
int ac[] = {1, -1, 0, 0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(7);
int n;
cin >> n;
string s;
cin >> s;
int cnt0, cnt1;
cnt0 = cnt1 = 0;
for (int i = 0; i < n; i++)
if (s[i] == '0')
cnt0++;
else
cnt1++;
if (cnt0 == cnt1) {
cout << 2 << '\n' << s.substr(0, n - 1) << ' ' << s.back();
} else
cout << 1 << ' ' << s << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> multiples8;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(20);
for (int i = 0; i < 1000; i++)
if (i % 8 == 0) multiples8.push_back(to_string(i));
string s;
cin >> s;
for (int i = 0; i < multiples8.size(); i++) {
int k = 0;
for (int j = 0; j < s.size(); j++) {
k += multiples8[i][k] == s[j];
if (k == multiples8[i].size()) {
cout << "YES\n";
cout << multiples8[i] << '\n';
return 0;
}
}
}
cout << "NO\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)1e5 + 1000;
const long long maxe = (long long)1e6 + 7;
const long long INF = (long long)1e9 + 7;
const double PI = acos(-1);
int dx[4] = {0, 0, 1, -1};
int dy[4] = {-1, 1, 0, 0};
void mul(long long &a, long long b) {
a = a * b % mod;
a %= mod;
}
int n;
struct E {
int to, x, col;
E(int to, int x, int col) : to(to), x(x), col(col) {}
};
vector<E> G[maxn];
bool cen[maxn];
int si[maxn];
long long ans = 1;
void calsize(int v, int p) {
si[v] = 1;
for (int i = 0; i < ((int)(G[v]).size()); i++) {
E e = G[v][i];
if (e.to == p || cen[e.to]) continue;
calsize(e.to, v);
si[v] += si[e.to];
}
}
pair<int, int> findcen(int v, int p, int t) {
pair<int, int> res = make_pair(INF, -1);
int s = 1, m = 0;
for (int i = 0; i < ((int)(G[v]).size()); i++) {
int u = G[v][i].to;
if (u == p || cen[u]) continue;
res = min(res, findcen(u, v, t));
m = max(m, si[u]);
s += si[u];
}
m = max(m, t - s);
res = min(res, make_pair(m, v));
return res;
}
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
n >>= 1;
x = x * x % mod;
}
return res;
}
long long NI(long long x) {
long long n = mod - 2;
return qpow(x, n);
}
struct BIT {
long long pro[maxn * 3];
int sum[maxn * 3];
void add(int x, long long p) {
while (x < maxn * 3) {
pro[x] *= p;
pro[x] %= mod;
sum[x] += 1;
x += x & -x;
}
}
pair<long long, int> cal(int x) {
long long res = 1;
int su = 0;
while (x) {
res *= pro[x];
res %= mod;
su += sum[x];
x -= x & -x;
}
return make_pair(res, su);
}
void clear(int x) {
while (x < maxn * 3) {
sum[x] = 0;
pro[x] = 1;
x += x & -x;
}
}
void init(vector<int> v) {
int a = v[0];
int b = v[1];
clear(2 * b - a + 2 * maxn);
}
};
BIT bit[2];
void add_sum(int a, int b, long long x) {
bit[0].add(2 * b - a + 2 * maxn, x);
bit[1].add(2 * a - b + 2 * maxn, x);
}
void dfs(int v, int p, vector<int> c, long long pro,
vector<pair<vector<int>, long long> > &V) {
V.push_back(make_pair(c, pro));
for (int i = 0; i < ((int)(G[v]).size()); i++) {
int u = G[v][i].to;
if (cen[u] || u == p) continue;
c[G[v][i].col]++;
dfs(u, v, c, pro * G[v][i].x % mod, V);
c[G[v][i].col]--;
}
}
pair<long long, int> cal(vector<int> col) {
pair<long long, int> res = bit[0].cal(3 * maxn - 1);
pair<long long, int> rs1 = bit[0].cal(col[0] - 2 * col[1] + 2 * maxn - 1);
pair<long long, int> rs2 = bit[1].cal(col[1] - 2 * col[0] + 2 * maxn - 1);
res.first *= NI(rs1.first);
res.first %= mod;
res.first *= NI(rs2.first);
res.first %= mod;
res.second -= rs1.second;
res.second -= rs2.second;
return res;
}
void solve(int v) {
calsize(v, -1);
int s = findcen(v, -1, si[v]).second;
cen[s] = true;
for (int i = 0; i < ((int)(G[s]).size()); i++) {
int u = G[s][i].to;
if (!cen[u]) solve(u);
}
add_sum(0, 0, 1);
vector<vector<int> > gar;
vector<int> beg(2, 0);
gar.push_back(beg);
for (int i = 0; i < ((int)(G[s]).size()); i++) {
int u = G[s][i].to;
if (cen[u]) continue;
vector<pair<vector<int>, long long> > V;
vector<int> c(2, 0);
c[G[s][i].col]++;
dfs(u, s, c, G[s][i].x, V);
for (int j = 0; j < V.size(); j++) {
pair<long long, int> rs = cal(V[j].first);
mul(ans, qpow(V[j].second, rs.second));
mul(ans, rs.first);
}
for (int j = 0; j < V.size(); j++) {
add_sum(V[j].first[0], V[j].first[1], V[j].second);
gar.push_back(V[j].first);
}
}
for (int i = 0; i < gar.size(); i++) {
bit[0].init(gar[i]);
reverse(gar[i].begin(), gar[i].end());
bit[1].init(gar[i]);
}
cen[s] = false;
}
int main() {
cin >> n;
for (int i = 0; i < 3 * maxn; i++) bit[0].pro[i] = bit[1].pro[i] = 1;
for (int i = 1; i < n; i++) {
int u, v, x, c;
cin >> u >> v >> x >> c;
G[u].push_back(E(v, x, c));
G[v].push_back(E(u, x, c));
}
solve(1);
cout << ans << endl;
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long s = 0;
long long f(long long x) {
int r = x % 4;
if (r == 1) return 1LL;
if (r == 2) return x + 1;
if (r == 3) return 0LL;
return x;
}
int main() {
cin >> n;
while (n--) {
long long x, m;
cin >> x >> m;
s ^= f(x - 1) ^ f(x + m - 1);
}
if (s != 0)
cout << "tolik\n";
else
cout << "bolik\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1 || n == 2) {
cout << 0 << endl;
continue;
}
int ok = 0, ans = 100001;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
for (int i = 1; i <= n; i++) b[i] = a[i];
int c = 0, ok = 1;
b[1] += i;
b[2] += j;
if (i) c++;
if (j) c++;
int d = b[2] - b[1];
for (int i = 3; i <= n; i++) {
if (b[i] - b[i - 1] == d)
continue;
else if (b[i] - b[i - 1] == d - 1)
b[i]++, c++;
else if (b[i] - b[i - 1] == d + 1)
b[i]--, c++;
else {
ok = 0;
break;
}
}
if (ok) ans = min(ans, c);
}
if (ans == 100001) {
cout << -1 << endl;
continue;
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> m >> n;
double Sum = 0;
double Count = 0;
for (double i = 1; i <= m; i++) {
double x = pow(i / m, n) - pow((i - 1) / m, n);
Sum += i * x;
}
cout.precision(12);
cout << fixed << double(Sum);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m;
int main() {
cin >> n >> m;
int ans = n + 5;
int l, r;
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
ans = min(r - l + 1, ans);
}
printf("%d\n", ans);
for (int i = 0; i < n; i++) printf("%d ", i % ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double a;
cin >> a;
if (a <= 127)
cout << "byte" << endl;
else if (a <= 32767)
cout << "short" << endl;
else if (a <= 2147483647)
cout << "int" << endl;
else if (a <= 9223372036854775807)
cout << "long" << endl;
else
cout << "BigInteger" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
long long int a[105][105];
void f(long long int x, long long int y, long long int val) {
if (a[x][y] != -1) return;
a[x][y] = val;
if (x + 1 <= n) {
if (y + 2 <= n) {
f(x + 1, y + 2, (val + 1) % 2);
}
if (y - 2 >= 1) {
f(x + 1, y - 2, (val + 1) % 2);
}
}
if (x + 2 <= n) {
if (y + 1 <= n) {
f(x + 2, y + 1, (val + 1) % 2);
}
if (y - 1 >= 1) {
f(x + 2, y - 1, (val + 1) % 2);
}
}
if (x - 1 >= 1) {
if (y + 2 <= n) {
f(x - 1, y + 2, (val + 1) % 2);
}
if (y - 2 >= 1) {
f(x - 1, y - 2, (val + 1) % 2);
}
}
if (x - 2 >= 1) {
if (y + 1 <= n) {
f(x - 2, y + 1, (val + 1) % 2);
}
if (y - 1 >= 1) {
f(x - 2, y - 1, (val + 1) % 2);
}
}
}
void solve(long long int t) {
cin >> n;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= n; j++) {
a[i][j] = -1;
}
}
f(1, 1, 0);
char ans[n + 1][n + 1];
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= n; j++) {
if (a[i][j] == 0)
ans[i][j] = 'W';
else
ans[i][j] = 'B';
cout << ans[i][j];
}
cout << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
for (long long int i = 1; i <= t; i++) {
solve(i);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 3) {
cout << "NO" << endl;
} else {
int curr = n;
int count = 0;
cout << "YES" << endl;
if (n % 2 == 0) {
while (curr > 4) {
cout << curr << " - " << curr - 1 << " = 1" << endl;
curr -= 2;
count++;
}
while (count--) {
cout << 1 << " * " << 1 << " = 1" << endl;
}
cout << 4 << " * " << 3 << " = 12" << endl;
cout << 2 << " * " << 12 << " = 24" << endl;
cout << 24 << " * " << 1 << " = 24" << endl;
} else {
while (curr > 5) {
cout << curr << " - " << curr - 1 << " = 1" << endl;
curr -= 2;
count++;
}
while (count--) {
cout << 1 << " * " << 1 << " = 1" << endl;
}
cout << 5 << " + " << 4 << " = 9" << endl;
cout << 9 << " + " << 3 << " = 12" << endl;
cout << 12 << " * " << 2 << " = 24" << endl;
cout << 24 << " * " << 1 << " = 24" << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, i, p, j;
double v = 0;
scanf("%d", &n);
int a[100];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
v += ((double)a[i] / n);
}
printf("%.12lf", v);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int maxn = 305;
int val[maxn][maxn];
int row[maxn], col[maxn];
int main() {
int T;
scanf("%d", &T);
int n, k;
while (T--) {
scanf("%d%d", &n, &k);
int i, j;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) val[i][j] = 0;
col[i] = row[i] = 0;
}
int x = 1, y = 1;
for (i = 0; i < k; i++) {
val[x][y] = 1;
x++, y++;
if (x > n) {
x = 1, y++;
}
if (y > n) y -= n;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
row[i] += val[i][j];
col[j] += val[i][j];
}
}
int rmax = row[1], rmin = row[1], cmax = col[1], cmin = col[1];
for (i = 1; i <= n; i++) {
rmax = max(rmax, row[i]);
rmin = min(rmin, row[i]);
cmax = max(cmax, col[i]);
cmin = min(cmin, col[i]);
}
int ans = (rmax - rmin) * (rmax - rmin) + (cmax - cmin) * (cmax - cmin);
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
for (j = 1; j < n; j++) {
printf("%d", val[i][j]);
}
printf("%d\n", val[i][j]);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int k;
int main() {
scanf("%d", &k);
if (k % 2) {
printf("-1\n");
return 0;
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
for (int l = 0; l < k; l++)
printf("%c", (i / 2 + j % 2 + l / 2) % 2 ? 'w' : 'b');
printf("\n");
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1ll * inf * inf;
const int N = 500000 + 7;
const int M = 31;
const int multipleTest = 0;
class SegmentTree {
public:
const static int MAXN = N;
struct node {
long long val;
int lz;
int leftChild;
int rightChild;
int leftIdx, rightIdx;
int sz;
node() {
val = lz = 0;
rightChild = leftChild = -1;
}
void reset(int u, int v, int _left, int _right) {
val = lz = 0;
leftChild = _left;
rightChild = _right;
leftIdx = u;
rightIdx = v;
sz = rightIdx - leftIdx + 1;
}
};
node tree[MAXN * 2];
int cnt = 0;
void buildTree(node& root, int l, int r) {
if (l == r) {
root.reset(l, r, -1, -1);
return;
}
int g = (l + r) >> 1;
int leftChild = cnt++, rightChild = cnt++;
buildTree(tree[leftChild], l, g);
buildTree(tree[rightChild], g + 1, r);
root.reset(l, r, leftChild, rightChild);
}
void init(int l, int r) {
cnt = 1;
buildTree(tree[0], l, r);
}
inline void pushDown(node& root, int val) {
root.val += val * root.sz;
root.lz += val;
}
inline void updateLz(node& root) {
if (root.lz) {
pushDown(tree[root.leftChild], root.lz);
pushDown(tree[root.rightChild], root.lz);
root.lz = 0;
}
}
void update(node& root, int u, int v) {
if (root.leftIdx == u && root.rightIdx == v) {
pushDown(root, 1);
return;
}
updateLz(root);
int g = (root.leftIdx + root.rightIdx) >> 1;
if (u <= g) update(tree[root.leftChild], u, min(g, v));
if (g < v) update(tree[root.rightChild], max(u, g + 1), v);
root.val = tree[root.leftChild].val + tree[root.rightChild].val;
return;
}
void update(int u, int v) { update(tree[0], u, v); }
long long get(node& root, int u, int v) {
if (u <= root.leftIdx && root.rightIdx <= v) return root.val;
if (u > root.rightIdx || v < root.leftIdx) return 0;
updateLz(root);
long long res =
get(tree[root.leftChild], u, v) + get(tree[root.rightChild], u, v);
return res;
}
long long get(int u, int v) { return get(tree[0], u, v); }
} segmentTree;
vector<int> adj[N];
int pa[N];
int pos[N];
int nxt[N], f[N];
int depth[N];
int root[N];
int k = 0;
int n;
vector<int> ver[N];
void dfs(int u, int r) {
pa[u] = r;
f[u] = 1;
ver[depth[u]].push_back(u);
for (int v : adj[u]) {
if (v != r) {
depth[v] = depth[u] + 1;
dfs(v, u);
f[u] += f[v];
if (nxt[u] == 0 || f[nxt[u]] < f[v]) {
nxt[u] = v;
}
}
}
}
void buildHLD() {
for (int i = 0; i < n; ++i) {
for (int u : ver[i]) {
if (pos[u] == 0) {
root[u] = u;
pos[u] = ++k;
int v = u;
while (nxt[v]) {
v = nxt[v];
pos[v] = ++k;
root[v] = u;
}
}
}
}
}
long long res[N];
void update(int u) {
while (u != -1) {
int r = root[u];
segmentTree.update(pos[r], pos[u]);
u = pa[r];
}
}
long long get(int u) {
long long cur = 0;
while (u != -1) {
int r = root[u];
cur += segmentTree.get(pos[r], pos[u]);
u = pa[r];
}
return cur;
}
void solve() {
cin >> n;
for (int i = (1), _b = (n + 1); i < _b; ++i) {
int u;
scanf("%d", &u);
adj[u].push_back(i);
}
dfs(adj[0].back(), -1);
buildHLD();
segmentTree.init(1, n);
for (int d = 0; d < n; ++d) {
for (int u : ver[d]) {
update(u);
}
for (int u : ver[d]) {
res[u] = get(u) - (d + 1);
}
}
string rr = "";
for (int i = (1), _b = (n); i <= _b; ++i) {
if (res[i]) {
string cur = "";
while (res[i]) {
int c = res[i] % 10;
cur += char(c + '0');
res[i] /= 10;
}
reverse(cur.begin(), cur.end());
rr += cur;
} else
rr += '0';
rr += ' ';
}
cout << rr;
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(const int &a, const int &b) { return a > b; }
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
long long int n;
cin >> n;
vector<long long int> v;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
v.push_back(x);
}
sort(begin(v), end(v));
long long int ans = 1;
for (int i = 0; i < n; i++) {
if (v[i] >= ans) ans++;
}
cout << ans - 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int n, k;
string t, s[maxn];
bool ans, a, b;
int main() {
string t;
cin >> t >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == t) {
ans = 1;
}
if (s[i][0] == t[1]) {
a = 1;
}
if (s[i][1] == t[0]) {
b = 1;
}
ans |= a && b;
}
if (ans) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int nmax = 210;
int c[nmax][nmax];
int f[nmax][nmax];
vector<int> g[nmax];
int gA[2010];
int* gAf[nmax];
int gAk[nmax];
int G[nmax][nmax];
vector<int> Gv[nmax];
bool used[nmax];
int T;
int d[nmax];
int q[nmax];
bool bfs(int s, int t) {
memset((d), -1, sizeof(d));
d[s] = 0;
int ql = 0;
int qr = 0;
q[qr++] = s;
while (ql < qr) {
int v = q[ql++];
for (int(i) = 0; (i) < (int((g[v]).size())); ++(i)) {
int to = g[v][i];
if (d[to] == -1 && f[v][to] < c[v][to]) {
d[to] = d[v] + 1;
q[qr++] = to;
}
}
}
return d[t] != -1;
}
int idx[nmax];
int dfs(int v, int mn) {
if (v == T) return mn;
used[v] = true;
int pushed = 0;
for (; idx[v] < gAk[v] && pushed < mn; ++idx[v]) {
int to = gAf[v][idx[v]];
if (!used[to] && d[to] == d[v] + 1 && f[v][to] < c[v][to]) {
int val = dfs(to, min(mn - pushed, c[v][to] - f[v][to]));
if (val) {
f[v][to] += val;
f[to][v] -= val;
pushed += val;
}
}
}
return pushed;
}
int flow(int s, int t) {
memset((f), 0, sizeof(f));
T = t;
int res = 0;
while (bfs(s, t)) {
memset((idx), 0, sizeof(idx));
memset((used), 0, sizeof(used));
int val;
while (val = dfs(s, 1000000000)) {
res += val;
}
}
return res;
}
void dfsReachable(int v) {
used[v] = true;
for (int(i) = 0; (i) < (int((g[v]).size())); ++(i)) {
int to = g[v][i];
if (!used[to] && f[v][to] < c[v][to]) dfsReachable(to);
}
}
int comp[nmax];
void dfsFindBest(int v) {
used[v] = true;
for (int(i) = 0; (i) < (int((Gv[v]).size())); ++(i)) {
int to = Gv[v][i];
if (!used[to] && G[v][to]) dfsFindBest(to);
}
}
void findBest(vector<int> a, int answer[]) {
if (a.size() == 1) {
answer[0] = a[0];
return;
}
int curMin = 1000000000;
int v = -1, u = -1;
for (int(i) = 0; (i) < (int((a).size())); ++(i))
for (int(j) = 0; (j) < (i); ++(j))
if (G[a[i]][a[j]] && curMin > G[a[i]][a[j]]) {
curMin = G[a[i]][a[j]];
v = a[i];
u = a[j];
}
G[v][u] = G[u][v] = 0;
memset((used), 0, sizeof(used));
dfsFindBest(v);
vector<int> b;
vector<int> c;
for (int(i) = 0; (i) < (int((a).size())); ++(i)) {
if (used[a[i]]) {
b.push_back(a[i]);
} else {
c.push_back(a[i]);
}
}
findBest(b, answer);
findBest(c, answer + b.size());
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int(i) = 0; (i) < (m); ++(i)) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
--x;
--y;
c[x][y] = c[y][x] += z;
g[x].push_back(y);
g[y].push_back(x);
}
int* gPointer = gA;
for (int(v) = 0; (v) < (n); ++(v)) {
gAf[v] = gPointer;
gAk[v] = g[v].size();
for (int(i) = 0; (i) < (int((g[v]).size())); ++(i)) *gPointer++ = g[v][i];
}
int ans = 0;
for (int(k) = 0; (k) < (n - 1); ++(k)) {
int s = -1, t = -1;
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (n); ++(j)) {
if (i != j && comp[i] == comp[j]) {
s = i;
t = j;
}
}
}
assert(s != -1 && t != -1 && s != t);
int flowFound = flow(s, t);
ans += flowFound;
G[s][t] = G[t][s] = flowFound;
Gv[s].push_back(t);
Gv[t].push_back(s);
memset((used), 0, sizeof(used));
dfsReachable(s);
for (int(i) = 0; (i) < (n); ++(i))
if (comp[i] == comp[s] && !used[i]) comp[i] = k + 1;
}
cout << ans << endl;
vector<int> a(n);
int answer[nmax];
for (int(i) = 0; (i) < (n); ++(i)) a[i] = i;
findBest(a, answer);
for (int(i) = 0; (i) < (n); ++(i))
cout << answer[i] + 1 << (i + 1 == n ? "\n" : " ");
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const double G = 6.67430e-11;
int t;
int n;
int a[maxn];
int main() {
cin >> t;
while (t--) {
cin >> n;
int s = 0;
for (int i = 1; i <= n; ++i) cin >> a[i];
if (a[1] == 1) s++;
int p = 0;
for (int i = 2; i <= n; ++i) {
if (a[i] == 1)
p++;
else {
s += p / 3;
p = 0;
}
if (i == n) s += p / 3;
}
cout << s << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char S[1000], ch;
int b, g, r, y, ex = 0;
int one = 0, two = 0, three = 0, four = 0;
cin >> S;
int l = strlen(S);
for (int i = 0; i < l; i = i + 4) {
if (S[i] == '!')
ex++;
else
ch = S[i];
}
if (ch == 'B') b = ex;
if (ch == 'G') g = ex;
if (ch == 'R') r = ex;
if (ch == 'Y') y = ex;
ex = 0;
for (int i = 1; i < l; i = i + 4) {
if (S[i] == '!')
ex++;
else
ch = S[i];
}
if (ch == 'B') b = ex;
if (ch == 'G') g = ex;
if (ch == 'R') r = ex;
if (ch == 'Y') y = ex;
ex = 0;
for (int i = 2; i < l; i = i + 4) {
if (S[i] == '!')
ex++;
else
ch = S[i];
}
if (ch == 'B') b = ex;
if (ch == 'G') g = ex;
if (ch == 'R') r = ex;
if (ch == 'Y') y = ex;
ex = 0;
for (int i = 3; i < l; i = i + 4) {
if (S[i] == '!')
ex++;
else
ch = S[i];
}
if (ch == 'B') b = ex;
if (ch == 'G') g = ex;
if (ch == 'R') r = ex;
if (ch == 'Y') y = ex;
cout << r << " " << b << " " << y << " " << g << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, res;
int matrixs[120][120];
bool jgood(int row, int col) {
return row == n / 2 || col == n / 2 || row == col || row + col == n - 1;
}
void calcT(void) {
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j)
if (jgood(i, j)) res += matrixs[i][j];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (n); ++j) scanf("%d", &matrixs[i][j]);
res = 0;
calcT();
printf("%d\n", res);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long h[200005], to[200005], ne[200005], en = 0, fr[200005], siz[200005],
dst[200005];
vector<long long> ve, v[200005], prs[200005];
map<pair<long long, long long>, double> ans;
void add(long long a, long long b) {
to[en] = b;
fr[en] = a;
ne[en] = h[a];
h[a] = en++;
}
long long n, m, q, fa[200005], dep[200005], mx, mxl, mxr, maxx[200005];
long long gf(long long k) {
if (fa[k] == k)
return k;
else
return fa[k] = gf(fa[k]);
}
void dfs_to_que(long long o, long long fa) {
if (dep[o] > mx) mx = dep[o], mxl = o;
ve.push_back(o);
for (long long i = h[o]; i >= 0; i = ne[i])
if (to[i] != fa) {
dep[to[i]] = dep[o] + 1;
dfs_to_que(to[i], o);
}
}
void dfs(long long o, long long fa) {
if (dep[o] > mx) mx = dep[o], mxl = o;
for (long long i = h[o]; i >= 0; i = ne[i])
if (to[i] != fa) {
dep[to[i]] = dep[o] + 1;
dfs(to[i], o);
}
}
void solve(long long o) {
ve.clear();
mx = -1;
mxl = -1;
dfs_to_que(o, 0);
long long rt = mxl;
mx = -1;
mxl = -1;
dep[rt] = 0;
dfs(rt, 0);
for (long long i = 0; i < (long long)ve.size(); ++i)
maxx[ve[i]] = max(maxx[ve[i]], dep[ve[i]]);
dep[mxl] = 0;
dfs(mxl, 0);
for (long long i = 0; i < (long long)ve.size(); ++i)
maxx[ve[i]] = max(maxx[ve[i]], dep[ve[i]]);
}
double Cal(long long a, long long b) {
double ret = 0;
if (siz[a] > siz[b]) swap(a, b);
long long lim = max(dst[a], dst[b]), sb = v[b].size();
for (long long i = 0; i < (long long)v[a].size(); ++i) {
long long l = 0, r = v[b].size() - 1;
while (l < r) {
long long mid = (l + r) >> 1;
if (v[a][i] + v[b][mid] + 1 <= lim)
l = mid + 1;
else
r = mid;
}
if (l >= 0 && l < (long long)v[b].size() && v[b][l] + v[a][i] + 1 <= lim)
l++;
if (l >= 0 && l < (long long)v[b].size() && v[b][l] + v[a][i] + 1 > lim)
l--;
if (l == (long long)v[b].size())
ret += sb * lim;
else if (l == -1)
ret += prs[b][sb - 1] + v[a][i] * sb + sb;
else {
ret += (prs[b][sb - 1] - (l == 0 ? 0 : prs[b][l - 1])) +
(sb - l) * (v[a][i] + 1);
ret += l * lim;
}
}
return ret;
}
signed main() {
memset(h, -1, sizeof h);
scanf("%I64d%I64d%I64d", &n, &m, &q);
for (long long i = 1; i <= n; ++i) fa[i] = i;
for (long long i = 1; i <= m; ++i) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
add(x, y);
add(y, x);
fa[gf(x)] = y;
}
for (long long i = 1; i <= n; ++i)
if (gf(i) == i) solve(i);
for (long long i = 1; i <= n; ++i)
siz[gf(i)]++, v[gf(i)].push_back(maxx[i]),
dst[gf(i)] = max(maxx[i], dst[gf(i)]);
for (long long i = 1; i <= n; ++i)
if (gf(i) == i) {
sort(v[i].begin(), v[i].end());
long long now = 0;
for (long long j = 0; j < (long long)v[i].size(); ++j) {
now += v[i][j];
prs[i].push_back(now);
}
}
for (long long i = 1; i <= q; ++i) {
long long fl, fr, l, r;
scanf("%I64d%I64d", &l, &r);
fl = gf(l);
fr = gf(r);
if (fl == fr) {
printf("-1\n");
continue;
}
if (fl > fr) swap(fl, fr);
if (ans[make_pair(fl, fr)])
printf("%.10lf\n", ans[make_pair(fl, fr)] / (1.0 * siz[fl] * siz[fr]));
else
printf("%.10lf\n", (ans[make_pair(fl, fr)] = Cal(fl, fr)) /
(1.0 * siz[fl] * siz[fr]));
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
struct pt {
int x, y;
pt() {}
pt(int _x, int _y) : x(_x), y(_y) {}
pt operator-(const pt &p) const { return pt(x - p.x, y - p.y); }
long long operator%(const pt &p) const {
return 1LL * x * p.x + 1LL * y * p.y;
}
long long d2() const { return (*this) % (*this); }
double d() const { return sqrt((double)d2()); }
};
void upd(double &x, double y) { x = max(x, y); }
const int N = 5050;
double dp[N / 2][N][2];
int main() {
int n;
while (scanf("%d", &n) == 1) {
vector<pt> a(n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
}
for (int i = 0; i < n; i++) a.push_back(a[i]);
int N = a.size();
for (int i = 0; i < N / 2; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < 2; k++) dp[i][j][k] = -1;
double ans = 0;
function<double(int, int, int)> get = [&](int i, int j, int k) {
if (i >= n) {
i -= n;
j -= n;
}
if (dp[i][j][k] > -0.5) return dp[i][j][k];
dp[i][j][k] = 0;
pt s = k == 0 ? a[i] : a[j];
if (i + 1 != j) {
upd(dp[i][j][k], get(i + 1, j, 0) + (a[i + 1] - s).d());
upd(dp[i][j][k], get(i, j - 1, 1) + (a[j - 1] - s).d());
}
return dp[i][j][k];
};
for (int i = 0; i < n; i++) {
for (int j = 1; j < n && i + j < N; j++) {
for (int k = 0; k < 2; k++) {
ans = max(ans, get(i, i + j, k) + (a[i] - a[i + j]).d());
}
}
}
printf("%.15f\n", ans);
}
return 0;
}
| 15 |
Subsets and Splits