solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct intr {
int a;
int b;
};
int main() {
int n, P1, P2, P3, T1, T2;
vector<intr> v;
int wTime = 0;
cin >> n >> P1 >> P2 >> P3 >> T1 >> T2;
for (int i = 0; i != n; i++) {
intr tmp;
cin >> tmp.a >> tmp.b;
v.push_back(tmp);
}
wTime += (v[0].b - v[0].a) * P1;
for (int i = 1; i < n; i++) {
wTime += (v[i].b - v[i].a) * P1;
if (v[i].a - v[i - 1].b >= T1 + T2) {
wTime += (v[i].a - v[i - 1].b - T1 - T2) * P3 + T2 * P2 + T1 * P1;
} else if (v[i].a - v[i - 1].b >= T1) {
wTime += (v[i].a - v[i - 1].b - T1) * P2 + T1 * P1;
}
if (v[i].a - v[i - 1].b < T1) wTime += (v[i].a - v[i - 1].b) * P1;
}
cout << wTime;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, t;
cin >> n >> t;
long double tt = 1.000000011, ans = 1.0;
while (t) {
if (t & 1) ans *= tt;
tt *= tt;
t >>= 1;
}
ans *= (long double)n;
cout << fixed << setprecision(20) << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long a, b;
long long f[100];
int nf;
void run() {
scanf("%I64d%I64d", &a, &b);
if (gcd(a, b) != 1) {
printf("Impossible\n");
return;
}
nf = 0;
while (b != 0) {
f[nf++] = a / b;
a %= b;
swap(a, b);
}
for (int i = (0); i < (nf); ++i)
if (f[i] != 0) printf("%I64d%c", f[i] - (i == nf - 1 ? 1 : 0), "AB"[i % 2]);
puts("");
}
int main() {
run();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105, inf = 1e9;
int n, m, st, ed;
int G[N][N];
vector<int> g[N][N];
int s[N], t[N], K;
vector<int> bus[N];
vector<int> *vv;
int cnt[N], vis[N], TOT;
bool MOB[N][N];
bool *uu, Good[N][N], Flag[N];
bool dfs(int u) {
if (vis[u] == TOT) return uu[u];
vis[u] = TOT;
bool flag = vv[u].size() > 0;
for (int v : vv[u]) flag &= dfs(v);
return uu[u] |= flag;
}
void DP() {
int i, j, k, d;
for (auto u : bus[ed]) Good[u][ed] = 1;
for (d = 1; d <= n; d++) {
for (i = 1; i <= K; i++) {
vv = g[i];
uu = Good[i];
++TOT;
dfs(s[i]);
}
for (auto u : bus[st]) {
if (Good[u][st]) {
printf("%d\n", d);
return;
}
}
for (i = 1; i <= n; i++) {
for (auto u : bus[i]) {
if (Good[u][i]) {
;
for (int v = 1; v <= K; v++)
if (MOB[v][i]) Good[v][i] = 1;
break;
}
}
}
}
puts("-1");
}
void input_bus(int x) {
int i, j, d, k;
vv = g[x];
bool *cur = MOB[x];
int &ss = s[x], &tt = t[x];
scanf("%d%d", &ss, &tt);
k = G[ss][tt];
if (k == inf) return;
for (i = 1; i <= n; i++) {
d = G[ss][i];
if (d + G[i][tt] == k) {
cur[i] = true;
cnt[d]++;
for (j = 1; j <= n; j++) {
if (G[i][j] == 1 && d + G[j][tt] + 1 == k) {
vv[i].push_back(j);
;
}
}
}
};
for (i = 1; i <= n; i++)
if (cur[i]) {
d = G[ss][i];
if (cnt[d] == 1) {
bus[i].push_back(x);
;
}
cnt[d] = 0;
};
}
int main() {
int i, j, k, x, y;
scanf("%d%d%d%d", &n, &m, &st, &ed);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) G[i][j] = i != j ? inf : 0;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
G[x][y] = 1;
}
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (G[i][j] > G[i][k] + G[k][j]) G[i][j] = G[i][k] + G[k][j];
scanf("%d", &K);
for (i = 1; i <= K; i++) input_bus(i);
DP();
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n;
long long x, y;
cin >> x >> y;
char s[12];
sprintf(s, "%d", y);
reverse(s, s + strlen(s));
i = 0;
y = 0;
while (s[i]) {
y *= 10;
y += s[i] - '0';
i++;
}
printf("%I64d\n", x + y);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, COEFF = 1e6;
inline void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
inline int mul(int a, int b) { return (int)((long long)a * b % mod); }
inline int power(int a, long long b) {
int res = 1;
while (b) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a), b >>= 1;
}
return res;
}
inline int inv(int a) { return power(a, mod - 2); }
void sub(vector<int> &a, vector<int> b) {
while (a.size() < b.size()) {
a.push_back(0);
}
for (int i = 0; i < b.size(); i++) sub(a[i], b[i]);
}
vector<int> integrate(vector<int> a) {
vector<int> b = {0};
for (int i = 0; i < a.size(); i++) b.push_back(mul(a[i], inv(i + 1)));
return b;
}
int eval(vector<int> a, int x) {
int res = 0;
for (int i = a.size() - 1; i >= 0; i--) {
res = mul(res, x);
add(res, a[i]);
}
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> x(n), uni;
for (int i = 0; i < n; i++) {
double in;
cin >> in;
x[i] = in * COEFF + 0.5;
uni.push_back(x[i] % COEFF);
}
uni.push_back(0);
sort(uni.begin(), uni.end());
uni.resize(unique(uni.begin(), uni.end()) - uni.begin());
int cnt = uni.size();
vector<int> point(n * cnt + 1), cut(n), sz(n * cnt);
for (int i = 0; i <= n * cnt; i++) point[i] = i / cnt * COEFF + uni[i % cnt];
for (int i = 0; i < n; i++)
cut[i] = find(point.begin(), point.end(), x[i]) - point.begin();
for (int i = 0; i < n * cnt; i++)
sz[i] = mul((point[i + 1] - point[i] + mod) % mod, inv(COEFF));
vector<vector<int> > a(n * cnt);
vector<int> sum(n * cnt);
for (int i = 0; i < n * cnt; i++) {
a[i] = i < min(cnt, cut[0]) ? vector<int>{0, 1} : vector<int>{0};
sum[i] = a[i].size() == 2 ? sz[i] : 0;
}
for (int id = 1; id < n; id++)
for (int i = n * cnt - 1; i >= 0; i--) {
if (i >= cut[id]) {
a[i] = {0};
sum[i] = 0;
} else {
for (int j = i - 1; j >= max(i - cnt, 0); j--) add(a[i][0], sum[j]);
if (i - cnt >= 0) sub(a[i], a[i - cnt]);
a[i] = integrate(a[i]);
sum[i] = eval(a[i], sz[i]);
}
}
int ans = 0;
for (int i = 0; i < n * cnt; i++) {
add(ans, sum[i]);
}
cout << ans << endl;
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
int dp[2500][150][150];
int n;
int pre[4005];
int maxi(int l, int diff, int length) {
if (l + length > n - l - diff) {
dp[l][diff][length] = 0;
return 0;
} else if (dp[l][diff][length] != -pow(10, 9)) {
return dp[l][diff][length];
} else if (l + 2 * length + 3 <= n - l - diff) {
dp[l][diff][length] =
pre[l + length] - pre[l] +
min(maxi(l + length, diff, length) -
(pre[n - l - diff] - pre[n - l - diff - length]),
maxi(l + length, diff + 1, length + 1) -
(pre[n - l - diff] - pre[n - l - diff - length - 1]));
dp[l][diff][length] =
max(dp[l][diff][length],
pre[l + length + 1] - pre[l] +
min(maxi(l + length + 1, diff, length + 1) -
(pre[n - l - diff] - pre[n - l - diff - length - 1]),
maxi(l + length + 1, diff + 1, length + 2) -
(pre[n - l - diff] - pre[n - l - diff - length - 2])));
} else if (l + 2 * length + 2 == n - l - diff) {
dp[l][diff][length] =
pre[l + length] - pre[l] +
min(maxi(l + length, diff, length) -
(pre[n - l - diff] - pre[n - l - diff - length]),
maxi(l + length, diff + 1, length + 1) -
(pre[n - l - diff] - pre[n - l - diff - length - 1]));
dp[l][diff][length] = max(
dp[l][diff][length],
pre[l + length + 1] - pre[l] + maxi(l + length + 1, diff, length + 1) -
(pre[n - l - diff] - pre[n - l - diff - length - 1]));
} else if (l + 2 * length + 1 == n - l - diff) {
dp[l][diff][length] =
pre[l + length] - pre[l] +
min(maxi(l + length, diff, length) -
(pre[n - l - diff] - pre[n - l - diff - length]),
maxi(l + length, diff + 1, length + 1) -
(pre[n - l - diff] - pre[n - l - diff - length - 1]));
dp[l][diff][length] =
max(dp[l][diff][length], pre[l + length + 1] - pre[l]);
} else if (l + 2 * length == n - l - diff) {
dp[l][diff][length] = pre[l + length] - pre[l] +
maxi(l + length, diff, length) -
(pre[n - l - diff] - pre[n - l - diff - length]);
dp[l][diff][length] =
max(dp[l][diff][length], pre[l + length + 1] - pre[l]);
} else if (l + length + 1 <= n - l - diff) {
dp[l][diff][length] =
max(pre[l + length + 1] - pre[l], pre[l + length] - pre[l]);
} else if (l + length == n - l - diff) {
dp[l][diff][length] = pre[l + length] - pre[l];
}
return dp[l][diff][length];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (int i = 0; i < 2500; i++) {
for (int j = 0; j < 150; j++) {
for (int k = 0; k < 150; k++) {
dp[i][j][k] = -pow(10, 9);
}
}
}
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
pre[0] = 0;
pre[1] = arr[0];
for (int i = 2; i <= n; i++) {
pre[i] = pre[i - 1] + arr[i - 1];
}
cout << maxi(0, 0, 1);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long int N, x, B[105][105], cnt[105], dp[100006], sol[105][105],
aux[105][105];
void mult(long long int A[105][105], long long int B[105][105],
long long int C[105][105]) {
int i, j, k;
for (i = 1; i <= 101; i++)
for (j = 1; j <= 101; j++) {
C[i][j] = 0;
for (k = 1; k <= 101; k++)
C[i][j] = (C[i][j] + (A[i][k] * B[k][j]) % 1000000007LL) % 1000000007LL;
}
}
int main() {
cin >> N >> x;
long long int i, j, u;
for (i = 1; i <= N; i++) {
cin >> u;
cnt[u]++;
}
for (i = 1; i <= 99; i++) B[i + 1][i] = 1;
for (i = 1; i <= 100; i++) B[i][100] = cnt[100 - i + 1];
B[101][100] = B[101][101] = 1;
dp[0] = 1;
for (i = 1; i <= 100; i++) {
dp[i] = 1;
for (j = 1; j <= i; j++)
dp[i] = (dp[i] + 1LL * cnt[j] * dp[i - j]) % 1000000007LL;
}
for (i = 1; i <= 101; i++) sol[i][i] = 1;
if (x <= 100) {
cout << dp[x] << "\n";
return 0;
}
x -= 100;
while (x) {
if (x & 1) {
mult(sol, B, aux);
memcpy(sol, aux, sizeof(sol));
}
mult(B, B, aux);
memcpy(B, aux, sizeof(B));
x >>= 1;
}
long long int res = 0;
for (i = 1; i <= 100; i++)
res = (res + (1LL * sol[i][100] * dp[i]) % 1000000007LL) % 1000000007LL;
res = (res + sol[101][100]) % 1000000007LL;
cout << res;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long int x, i;
signed main() {
cin >> x;
if (x == 0) {
cout << 0;
return 0;
} else if (x < 0) {
x = -x;
}
i = ((-1) + sqrt((1 + 8 * x))) / 2;
for (; 1; i++) {
if ((i + 1) * i / 2 >= x && ((i + 1) * i / 2) % 2 == x % 2) {
cout << i;
return 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, off, q;
int niz[100005];
pair<int, int> tur[400005];
int nzd(int a, int b) {
if (a < b) swap(a, b);
while (b > 0) {
a = a % b;
swap(a, b);
}
return a;
}
void postava() {
for (off = 1; off < n; off *= 2)
;
for (int i = off; i < off + n; i++) {
tur[i].first = niz[i - off];
tur[i].second = 1;
}
for (int i = off - 1; i > 0; i--) {
tur[i].first = nzd(tur[i * 2].first, tur[i * 2 + 1].first);
if (tur[i * 2].first == tur[i].first) tur[i].second += tur[i * 2].second;
if (tur[i * 2 + 1].first == tur[i].first)
tur[i].second += tur[i * 2 + 1].second;
}
}
pair<int, int> upit(int node, int a, int b, int l, int r) {
if (l > b || r < a) return make_pair(0, 0);
if (a >= l && b <= r) return tur[node];
pair<int, int> lijevo, desno;
lijevo = upit(node * 2, a, (a + b) / 2, l, r);
desno = upit(node * 2 + 1, (a + b) / 2 + 1, b, l, r);
int gcd, rez = 0;
gcd = nzd(lijevo.first, desno.first);
if (gcd == lijevo.first) rez += lijevo.second;
if (gcd == desno.first) rez += desno.second;
return make_pair(gcd, rez);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &niz[i]);
postava();
cin >> q;
int l, r;
for (int i = 0; i < q; i++) {
scanf("%d%d", &l, &r);
l--;
r--;
int res = r - l + 1 - upit(1, 0, off - 1, l, r).second;
cout << res << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
set<int> sumTerm;
int l[1000005], a00, a01, a10, a11;
bool Solve(int m, int n) {
int a = a10, i, p, ll, rr;
if (a01 + a10 != m * n) return false;
if (n == 0 && m == 0) return false;
ll = rr = 0;
for (i = m - 1; i >= 0; i--) {
l[i] = min(a, n);
a -= l[i];
ll += l[i];
rr += n - l[i];
}
assert(a == 0);
assert(ll == a10 && rr == a01);
p = 0;
for (i = 0; i < m; i++) {
while (p < l[i]) {
printf("1");
p++;
}
a10 -= p;
a01 -= n - p;
printf("0");
}
while (p < n) {
printf("1");
p++;
}
assert(a01 == 0 && a10 == 0);
return true;
}
int main() {
int i, x, j, m, n;
vector<int> mm, nn;
i = 0;
while (true) {
x = (i * (i + 1)) / 2;
if (x > 1000000007) break;
sumTerm.insert(x);
i++;
}
scanf("%d %d %d %d", &a00, &a01, &a10, &a11);
if (sumTerm.find(a00) == sumTerm.end() ||
sumTerm.find(a11) == sumTerm.end()) {
printf("Impossible\n");
return 0;
}
m = 0;
while ((m * (m + 1)) / 2 != a00) m++;
n = 0;
while ((n * (n + 1)) / 2 != a11) n++;
if (m == 0) {
mm.push_back(0);
mm.push_back(1);
} else {
mm.push_back(m + 1);
}
if (n == 0) {
nn.push_back(0);
nn.push_back(1);
} else {
nn.push_back(n + 1);
}
for (i = 0; i < mm.size(); i++)
for (j = 0; j < nn.size(); j++)
if (Solve(mm[i], nn[j])) return 0;
printf("Impossible\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 3100;
int a[maxn], b[maxn], c[maxn];
int dp[maxn][2];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
dp[0][0] = a[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + dp[i - 1][0] - a[i - 1] + b[i - 1];
if (i > 1)
dp[i][0] = max(dp[i][0], a[i] + dp[i - 1][1] - b[i - 1] + c[i - 1]);
dp[i][1] = b[i] + dp[i - 1][0];
dp[i][1] = max(dp[i][1], b[i] + dp[i - 1][1]);
}
cout << max(dp[n - 1][0], dp[n - 1][1]) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, da, db;
vector<vector<int>> adj;
pair<int, int> getfurthest(int a) {
queue<pair<int, int>> Q;
vector<bool> vis(n, false);
Q.push(pair<int, int>(a, 0));
vis[a] = true;
pair<int, int> x;
while (Q.size()) {
x = Q.front();
Q.pop();
for (int i : adj[x.first]) {
if (vis[i] == false) {
vis[i] = true;
Q.push(pair<int, int>(i, x.second + 1));
}
}
}
return x;
}
int getdist(int a, int b) {
queue<pair<int, int>> Q;
vector<bool> vis(n, false);
Q.push(pair<int, int>(a, 0));
vis[a] = true;
pair<int, int> x;
while (Q.size()) {
x = Q.front();
Q.pop();
if (x.first == b) return x.second;
for (int i : adj[x.first]) {
if (vis[i] == false) {
vis[i] = true;
Q.push(pair<int, int>(i, x.second + 1));
}
}
}
return 0;
}
int main() {
std::ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
cin >> n >> a >> b >> da >> db;
a--;
b--;
adj = vector<vector<int>>(n, vector<int>());
int x, y;
for (int i = 1; i < n; i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (da * 2 >= db || getdist(a, b) <= da) {
cout << "Alice\n";
continue;
}
pair<int, int> A = getfurthest(0);
pair<int, int> B = getfurthest(A.first);
int diameter = B.second;
if (da * 2 >= diameter) {
cout << "Alice\n";
continue;
}
cout << "Bob\n";
continue;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, u[100005], u1[100005], cur_color, col[100005];
set<int> g[100005], g1[100005], gr[100005], g_cond[100005];
set<int> ind[100005];
bool used[100005];
vector<int> order, comp[100005];
void dfs1(int v) {
u1[v] = u[v] + 1;
if (u1[v] == h) {
u1[v] = 0;
}
for (int i : g[v]) {
if (u1[v] == u[i]) {
if (u1[i] == u[i]) {
dfs1(i);
}
g1[v].insert(i);
}
}
}
void top_sort(int v) {
used[v] = true;
for (int i : g1[v]) {
if (!used[i]) {
top_sort(i);
}
}
order.push_back(v);
}
void get_comps(int v) {
col[v] = cur_color;
comp[cur_color].push_back(v);
used[v] = true;
for (int i : gr[v]) {
if (!used[i]) {
get_comps(i);
}
}
}
void condensate(int v) {
used[v] = true;
for (int i : g1[v]) {
if (col[v] != col[i]) {
g_cond[col[v]].insert(col[i]);
}
if (!used[i]) {
condensate(i);
}
}
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) {
cin >> u[i];
u1[i] = u[i];
}
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
g[a].insert(b);
g[b].insert(a);
}
for (int i = 1; i <= n; ++i) {
if (u[i] == u1[i]) {
dfs1(i);
}
}
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
top_sort(i);
}
}
for (int i = 1; i <= n; ++i) {
for (int j : g1[i]) {
gr[j].insert(i);
}
}
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
cur_color = 0;
for (int i = n - 1; i >= 0; --i) {
int v = order[i];
if (!used[v]) {
cur_color++;
get_comps(v);
}
}
for (int i = 1; i <= n; ++i) {
used[i] = false;
}
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
condensate(i);
}
}
int minv = 1e6;
for (int i = 1; i <= cur_color; ++i) {
if ((int)g_cond[i].size() == 0) {
minv = min(minv, (int)comp[i].size());
}
}
for (int i = 1; i <= cur_color; ++i) {
if ((int)g_cond[i].size() == 0) {
if ((int)comp[i].size() == minv) {
cout << minv << endl;
for (int j = 0; j < minv; ++j) {
cout << comp[i][j] << ' ';
}
cout << endl;
return 0;
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
int n, x, y, dp[N][20][2];
int f(int x, int y) { return (1 << x) % mod * (y ? 3 : 1) % mod; }
signed main() {
scanf("%d", &n);
x = log2(n), dp[1][x][0] = 1;
if ((1 << (x - 1)) * 3 <= n) dp[1][x - 1][1] = 1, y = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= x; j++)
for (int k = 0; k <= y; k++) {
int now = f(j, k);
dp[i][j][k] =
1ll *
(dp[i][j][k] +
1ll * dp[i - 1][j][k] * (n / now % mod - (i - 1) % mod) % mod) %
mod;
if (j)
dp[i][j - 1][k] =
1ll *
(dp[i][j - 1][k] + 1ll * dp[i - 1][j][k] *
(n / f(j - 1, k) % mod - n / now % mod) %
mod) %
mod;
if (k)
dp[i][j][k - 1] =
1ll *
(dp[i][j][k - 1] + 1ll * dp[i - 1][j][k] *
(n / f(j, k - 1) % mod - n / now % mod) %
mod) %
mod;
}
}
printf("%d\n", dp[n][0][0]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp1;
int main() {
int n;
int m;
cin >> n;
long long a[100009];
long long b[100009];
long long x[100009];
long long y[100009];
long long ans;
for (int i = 0; i < n; i++) {
cin >> a[i] >> x[i];
mp1[a[i]] = x[i];
}
cin >> m;
for (int j = 0; j < m; j++) {
cin >> b[j] >> y[j];
if (mp1[b[j]] == 0) {
ans += y[j];
} else {
if (mp1[b[j]] * 1ll > y[j] * 1ll) {
ans += mp1[b[j]] * 1ll;
} else {
ans += y[j];
}
mp1[b[j]] = 0;
}
}
map<long long, long long>::iterator it = mp1.begin();
for (it; it != mp1.end(); it++) {
if (it->second != 0) ans += it->second;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f;
template <typename T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
std::string procStatus() {
std::ifstream t("/proc/self/status");
return std::string(std::istreambuf_iterator<char>(t),
std::istreambuf_iterator<char>());
}
template <typename T>
T read(T &first) {
int f = 1;
char ch = getchar_unlocked();
for (; !isdigit(ch); ch = getchar_unlocked())
if (ch == '-') f = -1;
for (first = 0; isdigit(ch); ch = getchar_unlocked())
first = 10 * first + ch - '0';
return first *= f;
}
template <typename T>
void write(T first) {
if (first == 0) {
putchar_unlocked('0');
return;
}
if (first < 0) {
putchar_unlocked('-');
first = -first;
}
static char s[20];
int top = 0;
for (; first; first /= 10) s[++top] = first % 10 + '0';
while (top) putchar_unlocked(s[top--]);
}
const int MAXN = 1e6 + 5, MAXM = 1e6 + 5;
struct Edge {
int v, next;
Edge() {}
Edge(int v0, int next0) : v(v0), next(next0) {}
};
int N, M, S, T;
int tote, head[MAXN];
Edge edge[MAXM];
int indeg[MAXN];
inline void addEdge(int u, int v) {
edge[++tote] = Edge(v, head[u]);
head[u] = tote;
}
void input() {
read(N);
read(M);
for (int i = 1; i <= M; ++i) {
int u, v;
read(u);
read(v);
addEdge(v, u);
++indeg[u];
}
read(S);
read(T);
}
void solve() {
static int dp[MAXN];
static int q0[MAXN * 4 + 5];
static bool vis[MAXN];
int front = 0, rear = 0;
int *q = q0 + N + 1;
memset(dp, +oo, sizeof(dp));
dp[T] = 0;
q[rear++] = T;
while (front != rear) {
int u = q[front++];
if (vis[u]) continue;
vis[u] = true;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].v;
if (--indeg[v] == 0) {
if (chkmin(dp[v], dp[u])) q[--front] = v;
} else if (chkmin(dp[v], dp[u] + 1))
q[rear++] = v;
}
}
printf("%d\n", dp[S] == +oo ? -1 : dp[S]);
}
int main() {
input();
solve();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
string s, t;
while (cin >> s >> t) {
map<char, int> T;
for (int i = 0; i < t.length(); i++) T[t[i]]++;
int y = 0, w = 0;
map<int, bool> done;
for (int i = 0; i < s.length(); i++) {
if (T[s[i]] > 0) {
T[s[i]]--;
y++;
done[i] = true;
}
}
for (int i = 0; i < s.length(); i++) {
if (!done[i]) {
if (T[toupper(s[i])] > 0 || T[tolower(s[i])] > 0) {
T[toupper(s[i])]--;
T[tolower(s[i])]--;
w++;
}
}
}
cout << y << " " << w << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E6 + 7;
int n, ans = N;
long long a[N];
bool visited[N];
set<long long> res;
vector<int> prime, id;
long long cl = chrono::steady_clock::now().time_since_epoch().count();
void init() { shuffle(id.begin(), id.end(), default_random_engine(cl)); }
void sieve() {
for (int i = 2; i < N; i++) {
if (visited[i] == 0) {
prime.push_back(i);
for (int j = i; j < N; j += i) visited[j] = true;
}
}
}
void factorize(long long num) {
for (int i = 0; i < prime.size(); ++i) {
int v = prime[i];
if (num % v == 0) {
res.insert(v);
while (num % v == 0) num = num / v;
}
}
if (num > 1) res.insert(num);
}
int solve(long long num) {
long long final = 0;
for (int i = 1; i <= n; i++) {
long long add_final = 0;
if (a[i] < num)
add_final = num - a[i];
else
add_final = min(a[i] % num, num - a[i] % num);
final = min(1LL * n, final + add_final);
}
return final;
}
int main() {
ios::sync_with_stdio(NULL);
cin.tie(NULL);
sieve();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
id.push_back(i);
}
init();
for (int i = 0; i < min(100, (int)id.size()); i++) {
int ind = id[i];
factorize(a[ind]);
factorize(a[ind] + 1);
if (a[ind] - 1 > 0) factorize(a[ind] - 1);
}
for (long long v : res) ans = min(ans, solve(v));
cout << ans;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, s, i;
cin >> n >> s;
vector<long long> ans(s + 1, 0);
long long need = n - s, br = 1;
while (need > 0 || br == 1) {
for (i = 1; i <= s; i++) {
if (br == 1) {
need++;
}
long long num = 1;
while (num <= need) {
num *= 10;
}
num /= 10;
need -= num;
ans[i] += num;
}
br = 0;
}
for (i = 1; i <= s; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
long long n;
cin >> n;
while (n--) {
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, arr[1000], count = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
for (i = 1; i < n - 1; i++) {
if (arr[i] == 0 && arr[i - 1] == 1 && arr[i + 1] == 1) {
count++;
i = i + 2;
}
}
cout << count << endl;
}
| 2 |
/*---Author:HenryHuang---*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxm=2e6+5;
const ll maxn=2e5+5;
struct edge{
ll to,nex,w;
}e[maxm<<1];
ll head[maxn],cur[maxn],cnt=1;
ll n,m,s,t;
void add(ll a,ll b,ll c){
e[++cnt]=(edge){b,head[a],c};
head[a]=cur[a]=cnt;//当前弧优化
}
void addedge(ll a,ll b,ll c){
add(a,b,c),add(b,a,0);
}
ll dis[maxn];
ll bfs(){
memset(dis,0,sizeof dis);
queue<int> Q;
dis[s]=1;Q.push(s);
for(ll i=s;i<=t;++i) cur[i]=head[i];
while(!Q.empty()){
ll u=Q.front();Q.pop();
for(ll i=head[u];i;i=e[i].nex){
ll v=e[i].to;
if(e[i].w&&!dis[v]){
dis[v]=dis[u]+1;
Q.push(v);
}
}
}
return dis[t];
}
ll dfs(ll u,ll in){
if(u==t) return in;
ll out=0,tmp;
for(ll &i=cur[u];i;i=e[i].nex){
ll v=e[i].to;
if(e[i].w&&dis[v]==dis[u]+1&&(tmp=dfs(v,min(in,e[i].w)))){
e[i].w-=tmp;
e[i^1].w+=tmp;
in-=tmp;
out+=tmp;
if(!in) break;
}
}
if(!out) dis[u]=0;
return out;
}
ll calc(ll x,ll y){
return ((y&1)<<1|((x&1)==(y&1)));
}
ll xx[maxn],yy[maxn];
int main(){
ios::sync_with_stdio(0);
cin.tie(0),cout.tie(0);
cin>>n;
s=0,t=2*n+1;
ll sum=0;
for(ll i=1;i<=n;++i){
ll z;cin>>xx[i]>>yy[i]>>z;
sum+=z;
addedge(i,i+n,z);
if(calc(xx[i],yy[i])==0) addedge(s,i,1e9);
if(calc(xx[i],yy[i])==3) addedge(i+n,t,1e9);
}
// for(int i=-5;i<=5;++i){
// for(int j=-5;j<=5;++j){
// cout<<calc(i,j);
// }
// cout<<'\n';
// }
for(ll i=1;i<=n;++i){
for(int j=1;j<=n;++j){
if(calc(xx[i],yy[i])+1==calc(xx[j],yy[j])&&abs(xx[i]-xx[j])+abs(yy[i]-yy[j])==1){
addedge(i+n,j,1e9);
}
}
}
ll ans=0;
while(bfs()) ans+=dfs(s,2e9);
cout<<sum-ans<<'\n';
return 0;
}
/*
10
-535541974 -572774963 799430338
-535541973 -572774960 348212269
-535541972 -572774962 236752893
-535541973 -572774963 657120913
-535541975 -572774961 155042637
-535541975 -572774962 81575270
-535541971 -572774961 888834471
-535541974 -572774961 899782743
-535541971 -572774960 614959267
-535541972 -572774961 816616774
*/
/*
10
-535541974 -572774963 799430338
-535541973 -572774960 348212269
-535541972 -572774962 236752893
-535541973 -572774963 657120913
-535541975 -572774961 155042637
-535541975 -572774962 81575270
-535541971 -572774961 888834471
-535541974 -572774961 899782743
-535541971 -572774960 614959267
-535541972 -572774961 816616774
*/
| 25 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000], ans = numeric_limits<int>::max();
void solve() {
cin >> n;
a[0] = 1;
a[n + 1] = 1000000;
for (int i = int(1); i <= int(n); i++) {
cin >> a[i];
}
for (int i = int(0); i <= int(n); i++) {
ans = min(ans, max(a[i] - 1, 1000000 - a[i + 1]));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int v[31][31];
int dx[5] = {0, 0, 1, 0, -1};
int dy[5] = {0, 1, 0, -1, 0};
int used[31][31][6];
int getV(char c) {
if (c == 'U') return 1;
if (c == 'R') return 2;
if (c == 'D') return 3;
if (c == 'L') return 4;
}
void fill0() {
for (int i = 0; i < 31; i++)
for (int j = 0; j < 31; j++)
for (int r = 1; r <= 5; r++) used[i][j][r] = -1;
}
int n, b;
bool out(int x, int y) { return max(x, y) > b || min(x, y) < 0; }
int main() {
scanf("%d%d", &n, &b);
for (int i = 0; i < n; i++) {
int sx, sy, fx, fy, r = 0;
scanf("%d%d%d%d", &sx, &sy, &fx, &fy);
if (sx == fx) {
if (sy < fy)
r = 1;
else
r = 3;
for (int j = min(sy, fy); j <= max(sy, fy); j++) v[sx][j] = r;
} else {
if (sx < fx)
r = 2;
else
r = 4;
for (int j = min(sx, fx); j <= max(sx, fx); j++) v[j][sy] = r;
}
}
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y, r;
long long TL;
char c;
scanf("%d%d%*c%c%I64d", &x, &y, &c, &TL);
r = getV(c);
fill0();
bool OUT = 0, LOOP = 0;
long long t, need;
for (t = 0; t < TL; t++) {
if (used[x][y][r] != -1) {
LOOP = 1;
break;
}
used[x][y][r] = t;
if (v[x][y] != 0) r = v[x][y];
if (out(x + dx[r], y + dy[r])) {
OUT = 1;
break;
}
x += dx[r];
y += dy[r];
}
if (LOOP) {
need = TL - t;
need %= t - used[x][y][r];
for (t = 0; t < need; t++) {
if (v[x][y] != 0) r = v[x][y];
x += dx[r];
y += dy[r];
}
printf("%d %d\n", x, y);
} else {
printf("%d %d\n", x, y);
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s[1005] = {0}, n, m, a;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a;
s[a]++;
}
sort(s, s + n + 1);
cout << s[1] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool flag;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, arr[200005], cnt = 0, check = 0;
vector<vector<int>> v;
cin >> a >> b;
v.resize(b);
for (int i = 0; i < a; i++) {
cin >> arr[i];
if (arr[i] % 2) cnt++;
}
if (cnt < b || (cnt - b) % 2) {
cout << "NO"
<< "\n";
continue;
}
for (int i = 0; i < a; i++) {
v[check].push_back(i + 1);
if (arr[i] % 2)
if (check < b - 1) check++;
}
cout << "YES"
<< "\n";
for (int i = 0; i < b; i++) cout << v[i].back() << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0, max = 0, s;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m;
cin >> m;
int b[m];
for (int j = 0; j < m; j++) {
cin >> b[j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (b[j] % a[i] == 0) {
s = (b[j] / a[i]);
if (s == max) {
c++;
}
if (s > max) {
max = s, c = 1;
}
}
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sq(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
bool inside(T a, T b, T c) {
return a <= b && b <= c;
}
template <class T>
void setmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T power(T N, T P) {
return (P == 1) ? N : N * power(N, P - 1);
}
vector<string> in;
string a, temp;
int main() {
int n, T, t, m;
while (cin >> a) {
scanf("%d", &m);
in.clear();
for (__typeof(m) i = 0; i < m; i++) {
cin >> temp;
in.push_back(temp);
}
sort(in.begin(), in.end());
string ans = a;
for (__typeof(m) i = 0; i < m; i++) {
if (a == in[i].substr(0, a.size())) {
ans = in[i];
break;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 1e5 + 5;
struct pa {
int x, y;
};
queue<int> Q, V;
vector<pa> ans;
int a[N];
bool book[N];
int n;
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
int d = n + 1;
bool flg = true;
for (int i = n; i >= 1; i--) {
if (a[i] == 1) {
Q.push(i);
continue;
} else if (a[i] == 2) {
if (!int(Q.size())) {
flg = false;
break;
}
int q = Q.front();
Q.pop();
ans.push_back((pa){d - 1, i}), ans.push_back((pa){d - 1, q});
V.push(i);
book[i] = true, book[q] = true;
d--;
} else if (a[i] == 3) {
if (int(V.size())) {
int v = V.front();
V.pop();
ans.push_back((pa){d - 1, i}), ans.push_back((pa){d - 1, v});
V.push(i);
book[i] = true;
d--;
continue;
}
if (int(Q.size())) {
int q = Q.front();
Q.pop();
ans.push_back((pa){d - 2, i}), ans.push_back((pa){d - 2, q}),
ans.push_back((pa){d - 1, q});
book[i] = true, book[q] = true;
V.push(i);
d -= 2;
continue;
}
flg = false;
break;
}
book[i] = true;
}
if (!flg) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
if (book[i]) continue;
ans.push_back((pa){d - 1, i});
d--;
}
printf("%d\n", int(ans.size()));
for (int i = 0; i < int(ans.size()); i++) {
printf("%d %d\n", ans[i].x, ans[i].y);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m1[100] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31,
30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30,
31, 31, 30, 31, 30, 31, 31, 29, 31, 30, 31, 30, 31, 31, 30,
31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int n;
cin >> n;
int a[100];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int sk = 0, kint = 0;
for (int i = 0; i < 72; i++) {
if (m1[i] == a[0]) {
for (int j = i; j < i + n; j++) {
if (a[sk] == m1[j]) {
kint++;
sk++;
}
}
if (kint == n) {
cout << "Yes";
return 0;
break;
} else {
sk = 0;
kint = 0;
}
}
}
cout << "No";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
void run_case() {
long long n, x, c = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
if (i > x) break;
if (x % i == 0 && x / i <= n) c++;
}
cout << c << endl;
}
int tests, n;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
run_case();
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\t";
err(++it, args...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2>& v) {
c << "(" << v.first << "," << v.second << ")";
return c;
}
template <template <class...> class TT, class... T>
ostream& operator<<(ostream& out, TT<T...>& c) {
out << "{ ";
for (auto& x : c) out << x << " ";
out << "}";
return out;
}
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
int t, n, m, k, x, y, w;
int dp[65][5][4];
int nxt[65][5][4];
long long xo = 0, sm = 0;
bool solve(int i, int c, int d) {
if (dp[i][c][d] != -1) return dp[i][c][d];
int cur = ((sm & (1ll << i)) > 0) ? 1 : 0;
cur += c;
int cur2 = ((i > 0) ? (((xo & (1ll << (i - 1))) > 0) ? 1 : 0) : 0);
bool ok = 0;
for (int j = 0; j < 4; ++j) {
int nc = (cur + j) / 2;
int cur4 = ((cur + j) & 1) ? 1 : 0;
int cur3 = ((cur2 + d) & 1) ? 1 : 0;
if (cur4 == cur3 && solve(i + 1, nc, j)) {
nxt[i][c][d] = j;
ok = 1;
break;
}
}
return dp[i][c][d] = ok;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
sm = 0, xo = 0;
for (int i = 0; i < n; ++i) {
cin >> x;
sm += x;
xo = xo ^ x;
}
for (int i = 0; i < 60; ++i)
for (int j = 0; j < 5; ++j)
for (int k = 0; k < 4; ++k) dp[i][j][k] = -1;
for (int j = 0; j < 5; ++j)
for (int k = 0; k < 4; ++k) dp[60][j][k] = 0;
dp[60][0][0] = 1;
bool ys = solve(0, 0, 0);
long long a[3] = {0};
int c = 0, d = 0;
for (int i = 0; i < 60; ++i) {
int cur = nxt[i][c][d];
for (int j = 0; j < cur; ++j) {
a[j] += (1ll << i);
}
d = cur;
c += cur;
c += (((sm & (1ll << i)) > 0) ? 1 : 0);
c /= 2;
}
cout << 3 << "\n" << a[0] << " " << a[1] << " " << a[2] << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int M[4][4];
const int MAXLENGTH = 1000111;
string s[4];
char inv(char c) {
if (c == 'a') return 'b';
return 'a';
}
int main() {
int mn = 1000111;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++) scanf("%d", &M[i][j]);
for (int k = 0; k <= MAXLENGTH; k++) {
M[0][1] -= k;
M[0][2] -= k;
M[0][3] -= k;
int x[7];
x[6] = k;
x[5] = (M[0][1] - M[1][2] + M[0][2]) / 2;
x[4] = (M[0][1] - M[1][3] + M[0][3]) / 2;
x[3] = M[1][3] - M[0][3];
x[3] += x[4];
x[3] -= x[5];
x[2] = (M[0][2] - M[2][3] + M[0][3]) / 2;
x[1] = M[0][2];
x[1] -= x[2];
x[1] -= x[5];
x[0] = M[0][3];
x[0] -= x[2];
x[0] -= x[4];
M[0][1] += k;
M[0][2] += k;
M[0][3] += k;
if (x[3] + x[4] + x[5] + x[6] != M[0][1]) continue;
if (x[1] + x[2] + x[5] + x[6] != M[0][2]) continue;
if (x[0] + x[2] + x[4] + x[6] != M[0][3]) continue;
if (x[1] + x[2] + x[3] + x[4] != M[1][2]) continue;
if (x[0] + x[2] + x[3] + x[5] != M[1][3]) continue;
if (x[0] + x[1] + x[4] + x[5] != M[2][3]) continue;
bool flag = true;
int len = 0;
for (int i = 0; i < 7; i++) {
if (x[i] < 0) {
flag = false;
break;
}
len += x[i];
}
if (!flag) continue;
if (len < mn) {
mn = len;
s[0] = s[1] = s[2] = s[3] = "";
for (int k = 0; k < 7; k++) {
int bm = k + 1;
for (int j = 0; j < x[k]; j++) {
for (int i = 0; i < 4; i++) {
s[3 - i].push_back((bm & (1 << i)) ? 'b' : 'a');
}
}
}
}
}
if (mn == 1000111)
printf("-1\n");
else {
printf("%d\n", mn);
for (int i = 0; i < 4; i++) printf("%s\n", s[i].c_str());
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int first = 0, second = 0, third = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
first += x;
}
for (int i = 0; i < n - 1; i++) {
int x;
cin >> x;
second += x;
}
for (int i = 0; i < n - 2; i++) {
int x;
cin >> x;
third += x;
}
cout << first - second << endl << second - third;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0, n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
if (x % i == 0 && (x / i) <= n) ans++;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void add_rem_i(long long* fr, long long* bit, long long i, long long n,
long long q) {
fr[i] += q;
long long j = i;
while (j <= n) {
bit[j] += q;
j += (j & (-j));
}
}
long long find_cum_fr(long long* bit, long long i) {
long long count = 0;
while (i > 0) {
count += bit[i];
i -= (i & -i);
}
return count;
}
long long find_kth_ord_stat(long long* bit, long long k, long long l,
long long r) {
long long pos = 0;
while (l < r) {
long long mid = (l + r) / 2;
long long fr_mid = find_cum_fr(bit, mid);
if (fr_mid >= k) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, q;
cin >> n >> q;
long long fr[n + 1];
memset(fr, 0, sizeof(fr));
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
fr[x] += 1;
}
long long bit[n + 1];
memset(bit, 0, sizeof(bit));
for (long long i = 1; i <= n; i++) {
long long j = i;
while (j <= n) {
bit[j] += fr[i];
j += (j & (-j));
}
}
for (int i = 0; i < q; i++) {
long long k;
cin >> k;
if (k > 0) {
add_rem_i(fr, bit, k, n, 1);
} else {
k *= -1;
long long j = find_kth_ord_stat(bit, k, 1, n);
add_rem_i(fr, bit, j, n, -1);
}
}
long long i = 1;
while (fr[i] == 0 && i <= n) i++;
if (i > n)
cout << "0" << endl;
else
cout << i << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 1e5 + 10, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n;
long long m;
int A;
long long cf, cm;
long long sum[N];
struct Skill {
int v, o;
} a[N];
bool cmp1(Skill a, Skill b) { return a.v < b.v; }
bool cmp2(Skill a, Skill b) { return a.o < b.o; }
int solve(int R, long long now) {
if (R == 0) return A;
int l = 1;
int r = R;
while (l < r) {
int mid = (l + r + 1) >> 1;
long long need = (long long)a[mid].v * mid - sum[mid];
if (need > now)
r = mid - 1;
else
l = mid;
}
long long need = (long long)a[l].v * l - sum[l];
long long more = (now - need) / l;
return min((long long)A, a[l].v + more);
}
int main() {
while (~scanf("%d%d%lld%lld%lld", &n, &A, &cf, &cm, &m)) {
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].v);
a[i].o = i;
}
sort(a + 1, a + n + 1, cmp1);
a[n + 1].v = A;
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i].v;
long long ans = -1;
long long cost = 0;
int v, p;
for (int i = n; i >= 0; --i) {
cost += A - a[i + 1].v;
if (cost > m) break;
int minv = solve(i, m - cost);
long long tmp = minv * cm + (n - i) * cf;
if (tmp > ans) {
ans = tmp;
p = i;
v = minv;
}
}
printf("%lld\n", ans);
for (int i = n; i > p; --i) a[i].v = A;
for (int i = 1; i <= p; ++i) gmax(a[i].v, v);
sort(a + 1, a + n + 1, cmp2);
for (int i = 1; i <= n; ++i) printf("%d ", a[i].v);
puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long BINF = 9e18, LINF = 2e9, mod = 1e9 + 7, P = 179, Q = 1791791791;
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
long long sum = 0;
for (long long i = 0; i < n; ++i) {
sum += (long long)(s[i] - '0');
}
if (n == 1) {
cout << "NO";
return;
}
if (sum == 0) {
cout << "YES";
return;
}
for (long long i = 1; i < 1000; ++i)
if (sum % i == 0) {
bool ok = 1;
long long ptr = 0;
long long bck = sum / i;
long long lsum = 0;
long long cnt = 0;
while (ptr < n) {
lsum = 0;
if (lsum >= bck) {
cout << lsum << " " << bck << " " << sum << endl;
exit(1);
}
while (ptr < n && lsum < bck) {
lsum += s[ptr] - '0';
++ptr;
}
while (ptr < n && lsum == bck && s[ptr] == '0') ++ptr;
if (lsum != bck) ok = 0;
++cnt;
}
if (ok && cnt > 1) {
cout << "YES";
return;
}
}
cout << "NO";
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cout.precision(40);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a[100001], b[100001], q[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) b[i] = a[i] + b[i - 1];
cin >> m;
for (int i = 0; i < m; i++) {
long long int first = 1, last = n, mid, ans = 0;
cin >> q[i];
while (first <= last) {
mid = (first + last) / 2;
if (q[i] <= b[mid])
ans = mid, last = mid - 1;
else
first = mid + 1;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m;
cin >> n >> m;
int nn[n], mm[m], ss[92];
for (i = 0; i < n; i++) cin >> nn[i];
for (i = 0; i < m; i++) cin >> mm[i];
for (i = 0, k = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (nn[i] == mm[j]) {
ss[k] = nn[i];
k++;
}
}
}
i = 0;
while (i < k) {
if (i == k - 1)
cout << ss[i];
else
cout << ss[i] << " ";
i++;
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 9;
bitset<N> bs;
vector<long long> non_prime;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
long long ans = 1;
if (n < 4 or n == 5 or n == 7 or n == 11) {
cout << -1 << endl;
continue;
}
if (n % 4 == 0) {
cout << n / 4 << endl;
continue;
}
if ((n - 6) % 4 == 0) {
cout << ((n - 6) / 4) + 1 << endl;
continue;
}
n = n - 9;
if (n % 4 == 0) {
cout << (n / 4) + 1 << endl;
continue;
} else {
n = n - 6;
cout << (n / 4) + 2 << endl;
continue;
}
cout << -1 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000 + 10;
vector<int> G0[MAX], G1[MAX];
vector<pair<int, int> > e;
bool mark1[MAX], mark0[MAX];
int d[MAX];
void DFS0(int v) {
mark0[v] = true;
for (int i = 0; i < G0[v].size(); i++)
if (!mark0[G0[v][i]]) DFS0(G0[v][i]);
}
void DFS1(int v) {
mark1[v] = true;
for (int i = 0; i < G1[v].size(); i++)
if (!mark1[G1[v][i]]) DFS1(G1[v][i]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m, cnt;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G0[u].push_back(v);
G1[v].push_back(u);
e.push_back(make_pair(u, v));
}
DFS0(1);
DFS1(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (mark0[e[j].first] && mark1[e[j].second]) {
if (d[e[j].first] + 2 < d[e[j].second]) {
cnt = i;
d[e[j].second] = d[e[j].first] + 2;
}
if (d[e[j].first] + 1 > d[e[j].second]) {
cnt = i;
d[e[j].first] = d[e[j].second] - 1;
}
if (cnt == n - 1) return cout << "No\n", 0;
}
cout << "Yes\n";
for (int i = 0; i < m; i++)
if (mark0[e[i].first] && mark1[e[i].second])
cout << d[e[i].second] - d[e[i].first] << endl;
else
cout << 1 << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, y, i, j, fs, ls, ck;
cin >> n >> x >> y;
vector<long long int> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
fs = i - x;
if (fs < 0) fs = 0;
ls = i + y;
if (ls >= n) ls = n - 1;
ck = 1;
for (j = fs; j <= ls; j++) {
if (a[i] > a[j]) {
ck = 0;
break;
}
}
if (ck == 1) {
cout << i + 1;
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long K;
inline long long sum(long long n) { return (1 + n) * n / 2; }
int main() {
cin >> N >> K;
for (int i = 1; i <= N; ++i) {
long long x = sum(i - 1);
if (i == N) {
if (x < K) {
puts("Impossible");
return 0;
} else {
for (int j = 1; j <= N; ++j) putchar('(');
for (int j = 1; j <= N; ++j) putchar(')');
putchar('\n');
return 0;
}
}
if (sum(i) > K) {
long long p = K - x;
for (int j = 1; j <= p; ++j) putchar('(');
putchar('('), putchar(')');
for (int j = p + 1; j <= i; ++j) putchar('(');
for (int j = 1; j <= i; ++j) putchar(')');
for (int j = i + 1; j < N; ++j) {
putchar('(');
putchar(')');
}
return 0;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, sum = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
sum += temp;
}
if (n != m || n == 2) {
cout << "-1\n";
return;
}
cout << 2 * sum << "\n";
for (int i = 1; i < n; i++) {
cout << i << " " << i + 1 << "\n";
}
cout << 1 << " " << n << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int tc = 1;
cin >> tc;
while (tc--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
set<int> a[30];
string s;
int main() {
ios::sync_with_stdio(false);
int q;
while (cin >> s) {
for (int i = 0; i < 30; i++) a[i].clear();
for (int i = 0; i < s.size(); i++) {
a[s[i] - 'a'].insert(i);
}
cin >> q;
int f;
int num, l, r;
char ch;
while (q--) {
cin >> f;
if (f == 1) {
cin >> num >> ch;
a[s[num - 1] - 'a'].erase(num - 1);
a[ch - 'a'].insert(num - 1);
s[num - 1] = ch;
} else {
cin >> l >> r;
int ans = 0;
for (int i = 0; i < 26; i++) {
set<int>::iterator k = a[i].lower_bound(l - 1);
if (k != a[i].end() && *k < r) ans++;
}
cout << ans << endl;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[5], A[20], B[20], Ans[20], was[20];
int v[20][5], ai, bi, stand[10], ans, u[20];
string s;
bool check() {
bool f = 1;
memset(stand, 0, sizeof stand);
memset(was, 0, sizeof was);
for (int j = 0; j < 4; j++) stand[a[j]] = j, was[a[j]] = 1;
for (int j = 0; j < n; j++) {
ai = bi = 0;
for (int i = 0; i < 4; i++)
if (was[v[j][i]])
if (stand[v[j][i]] == i)
ai++;
else
bi++;
if (ai == A[j] && bi == B[j])
f &= 1;
else
f &= 0;
}
return f;
}
void F(int i, int k) {
a[i] = k;
u[k] = 1;
if (i == 3) {
if (check()) {
ans++;
if (ans > 1) {
cout << "Need more data\n";
exit(0);
}
for (int j = 0; j < 4; j++) Ans[j] = a[j];
}
u[k] = 0;
return;
}
for (int j = 0; j < 10; j++)
if (!u[j]) F(i + 1, j);
u[k] = 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> A[i] >> B[i];
for (int j = 0; j < s.size(); j++) v[i][j] = s[j] - '0';
}
for (int i = 0; i < 10; i++) F(0, i);
if (!ans)
cout << "Incorrect data\n";
else
for (int j = 0; j < 4; j++) cout << Ans[j];
return 0;
}
| 9 |
#include <bits/stdc++.h>
const long long INF = (1e9 + 12312), MOD = 1e9 + 7;
const long double EPS = 0.0000000001;
using namespace std;
bool ask(long long first, long long second) {
cout << first << " " << second << endl;
string s;
cin >> s;
if (s == "Bad") {
exit(1);
}
return s == "Yes";
}
signed main() {
ios_base::sync_with_stdio(false);
srand(time(0));
long long n, k;
cin >> n >> k;
long long now = 0;
long long first = 1, second = n;
long long lastl = 1, lastr = n;
for (int i = 0; i < 4500; i++) {
if (now >= 7) {
first = max(lastl - 8 * k, 1LL);
second = min(lastr + 8 * k, n);
lastl = -1;
now = 0;
}
long long askl = first, askr = second;
if (second - first == 0) {
if (ask(first, first)) {
return 0;
}
first = 1, second = n;
continue;
}
if (second - first + 1 <= 43) {
if (lastl == -1) {
lastr = second;
lastl = first;
}
now++;
long long askl = first + rand() % (second - first + 1);
if (ask(askl, askl)) {
return 0;
}
continue;
} else {
now = 0;
lastl = -1;
lastr = -1;
if (rand() % 2) {
askl = first + (second - first + 1) / 2;
} else {
askr = second - (second - first + 1) / 2;
}
}
if (ask(askl, askr)) {
first = max(askl - k, 1LL);
second = min(askr + k, n);
} else {
if (askl != first) {
first -= k;
first = max(first, 1LL);
second = min(askl + k, n);
} else {
first = max(askr - k, 1LL);
second += k;
second = min(second, n);
}
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long a[101][101];
void com() {
a[1][1] = 1;
a[1][0] = 1;
for (int i = 2; i <= 100; i++) {
a[i][0] = 1;
for (int j = 1; j <= i; j++) a[i][j] = a[i - 1][j] + a[i - 1][j - 1];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
com();
long long t, n, m;
cin >> n >> m >> t;
long long ans = 0;
for (int i = 4; i < t; i++) {
ans = ans + (a[n][i] * a[m][t - i]);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool neprim[33000];
int p, m, n, primes[33000], t, a[5010], b[5010], curr_gcd[5010], total,
gcdExtra;
void ciur() {
for (int i = 2; i <= 32000; i++)
if (!neprim[i]) {
primes[++p] = i;
for (int j = i + i; j <= 32000; j += i) neprim[j] = 1;
}
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int get_value(int x) {
int ret = 0;
for (int i = 1; i <= m; i++)
while (x % b[i] == 0) {
x /= b[i];
ret--;
}
for (int i = 1; i <= p or primes[i] > x; i++)
while (x % primes[i] == 0) {
x /= primes[i];
ret++;
}
if (x > 1) ret++;
return ret;
}
int main() {
int i;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= m; i++) cin >> b[i];
ciur();
curr_gcd[1] = a[1];
total = get_value(a[1]);
for (i = 2; i <= n; i++) {
curr_gcd[i] = gcd(curr_gcd[i - 1], a[i]);
total += get_value(a[i]);
}
gcdExtra = 1;
for (i = n; i >= 1; i--) {
curr_gcd[i] /= gcdExtra;
if ((t = get_value(curr_gcd[i])) < 0) {
total -= i * t;
gcdExtra *= curr_gcd[i];
}
}
cout << total << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void afify() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long oo = (long long)1e13;
const double EPS = 1e-4;
int main() {
afify();
char arr[] = {'a', 'b', 'c', 'd'};
int n;
cin >> n;
int j = 0;
while (n--) {
cout << arr[j];
j++;
if (j == 4) {
j = 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string n;
cin >> t;
int len, ans;
while (t--) {
ans = 0;
cin >> n;
len = n.length();
ans = (len - 1) * 9;
int f = 0, p = 0, l = 0;
if (len == 1) {
ans = ((int)n[0] - 48);
} else {
for (int i = 0; i < len; i++) {
p += ((int)n[len - 1 - i] - 48) * pow(10, i);
l += ((int)n[0] - 48) * pow(10, i);
}
if (p < l) f = -1;
if (f == -1)
ans += ((int)n[0] - 49);
else
ans += ((int)n[0] - 48);
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> q;
int n;
class Graph {
int V;
list<int> *adj;
void topologicalSortUtil(int v, bool visited[], stack<int> &Stack);
public:
Graph(int V);
void addEdge(int v, int w);
void topologicalSort();
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) { adj[v].push_back(w); }
void Graph::topologicalSortUtil(int v, bool visited[], stack<int> &Stack) {
visited[v] = true;
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i)
if (!visited[*i]) topologicalSortUtil(*i, visited, Stack);
Stack.push(v);
}
void Graph::topologicalSort() {
stack<int> Stack;
bool *visited = new bool[V];
for (int i = 0; i < V; i++) visited[i] = false;
for (int i = 0; i < V; i++)
if (visited[i] == false) topologicalSortUtil(i, visited, Stack);
vector<int> ls;
while (Stack.empty() == false) {
ls.push_back(Stack.top());
Stack.pop();
}
int count = 0, ans[2] = {0, 0};
for (int i = 0; i < n; ++i) {
if (q[i] == n - 2) ans[count++] = i;
}
for (int i = 0; i < n; ++i) {
if (ls[i] == ans[0])
cout << ans[0] + 1 << " ";
else if (ls[i] == ans[1])
cout << ans[1] + 1 << " ";
}
}
int main() {
cin >> n;
Graph g(n);
for (int i = 0; i < n * (n - 1) / 2 - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
if (q.find(a) == q.end())
q[a] = 1;
else
q[a]++;
if (q.find(b) == q.end())
q[b] = 1;
else
q[b]++;
g.addEdge(a, b);
}
g.topologicalSort();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[1005], ans[1005], temp[1005], rel[1005][1005];
struct node {
int l, r;
bool is;
} tree[500000];
int len, root;
bool ok;
void dfs(int u, int cen, int ll, bool bb) {
if (ok || tree[u].is) return;
if (cen == 0) {
if (!bb) return;
ok = 1;
tree[u].is = 1;
int i;
for (i = 1; i <= ll; i++) temp[i] = ans[i];
return;
}
ans[cen] = 0;
if (tree[u].l >= 0) {
dfs(tree[u].l, cen - 1, ll, bb);
} else {
tree[len].l = tree[len].r = -1;
tree[len].is = 0;
tree[u].l = len++;
dfs(tree[u].l, cen - 1, ll, 1);
}
if (ok) return;
ans[cen] = 1;
if (tree[u].r >= 0) {
dfs(tree[u].r, cen - 1, ll, bb);
} else {
tree[len].l = tree[len].r = -1;
tree[len].is = 0;
tree[u].r = len++;
dfs(tree[u].r, cen - 1, ll, 1);
}
}
int main() {
scanf("%d", &n);
int i, j;
for (i = 0; i < n; i++) scanf("%d", arr + i);
tree[0].l = tree[0].r = -1;
tree[0].is = 0;
len++;
for (i = 0; i < n; i++) {
ok = 0;
dfs(root, arr[i], arr[i], 0);
if (ok == 0) {
puts("NO");
return 0;
}
for (j = arr[i]; j > 0; j--) rel[i][j] = temp[j];
}
puts("YES");
for (i = 0; i < n; i++) {
for (j = arr[i]; j > 0; j--) printf("%d", rel[i][j]);
puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
void xxx(int x, int ar[]) {
if (x == 0)
return;
else {
swap(&ar[x], &ar[x - 1]);
xxx(x - 1, ar);
}
}
int main() {
int n;
scanf("%d", &n);
int ar[n];
for (int i = 0; i < n; i++) ar[i] = i + 1;
xxx(n - 1, ar);
for (int i = 0; i < n; i++) printf("%d ", ar[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
long long dp[62];
long long get(long long x) {
if (!x) return 0;
long long llx = 0;
int i, j, k;
for (i = 1; i <= 60; ++i) {
for (j = 2; i * j <= 60; ++j) {
long long t = 0, ub, lb;
for (k = 0; k < j; ++k) t += 1ll << (i * k);
ub = min(x / t, (1ll << i) - 1), lb = 1ll << (i - 1);
if (lb <= ub) llx += (ub - lb + 1) * dp[j];
}
}
return llx;
}
int main() {
int i, j;
fill(dp + 1, dp + 61, 1);
for (i = 2; i <= 60; ++i)
for (j = i << 1; j <= 60; j += i) dp[j] -= dp[i];
long long l, r;
read(l), read(r);
write(get(r) - get(l - 1));
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[3333333];
int main() {
cin >> n;
for (int i = 2; i <= (1ll << (n + 1ll)) - 1ll; ++i) cin >> a[i];
long long k = n;
long long res = 0;
do {
k--;
for (int i = (1ll << k); i <= (1ll << (k + 1ll)) - 1ll; i++) {
a[i] = max(a[i + i], a[i + i + 1ll]) + a[i];
res += abs(a[i + i] - a[i + i + 1ll]);
}
} while (k);
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 4e5 + 10;
const int INF = 1000000000;
const int inf = 1e9 + 1;
const double eps = 1e-9;
set<string> ans;
string s;
bool go[N][3];
bool equals(int pos, int la, int lb) {
if (pos == 0) {
return false;
}
if (la != lb) {
return false;
}
pos -= la;
for (int(i) = (0); (i) < (la); ++(i)) {
if (s[pos + i] != s[pos + la + i]) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = (int)s.size();
if (n == 5) {
cout << 0 << endl;
return 0;
}
s = s.substr(5);
n -= 5;
reverse(s.begin(), s.end());
go[0][0] = true;
for (int(i) = (0); (i) < (n); ++(i)) {
for (int(j) = (0); (j) < (2); ++(j)) {
if (!go[i][j]) {
continue;
}
for (int(len) = (2); (len) < (4); ++(len)) {
if (i + len <= n) {
if (!equals(i, j + 2, len)) {
go[i + len][len - 2] = true;
string nt = "";
for (int(it) = (i + len - 1); (it) >= (i); --(it)) {
nt += s[it];
}
ans.insert(nt);
}
}
}
}
}
cout << (int)ans.size() << endl;
for (auto e : ans) {
cout << e << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100010], tdp[100010], rem[60][60];
long long cnt[100010], inv[100010], fac[100010], W;
char str[100010];
const long long mod = 1e9 + 7;
int c_pos(char c) {
if (c >= 'A' && c <= 'Z')
return c - 'A' + 1;
else
return c - 'a' + 1 + 26;
}
long long fpow(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
void get_w(int n) {
fac[0] = 1;
int m = n / 2;
for (int i = 1; i <= n; ++i) fac[i] = i * fac[i - 1] % mod;
W = fac[m] * fac[m] % mod;
for (int i = 1; i <= 52; ++i) {
if (cnt[i] == 0) continue;
inv[i] = fpow(fac[cnt[i]], mod - 2);
W = W * inv[i] % mod;
}
}
void init() {
scanf("%s", str + 1);
int len = strlen(str + 1);
for (int i = 1; i <= len; ++i) ++cnt[c_pos(str[i])];
get_w(len);
dp[0] = 1;
int m = len / 2;
for (int i = 1; i <= 52; ++i) {
if (cnt[i] == 0) continue;
for (int j = m; j >= cnt[i]; --j) dp[j] = (dp[j] + dp[j - cnt[i]]) % mod;
}
for (int i = 1; i <= 52; ++i) {
if (cnt[i] == 0) continue;
for (int k = 0; k <= m; ++k) tdp[k] = dp[k];
for (int k = cnt[i]; k <= m; ++k)
tdp[k] = (tdp[k] - tdp[k - cnt[i]] + mod) % mod;
for (int j = 1; j <= 52; ++j) {
if (cnt[j] == 0) continue;
if (i != j)
for (int k = cnt[j]; k <= m; ++k)
tdp[k] = (tdp[k] - tdp[k - cnt[j]] + mod) % mod;
rem[i][j] = tdp[m];
if (i != j)
for (int k = m; k >= cnt[j]; --k)
tdp[k] = (tdp[k] + tdp[k - cnt[j]]) % mod;
}
}
}
int main() {
init();
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int px = c_pos(str[x]), py = c_pos(str[y]);
printf("%lld\n", rem[px][py] * W * 2 % mod);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[30010][210][4], num[30010];
int main() {
int i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%d", &num[i]);
memset(dp, -0x3f, sizeof(dp));
for (j = 0; j <= n; j++)
for (i = 0; i < 4; i++) dp[j][0][i] = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
int tmp = 1 + (j != 1 && j != m);
dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j - 1][3]) - tmp * num[i];
dp[i][j][1] = max(dp[i - 1][j][1], dp[i][j][0]);
dp[i][j][2] = max(dp[i - 1][j][2], dp[i - 1][j - 1][1]) + tmp * num[i];
dp[i][j][3] = max(dp[i - 1][j][3], dp[i][j][2]);
if (tmp == 2) {
dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j - 1][1]);
dp[i][j][3] = max(dp[i][j][3], dp[i - 1][j - 1][3]);
}
}
}
cout << max(dp[n][m][1], dp[n][m][3]);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long a[100009];
map<int, int> m;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] != 0) {
cout << 1;
return 0;
}
m[0] = 1;
m[-1] = 1;
for (int i = 1; i < n; i++) {
if (m[a[i] - 1] == 1) {
m[a[i]] = 1;
} else {
cout << i + 1;
return 0;
}
}
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 5;
const long long mod = 1e9 + 7;
long long pw(long long b, long long r, long long md = mod) {
b = b % md;
long long ans = 1;
while (r) {
if (r & 1) ans = (ans * b) % md;
b = (b * b) % md;
r >>= 1;
}
return ans;
}
long long dp2[(1LL << 20)];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T = 1;
while (T--) {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i <= n - 1; ++i) cin >> arr[i];
for (long long i = 0; i <= n - 1; ++i) arr[i]--;
long long dp[20][20];
memset(dp, 0, sizeof dp);
;
long long mx[20];
for (long long i = 0; i <= 19; ++i) mx[i] = -1;
for (long long i = 0; i <= n - 1; ++i) mx[arr[i]] = i;
for (long long i = 0; i <= 19; ++i) {
long long prev = -1;
long long counter = 0;
for (long long j = mx[i]; j >= 0; j--) {
if (arr[j] == i) {
counter++;
continue;
}
dp[i][arr[j]] += counter;
}
}
for (long long i = 0; i <= (1LL << 20) - 1; ++i) dp2[i] = 1e16;
dp2[0] = 0;
for (long long i = 0; i <= (1LL << 20) - 1; ++i) {
for (long long j = 0; j <= 19; ++j) {
if ((1LL << j) & i) continue;
long long nb = i ^ (1LL << j);
long long req = 0;
for (long long k = 0; k <= 19; ++k) {
if ((1LL << k) & i) continue;
req += dp[j][k];
}
dp2[nb] = min(dp2[nb], dp2[i] + req);
}
}
long long ans = dp2[(1LL << 20) - 1];
cout << ans << '\n';
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long k;
cin >> n >> m >> k;
vector<long long> A(n);
for (int i = 0; i < n; ++i) cin >> A[i];
if (m > n) {
A.resize(m, -1);
n = m;
}
long long ans = 0;
vector<long long> dp(n);
dp[n - 1] = A[n - 1] - k;
for (int i = 1; i < m; ++i)
dp[n - i - 1] = max(dp[n - i] + A[n - i - 1], A[n - i - 1] - k);
for (int i = n - m - 1; i >= 0; --i) {
long long S = -k;
for (int j = 0; j < m; ++j) {
S += A[i + j];
dp[i] = max(dp[i], S);
}
dp[i] = max(dp[i], S + dp[i + m]);
}
for (int i = 0; i < n; ++i) ans = max(ans, dp[i]);
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
if (m - n >= 0 && k - n >= 0)
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ta, tb, tc, td;
double dp[2505][2505][2], to[2505][2505], x[2505], y[2505], ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf", x + i, y + i);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
to[i][j] = sqrt(((x[i] - x[j]) * (x[i] - x[j])) +
((y[i] - y[j]) * (y[i] - y[j])));
for (int i = 1; i < n; i++) {
ta = 0, tb = 1, tc = i - 1, td = i;
for (int j = 0; j < n; j++) {
dp[ta][td][0] =
max(dp[tb][td][0] + to[ta][tb], dp[td][tb][1] + to[ta][td]);
dp[td][ta][1] =
max(dp[tc][ta][1] + to[td][tc], dp[ta][tc][0] + to[td][ta]);
if (++ta == n) ta = 0;
if (++tb == n) tb = 0;
if (++tc == n) tc = 0;
if (++td == n) td = 0;
}
}
for (int i = 0; i < n; i++) ans = max(ans, dp[i][(i + 1) % n][1]);
printf("%.15lf\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535;
bool cmp(pair<double, double> a, pair<double, double> b) {
int t1, t2;
if (a.first >= 0 && a.second >= 0) {
t1 = 1;
} else if (a.first <= 0 && a.second >= 0) {
t1 = 2;
} else if (a.first <= 0 && a.second <= 0) {
t1 = 3;
} else {
t1 = 4;
}
if (b.first >= 0 && b.second >= 0) {
t2 = 1;
} else if (b.first <= 0 && b.second >= 0) {
t2 = 2;
} else if (b.first <= 0 && b.second <= 0) {
t2 = 3;
} else {
t2 = 4;
}
if (t1 == t2) {
return a.first * b.second > a.second * b.first;
} else {
return t1 < t2;
}
}
double crossproduct(double x, double y, double x1, double y1) {
return x * y1 - x1 * y;
}
int main() {
int n;
cin >> n;
vector<pair<double, double> > A(n);
for (int i = 0; i < n; i++) {
cin >> A[i].first >> A[i].second;
}
sort(A.begin(), A.end(), cmp);
if (n == 1) {
cout << "0.000000";
return 0;
}
double ans = 360;
bool flag = true;
for (int i = 0; i < n; i++) {
double x1 = A[i].first, y1 = A[i].second;
double x2 = A[(i + 1) % n].first, y2 = A[(i + 1) % n].second;
double t = crossproduct(x1, y1, x2, y2);
double t1 = x1 * x2 + y1 * y2;
if (t > 0) {
double v = atan2(t, x1 * x2 + y1 * y2);
v = fabs(v) / pi * 180;
ans = min(ans, 360 - v);
flag = false;
} else if (t == 0) {
if (x1 * x2 + y1 * y2 < 0) {
ans = min(ans, 180.0);
flag = false;
}
} else {
double v = atan2(t, x1 * x2 + y1 * y2);
v = fabs(v) / pi * 180;
ans = min(ans, v);
flag = false;
}
}
if (flag) {
cout << "0.000000";
return 0;
}
cout << fixed << setprecision(7) << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:36777216")
void solve();
int main() {
solve();
return 0;
}
const char* table[] = {
"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg",
"Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr",
"Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr",
"Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd",
"In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd",
"Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf",
"Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po",
"At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm",
"Bk", "Cf", "Es", "Fm"};
map<string, int> m;
int N, K;
int in[17];
int out[17];
void solve() {
for (int i = 0; i < 100; i++) {
m[table[i]] = i + 1;
}
cin >> N >> K;
for (int i = 0; i < N; i++) {
static string tmp;
cin >> tmp;
in[i] = m[tmp];
}
for (int i = 0; i < K; i++) {
static string tmp;
cin >> tmp;
out[i] = m[tmp];
}
static int dp[1 << 17];
int NN = 1 << N;
for (int mask = 0; mask < NN; mask++) {
int sum = 0;
for (int i = 0; i < N; i++) {
if (mask & (1 << i)) sum += in[i];
}
dp[mask] = sum;
}
int i = 0;
vector<int> Q1, Q2;
static int Prev[1 << 17];
Q1.push_back((1 << N) - 1);
static int H[1 << 17];
while (i < K) {
Q2.resize(0);
for (int j = 0; j < (int)((Q1).size()); j++) {
int m = Q1[j];
for (int s = m; s; s = (s - 1) & m) {
if (dp[s] == out[i]) {
int mask2 = m ^ s;
if (H[mask2] < i + 1) {
Prev[mask2] = m;
Q2.push_back(mask2);
H[mask2] = i + 1;
}
}
}
}
swap(Q1, Q2);
i++;
}
if (Q1.empty()) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
int mask = 0;
for (int i = K - 1; i >= 0; i--) {
int mask2 = Prev[mask];
int s = mask2 ^ mask;
int cnt = 0;
for (int j = 0; j < N; j++) {
if ((1 << j) & s) cnt++;
}
for (int j = 0; j < N; j++) {
if ((1 << j) & s) {
cnt--;
cout << table[in[j] - 1];
if (cnt)
cout << '+';
else
cout << "->";
}
}
cout << table[out[i] - 1] << '\n';
mask = mask2;
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (k == 0 && n > 1) {
puts("No solution");
return 0;
}
printf("%d", k);
--n;
while (n--) {
printf("%c", '0');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char sRead[10];
int main() {
vector<int> sign{1};
while (scanf("%s", sRead), sRead[0] != '=') {
if (sRead[0] == '+')
sign.push_back(1);
else if (sRead[0] == '-')
sign.push_back(-1);
}
int n;
scanf("%d", &n);
int qCount = sign.size();
int pos = 0, neg = 0;
for (int x : sign) (x == 1 ? pos : neg)++;
if (n < pos - neg * n || pos * n - neg < n) {
printf("Impossible\n");
return 0;
}
printf("Possible\n");
vector<int> pNums(pos, 1), nNums(neg, 1);
if (n <= pos - neg) {
int toCompensate = (pos - neg) - n;
for (int &x : nNums) {
int amt = min(toCompensate, n - 1);
toCompensate -= amt;
x += amt;
}
} else {
int toCompensate = n - (pos - neg);
for (int &x : pNums) {
int amt = min(toCompensate, n - 1);
toCompensate -= amt;
x += amt;
}
}
for (int i = 0; i < qCount; ++i) {
if (i > 0) {
printf(" %c ", sign[i] == 1 ? '+' : '-');
}
if (sign[i] == 1) {
printf("%d", pNums.back());
pNums.pop_back();
} else {
printf("%d", nNums.back());
nNums.pop_back();
}
}
printf(" = %d\n", n);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, jwb = 0, tmpjwb = INT_MAX;
cin >> n >> a >> b;
if (b > a && b + a + a <= n) {
tmpjwb = 2;
}
multiset<int> s;
for (int i = 0; i < 4; ++i) s.insert(a);
for (int i = 0; i < 2; ++i) s.insert(b);
while (!s.empty()) {
++jwb;
int tmp = 0;
auto it = s.end();
--it;
while (it != s.begin() && tmp < n) {
if ((*it) + tmp <= n) {
tmp += (*it);
auto it2 = it;
++it;
s.erase(it2);
}
--it;
}
if ((*it) + tmp <= n) {
tmp += (*it);
s.erase(s.begin());
}
}
cout << min(jwb, tmpjwb) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int n, m;
char s[1200 + 5][1200 + 5];
int judge(char a[3][3]) {
int tt = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) tt += (a[i][j] == 'O');
if (tt == 0 || tt == 4 || tt == 5 || tt == 1) return 0;
if (tt == 2) {
if (a[0][0] == 'O')
tt = -1;
else
tt = 1;
}
if (tt == 3) {
if (a[0][0] == 'O')
tt = -1;
else
tt = 1;
}
if (tt == 6) {
if (a[1][0] == '.')
tt = -1;
else
tt = 1;
}
return tt;
}
int x[250 + 5][250 + 5];
char t[3][3];
int c[250 + 5], d[250 + 5];
int done(vector<int> a) {
int n = (int)(a).size();
if (n % 2 == 1) return 0;
for (int i = 0; i < n; i++)
if (a[i] < 0) return 0;
return 1;
}
int dp[250 + 5];
int solve(vector<pair<int, int> > a) {
int n = (int)(a).size();
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < n; i++) {
if (a[i].first <= 0 && a[i].second <= 0) {
dp[i + 1] += dp[i];
dp[i + 1] %= MOD;
}
if (i + 1 < n) {
if (a[i].first >= 0 && a[i + 1].first >= 0) {
if (a[i].second >= 0 && a[i + 1].second >= 0) {
dp[i + 2] += dp[i];
dp[i + 2] %= MOD;
}
}
}
}
return dp[n];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < 4 * n + 1; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
for (int k = 0; k < 3; k++)
for (int l = 0; l < 3; l++) {
t[k][l] = s[4 * i + 1 + k][4 * j + 1 + l];
}
x[i][j] = judge(t);
}
memset(c, 0, sizeof(c));
memset(d, 0, sizeof(d));
for (int i = 0; i < m; i++) {
vector<int> temp;
for (int j = 0; j < n; j++) temp.push_back(x[j][i]);
c[i] = done(temp);
}
for (int i = 0; i + 1 < m; i++) {
vector<pair<int, int> > temp;
for (int j = 0; j < n; j++)
temp.push_back(pair<int, int>(x[j][i], x[j][i + 1]));
d[i] = solve(temp) - c[i] * c[i + 1];
if (d[i] < 0) d[i] += MOD;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < m; i++) {
dp[i + 1] = (1LL * dp[i + 1] + c[i] * dp[i]) % MOD;
dp[i + 2] = (1LL * dp[i + 2] + 1LL * d[i] * dp[i] % MOD) % MOD;
}
cout << (dp[m] % MOD + MOD) % MOD << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, a, b;
cin >> n >> m >> a >> b;
if (a * m < b)
cout << a * n << "\n";
else {
int ans = b * floor(n / (1.0 * m));
if ((n % m) * a < b)
ans += (n % m) * a;
else
ans += b;
cout << ans << "\n";
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
char a[1005];
cin >> a;
int i;
int len = (strlen(a) + 1) / 2 - 1;
bool flg = 1;
for (i = 0; i <= len; i++) {
if (a[i] != a[strlen(a) - 1 - i]) flg = 0;
}
if (flg == 1) {
bool flag = 1;
for (i = 1; i < strlen(a); i++)
if (a[i] != a[i - 1]) {
flag = 0;
break;
}
if (flag == 1)
cout << "-1" << endl;
else {
int p = len + 1;
while (a[len] == a[p]) {
p++;
}
char temp = a[p];
a[p] = a[len];
a[len] = temp;
cout << a << endl;
}
} else {
cout << a << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100005], t[400005], res, n, m, w, mx = 0;
long long int bs(long long int high, long long int low) {
if (low > high) return -100;
long long int mid = (high + low) / 2, cur = 0, sh = 0;
for (int i = 0; i < n; i++) {
cur -= t[i];
t[i] = 0;
if (mid > a[i] + cur) {
sh += (mid - (a[i] + cur));
t[i + w] += (mid - (a[i] + cur));
cur = mid - a[i];
}
}
if (sh > m) return bs(mid - 1, low);
return max(mid, bs(high, mid + 1));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(t, 0, sizeof t);
cin >> n >> m >> w;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
res = bs(m + mx + 1, 0);
cout << res << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int root = 1;
int n, tr[6000010][2], size = 1;
int sum[6000010], a[300010], ans;
void insert(int x) {
int nw = root;
for (int i = 30; i >= 0; i--) {
int p = (x >> i) & 1;
if (tr[nw][p] == 0) tr[nw][p] = ++size;
nw = tr[nw][p];
sum[nw]++;
}
}
void solve(int x) {
int nw = root;
for (int i = 30; i >= 0; i--) {
int p = (x >> i) & 1;
if (sum[tr[nw][p]] == 0) {
nw = tr[nw][p ^ 1];
ans += (1 << i);
} else
nw = tr[nw][p];
sum[nw]--;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int x, i = 1; i <= n; i++) scanf("%d", &x), insert(x);
for (int i = 1; i <= n; i++) ans = 0, solve(a[i]), printf("%d ", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct node {
int cv;
int tv;
vector<int> adj;
node() {
cv = 0;
tv = 0;
}
} g[N];
int n, u, v, sol;
vector<int> ans;
void dfs(int okle, int cur, int nivo, int par, int nepar) {
int curpar = 0, curnepar = 0;
if (nivo % 2 == 0)
g[cur].cv += par;
else
g[cur].cv += nepar;
g[cur].cv %= 2;
if (g[cur].cv != g[cur].tv) {
sol++;
ans.push_back(cur);
if (nivo % 2 == 0)
curpar = 1;
else
curnepar = 1;
}
for (int i = 0; i < g[cur].adj.size(); i++) {
if (g[cur].adj[i] != okle)
dfs(cur, g[cur].adj[i], nivo + 1, par + curpar, nepar + curnepar);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].adj.push_back(v);
g[v].adj.push_back(u);
}
for (int i = 1; i <= n; i++) scanf("%d", &g[i].cv);
for (int i = 1; i <= n; i++) scanf("%d", &g[i].tv);
dfs(-1, 1, 0, 0, 0);
printf("%d\n", sol);
for (int i = 0; i < ans.size(); i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 305;
long long Power(long long a, long long b) {
if (b == 0) return 1;
long long p = Power(a, b / 2);
p *= p;
if (b % 2) p *= a;
return p;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, o, z;
string s;
cin >> n >> s;
o = z = 0;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1] && s[i] == '0') z++;
if (s[i] == s[i - 1] && s[i] == '1') o++;
}
cout << max(z, o) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[55];
int Next[55];
void kmp_pre(char* pat) {
int l = strlen(pat);
int i = 0, j = -1;
Next[0] = -1;
while (i < l) {
if (j == -1 || pat[i] == pat[j]) {
i++;
j++;
Next[i] = j;
} else {
j = Next[j];
}
}
}
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s);
kmp_pre(s);
int cnt = Next[n];
if (cnt == 0) {
for (int i = 0; i < k; i++) {
printf("%s", s);
}
printf("\n");
} else {
printf("%s", s);
for (int i = 0; i < k - 1; i++) {
printf("%s", s + cnt);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> adj;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
adj.resize(n);
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<array<long long, 2>> ranges;
vector<bool> visited(n, false);
for (long long i = 0; i < n; i++) {
if (visited[i]) continue;
long long range_min = i, range_max = i;
queue<long long> q;
q.push(i);
visited[i] = true;
while (q.size()) {
long long u = q.front();
q.pop();
for (long long v : adj[u]) {
if (!visited[v]) {
visited[v] = true;
q.push(v);
if (v < range_min) range_min = v;
if (v > range_max) range_max = v;
}
}
}
ranges.push_back({range_min, range_max});
}
vector<vector<long long>> adj_comp(ranges.size());
long long max_vtx = 0;
for (long long i = 1; i < ranges.size(); i++) {
if (ranges[i][0] > ranges[max_vtx][1]) {
max_vtx = i;
} else {
adj_comp[i].push_back(max_vtx);
adj_comp[max_vtx].push_back(i);
if (ranges[i][1] > ranges[max_vtx][1]) {
max_vtx = i;
}
}
}
long long res = 0;
vector<bool> visited_comp(ranges.size(), false);
for (long long i = 0; i < (long long)ranges.size(); i++) {
long long this_size = 0;
if (visited_comp[i]) continue;
queue<long long> q;
q.push(i);
this_size++;
visited_comp[i] = true;
while (q.size()) {
long long u = q.front();
q.pop();
for (long long v : adj_comp[u]) {
if (!visited_comp[v]) {
this_size++;
visited_comp[v] = true;
q.push(v);
}
}
}
res += this_size - 1;
}
cout << res << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-7;
int sig(long double x) { return x < -eps ? -1 : x > eps; }
struct point {
long double x, y;
point() {}
point(long double x, long double y) : x(x), y(y) {}
void input() { cin >> x >> y; }
void output() { cout << x << ' ' << y << endl; }
point friend operator+(point a, point b) {
return point(a.x + b.x, a.y + b.y);
}
point friend operator-(point a, point b) {
return point(a.x - b.x, a.y - b.y);
}
point friend operator*(point a, long double b) {
return point(a.x * b, a.y * b);
}
point friend operator*(long double b, point a) {
return point(a.x * b, a.y * b);
}
point friend operator/(point a, long double b) {
return point(a.x / b, a.y / b);
}
long double norm() { return sqrt(x * x + y * y); }
long double norm2() { return x * x + y * y; }
point rot90() { return point(-y, x); }
point unit() { return point(x, y) / norm(); }
int getP() { return y > 0 || (y == 0 && x < 0); }
};
long double dot(point a, point b) { return a.x * b.x + a.y * b.y; }
long double det(point a, point b) { return a.x * b.y - a.y * b.x; }
bool cmp(point &a, point &b) {
return a.getP() < b.getP() || (a.getP() == b.getP() && det(a, b) > 0);
}
long double dist(point a, point b) { return (a - b).norm(); }
point point_proj_line(point p, point a, point b) {
return a + (b - a) * dot(b - a, p - a) / (b - a).norm2();
}
struct circle {
point o;
long double r;
circle() {}
circle(point o, long double r) : o(o), r(r) {}
};
int typeCC(circle a, circle b) {
long double d = dist(a.o, b.o);
if (sig(d - (a.r + b.r)) == 1) return 4;
if (sig(d - (a.r + b.r)) == 0) return 3;
if (sig(d - abs(a.r - b.r)) == 1) return 2;
if (sig(d - abs(a.r - b.r)) == 0) return 1;
return 0;
}
long double area(long double a, long double b, long double c) {
long double p = (a + b + c) / 2.0;
return sqrt(p * (p - a) * (p - b) * (p - c));
}
vector<point> isCC(circle a, circle b) {
if (typeCC(a, b) % 4 == 0) return {};
long double d = min(dist(a.o, b.o), a.r + b.r);
long double x = (a.r * a.r + d * d - b.r * b.r) / (2.0 * d);
d = sqrt(a.r * a.r - x * x);
point e = (b.o - a.o).unit(), m = a.o + x * e;
e = e.rot90();
return {m - d * e, m + d * e};
}
bool eql(point a, point b) { return sig(det(a, b)) == 0 && sig(dot(a, b)) > 0; }
int main() {
int n, d;
cin >> n >> d;
vector<pair<point, point> > v;
while (n--) {
int x, y, r;
cin >> x >> y >> r;
point p(x, y), o(0, 0);
long double L = dist(o, p) - r, R = dist(o, p) + r;
for (long double dd = max(floor(L / d) * d - d, (long double)d);
dd < R + d + eps; dd += d) {
circle c1(o, dd), c2(p, r);
vector<point> r = isCC(c1, c2);
if (r.size()) v.push_back({r[0], r[1]});
}
}
vector<point> vec;
for (auto i : v) vec.push_back(i.first), vec.push_back(i.second);
sort(vec.begin(), vec.end(), cmp);
map<pair<long double, long double>, int> m;
int cnt = 1;
for (int i = 0, j = 0; i < (int)vec.size(); i = j) {
while (j < (int)vec.size() && eql(vec[j], vec[i]))
m[{vec[j].x, vec[j].y}] = cnt, j++;
cnt++;
}
vector<int> s(cnt + 1);
for (auto i : v) {
int l = m[{i.first.x, i.first.y}], r = m[{i.second.x, i.second.y}];
if (l <= r)
s[l]++, s[r + 1]--;
else
s[l]++, s[1]++, s[r + 1]--;
}
int ans = 0;
for (int i = 1; i < cnt; i++) s[i] += s[i - 1], ans = max(ans, s[i]);
cout << ans << endl;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long getSize(long long num) {
if (num <= 1) return 1;
return 2 * getSize(num / 2) + 1;
}
long long l, r;
long long solve(long long n, long long cl, long long cr) {
if (cl > r or cr < l) return 0;
if (!n) return 0;
if (cl > cr) return 0;
long long ret = 0;
long long mid = (cl + cr) / 2;
if (mid >= l and mid <= r and n & 1) ret++;
ret += solve(n / 2, cl, mid - 1);
ret += solve(n / 2, mid + 1, cr);
return ret;
}
const long long N = 5e5 + 5;
int main() {
ios_base::sync_with_stdio(false);
long long n, t, m, k, ans, i, j, res = 0, fl;
t = 1;
while (t--) {
cin >> n >> l >> r;
long long siz = getSize(n);
cout << solve(n, 1, siz) << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
typedef int i_N[maxN];
int N, M;
i_N A;
int ITodd[maxN * 4], ITeven[maxN * 4];
namespace graph {
int Cnum;
i_N num, hi, P, depth;
vector<int> adj[maxN];
void link(const int u, const int v) { adj[u].push_back(v); }
void DFS(const int u) {
num[u] = hi[u] = ++Cnum;
for (int i = 0; i < (int)adj[u].size(); i++) {
const int v = adj[u][i];
if (P[v]) continue;
P[v] = u;
depth[v] = depth[u] + 1;
DFS(v);
hi[u] = max(hi[u], hi[v]);
}
}
} // namespace graph
void update(int *IT, const int key, const int l, const int r, const int i,
const int j, const int val) {
if (j < l || i > r) return;
if (i <= l && j >= r) {
IT[key] += val;
return;
}
const int mid = (l + r) / 2;
update(IT, key * 2, l, mid, i, j, val);
update(IT, key * 2 + 1, mid + 1, r, i, j, val);
}
int get_IT(int *IT, const int key, const int l, const int r, const int i) {
if (i < l || i > r) return 0;
int tmp = IT[key];
if (l == r) return tmp;
const int mid = (l + r) / 2;
return get_IT(IT, key * 2, l, mid, i) +
get_IT(IT, key * 2 + 1, mid + 1, r, i) + tmp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (int i = 0; i < N; i++) cin >> A[i + 1];
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v;
graph::link(u, v);
graph::link(v, u);
}
graph::P[1] = -1;
graph::DFS(1);
{
using namespace graph;
for (int i = 0; i < M; i++) {
using namespace graph;
int cmd, u, val;
cin >> cmd;
if (cmd == 1) {
cin >> u >> val;
int *x = ITeven, *y = ITodd;
if (depth[u] % 2) swap(x, y);
update(x, 1, 1, N, num[u], hi[u], val);
update(y, 1, 1, N, num[u], hi[u], -val);
} else {
cin >> u;
int *x = (depth[u] % 2) ? ITodd : ITeven;
int ans = get_IT(x, 1, 1, N, num[u]);
cout << ans + A[u] << endl;
}
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, a1, b1;
while (~scanf("%lld%lld%lld%lld", &a, &b, &a1, &b1)) {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; i++) {
long long c, d, e;
scanf("%lld%lld%lld", &c, &e, &d);
if (c * a + b * e + d > 0 && a1 * c + b1 * e + d < 0) {
ans++;
}
if (c * a + b * e + d < 0 && a1 * c + b1 * e + d > 0) {
ans++;
}
}
printf("%d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
int check(int pos, char x) {
if (s[pos - 1] != x && s[pos + 1] != x)
return 1;
else
return 0;
}
int main() {
int i, j, k;
cin >> s;
for (i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1]) {
if (check(i, 'a')) s[i] = 'a';
if (check(i, 'b')) s[i] = 'b';
if (check(i, 'c')) s[i] = 'c';
}
}
for (i = 0; i < s.length(); i++) {
cout << s[i];
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int intmax = 0x3f3f3f3f;
const long long lldmax = 0x3f3f3f3f3f3f3f3fll;
double eps = 1e-6;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T checkmod(T n, T m) {
return (n % m + m) % m;
}
inline int rand(int a, int b) {
if (a >= b) return a;
return rand() % (b - a) + a;
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T euclid(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclid(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclid(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclid(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T eularFunction(T n) {
vector<pair<T, int> > R = factorize(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline int dblcmp(T a, const T b) {
a -= b;
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
template <class T>
inline int sgn(T a) {
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
struct vec2 {
double x, y;
vec2(double x = 0.0, double y = 0.0) : x(x), y(y) {}
vec2 operator+(const vec2 &b) const { return vec2(x + b.x, y + b.y); }
vec2 operator-(const vec2 &b) const { return vec2(x - b.x, y - b.y); }
vec2 operator*(const double &b) const { return vec2(x * b, y * b); }
vec2 operator/(const double &b) const { return vec2(x / b, y / b); }
double operator*(const vec2 &b) const { return x * b.x + y * b.y; }
double operator^(const vec2 &b) const { return x * b.y - y * b.x; }
double len() { return sqrt(x * x + y * y); }
vec2 unit() { return *this / len(); }
vec2 rotate(double r) {
vec2 t(sin(r), cos(r));
return vec2(*this ^ t, *this * t);
}
bool operator<(const vec2 &b) const {
if (dblcmp(x, b.x) != 0)
return dblcmp(x, b.x) < 0;
else
return dblcmp(y, b.y) < 0;
}
};
const int N = 1100;
int in[N][N], num[N];
double dp[N][N], comb[N][N];
double gao[N][N];
int a[N], b[N];
int tot[N];
int main() {
int n, m;
for (int i = 0; i < N; ++i) {
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; ++j) {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
}
}
while (scanf("%d%d", &n, &m) != EOF) {
int top = 0;
for (int i = 0; i < m; ++i) {
scanf("%d", &num[i]);
for (int j = 0; j < num[i]; ++j) {
scanf("%d", &in[i][j]);
tot[top++] = in[i][j];
}
}
sort(tot, tot + top);
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
int sum = 0, sb = 0;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < num[i]; ++j) {
if (in[i][j] == tot[top - n])
a[i]++;
else if (in[i][j] > tot[top - n])
b[i]++;
}
sb += b[i];
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
memset(gao, 0, sizeof(gao));
gao[0][0] = 1;
for (int i = 0; i < m; ++i) {
sum += a[i];
for (int j = 0; j <= sum && j <= n - sb; ++j) {
for (int k = 0; k <= a[i] && k <= j; ++k) {
gao[i + 1][j] += gao[i][j - k];
dp[i + 1][j] += dp[i][j - k] * comb[a[i]][k] / comb[num[i]][b[i] + k];
}
}
}
printf("%.9lf\n", dp[m][n - sb] / gao[m][n - sb]);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans[2010];
struct _2sat {
bitset<2010> g[2010];
int m;
int get(int x) {
if (x > 0)
return x * 2 - 2;
else
return -x * 2 - 1;
}
void read() {
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
x = get(x);
y = get(y);
g[x ^ 1].set(y);
g[y ^ 1].set(x);
}
for (int i = 0; i < n * 2; i++) g[i].set(i);
}
void calc() {
for (int i = 0; i < n * 2; i++)
for (int j = 0; j < n * 2; j++)
if (g[j][i]) g[j] |= g[i];
}
void solve() {
calc();
for (int i = 0; i < n * 2; i++) {
if (g[i][i ^ 1]) {
for (int j = 0; j < n * 2; j++) {
g[i].set(j);
g[j].set(i ^ 1);
}
}
}
calc();
}
void dfs(int v) {
if (ans[v] != -1) return;
ans[v] = 1;
ans[v ^ 1] = 0;
for (int i = 0; i < n * 2; i++) {
if (g[v][i]) dfs(i);
}
}
void getans(int u, int v) {
dfs(u);
dfs(v ^ 1);
for (int i = 0; i < n * 2; i++) {
if ((ans[i] == -1) && !g[i][i ^ 1]) dfs(i);
}
}
};
_2sat f, g;
int main() {
scanf("%d", &n);
scanf("%d%d", &f.m, &g.m);
f.read();
f.calc();
f.solve();
g.read();
g.calc();
g.solve();
memset(ans, -1, sizeof(ans));
for (int i = 0; i < n * 2; i++) {
for (int j = 0; j < n * 2; j++) {
if (f.g[i][j] != g.g[i][j]) {
if (f.g[i][j])
g.getans(i, j);
else
f.getans(i, j);
for (int k = 0; k < n; k++) printf("%d ", ans[k * 2]);
puts("");
return 0;
}
}
}
puts("SIMILAR");
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > G[2002];
int vis[2002];
void go(int i, int col) {
vis[i] = col;
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j].first;
int w = G[i][j].second;
if (w == 1) {
if (vis[v] != 3) go(v, col);
}
}
return;
}
int flag = 0;
void dfs(int i, int col) {
if (flag == 1) {
return;
}
if (vis[i] == 3) {
return;
}
if (vis[i] == 0) {
vis[i] = col;
} else {
if (vis[i] != col) {
go(i, 3);
flag = 1;
return;
} else {
return;
}
}
if (col == 1) {
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j].first;
int w = G[i][j].second;
if (w == 1) {
dfs(v, 1);
} else {
dfs(v, 2);
}
}
} else {
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j].first;
int w = G[i][j].second;
if (w == 1) {
dfs(v, 2);
}
}
}
}
int main() {
int n, k, m;
cin >> n;
cin >> k;
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(make_pair(b, 1));
G[b].push_back(make_pair(a, 1));
}
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(make_pair(b, 2));
G[b].push_back(make_pair(a, 2));
}
int mx = 0;
for (int i = 1; i <= n; i++) {
flag = 0;
if (vis[i] == 0) {
dfs(i, 1);
if (flag == 0) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
if (vis[j] == 1) {
vis[j] = 3;
cnt++;
} else if (vis[j] == 2) {
vis[j] = 0;
}
}
mx = max(mx, cnt);
}
}
}
cout << mx << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, i, j, m;
long long k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%lld %d", &k, &m);
printf("%lld\n", 9 * (k - 1) + m);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
const long long mod = 1e9 + 7;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
vector<int> G[N];
int n, m, q[N];
bool vis[N];
void solve() {
n = read();
m = read();
for (int i = 0; i <= n * 2 + 2; i++) G[i].clear();
memset(vis, 0, sizeof(bool) * (n * 2 + 2));
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
if (u == v) continue;
G[u].push_back(v + n);
G[v + n].push_back(u);
}
int s = 0, t = 0;
q[t++] = 1;
while (s < t) {
int x = q[s++];
vis[x] = 1;
for (auto v : G[x]) {
v -= n;
if (!vis[v]) vis[v] = 1, q[t++] = v;
}
}
if (t < n) {
puts("Yes");
printf("%d %d\n", t, n - t);
for (int i = 1; i <= n; i++)
if (vis[i]) printf("%d ", i);
puts("");
for (int i = 1; i <= n; i++)
if (!vis[i]) printf("%d ", i);
puts("");
return;
}
s = 0;
t = 0;
q[t++] = 1 + n;
memset(vis, 0, sizeof(bool) * (n * 2 + 2));
while (s < t) {
int x = q[s++];
vis[x - n] = 1;
for (auto v : G[x]) {
if (!vis[v]) vis[v] = 1, q[t++] = v + n;
}
}
if (t < n) {
puts("Yes");
printf("%d %d\n", n - t, t);
for (int i = 1; i <= n; i++)
if (!vis[i]) printf("%d ", i);
puts("");
for (int i = 1; i <= n; i++)
if (vis[i]) printf("%d ", i);
puts("");
return;
}
puts("No");
}
int main() {
int T = read();
while (T--) solve();
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long tom[200];
long long ban[200];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> tom[i];
}
for (int i = 0; i < m; i++) {
cin >> ban[i];
}
long long result = -1e18;
long long result_prod = -1e18;
long long num = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
long long prod = tom[i] * ban[j];
if (prod >= result) {
result = prod;
num = tom[i];
}
}
}
bool hidden = false;
for (int i = n - 1; i >= 0; i--) {
if (tom[i] == num && !hidden) {
hidden = true;
continue;
}
for (int j = m - 1; j >= 0; j--) {
long long prod = tom[i] * ban[j];
result_prod = max(prod, result_prod);
}
}
cout << result_prod << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int maxn = 6005;
int n, sum, flg;
int a[maxn];
int check(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 1;
return 0;
}
int main() {
scanf("%d", &n);
sum = n * (n + 1) / 2;
if (check(sum) == 0) {
for (int i = 1; i <= n; i++) printf("1%c", i == n ? '\n' : ' ');
return 0;
}
if (sum % 2 == 1) {
if (check(sum - 2) == 0) {
for (int i = 1; i <= n; i++)
printf("%d%c", i == 2 ? 1 : 2, i == n ? '\n' : ' ');
return 0;
}
flg = 1;
sum -= 3;
}
for (int i = flg == 0 ? 2 : 5; i <= n; i++)
if (check(i) == 0 && check(sum - i) == 0) {
for (int j = 1; j <= n; j++)
printf("%d%c", j == i ? 1 : (flg == 1 && j == 3 ? 3 : 2),
j == n ? '\n' : ' ');
return 0;
}
puts("-1");
return 0;
}
| 14 |
#include <bits/stdc++.h>
const int N = 1e6 + 61;
std::vector<int> g[N];
int dep[N], son[N];
void dfs1(int x, int p) {
for (int nx : x[g])
if (nx != p) {
dfs1(nx, x);
if (nx[dep] > x[son][dep]) x[son] = nx;
}
x[dep] = x[son][dep] + 1;
}
int buf[N], *pt = buf;
int *f[N], ans[N];
void dfs2(int x, int p) {
f[x][0] = 1;
if (x[son]) {
f[x[son]] = f[x] + 1;
dfs2(x[son], x);
x[ans] = x[son][ans] + 1;
}
for (int nx : x[g])
if (nx != p && nx != x[son]) {
f[nx] = pt, pt += nx[dep];
dfs2(nx, x);
for (int i = 1; i <= nx[dep]; i++) {
f[x][i] += f[nx][i - 1];
if (f[x][i] > f[x][x[ans]] || (f[x][i] == f[x][x[ans]] && i < x[ans]))
x[ans] = i;
}
}
if (f[x][x[ans]] == 1) x[ans] = 0;
}
int n;
int main() {
scanf("%d", &n);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
x[g].push_back(y);
y[g].push_back(x);
}
dfs1(1, 1);
f[1] = pt, pt += 1 [dep];
dfs2(1, 1);
for (int i = 1; i <= n; i++) printf("%d\n", i[ans]);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
if (n <= m) {
cout << n << endl;
return 0;
}
n -= m;
n *= 2;
long long int x = sqrt(n);
if ((x * (x + 1)) >= n)
cout << x + m << endl;
else
cout << x + 1 + m << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 100002;
int n;
int val[N_MAX];
vector<int> edges[N_MAX];
bool blocked[N_MAX];
int subSize[N_MAX];
void dfs(int node, int parent = -1) {
subSize[node] = 1;
for (int u : edges[node])
if (u != parent && blocked[u] == false) {
dfs(u, node);
subSize[node] += subSize[u];
}
}
int searchCentroid(int node, int treeSize, int parent = -1) {
int maxSonSize = treeSize - subSize[node];
for (int u : edges[node])
if (u != parent && blocked[u] == false) {
int c = searchCentroid(u, treeSize, node);
if (c != -1) return c;
maxSonSize = max(maxSonSize, subSize[u]);
}
if (maxSonSize > treeSize / 2) return -1;
return node;
}
int findCentroid(int node) {
dfs(node);
return searchCentroid(node, subSize[node]);
}
struct xorVal {
long long zeros[20], ones[20];
};
void operator+=(xorVal &a, const xorVal &b) {
for (int i = 0; i < 20; i++) {
a.zeros[i] += b.zeros[i];
a.ones[i] += b.ones[i];
}
}
xorVal xorCount(int node, int parent = -1) {
xorVal answer;
for (int i = 0; i < 20; i++) {
answer.zeros[i] = 1;
answer.ones[i] = 0;
}
for (int u : edges[node])
if (u != parent && blocked[u] == false) answer += xorCount(u, node);
for (int i = 0; i < 20; i++)
if ((val[node] >> i) & 1) swap(answer.zeros[i], answer.ones[i]);
return answer;
}
xorVal answer;
void centroidDecomposition(int node) {
int centroid = findCentroid(node);
blocked[centroid] = true;
xorVal total;
xorVal answer1;
for (int i = 0; i < 20; i++) {
answer1.zeros[i] = total.zeros[i] = 1;
answer1.ones[i] = total.ones[i] = 0;
}
for (int u : edges[centroid])
if (blocked[u] == false) {
xorVal current = xorCount(u);
for (int i = 0; i < 20; i++) {
answer1.zeros[i] +=
current.zeros[i] * total.zeros[i] + current.ones[i] * total.ones[i];
answer1.ones[i] +=
current.zeros[i] * total.ones[i] + current.ones[i] * total.zeros[i];
}
total += current;
}
for (int i = 0; i < 20; i++)
if ((val[centroid] >> i) & 1) swap(answer1.zeros[i], answer1.ones[i]);
answer += answer1;
for (int u : edges[centroid])
if (blocked[u] == false) centroidDecomposition(u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edges[u].push_back(v);
edges[v].push_back(u);
}
long long sum = 0;
centroidDecomposition(1);
for (int i = 0; i < 20; i++) sum += (1 << i) * answer.ones[i];
cout << sum << "\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
double pi = 2 * acos(0);
long long mod = 1e9 + 7;
const int mysz = 1e5;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int p = 1000;
vector<vector<long long>> dp(p);
for (int i = 0; i < p; i++) {
vector<long long> nv(p, 0);
dp[i] = nv;
}
for (int i = 0; i < p; i++) dp[i][0] = 1;
for (int i = 1; i < p; i++) {
for (int j = 1; j < p; j++) dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
}
cout << dp[n][5] + dp[n][6] + dp[n][7] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const int mod = 1000000007;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
template <class T>
inline void read(T& x, T& y, T& z, T& q) {
read(x);
read(y);
read(z);
read(q);
}
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 1111, M = 111111;
int l, m, n, t, C, a[N][N];
int main() {
scanf("%d", &n);
if (n == 4) {
puts("-1");
return 0;
}
if (n & 1) {
for (int _tmp = n, i = 1; i <= _tmp; ++i)
for (int _tmp = n, j = 1; j <= _tmp; ++j)
if ((i - j + n) % n <= n / 2 && i != j) a[i][j] = 1;
} else {
n--;
for (int _tmp = n, i = 1; i <= _tmp; ++i)
for (int _tmp = n, j = 1; j <= _tmp; ++j)
if ((i - j + n) % n <= n / 2 && i != j) a[i][j] = 1;
n++;
for (int _tmp = n - 1, i = 1; i <= _tmp; ++i)
if (i & 1)
a[n][i] = 1;
else
a[i][n] = 1;
}
for (int _tmp = n, i = 1; i <= _tmp; ++i) {
for (int _tmp = n, j = 1; j <= _tmp; ++j) printf("%d ", a[i][j]);
puts("");
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, i, j, n, m, k;
int mas[100001];
long long cs[100001], a1;
inline long long sum(int l, int r) {
if (!l)
return cs[r];
else
return cs[r] - cs[l - 1];
}
inline long long calc(int k) {
if (k == 1) return a1;
int cur = 1, h = 0, pos = n - 1;
long long ans = 0;
while (pos >= 0) {
int l = pos - cur + 1;
if (l < 0) l = 0;
ans += (long long)h * sum(l, pos);
++h;
pos = l - 1;
if ((long long)cur * k > 1000000000)
cur = 1000000000;
else
cur *= k;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int _n((n)-1), i(0); i <= _n; i++) scanf("%d", &mas[i]);
sort(mas, mas + n);
for (int _n((n)-1), i(0); i <= _n; i++) {
cs[i] = mas[i];
if (i) cs[i] += cs[i - 1];
}
a1 = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
a1 += (long long)(n - i - 1) * mas[i];
}
scanf("%d", &m);
for (int _n((m)-1), i(0); i <= _n; i++) {
scanf("%d", &a);
if (a > n - 1) a = n - 1;
long long ans = calc(a);
if (i) printf(" ");
printf("%I64d", ans);
}
printf("\n");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n, first, second;
cin >> n;
char c;
string a;
cin >> a;
for (int i = 0; i < n; i++) {
int b;
cin >> b;
v.push_back(b);
}
int count = 0, i = 0;
while (n != count) {
if (a[i] == '>') {
first = v[i];
if (i + first < n) {
i = i + first;
count++;
} else {
cout << "FINITE" << endl;
return 0;
}
}
if (count >= n) {
break;
}
if (a[i] == '<') {
first = v[i];
if (i - first >= 0) {
i = i - first;
count++;
} else {
cout << "FINITE" << endl;
return 0;
}
}
if (count >= n) {
break;
}
}
cout << "INFINITE" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, h, i, cnt;
int main() {
cin >> n;
while (cnt <= n) {
h++;
cnt += (h * (h + 1)) / 2;
}
cout << h - 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l;
int r;
Node() {
l = 0;
r = 0;
}
} node[50];
int vis[50];
int fa[50];
int Find(int x) { return fa[x] == x ? x : Find(fa[x]); }
set<int> s[50];
int main() {
int n, m;
cin >> n >> m;
int f = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
int rx = Find(x);
int ry = Find(y);
fa[rx] = ry;
}
for (int i = 1; i <= n; i++) {
int x = Find(i);
s[x].insert(i);
if (s[x].size() > 3) {
f = 1;
break;
}
}
if (f) {
printf("-1\n");
return 0;
}
vector<int> v;
int n1 = 0;
int n2 = 0;
for (int i = 1; i <= n; i++) {
if (s[i].size() == 1) {
n1++;
v.push_back(i);
} else if (s[i].size() == 2) {
n2++;
}
}
if (n2 > n1) {
cout << -1 << endl;
return 0;
} else if ((n1 - n2) % 3) {
cout << -1 << endl;
return 0;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (s[i].size() == 3) {
set<int>::iterator it = s[i].begin();
int a = (*it++);
int b = (*it++);
int c = (*it++);
cout << a << " " << b << " " << c << endl;
vis[a] = 1, vis[b] = 1, vis[c] = 1;
} else if (s[i].size() == 2) {
set<int>::iterator it = s[i].begin();
int a = (*it++);
int b = (*it++);
int c = v[cnt];
cnt++;
cout << a << " " << b << " " << c << endl;
vis[a] = 1, vis[b] = 1, vis[c] = 1;
}
}
while (cnt < v.size()) {
int a = v[cnt++];
if (a > n) cout << "+++++" << endl;
int b = v[cnt++];
if (b > n) cout << "+++++" << endl;
int c = v[cnt++];
if (c > n) cout << "+++++" << endl;
cout << a << " " << b << " " << c << endl;
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.