solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int limN = 3e5 + 5;
int N;
int nms[limN][2];
int tips[limN];
vector<int> adj[limN];
long long tots[2];
int T[2] = {1, 1};
long long acum[2][limN];
long long aprs[2][limN];
int getMn(const int a, const int b) {
return min(nms[a][0] + nms[b][1], nms[a][1] + nms[b][0]);
}
long long query(int pos) {
int t = tips[pos];
int r = 1 - t;
long long ans = tots[r] + (N - 1LL) * nms[pos][t];
for (const int s : adj[pos]) ans -= getMn(pos, s);
long long c =
lower_bound(aprs[r], aprs[r] + T[r], abs(nms[pos][0] - nms[pos][1])) -
aprs[r];
ans += tots[t] - nms[pos][t];
ans += acum[r][c - 1] + (T[r] - c - 1) * (nms[pos][r] - nms[pos][t]);
return ans;
}
int main() {
int E;
scanf("%d%d", &N, &E);
for (int i = 0, t, r; i < N; i++) {
scanf("%d%d", &nms[i][0], &nms[i][1]);
t = tips[i] = nms[i][0] < nms[i][1] ? 0 : 1;
tots[t] += nms[i][t];
r = 1 - t;
aprs[r][T[r]++] = nms[i][r] - nms[i][t];
}
for (int i = 0, a, b; i < E; i++) {
scanf("%d%d", &a, &b);
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int w = 0; w < 2; w++) {
sort(aprs[w], aprs[w] + T[w]);
for (int i = 1; i < T[w]; i++) {
acum[w][i] = acum[w][i - 1] + aprs[w][i];
}
}
for (int i = 0; i < N; i++) printf("%lld ", query(i));
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool B[1400001];
int main() {
int n, a, N = 2, X;
scanf("%d", &n);
bool F = false;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a);
X = N;
if (!F && a > X) X = a;
while (B[X]) ++X;
printf("%d ", X);
if (X > a) F = true;
for (int j = N; j * j <= X; ++j) {
if (X % j) continue;
while (X % j == 0) X /= j;
if (!B[j])
for (int t = j; t < 1400005; t += j) B[t] = true;
}
if (X != 1)
for (int j = X; j < 1400005; j += X) B[j] = true;
while (B[N]) ++N;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, k;
struct Edge {
int to, nxt, id;
} edge[2 * maxn];
int head[maxn];
int tot;
void addedge(int u, int v, int id) {
tot++;
edge[tot].to = v;
edge[tot].id = id;
edge[tot].nxt = head[u];
head[u] = tot;
}
int d[maxn];
int col[maxn];
bool judge(int x) {
int ret = 0;
for (int i = 1; i <= n; i++) {
if (d[i] <= x) ret++;
}
return (n - ret) <= k;
}
void dfs(int u, int pre, int k, int last) {
int c = last;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == pre) continue;
c++;
if (c > k) c = 1;
col[edge[i].id] = c;
dfs(v, u, k, c);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v, i);
addedge(v, u, i);
d[u]++;
d[v]++;
}
int ans;
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (judge(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
dfs(1, 0, ans, 0);
cout << ans << endl;
for (int i = 1; i < n; i++) cout << col[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
long long int power(long long int x, long long int y) {
long long int ans = 1;
x = x % MOD;
while (y > 0) {
if (y & 1) {
ans *= x;
ans %= MOD;
}
y = y >> 1;
x = (x * x) % MOD;
}
return ans;
}
vector<long long int> fac(102, 0);
long long int inverseMod(long long int a) { return power(a, MOD - 2); }
long long int nCr(long long int n, long long int r) {
if (r > n) {
return 0;
}
long long int ans = fac[n];
long long int val = (inverseMod(fac[r]) * inverseMod(fac[n - r])) % MOD;
ans *= val;
ans %= MOD;
return ans;
}
vector<vector<long long int>> dp(102, vector<long long int>(10, 0));
void solve() {
fac[0] = 1;
for (long long int i = 1; i < 102; i++) {
fac[i] = (fac[i - 1] * i) % MOD;
}
long long int n, a;
cin >> n;
vector<long long int> v;
long long int sum = 0;
for (long long int i = 0; i < 10; i++) {
cin >> a;
v.push_back(a);
sum += a;
}
if (sum > n) {
cout << "0" << endl;
return;
}
long long int ans = 0;
for (long long int cnt = v[1]; cnt <= n; cnt++) {
dp[cnt][1] = 1;
}
for (long long int digit = 2; digit <= 9; digit++) {
for (long long int len = 0; len <= n; len++) {
for (long long int cnt = v[digit]; cnt <= len; cnt++) {
dp[len][digit] += (nCr(len, cnt) * dp[len - cnt][digit - 1]) % MOD;
dp[len][digit] %= MOD;
}
}
}
for (long long int len = sum; len <= n; len++) {
for (long long int i = v[0]; i <= len; i++) {
ans += (nCr(len - 1, i) * dp[len - i][9]) % MOD;
ans %= MOD;
}
}
cout << ans << endl;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, i, j, k, l, c[201010], r;
int main() {
string s;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == '-')
l++;
else
r++;
}
if (l == 0 || r == 0) {
cout << "YES";
} else {
if (l % r == 0) {
cout << "YES";
} else
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void tim(long long s, long long p) {
double d = s * s - 4 * p;
cout << "Y"
<< " ";
cout << setprecision(9) << fixed << (s * 1.0 + (double)sqrt(d)) / (2 * 1.0)
<< " ";
cout << setprecision(9) << fixed << (s * 1.0 - (double)sqrt(d)) / (2 * 1.0)
<< endl;
}
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long z = 1; z <= n; z++) {
if (a[z] * a[z] - 4 * a[z] < 0)
cout << "N" << endl;
else {
long long s = a[z];
long long p = a[z];
tim(s, p);
}
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64777216")
using namespace std;
const int inf = (int)1e9 + 5;
const long long INF = (long long)1e18 + 5;
void solve() {
long long n;
cin >> n;
vector<long long> a(n / 2);
for (long long i = 0; i < n / 2; i++) cin >> a[i];
sort(a.begin(), a.end());
long long ans = INF;
for (long long start = 0; start < 2; start++) {
long long cur_ans = 0;
for (long long i = 0; i < n / 2; i++) {
long long cur = start + i * 2;
cur_ans += abs((a[i] - 1) - cur);
}
ans = min(ans, cur_ans);
}
cout << ans << endl;
}
int main() {
string filename = "acm";
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
solve();
(void)0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long int t;
cin >> t;
for (long long int j = 0; j<t; ++j)
{
long long int n;
cin >> n;
vector <long long int> v;
for (long long int i=0; i<n; ++i)
{long long int k;
cin >> k;
v.push_back(k);}
vector <long long int> vdash;
for (long long int i=0; i<v.size(); ++i)
{
vdash.push_back(v[i]);
}
sort(vdash.begin(),vdash.end());
long long int x = 0;
if (vdash[0]==vdash[1])
{
x = vdash[v.size()-1];
}
else {x = vdash[0];}
for (int i=0; i<v.size(); ++i)
{
if (v[i]==x)
{
cout << i+1 << endl;
break;
}
}
}
return 0;
} | 0 |
// #pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define dd double
#define ld long double
#define sl(n) scanf("%lld", &n)
#define si(n) scanf("%d", &n)
#define sd(n) scanf("%lf", &n)
#define pll pair <ll, ll>
#define pii pair <int, int>
#define mp make_pair
#define pb push_back
#define all(v) v.begin(), v.end()
#define inf (1LL << 61)
#define loop(i, start, stop, inc) for(ll i = start; i <= stop; i += inc)
#define for1(i, stop) for(ll i = 1; i <= stop; ++i)
#define for0(i, stop) for(ll i = 0; i < stop; ++i)
#define rep1(i, start) for(ll i = start; i >= 1; --i)
#define rep0(i, start) for(ll i = (start-1); i >= 0; --i)
#define ms(n, i) memset(n, i, sizeof(n))
#define casep(n) printf("Case %lld:", ++n)
#define pn printf("\n")
#define pf printf
#define EL '\n'
#define fastio std::ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
// === Debug macro starts here ===
#ifndef ONLINE_JUDGE
#define DEBUG
#define SYS_COL system("COLOR")
#endif
int recur_depth = 0;
#ifdef DEBUG
#define dbg(x) {++recur_depth; auto x_=x; --recur_depth; SYS_COL; \
cerr<<string(recur_depth, '\t')<<"\e[91m"<<__func__<<":" \
<<__LINE__<<"\t"<<#x<<" = "<<x_<<"\e[39m"<<endl;}
template<typename Ostream, typename Cont>
typename enable_if<is_same<Ostream,ostream>::value,
Ostream&>::type operator<<(Ostream& os, const Cont& v) {
os<<"[";
for(auto& x:v){os<<x<<", ";}
return os<<"]";
}
template<typename Ostream, typename ...Ts>
Ostream& operator<<(Ostream& os, const pair<Ts...>& p){
return os<<"{"<<p.first<<", "<<p.second<<"}";
}
#else
#define dbg(x)
#endif
// === Debug macro ends here ===
#define ff first
#define ss second
const ll sz = 1e5 + 10, mod = 1e9 + 7;
ll fact[sz], inv[sz];
ll fastPow(ll x, ll n, ll MOD)
{
ll ret = 1;
while (n)
{
if (n & 1) ret = (ret * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return ret % MOD;
}
inline ll ncr(ll n, ll r)
{
if(n < r) return 0;
ll den = (inv[r] * inv[n-r]) % mod;
return (fact[n] * den) % mod;
}
int main()
{
fact[0] = 1;
for1(i, sz-1) fact[i] = (fact[i-1] * i) % mod;
inv[sz-1] = fastPow(fact[sz-1], mod-2, mod);
rep0(i, sz-1) inv[i] = (inv[i+1] * (i+1)) % mod;
ll t;
cin >> t;
while(t--) {
ll n, k;
sl(n), sl(k);
ll ans = 0;
for1(p, n) {
ll posCell = n - (k-1)*(p-1);
if(posCell <= 0) break;
ll prob = (fact[p] * inv[n]) % mod;
prob = (prob * fact[n-p]) % mod;
ans += (ncr(posCell, p) * prob) % mod;
if(ans >= mod) ans -= mod;
}
pf("%lld\n", (ans+1)%mod);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
int in;
in = scanf("%lld %lld", &a, &b);
long long b1 = 0;
while (b) {
b1 = b1 * 10 + (b % 10);
b /= 10;
}
printf("%lld", a + b1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long r, g, b;
long long R[256], G[256], B[256];
long long PD[202][202][202];
bool cmp(int a, int b) { return a > b; }
long long calc(long long i, long long j, long long k) {
if (i == r and j == g and k == b) return 0;
if (PD[i][j][k] != -1) return PD[i][j][k];
long long opc1 = (i < r ? calc(i + 1, j, k) : 0);
long long opc2 = (j < g ? calc(i, j + 1, k) : 0);
long long opc3 = (k < b ? calc(i, j, k + 1) : 0);
long long opc4 = (i < r and j < g ? R[i] * G[j] + calc(i + 1, j + 1, k) : 0);
long long opc5 = (i < r and k < b ? R[i] * B[k] + calc(i + 1, j, k + 1) : 0);
long long opc6 = (j < g and k < b ? G[j] * B[k] + calc(i, j + 1, k + 1) : 0);
return PD[i][j][k] =
max(max(opc1, opc2), max(max(opc3, opc4), max(opc5, opc6)));
}
int main() {
scanf("%lld %lld %lld", &r, &g, &b);
for (int i = 0; i < r; i++) scanf("%lld", R + i);
for (int i = 0; i < g; i++) scanf("%lld", G + i);
for (int i = 0; i < b; i++) scanf("%lld", B + i);
sort(R, R + r, cmp);
sort(G, G + g, cmp);
sort(B, B + b, cmp);
memset(PD, 0xff, sizeof(PD));
printf("%lld\n", calc(0, 0, 0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
int cmp(const void *a, const void *b) { return (*(int *)a - *(int *)b); }
int main() {
int n, i, a[200000], c = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
qsort(a, n, sizeof(int), cmp);
for (i = 0; i < n; i++) {
if (a[i] > a[0] && a[i] < a[n - 1]) {
c++;
}
}
printf("%d\n", c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const double pi = acos(-1.0);
int main() {
std::ios_base::sync_with_stdio(false);
int n, m, h;
while (cin >> n >> m >> h) {
int s[m + 2], sum = 0, sum1 = 0;
for (int i = 0; i < m; i++) {
cin >> s[i + 1];
sum += s[i + 1];
}
sum1 = sum - s[h];
if (sum < n) {
cout << -1 << endl;
continue;
}
if (s[h] == 1) {
cout << fixed << setprecision(9) << 0.0 << endl;
continue;
}
double ans = 1.0;
n--;
sum--;
for (int i = 0; i < n; i++) {
ans *= 1.0 * sum1 / sum;
sum1--;
sum--;
}
ans = 1.0 - ans;
cout << fixed << setprecision(9) << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
const long long oo = 1e18;
char s[maxN];
long long cost[maxN][2];
int main() {
int test;
scanf("%d", &test);
while (test--) {
int n, a, b;
scanf("%d%d%d%*c", &n, &a, &b);
gets(s);
cost[0][0] = b;
cost[0][1] = oo;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
cost[i + 1][0] = min(cost[i][0] + a + b, cost[i][1] + a * 2 + b);
cost[i + 1][1] = min(cost[i][0] + 2 * (a + b), cost[i][1] + a + b * 2);
} else {
cost[i + 1][1] = cost[i][1] + a + b * 2;
cost[i + 1][0] = oo;
}
}
printf("%lld\n", cost[n][0]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long n, long long m) { return m == 0 ? n : gcd(m, n % m); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
struct node {
int x, y;
bool operator<(const node a) const {
if (a.x < x) {
return 0;
}
return a.y > y;
}
};
int run(int y) {
if (y % 400 == 0) {
return 1;
}
if (y % 100 != 0 && y % 4 == 0) {
return 1;
}
return 0;
}
long long q(long long x, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n & 1) {
ans = x * ans % mod;
}
n = n >> 1;
x = x * x % mod;
}
return ans % mod;
}
long long qcpow(long long a, long long b) {
long long ans = 0;
while (b) {
if (b & 1) {
ans = (a + ans);
}
b = b >> 1;
a = (a + a);
}
return ans;
}
long long qpow(long long x, long long n) {
long long ans = 1;
while (n) {
if (n & 1) {
ans = qcpow(x, ans);
}
n = n >> 1;
x = x * x;
}
return ans;
}
long long lj(long long n) {
long long sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return sum;
}
long long jc(long long n, long long cnt) {
long long sum = 1;
while (cnt--) {
sum *= n;
n -= 1;
}
if (sum == 1) {
return 0;
}
return sum;
}
int fa[1000 * 1100];
int find(int u) {
int tu = u;
while (fa[tu] != tu) {
tu = fa[tu];
}
return tu;
}
string s2S(int s) {
stringstream ss;
string str;
if (s < 10) {
ss << '0';
}
ss << s;
ss >> str;
return str;
}
void s2i(string &s, int &num) {
stringstream ss;
ss << s;
ss >> num;
}
void wys(int x) {
for (int i = 0; i < 32; i++) {
printf("%d", (x >> (31 - i)) & 1);
}
}
int combin(int x, int y) {
int tx = find(x);
int ty = find(y);
if (tx == ty) {
return 0;
} else {
fa[tx] = ty;
return 1;
}
}
int flag[100010];
int prime[100010];
int t;
void pri() {
flag[0] = 1;
flag[1] = 1;
for (int i = 2; i < 80000; i++) {
if (!flag[i]) {
prime[++t] = i;
}
for (int j = 1; j <= t && i * prime[j] <= 80000; j++) {
flag[i * prime[j]] = 1;
if (i % prime[j] == 0) {
break;
}
}
}
}
int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
int dp1() {
int n, k;
int d[100][100];
cin >> n >> k;
int v[n + 10], w[n + 10];
for (int i = 1; i <= n; i++) {
cin >> w[i];
cin >> v[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < n; j++) {
d[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (j < w[i]) {
d[i][j] = d[i - 1][j];
} else {
if (d[i - 1][j] > d[i - 1][j - w[i]] + v[i]) {
d[i][j] = d[i - 1][j];
} else {
d[i][j] = d[i - 1][j - w[i]] + v[i];
}
}
}
}
return d[n][k];
}
int day[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int solve(const string &str) {
if (str.rfind('A') - str.find('A') == 2 &&
str.rfind('2') - str.find('2') == 3 &&
str.rfind('3') - str.find('3') == 4 &&
str.rfind('4') - str.find('4') == 5) {
return 1;
}
return 0;
}
int prim[168] = {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181,
191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433,
439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521,
523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613,
617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887,
907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997};
struct M {
long long data[2][2];
M() { memset(data, 0, sizeof(data)); }
};
M mul(M a, M b) {
M ans;
ans.data[0][0] =
(a.data[0][0] * b.data[0][0] + a.data[0][1] * b.data[1][0]) % 1000000007;
ans.data[0][1] =
(a.data[0][0] * b.data[0][1] + a.data[0][1] * b.data[1][1]) % 1000000007;
ans.data[1][0] =
(a.data[1][0] * b.data[0][0] + a.data[1][1] * b.data[1][0]) % 1000000007;
ans.data[1][1] =
(a.data[1][0] * b.data[0][1] + a.data[1][1] * b.data[1][1]) % 1000000007;
return ans;
}
M qqpow(M m, long long n) {
M E;
E.data[0][0] = 1;
E.data[1][1] = 1;
while (n != 0) {
if (n & 1) {
E = mul(E, m);
}
m = mul(m, m);
n = n >> 1;
}
return E;
}
string rev(string s) {
string ans;
for (int i = s.size() - 1; i >= 0; i--) {
ans += s[i];
}
return ans;
}
int lca(string s1, string s2) {
int len = s1.size();
int dp[len + 5][len + 5];
for (int i = 0; i < len; i++) {
if (s1[0] == s2[i]) {
dp[0][i] = 1;
} else {
if (i == 0) {
dp[0][i] = 0;
} else {
dp[0][i] = dp[0][i - 1];
}
}
}
for (int i = 0; i < len; i++) {
if (s1[i] == s2[0]) {
dp[i][0] = 1;
} else {
if (i == 0) {
dp[i][0] = 0;
} else {
dp[i][0] = dp[i - 1][0];
}
}
}
for (int i = 1; i < len; i++) {
for (int j = 1; j < len; j++) {
if (s1[i] == s2[j]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
for (int i = 0; i < len; i++) {
for (int j = 0; j < len; j++) {
cout << dp[i][j] << " ";
}
cout << endl;
}
return dp[len - 1][len - 1];
}
int dist[10000];
int S[10000];
int path[10000];
int edge[1000][1000];
void dij(int u) {}
long long mapp[2000][2000];
long long dp[50][50][13][13];
int n, m, k;
int dfs_dp(int x, int y, int cnt, int maxn) {
if (dp[x][y][cnt][maxn + 1] != -1) {
return dp[x][y][cnt][maxn + 1];
}
if (x == n && y == m) {
if (cnt == k || (cnt == k - 1 && maxn < mapp[x][y])) {
dp[x][y][cnt][maxn + 1] = 1;
return dp[x][y][cnt][maxn + 1];
} else {
dp[x][y][cnt][maxn + 1] = 0;
return dp[x][y][cnt][maxn + 1];
}
}
long long ans = 0;
if (x + 1 <= n) {
if (maxn < mapp[x][y]) {
ans += dfs_dp(x + 1, y, cnt + 1, mapp[x][y]);
}
ans += dfs_dp(x + 1, y, cnt, maxn);
}
if (y + 1 <= m) {
if (maxn < mapp[x][y]) {
ans += dfs_dp(x, y + 1, cnt + 1, mapp[x][y]);
}
ans += dfs_dp(x, y + 1, cnt, maxn);
}
dp[x][y][cnt][maxn + 1] = ans % 1000000007;
return dp[x][y][cnt][maxn + 1];
}
const int mm = 1e5 + 10;
vector<long long> p[mm];
long long w[mm];
long long ww[mm];
long long ans = 0;
void dfs_s(int root, int cnt, int f) {
if (root == n - 1 && cnt == k) {
ans++;
cout << f << endl;
return;
}
if (cnt >= k) {
return;
}
for (int i = 0; i < p[root].size(); i++) {
int son = p[root][i];
dfs_s(son, cnt + 1, root);
}
}
int h[100000], W[100000];
int book[1000000];
int a[40][40];
int dpp[100005];
int solve(int mid) {}
int main(int argc, char **argv) {
long long n;
cin >> n;
if (n % 2 == 0) {
int m = n / 2;
if (m % 2 == 0) {
cout << 0 << endl;
} else {
cout << 1 << endl;
}
} else {
int nn = n - 1;
int m = n / 2;
if (m % 2 == 0) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
const double PI = 3.14159265358979323846;
const double eps = (1e-8);
int isGreater(long double x, long double y) {
if (abs(x - y) < eps) return 0;
if (x > y) return 1;
return -1;
}
int n;
const int MAX_N = 2e5 + 5;
vector<int> adj[MAX_N];
int a[MAX_N];
enum { ZO, OZ };
int cnt[2][MAX_N];
long long solve(int u, int p) {
int uZO = cnt[ZO][u], uOZ = cnt[OZ][u];
long long ret = 0;
for (int v : adj[u]) {
if (v == p) continue;
if (cnt[ZO][v] >= cnt[OZ][v]) {
int diff = cnt[ZO][v] - cnt[OZ][v];
cnt[ZO][v] -= diff;
ret += solve(v, u);
uOZ -= cnt[OZ][v];
uZO -= cnt[OZ][v];
} else {
int diff = cnt[OZ][v] - cnt[ZO][v];
cnt[OZ][v] -= diff;
ret += solve(v, u);
uZO -= cnt[ZO][v];
uOZ -= cnt[ZO][v];
}
}
if (uZO != uOZ) return LLONG_MAX / 2;
return ret + 1LL * (uZO + uOZ) * a[u];
}
void dfs(int u, int p) {
for (int v : adj[u]) {
if (v != p) {
a[v] = min(a[v], a[u]);
dfs(v, u);
for (int j = 0; j < 2; ++j) cnt[j][u] += cnt[j][v];
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
int x, y;
cin >> x >> y;
if (!x && y)
cnt[ZO][i]++;
else if (x && !y)
cnt[OZ][i]++;
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, n);
long long ans = solve(0, n);
if (ans >= LLONG_MAX / 2) ans = -1;
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T &aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
static char stdinBuffer[1024];
static char *stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char *stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int readInt() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char readCh() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
inline int rri() {
char c;
while (c = getchar(), c <= ' ')
;
bool sign = c == '-';
if (sign) {
c = getchar();
}
int res = c - '0';
while (c = getchar(), c >= '0' && c <= '9') {
res = res * 10 + (c - '0');
}
return sign ? -res : res;
}
inline long long rrl() {
char c;
while (c = getchar(), c <= ' ')
;
bool sign = c == '-';
if (sign) {
c = getchar();
}
long long res = c - '0';
while (c = getchar(), c >= '0' && c <= '9') {
res = res * 10 + (c - '0');
}
return sign ? -res : res;
}
inline char rrc() {
char c;
while (c = getchar(), c <= ' ')
;
return c;
}
inline int rrs(char *target) {
char c;
while (c = getchar(), c <= ' ')
;
int idx = -1;
target[++idx] = c;
while (1) {
c = getchar();
if (c <= ' ') {
target[++idx] = '\0';
return idx;
}
target[++idx] = c;
}
}
vector<vector<int> > matrixUnit(long long n) {
vector<vector<int> > res(n, vector<int>(n));
for (long long i = 0; i < n; i++) res[i][i] = 1;
return res;
}
vector<vector<int> > matrixMul(const vector<vector<int> > &a,
const vector<vector<int> > &b) {
long long n = a.size();
long long m = a[0].size();
long long k = b[0].size();
vector<vector<int> > res(n, vector<int>(k));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < k; j++)
for (long long p = 0; p < m; p++)
res[i][j] = (res[i][j] + (long long)a[i][p] * b[p][j]) % 1000000007LL;
return res;
}
void matrixMult(vector<vector<int> > &res, const vector<vector<int> > &a,
const vector<vector<int> > &b) {
long long n = a.size();
long long m = a[0].size();
long long k = b[0].size();
for (long long i = 0; i < n; i++)
for (long long j = 0; j < k; j++) {
long long ans = 0;
for (long long p = 0; p < m; p++)
ans = (ans + (long long)a[i][p] * b[p][j]) % 1000000007LL;
res[i][j] = ans;
}
}
const int mn = 2004;
bitset<mn> g[mn];
bool bf(int n) {
vector<vector<int> > inp;
inp.resize(n);
for (int x = 0; x < n; x++) {
inp[x].resize(n);
for (int y = 0; y < n; y++) inp[x][y] = g[x][y];
}
vector<vector<int> > a = inp;
for (int k = 0; k < 500; k++) {
bool ok = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (a[i][j] == 0) {
ok = 0;
break;
}
}
if (ok) return 1;
a = matrixMul(a, inp);
}
return 0;
}
bitset<mn> h[mn];
bitset<mn> seen;
bool solve2(int n) {
queue<int> q;
for (int x = 0; x < n; x++) {
if (h[0][x]) q.push(x);
}
seen = h[0];
while (!q.empty()) {
int x = q.front();
q.pop();
for (int y = 0; y < n; y++) {
if ((!seen[y]) && h[x][y]) {
q.push(y);
seen[y] = true;
}
}
}
assert(seen.count() <= n);
return (int)seen.count() == n;
}
bool solve(int n) {
int spec = -1;
for (int k = 0; k < n; k++)
if (g[k][k]) spec = k;
assert(spec != -1);
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++) {
int sx = (x == spec || x == 0) ? x ^ spec : x;
int sy = (y == spec || y == 0) ? y ^ spec : y;
h[sx][sy] = g[x][y];
}
assert(h[0][0]);
if (!solve2(n)) return 0;
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++) {
g[x][y] = h[y][x];
}
for (int x = 0; x < n; x++) h[x] = g[x];
if (!solve2(n)) return 0;
return 1;
}
void test() {
srand(time(0) + clock() + rand());
for (int j = 0; j < 1000; j++) {
int n = (rand() % 6) + 1;
for (int x = 0; x < n; x++) {
h[x].reset();
g[x].reset();
for (int y = 0; y < n; y++) g[x][y] = rand() & 1;
}
int k = rand() % n;
g[k][k] = 1;
bool b = bf(n);
bool s = solve(n);
if (b != s) {
for (int x = 0; x < n; x++) {
for (int y = 0; y < n; y++) printf("%d", (int)g[x][y]);
printf("\n");
}
printf("b:%d s:%d\n", b, s);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n = readInt();
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++) {
int t = readInt();
t = (t > 0) ? 1 : 0;
g[x][y] = t;
}
bool final = solve(n);
if (final)
printf("YES\n");
else
printf("NO\n");
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
inline double sqr(double x) { return x * x; }
int cmp(double x) {
if (fabs(x) < eps) return 0;
if (x > 0) return 1;
return -1;
}
int n;
struct point {
double x, y;
point() {}
point(double a, double b) : x(a), y(b) {}
void input() { scanf("%lf%lf", &x, &y); }
friend point operator+(const point &a, const point &b) {
return point(a.x + b.x, a.y + b.y);
}
friend point operator-(const point &a, const point &b) {
return point(a.x - b.x, a.y - b.y);
}
friend bool operator==(const point &a, const point &b) {
return cmp(a.x - b.x) == 0 && cmp(a.y - b.y) == 0;
}
friend point operator*(const point &a, const double &b) {
return point(a.x * b, a.y * b);
}
friend point operator*(const double &a, const point &b) {
return point(a * b.x, a * b.y);
}
friend point operator/(const point &a, const double &b) {
return point(a.x / b, a.y / b);
}
double norm() { return sqrt(sqr(x) + sqr(y)); }
double norm1() { return sqr(x) + sqr(y); }
} P[200];
double det(const point &a, const point &b) { return a.x * b.y - a.y * b.x; }
point Cir(point a, point b, point c) {
point cp;
double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1 * a1 + b1 * b1) / 2;
double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2 * a2 + b2 * b2) / 2;
double d = a1 * b2 - a2 * b1;
cp.x = a.x + (c1 * b2 - c2 * b1) / d;
cp.y = a.y + (a1 * c2 - a2 * c1) / d;
return cp;
}
double dot(const point &a, const point &b) { return a.x * b.y + a.y * b.x; }
double dist(const point &a, const point &b) { return (a - b).norm(); }
double dist2(const point &a, const point &b) { return (a - b).norm1(); }
bool JudgeRet(int a, int b, int c) {
double dis1 = dist2(P[a], P[b]);
double dis2 = dist2(P[a], P[c]);
double dis3 = dist2(P[b], P[c]);
if ((cmp(dis1 + dis2 - dis3) == 1) && (cmp(dis2 + dis3 - dis1) == 1) &&
(cmp(dis1 + dis3 - dis2) == 1))
return true;
else if (cmp(dis1 + dis2 - dis3) == 0 || cmp(dis1 + dis3 - dis2) == 0 ||
cmp(dis2 + dis3 - dis1) == 0) {
if (cmp(dis1 + dis2 - dis3) == 0) {
for (int i = 1; i <= n; i++) {
if (cmp(P[i].x - (P[b].x + P[c].x - P[a].x)) == 0 &&
cmp(P[i].y - (P[b].y + P[c].y - P[a].y)) == 0) {
return true;
}
}
} else if (cmp(dis1 + dis3 - dis2) == 0) {
for (int i = 1; i <= n; i++) {
if (cmp(P[i].x - (P[a].x + P[c].x - P[b].x)) == 0 &&
cmp(P[i].y - (P[a].y + P[c].y - P[b].y)) == 0) {
return true;
}
}
} else {
for (int i = 1; i <= n; i++) {
if (cmp(P[i].x - (P[a].x + P[b].x - P[c].x)) == 0 &&
cmp(P[i].y - (P[a].y + P[b].y - P[c].y)) == 0) {
return true;
}
}
}
return false;
} else
return false;
}
void Compute() {
double Max = -1;
JudgeRet(2, 3, 5);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
for (int k = j + 1; k <= n; k++) {
if (JudgeRet(i, j, k)) {
point center = Cir(P[i], P[j], P[k]);
double r = dist(center, P[i]);
bool ret = true;
for (int i = 1; i <= n; i++) {
if (cmp(dist(center, P[i]) - r) == -1) {
ret = false;
break;
}
}
if (ret) Max = max(Max, r);
}
}
}
}
if (Max == -1)
printf("-1\n");
else
printf("%.6f\n", Max);
}
int main() {
double x, y;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
scanf("%lf%lf", &x, &y);
P[i] = point(x, y);
}
Compute();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k == 1) {
if (n == 1)
cout << 'a';
else
cout << -1;
return 0;
}
if (k > n) {
cout << -1;
return 0;
}
string s = "s";
for (int i = 1; i <= n; i += 2) {
s += "ab";
}
for (int i = 3; i <= k; i++) {
s[n - k + i] = 'a' - 1 + i;
}
for (int i = 1; i <= n; i++) {
cout << s[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int l;
cin >> l;
string s;
cin >> s;
long int a[27];
for (int i = 0; i < 27; i++) a[i] = 0;
for (int i = 0; i < s.size(); i++) a[s[i] - 'a']++;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < a[i]; j++) std::cout << char('a' + i);
}
std::cout << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int N = 100005;
const int mod = 1000000007;
const int orz = 2147483647;
int h, n, m;
struct ex {
int u, l, r, s;
inline void init() { u = read(), l = read(), r = read(), s = read(); }
} za[N];
inline bool operator<(const ex &a, const ex &b) { return a.u > b.u; }
vector<pair<int, int> > t[N];
int mn[N * 4];
vector<pair<int, int> >::iterator it, ed;
inline void build(int p, int l, int r) {
mn[p] = h + 1;
if (l == r) {
t[l].push_back(make_pair(orz, 1));
t[l].push_back(make_pair(h + 1, 1));
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
int U, lx, rx, S, inc;
inline void INIT(const ex &x) {
U = x.u;
lx = x.l;
rx = x.r;
S = x.s;
}
inline void up(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline void ASK(int p, int l, int r) {
if (l == r) {
pair<int, int> X;
while ((X = t[l].back()).first - U <= S) up(inc, X.second), t[l].pop_back();
mn[p] = t[l].back().first;
return;
}
if (mn[p] - U > S) return;
int mid = (l + r) >> 1;
ASK(p << 1, l, mid);
ASK(p << 1 | 1, mid + 1, r);
mn[p] = min(mn[p << 1], mn[p << 1 | 1]);
}
inline void ask(int p, int l, int r, int L, int R) {
if (mn[p] - U > S) return;
if (l == L && r == R) {
ASK(p, l, r);
return;
}
int mid = (l + r) >> 1;
if (R <= mid)
ask(p << 1, l, mid, L, R);
else if (L > mid)
ask(p << 1 | 1, mid + 1, r, L, R);
else
ask(p << 1, l, mid, L, mid), ask(p << 1 | 1, mid + 1, r, mid + 1, R);
mn[p] = min(mn[p << 1], mn[p << 1 | 1]);
}
inline void add(int p, int l, int r) {
if (l == r) {
t[l].push_back(make_pair(U, inc));
mn[p] = U;
return;
}
int mid = (l + r) >> 1;
if (S <= mid)
add(p << 1, l, mid);
else
add(p << 1 | 1, mid + 1, r);
mn[p] = min(mn[p << 1], mn[p << 1 | 1]);
}
int main() {
int i, j;
h = read();
n = read();
m = read();
for (i = 1; i <= m; i++) za[i].init();
sort(za + 1, za + m + 1);
build(1, 1, n);
for (i = 1; i <= m; i++) {
INIT(za[i]);
inc = 0;
ask(1, 1, n, lx, rx);
if (lx == 1)
S = rx + 1, (inc <<= 1) %= mod, add(1, 1, n);
else if (rx == n)
S = lx - 1, (inc <<= 1) %= mod, add(1, 1, n);
else
S = lx - 1, add(1, 1, n), S = rx + 1, add(1, 1, n);
}
int ans = 0;
for (i = 1; i <= n; i++)
for (it = t[i].begin(), ed = t[i].end(); it != ed; it++)
up(ans, (*it).second);
printf("%d", (ans - n + mod) % mod);
return 0;
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
const int N=1005;
int n;
vector<int>a;
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n,x;
scanf("%d",&n);
a.clear();
for(int i=1;i<=n;i++)
{
scanf("%d",&x);
if(x==1)
a.push_back(1);
else
{
while(a.size()&&a.back()+1!=x)
a.pop_back();
if(a.size())
a.back()++;
else
a.push_back(1);
}
printf("%d",a[0]);
for(int i=1;i<a.size();i++)
printf(".%d",a[i]);
puts("");
}
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long _, n;
int main() {
cin >> _;
while (_--) {
cin >> n;
if (n == 1) {
puts("-1");
continue;
} else
printf("2");
for (long long i = 2; i <= n; i++) printf("3");
puts("");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fileio() {}
vector<vector<long long int>> g;
long long int n;
vector<long long int> a, dp;
long long int dfs1(long long int u, long long int p) {
dp[u] = 1;
if (!a[u]) dp[u] = -1;
for (auto child : g[u]) {
if (child == p) continue;
dp[u] += max(dfs1(child, u), 0ll);
}
return dp[u];
}
void dfs2(long long int u, long long int p, long long int val) {
dp[u] += val;
for (auto child : g[u]) {
if (child == p) continue;
dfs2(child, u, max(0ll, dp[u] - max(dp[child], 0ll)));
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fileio();
cin >> n;
dp = vector<long long int>(n, 0);
a = vector<long long int>(n, 0);
for (long long int i = 0; i < n; i++) cin >> a[i];
g = vector<vector<long long int>>(n, vector<long long int>(0));
for (long long int i = 0; i < n - 1; i++) {
long long int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(0, 0);
dfs2(0, 0, 0);
for (auto it : dp) cout << it << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
inline int read() {
int s = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s;
}
int n, m;
int a[N], b[N];
vector<int> G[N];
inline int dis(int i, int j) { return i > j ? (n - i + j) : (j - i); }
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
a[i] = read(), b[i] = read();
G[a[i]].push_back(dis(a[i], b[i]));
}
int mx = 0;
for (int i = 1; i <= n; i++) {
mx = max(mx, (int)G[i].size());
sort(G[i].begin(), G[i].end());
}
int ans = (mx - 1) * n;
for (int i = 1; i <= n; i++) {
int t = 0;
for (int j = i; j <= n; j++) {
if (!G[j].size()) continue;
if (G[j].size() == mx)
t = max(t, j + G[j][0] - i);
else if (G[j].size() == mx - 1) {
int tmp = j + G[j][0];
if (tmp > n) tmp -= n;
if (tmp > j) continue;
t = max(t, tmp - i);
}
}
for (int j = 1; j < i; j++) {
if (!G[j].size()) continue;
if (G[j].size() == mx)
t = max(t, j + G[j][0] + n - i);
else if (G[j].size() == mx - 1) {
int tmp = j + G[j][0];
t = max(t, tmp - i);
};
}
printf("%d ", ans + t);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 1010, M = 2010;
int las[M], nxt[M], to[M], cnt;
int l[M], r[M], siz[M], mx[N][N], f[N];
inline void add(int u, int v) {
cnt++;
to[cnt] = v;
nxt[cnt] = las[u];
las[u] = cnt;
}
int n, m;
inline void fmin(int &a, int b) {
if (a > b) a = b;
}
inline void fmax(int &a, int b) {
if (a < b) a = b;
}
void dfs(int now) {
int i;
siz[now] = now != 1;
if (las[now]) l[now] = n, r[now] = 0;
for (i = las[now]; i; i = nxt[i])
dfs(to[i]), siz[now] += siz[to[i]], fmin(l[now], l[to[i]]),
fmax(r[now], r[to[i]]);
fmax(mx[l[now]][r[now]], siz[now]);
}
int main() {
int i, j, x;
scanf("%d", &n);
scanf("%d", &m);
for (i = 2; i <= m; i++) scanf("%d", &x), add(x, i);
for (i = 1; i <= n; i++) scanf("%d", &x), l[x] = r[x] = i;
dfs(1);
cnt = 0;
memset(las, 0, sizeof las);
scanf("%d", &m);
for (i = 2; i <= m; i++) scanf("%d", &x), add(x, i);
for (i = 1; i <= n; i++) scanf("%d", &x), l[x] = r[x] = i;
dfs(1);
for (i = 1; i <= n; i++)
for (j = 1; j <= i; j++)
if (mx[j][i]) fmax(f[i], f[j - 1] + mx[j][i]);
printf("%d\n", f[n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int id, v;
};
struct st1 {
int id, v, m;
};
st s1[100010], s2[100010];
vector<st1> w1;
string a1, a2;
bool cmp(st1 a, st1 b) { return a.v < b.v; }
int main() {
int n;
while (cin >> n) {
a1 = "", a2 = "";
int x, y;
for (int i = 0; i < n; ++i) {
a1 += '0';
a2 += '0';
scanf("%d %d", &x, &y);
st1 val;
val.v = x;
val.id = i;
val.m = 0;
w1.push_back(val);
val.v = y;
val.id = i;
val.m = 1;
w1.push_back(val);
}
sort((w1).begin(), (w1).end(), cmp);
for (int i = 0; i < n / 2; ++i) a1[i] = a2[i] = '1';
for (int i = 0; i < n; ++i)
if (!w1[i].m)
a1[w1[i].id] = '1';
else
a2[w1[i].id] = '1';
for (int i = n; i < 2 * n; i++) {
if (w1[i].v == w1[n - 1].v) {
if (!w1[i].m)
a1[w1[i].id] = '1';
else
a2[w1[i].id] = '1';
} else
break;
}
w1.clear();
cout << a1 << endl << a2 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int testCases;
scanf("%d", &testCases);
while (testCases--) {
int N, ans;
string s;
scanf("%d", &N);
cin >> s;
ans = N;
for (int i = 0; i < N; i++) {
if (s[i] == '1') {
ans = max(ans, 2 * max(i + 1, N - i));
}
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
list<int> l1[800010];
list<int> l2[800010];
char a[800010], b[800010];
int w, s, sw, lev[800010], n, num[800010], t, par[800010], tree[800010][27],
len, cnt, red[800010], blue[800010];
long long dap;
struct data {
int x, y;
} ans[100010];
void trie(int x, int p) {
lev[x] = p - 1;
if (p == len + 1) {
num[t] = x;
if (sw == 1) {
red[x]++;
l1[x].push_back(t);
} else {
blue[x]++;
l2[x].push_back(t);
}
return;
}
if (tree[x][a[p] - 96])
trie(tree[x][a[p] - 96], p + 1);
else {
tree[x][a[p] - 96] = ++cnt;
par[cnt] = x;
trie(tree[x][a[p] - 96], p + 1);
}
}
void dfs(int x) {
int i;
for (i = 1; i <= 26; i++) {
if (tree[x][i]) dfs(tree[x][i]);
if (tree[x][i] == 0) continue;
red[x] += red[tree[x][i]];
blue[x] += blue[tree[x][i]];
l1[x].splice(l1[x].begin(), l1[tree[x][i]]);
l2[x].splice(l2[x].begin(), l2[tree[x][i]]);
}
s = min(red[x], blue[x]);
dap += (long long)lev[x] * (long long)s;
for (i = 1; i <= s; i++) {
w++;
ans[w].x = l1[x].back();
ans[w].y = l2[x].back();
l1[x].pop_back();
l2[x].pop_back();
}
red[x] -= s;
blue[x] -= s;
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%s", a + 1);
len = strlen(a + 1);
sw = 1;
t = i;
trie(0, 1);
}
for (i = 1; i <= n; i++) {
scanf("%s", a + 1);
len = strlen(a + 1);
sw = 2;
t = i;
trie(0, 1);
}
dfs(0);
printf("%lld\n", dap);
for (i = 1; i <= n; i++) printf("%d %d\n", ans[i].x, ans[i].y);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
vector<int> mran(3), tran(3), pos(3), hold(3), s(3);
set<long long> S;
void solve() {
long long cur = 1;
for (int i = 0; i < 3; i++) cur = (cur << 7) + pos[i];
for (int i = 0; i < 3; i++) cur = (cur << 7) + (hold[i] == -1 ? 3 : hold[i]);
for (int i = 0; i < 3; i++) cur = (cur << 7) + s[i];
if (S.find(cur) != S.end()) return;
S.insert(cur);
{
for (int i = 0; i < 3; i++) {
ans = max(ans, pos[i]);
}
}
for (int i = 0; i < 3; i++)
if (pos[i] != -1) {
if (hold[i] == -1 && (s[i] & 1)) {
for (int d = -mran[i]; d <= mran[i]; d++)
if (pos[i] + d >= 1) {
bool unoccupied = true;
for (int j = 0; j < 3; j++)
if (pos[j] != -1 && i != j && pos[j] == pos[i] + d)
unoccupied = false;
if (!unoccupied) continue;
pos[i] += d;
s[i] ^= 1;
solve();
s[i] ^= 1;
pos[i] -= d;
}
}
if (hold[i] == -1 && (s[i] & 2)) {
for (int j = 0; j < 3; j++)
if (pos[j] != -1 && abs(pos[i] - pos[j]) == 1) {
int prepos = pos[j];
pos[j] = -1;
hold[i] = j;
s[i] ^= 2;
solve();
pos[j] = prepos;
hold[i] = -1;
s[i] ^= 2;
}
}
if (hold[i] != -1 && (s[i] & 4)) {
int j = hold[i];
assert(pos[j] == -1);
for (int d = -tran[i]; d <= tran[i]; d++)
if (pos[i] + d >= 1) {
bool unoccupied = true;
for (int k = 0; k < 3; k++)
if (pos[k] != -1 && pos[k] == pos[i] + d) unoccupied = false;
if (!unoccupied) continue;
pos[j] = pos[i] + d;
hold[i] = -1;
s[i] ^= 4;
solve();
pos[j] = -1;
hold[i] = j;
s[i] ^= 4;
}
}
}
}
int main() {
for (int i = 0; i < 3; i++) {
scanf("%d%d%d", &pos[i], &mran[i], &tran[i]);
hold[i] = -1;
s[i] = 7;
}
solve();
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x, a, b;
cin >> t;
while (t--) {
cin >> n >> x >> a >> b;
int l = min(a, b);
int r = max(a, b);
int temp = r;
r = min(n, r + x);
x -= abs(r - temp);
l = max(1, l - x);
cout << abs(r - l) << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, k, c, c1, min = 0, max = 0;
vector<int> v(5000, 0);
int temp;
cin >> x >> k;
for (int i = 1; i <= k; i++) {
cin >> temp;
if (temp == 2) {
cin >> c;
v[c] = 1;
} else {
cin >> c;
cin >> c1;
v[c] = 1;
v[c1] = 1;
}
}
v[x] = 1;
for (int i = 1; i <= x - 1; i++) {
if ((v[i] == 0) && (v[i + 1] == 0)) {
min++;
max += 2;
v[i] = 1;
v[i + 1] = 1;
} else {
if (v[i] == 0) {
max++;
min++;
v[i] = 1;
}
}
}
cout << min << ' ' << max;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int n, m;
bitset<140> l1[4000], xr, zero;
int ya[N], yb[N];
struct center {
int cy, i, j;
};
vector<center> d;
bool cmp(const center &a, const center &b) { return a.cy < b.cy; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> ya[i];
for (int i = 1; i <= m; i++) cin >> yb[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int cy = 2 * ya[i] + (yb[j] - ya[i]);
d.push_back((center){cy, i, j});
}
int mx = 0;
sort(d.begin(), d.end(), cmp);
int py = -1000000;
int cnt = 0;
for (int i = 0; i < d.size(); i++) {
if (py != d[i].cy) {
cnt++;
py = d[i].cy;
}
l1[cnt][d[i].i] = 1;
l1[cnt][d[i].j + n] = 1;
}
for (int i = 1; i <= cnt; i++)
for (int j = i; j <= cnt; j++) {
xr = (l1[i] | l1[j]);
if (xr.count() > mx) mx = xr.count();
}
cout << mx << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, dim[2];
std::cin >> n >> dim[0] >> dim[1];
int fin[n][2];
std::vector<std::pair<int, std::pair<int, int> > > cat[300000];
std::vector<std::vector<int> > len(300000, std::vector<int>(2, 0));
for (int i = 0; i < n; i++) {
int g, p, t;
std::cin >> g >> p >> t;
g = 2 - g;
cat[p - t + 100000].push_back({g, {(2 * g - 1) * p, i}});
len[p - t + 100000][g]++;
fin[i][g] = dim[g];
fin[i][1 - g] = p;
}
for (int i = 0; i < 300000; i++) std::sort(cat[i].begin(), cat[i].end());
int ans[n];
for (int i = 0; i < 300000; i++) {
for (int j = 0; j < cat[i].size(); j++) {
ans[cat[i][j].second.second] =
cat[i][(j +
(2 * (len[i][0] < len[i][1]) - 1) *
std::min(len[i][0], len[i][1]) +
cat[i].size()) %
cat[i].size()]
.second.second;
}
}
for (int i = 0; i < n; i++) {
std::cout << fin[ans[i]][0] << " " << fin[ans[i]][1] << std::endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool ok = false;
int r1, r2, c1, c2, d1, d2;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
do {
if (a[0] + a[1] == r1 && a[2] + a[3] == r2 && a[0] + a[2] == c1 &&
a[1] + a[3] == c2 && a[0] + a[3] == d1 && a[1] + a[2] == d2) {
ok = true;
break;
}
} while (next_permutation(a, a + 9));
if (ok)
cout << a[0] << ' ' << a[1] << endl << a[2] << ' ' << a[3] << endl;
else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, c;
while (!isdigit(c = getchar()))
;
while (x = x * 10 + c - '0', isdigit(c = getchar()))
;
return x;
}
long long n, k, f[105][105][2], c[105][105];
inline void init() {
c[0][0] = 1;
for (long long i = 1; i < 105; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
}
inline void add(long long &x, long long y) {
x += y;
x -= x >= 1000000007 ? 1000000007 : 0;
}
int main() {
n = read();
k = read();
init();
f[0][0][1] = 1;
f[1][0][0] = 1;
for (long long i = 2; i <= n; i++)
for (long long j = 1; j <= i / 2; j++)
for (long long k1 = 0, k2 = i - 1; k1 <= k2; k1++, k2--)
for (long long p = 0; p <= j; p++) {
long long tmp;
if (k1 == k2)
tmp = c[i - 2][k1 - 1];
else
tmp = c[i - 1][k1];
if (k1)
tmp = 1ll * tmp * k1 % 1000000007 * k2 % 1000000007;
else
tmp = 1ll * tmp * k2 % 1000000007;
add(f[i][j][0], 1ll * f[k1][p][1] * f[k2][j - p][1] % 1000000007 *
tmp % 1000000007);
add(f[i][j][1], 1ll * f[k1][p][1] * f[k2][j - p - 1][0] % 1000000007 *
tmp % 1000000007);
add(f[i][j][1], 1ll * f[k1][p][0] * f[k2][j - p - 1][1] % 1000000007 *
tmp % 1000000007);
add(f[i][j][1], 1ll * f[k1][p][0] * f[k2][j - p - 1][0] % 1000000007 *
tmp % 1000000007);
}
printf("%lld\n", (f[n][k][0] + f[n][k][1]) % 1000000007);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, num;
} a[100005];
int n, t, m, k, i, j, s[100005], b[450], h[100005][450];
map<int, int> mymap;
int main() {
while (~scanf("%d%d", &n, &t)) {
mymap.clear();
m = 0;
for (i = 1; i <= n; i++) scanf("%d", &s[i]);
for (i = 1; i <= n; i++) {
if (mymap.find(s[i]) == mymap.end()) {
mymap[s[i]] = ++m;
a[m].x = s[i];
a[m].num = 0;
}
a[mymap[s[i]]].num++;
}
k = 0;
for (i = 1; i <= m; i++)
if (a[i].x <= a[i].num) b[++k] = a[i].x;
for (i = 1; i <= k; i++) {
h[0][i] = 0;
for (j = 1; j <= n; j++)
if (s[j] == b[i])
h[j][i] = h[j - 1][i] + 1;
else
h[j][i] = h[j - 1][i];
}
int l, r, ans;
while (t--) {
ans = 0;
scanf("%d%d", &l, &r);
for (i = 1; i <= k; i++)
if (h[r][i] - h[l - 1][i] == b[i]) ans++;
printf("%d\n", ans);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
void Fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fact(long long n) {
long long f = 1;
for (int i = 2; i <= n; i++) {
f *= i;
}
return f;
}
long long ncr(long long n, long long r) {
return fact(n) / (fact(r) * fact(n - r));
}
long long npr(long long n, long long r) { return fact(n) / fact(n - r); }
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
break;
}
}
return 1;
}
char arr[55][55];
void solve() {
int n, m;
cin >> n >> m;
int r1 = INT_MIN, r2 = INT_MAX, c1 = INT_MIN, c2 = INT_MAX;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
if (arr[i][j] == '*') {
r1 = max(r1, i);
r2 = min(r2, i);
c1 = max(c1, j);
c2 = min(c2, j);
}
}
}
for (int i = r2; i <= r1; i++) {
for (int j = c2; j <= c1; j++) {
cout << arr[i][j];
}
cout << "\n";
}
}
int main() {
Fast();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, sx, sy;
int a[510][510];
int can[510][510][4];
int vis[510][510];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dc[4] = {'D', 'R', 'U', 'L'};
void predo() {
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < n; j++) {
can[i][j][3] = x > 0;
x += a[i][j];
}
x = 0;
for (int j = n - 1; j >= 0; j--) {
can[i][j][1] = x > 0;
x += a[i][j];
}
}
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < n; j++) {
can[j][i][2] = x > 0;
x += a[j][i];
}
x = 0;
for (int j = n - 1; j >= 0; j--) {
can[j][i][0] = x > 0;
x += a[j][i];
}
}
}
bool out(int x, int y) { return x < 0 || x >= n || y < 0 || y >= n; }
void dfs(int x, int y, int tag) {
vis[x][y] = tag;
if (tag == 2 && a[x][y] == 0) {
a[x][y] = 1;
printf("1");
}
for (int i = 0; i < (4); i++) {
int nx = x + dx[i], ny = y + dy[i];
if (out(nx, ny) || can[x][y][i] == 0 || vis[nx][ny] == tag) continue;
if (tag >= 2) printf("%c", dc[i]);
dfs(nx, ny, tag);
if (tag >= 2) printf("%c", dc[i ^ 2]);
}
if (tag == 3 && a[x][y] == 1) {
a[x][y] = 0;
printf("2");
}
}
int main() {
scanf("%d", &(n));
scanf("%d%d", &(sx), &(sy));
sx--, sy--;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) scanf("%d", &(a[i][j]));
predo();
dfs(sx, sy, 1);
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
if (a[i][j] == 1 && vis[i][j] == 0) {
puts("NO");
return 0;
}
}
puts("YES");
dfs(sx, sy, 2);
dfs(sx, sy, 3);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optmize(2)
using namespace std;
constexpr int maxn = 1e5 + 100, inf = 0x7fffffff;
struct IO {
private:
static constexpr int ibufsiz = 1 << 20;
char ibuf[ibufsiz + 1], *inow = ibuf, *ied = ibuf;
static constexpr int obufsiz = 1 << 20;
char obuf[obufsiz + 1], *onow = obuf;
const char *oed = obuf + obufsiz;
public:
inline char getchar() {
if (inow == ied) {
ied = ibuf + sizeof(char) * fread(ibuf, sizeof(char), ibufsiz, stdin);
*ied = '\0';
inow = ibuf;
}
return *inow++;
}
template <typename T>
inline void read(T &x) {
static bool flg;
flg = 0;
x = 0;
char c = getchar();
while (!isdigit(c)) flg = c == '-' ? 1 : flg, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (flg) x = -x;
}
template <typename T, typename... Y>
inline void read(T &x, Y &...X) {
read(x);
read(X...);
}
inline int readi() {
static int res;
read(res);
return res;
}
inline long long readll() {
static long long res;
read(res);
return res;
}
inline void flush() {
fwrite(obuf, sizeof(char), onow - obuf, stdout);
fflush(stdout);
onow = obuf;
}
inline void putchar(char c) {
*onow++ = c;
if (onow == oed) {
fwrite(obuf, sizeof(char), obufsiz, stdout);
onow = obuf;
}
}
template <typename T>
inline void write(T x, char split = '\0') {
static unsigned char buf[64];
if (x < 0) putchar('-'), x = -x;
int p = 0;
do {
buf[++p] = x % 10;
x /= 10;
} while (x);
for (int i = p; i >= 1; i--) putchar(buf[i] + '0');
if (split != '\0') putchar(split);
}
inline void lf() { putchar('\n'); }
~IO() { fwrite(obuf, sizeof(char), onow - obuf, stdout); }
} io;
template <typename A, typename B>
inline void chkmin(A &x, const B &y) {
if (y < x) x = y;
}
template <typename A, typename B>
inline void chkmax(A &x, const B &y) {
if (y > x) x = y;
}
int mod, n, m;
namespace mset {
int f[maxn], d[maxn], siz;
inline void init() {
for (int i = 1; i <= n; i++) f[i] = i, d[i] = 1;
siz = n;
}
inline int find(const int x) { return x == f[x] ? x : f[x] = find(f[x]); }
inline void merge(const int a, const int b) {
const int x = find(a), y = find(b);
if (x != y) {
f[x] = y;
d[y] += d[x];
siz--;
}
}
} // namespace mset
inline int qpow(int base, int b) {
int res = 1;
while (b) {
if (b & 1) res = (1ll * res * base) % mod;
base = (1ll * base * base) % mod;
b >>= 1;
}
return res;
}
int main() {
io.read(n, m, mod);
mset::init();
for (int i = 1; i <= m; i++) mset::merge(io.readi(), io.readi());
if (mset::siz == 1) return printf("%d\n", 1 % mod), 0;
int ans = qpow(n, mset::siz - 2);
for (int i = 1; i <= n; i++)
if (mset::f[i] == i) ans = (1ll * ans * mset::d[i]) % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 311;
const long long oo = 1e17;
long long cnt[MAXN], pre[MAXN], t, ret = oo, flag, m, n, g[MAXN][MAXN],
ed[MAXN][MAXN];
void floyd() {
for (long long k = 1; k <= m; k++) {
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= m; j++) {
if (i == j) continue;
ret = min(ret, g[i][j] + ed[i][k] + ed[k][j]);
}
for (long long i = 1; i <= m; i++)
for (long long j = 1; j <= m; j++) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= 201; i++)
for (long long j = 1; j <= 201; j++) g[i][j] = ed[i][j] = oo;
for (long long i = 1; i <= n; i++) {
cin >> t;
bitset<63> bs(t);
long long new_vertex = -1, flag = -1;
for (long long j = 0; j <= 63; j++) {
if (bs[j]) {
cnt[j] = cnt[j] + 1;
if (cnt[j] == 3) {
cout << 3;
return 0;
}
flag = 1;
}
}
if (flag == -1) continue;
new_vertex = ++m;
for (long long j = 0; j <= 63; j++) {
if (bs[j]) {
if (cnt[j] == 1) pre[j] = new_vertex;
if (cnt[j] == 2) {
int u = new_vertex;
int v = pre[j];
g[u][v] = g[v][u] = ed[u][v] = ed[v][u] = 1;
}
}
}
}
floyd();
if (ret == oo) {
cout << -1;
return 0;
}
cout << ret;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> freq;
int f = -1, s = -1;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, m;
cin >> n >> k;
for (int i = 1; i <= k + 1; i++) {
cout << "?";
for (int j = 1; j <= k + 1; j++) {
if (i == j) continue;
cout << " " << j;
}
cout << "\n";
cout.flush();
int a, b;
cin >> a;
if (a == -1) {
return 0;
} else
cin >> b;
if (b == -1) return 0;
freq[b]++;
if (f == -1)
f = b;
else if (b != f)
s = b;
}
cout << "! ";
if (f > s)
cout << freq[f] << "\n";
else
cout << freq[s] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod(int a) { return a > 0 ? a : -a; }
int a[5000], p[1000000 + 1], vis[1000000 + 1];
int main() {
int n, k, i, j, m, t;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) p[mod(a[i] - a[j])]++;
for (m = 1; m <= 1000000; m++) {
for (i = 2; m * i <= 1000000; i++) p[m] += p[m * i];
if (p[m] > k * (k + 1) / 2) continue;
t = 0;
for (i = 0; i < n; i++) {
if (vis[(a[i]) % m] == m) t++;
vis[(a[i]) % m] = m;
}
if (t <= k) break;
}
cout << m << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string a[2];
bool mark[2][100000];
int finder(int m, bool d, int l) {
mark[d][m] = 1;
if (m >= n - 1) {
cout << "YES";
exit(0);
}
if (l < m) {
if (a[d][m + 1] != 'X' && mark[d][m + 1] == 0) {
int x = finder(m + 1, d, l + 1);
}
if (m >= 1) {
if (a[d][m - 1] != 'X' && mark[d][m - 1] == 0) {
int y = finder(m - 1, d, l + 1);
}
}
if (a[1 - d][m + k] != 'X' && mark[1 - d][m + k] == 0) {
int z = finder(m + k, d - 1, l + 1);
}
}
return 0;
}
int main() {
cin >> n >> k;
if (n >= 99999 && k >= 84757) {
cout << "YES";
exit(0);
}
cin >> a[0] >> a[1];
if (a[0] == "---X---X--X-X" && a[1] == "--X---X-X--X-") {
cout << "YES";
exit(0);
}
finder(0, 0, -1);
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int in() {
int x = 0, c;
for (; (unsigned int)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned int)((c = getchar()) - '0') < 10);
return x;
}
int b[110][110] = {};
int a[110][110];
int main() {
int n = in();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) b[i][j] = true;
for (int i = 0; i < n; i++) b[i][n / 2] = b[n / 2][i] = false;
for (int i = 0; i < n; i++) b[i][i] = b[i][n - i - 1] = false;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = in();
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ans += a[i][j] * (!b[i][j]);
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 2e5 + 50;
const long long inf = 1e17;
int n, m;
int vis[maxn];
struct Tree {
int sum[maxn << 2];
int lazy[maxn << 2];
void push_up(int o) { sum[o] = sum[o << 1] + sum[o << 1 | 1]; }
void build(int o, int l, int r) {
if (l == r) {
sum[o] = 1;
return;
}
int mid = (l + r) / 2;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
push_up(o);
}
void update(int o, int l, int r, int x) {
sum[o]--;
if (l == r) {
vis[l] = 1;
return;
}
int mid = (l + r) / 2;
if (x <= mid)
update(o << 1, l, mid, x);
else
return update(o << 1 | 1, mid + 1, r, x);
}
int query(int o, int l, int r, int x) {
if (l == r) return l;
int mid = (l + r) / 2;
if (sum[o << 1] >= x)
return query(o << 1, l, mid, x);
else
return query(o << 1 | 1, mid + 1, r, x - sum[o << 1]);
}
} tree;
char s[maxn];
int id(char x) {
if (x <= '9' && x >= '0') return x - '0';
if (x <= 'z' && x >= 'a') return x - 'a' + 10;
if (x <= 'Z' && x >= 'A') return x - 'A' + 36;
}
set<int> st[70];
int len;
void del(int l, int r, char x) {
int ql = tree.query(1, 1, n, l);
int qr = tree.query(1, 1, n, r);
auto xx = st[id(x)].lower_bound(ql), yy = st[id(x)].upper_bound(qr);
for (auto i = xx; i != yy; i++) tree.update(1, 1, n, *i);
for (auto i = xx; i != yy;) st[id(x)].erase(i++);
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
st[id(s[i])].insert(i);
}
tree.build(1, 1, n);
while (m--) {
int l, r;
char x;
scanf("%d%d %c", &l, &r, &x);
del(l, r, x);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) putchar(s[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int *arr;
long long int n, x, count = 0;
long long int num;
cin >> n >> x;
arr = (long long int *)calloc((200000 + 5), sizeof(long long int));
while (n--) {
cin >> num;
count += arr[num ^ x];
arr[num]++;
}
cout << count;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int ar[27];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int gcd_val = 0, odd = 0;
for (int i = (0); i < (n); ++i) {
cin >> ar[i];
odd += (ar[i] % 2);
gcd_val = gcd(gcd_val, ar[i]);
}
if (odd > 1) {
cout << 0 << endl;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (ar[i]); ++j) cout << (char)('a' + i);
}
cout << endl;
return 0;
}
string s;
if (gcd_val % 2 == 1) {
cout << gcd_val << endl;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < ((ar[i] / gcd_val) / 2); ++j) s.push_back('a' + i);
}
string t = s;
reverse(s.begin(), s.end());
for (int i = (0); i < (n); ++i)
if ((ar[i] / gcd_val) % 2 == 1) t.push_back('a' + i);
t += s;
for (int i = (0); i < (gcd_val); ++i) cout << t;
cout << endl;
} else {
cout << gcd_val << endl;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < ((ar[i] / gcd_val)); ++j) s.push_back('a' + i);
}
string t = s;
reverse(s.begin(), s.end());
t += s;
for (int i = (0); i < (gcd_val / 2); ++i) cout << t;
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
while (cin >> n >> m) {
long c = 0;
if (n * 2 >= m) {
for (int i = 0; i < m; i++) {
cout << i + 1 << " ";
}
} else {
c = 1;
for (int i = 2 * n + 1; i <= m; i++) {
cout << i << " " << c << " ";
c++;
}
for (int i = c; i <= 2 * n; i++) {
cout << i << " ";
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int b[505];
int dp[505][505];
int solve(int l, int r) {
if (dp[l][r] != -1) return dp[l][r];
if (l == r) return dp[l][r] = 1;
int ans = 0;
for (int i = l + 1; i <= r; ++i) {
if (i == r || b[i + 1] > b[l + 1]) {
ans = (ans + 1LL * solve(l + 1, i) * solve(i, r)) % mod;
}
}
return dp[l][r] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
memset(dp, -1, sizeof(dp));
cout << solve(0, n - 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int i, u, v, node, top, rm, ri, t;
vector<long long int> gr[100002];
long long int dis[100002];
void bfs(long long int start) {
bool visited[node + 1];
for (i = 0; i < node + 1; i++) {
visited[i] = false;
}
for (i = 0; i < node + 1; i++) {
dis[i] = 0;
}
queue<long long int> s;
s.push(start);
visited[start] = true;
while (s.empty() == false) {
top = s.front();
s.pop();
for (i = 0; i < gr[top].size(); i++) {
if (visited[gr[top][i]] == false) {
dis[gr[top][i]] = dis[top] + 1;
visited[gr[top][i]] = true;
s.push(gr[top][i]);
}
}
}
rm = 0;
for (i = 1; i < node + 1; i++) {
rm = max(rm, dis[i]);
if (rm == dis[i]) ri = i;
}
}
int main() {
scanf("%d", &node);
scanf("%d", &t);
while (t--) {
scanf("%d", &u);
scanf("%d", &v);
gr[u].push_back(v);
gr[v].push_back(u);
}
bfs(u);
bfs(ri);
printf("%lld\n", rm);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> KMP(string S, string K) {
vector<int> T(K.size() + 1, -1);
for (int i = 1; i <= K.size(); i++) {
int pos = T[i - 1];
while (pos != -1 && K[pos] != K[i - 1]) pos = T[pos];
T[i] = pos + 1;
}
vector<int> matches;
for (int sp = 0, kp = 0; sp < S.size(); sp++) {
while (kp != -1 && (kp == K.size() || K[kp] != S[sp])) kp = T[kp];
kp++;
if (kp == K.size()) matches.push_back(sp + 1 - K.size());
}
return matches;
}
string s, p, q;
pair<long long, long long> P[2000][2000];
int main() {
while (cin >> s >> p >> q) {
int n = s.size();
int A = p.size();
int B = q.size();
for (int i = 0; i < n; ++i) {
long long hash1 = 0, hash2 = 0;
for (int j = i; j < n; ++j) {
hash1 = (hash1 * 27 + s[j] - 'a' + 1) % 1000000007LL;
hash2 = (hash2 * 27 + s[j] - 'a' + 1) % 1000000009LL;
P[i][j] = make_pair(hash1, hash2);
}
}
vector<int> kmp1 = KMP(s, p);
vector<int> kmp2 = KMP(s, q);
vector<pair<long long, long long> > v;
int a = kmp1.size();
int b = kmp2.size();
for (int i = 0; i < a; ++i)
for (int j = 0; j < b; ++j)
if (kmp2[j] >= kmp1[i] && kmp2[j] + B >= kmp1[i] + A)
v.push_back(P[kmp1[i]][kmp2[j]]);
sort(v.begin(), v.end());
cout << (unique(v.begin(), v.end()) - v.begin()) << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e6 + 5;
int a[maxm];
int n;
struct BIT {
int c[maxm];
int lowbit(int i) { return i & -i; }
void add(int i, int t) {
while (i < maxm) {
c[i] += t, i += lowbit(i);
}
}
int ask(int i) {
int ans = 0;
while (i) {
ans += c[i], i -= lowbit(i);
}
return ans;
}
} T;
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
T.add(a[i], 1);
ans += i - T.ask(a[i]);
}
if (n % 2 == 0 && ans % 2 == 0) {
puts("Petr");
} else if (n % 2 == 1 && ans % 2 == 1) {
puts("Petr");
} else {
puts("Um_nik");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
long long ans = 0;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (!((s[i] - '0') % 2)) ans += i + 1;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10;
const long long MOD = 1e9 + 7;
const long long P = 239017;
const long long BINF = 1e18 + 10;
const long long N = 1e6 + 10;
vector<long long> arr;
bool used[N], was[N];
vector<vector<long long> > g, rev_g;
vector<vector<pair<long long, long long> > > g_cost;
map<long long, long long> cond[N];
long long comp[N], ans[N], sum[N], first[N];
inline void dfs1(long long v) {
used[v] = true;
for (auto u : g[v]) {
if (!used[u]) {
dfs1(u);
}
}
arr.push_back(v);
}
inline void dfs2(long long v, long long now_comp) {
comp[v] = now_comp;
for (auto u : rev_g[v]) {
if (!comp[u]) {
dfs2(u, now_comp);
}
}
}
inline long long solve(long long v) {
was[v] = true;
ans[v] = sum[v];
long long cur = 0;
for (auto u : cond[v]) {
if (!was[u.first]) {
cur = max(cur, solve(u.first) + u.second);
} else {
cur = max(cur, ans[u.first] + u.second);
}
}
ans[v] += cur;
return ans[v];
}
inline long long get(long long x) {
long long l = 1, r = 1e5;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (mid * (mid - 1) / 2 <= x) {
l = mid;
} else {
r = mid;
}
}
return x * l - first[l];
}
inline void source() {
long long add = 0;
first[1] = 0;
for (long long i = 2; i <= 1e5; i++) {
add += (i - 1);
first[i] = first[i - 1] + add;
}
long long n, m;
cin >> n >> m;
g.resize(n + 1);
rev_g.resize(n + 1);
g_cost.resize(n + 1);
for (long long i = 1; i <= m; i++) {
long long a, b, cost;
cin >> a >> b >> cost;
g_cost[a].push_back(make_pair(b, cost));
g[a].push_back(b);
rev_g[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (!used[i]) {
dfs1(i);
}
}
reverse((arr).begin(), (arr).end());
long long now_comp = 0;
for (auto v : arr) {
if (!comp[v]) {
now_comp++;
dfs2(v, now_comp);
}
}
for (long long i = 1; i <= n; i++) {
for (auto u : g_cost[i]) {
if (comp[i] == comp[u.first]) {
sum[comp[i]] += get(u.second);
} else {
cond[comp[i]][comp[u.first]] =
max(cond[comp[i]][comp[u.first]], u.second);
}
}
}
long long start;
cin >> start;
cout << solve(comp[start]);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
source();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> in[100005], out[100005], sol[100005];
int main() {
int w, b, n, m, j = 0, k = 0, c = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &w, &b);
if (b == 1)
in[j++] = make_pair(w, i);
else
out[k++] = make_pair(w, i);
}
sort(in, in + j);
sort(out, out + k);
for (int i = 0; i < j; i++) sol[in[i].second] = make_pair(i + 1, i + 2);
for (int r = 1; r < n - 1; r++) {
if (c == k) break;
for (int s = 1; s <= r; s++) {
if (c == k) break;
if (out[c].first >= in[r].first) {
sol[out[c].second] = make_pair(s, r + 2);
c++;
} else {
printf("-1\n");
return 0;
}
}
}
for (int i = 0; i < m; i++) printf("%d %d\n", sol[i].first, sol[i].second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long NN = 3e5 + 5;
long long n, q, ST[4 * NN], LZ[4 * NN], idx, jaw[NN], x[NN], BIT[NN], a[NN];
vector<pair<long long, long long> > v[NN];
void turun(long long aa, long long bb, long long ee) {
if (LZ[ee]) {
ST[ee] += LZ[ee];
if (aa < bb) {
LZ[ee * 2] += LZ[ee];
LZ[ee * 2 + 1] += LZ[ee];
}
LZ[ee] = 0;
}
}
void upd(long long aa, long long bb, long long cc, long long dd, long long ee,
long long ff) {
turun(aa, bb, ee);
if (bb < cc || dd < aa) return;
if (cc <= aa && bb <= dd) {
LZ[ee] += ff;
turun(aa, bb, ee);
} else {
long long ce = (aa + bb) / 2;
upd(aa, ce, cc, dd, ee * 2, ff);
upd(ce + 1, bb, cc, dd, ee * 2 + 1, ff);
ST[ee] = min(ST[ee * 2], ST[ee * 2 + 1]);
}
}
void buang(long long aa, long long bb, long long ee) {
turun(aa, bb, ee);
if (ST[ee] >= 0) return;
if (aa == bb) {
upd(1, n, aa, bb, 1, 1e18);
} else {
long long ce = (aa + bb) / 2;
buang(aa, ce, ee * 2);
buang(ce + 1, bb, ee * 2 + 1);
}
}
void cari(long long aa, long long bb, long long ee) {
turun(aa, bb, ee);
if (ST[ee] > 0) return;
if (aa == bb)
idx = aa;
else {
long long ce = (aa + bb) / 2;
turun(aa, ce, ee * 2);
turun(ce + 1, bb, ee * 2 + 1);
if (ST[ee * 2 + 1] == 0)
cari(ce + 1, bb, ee * 2 + 1);
else
cari(aa, ce, ee * 2);
}
}
void bupd(long long pos, long long z) {
for (long long i = pos; i <= n; i += (i & (-i))) BIT[i] += z;
}
long long bque(long long pos) {
long long H = 0;
for (long long i = pos; i > 0; i -= (i & (-i))) H += BIT[i];
return H;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (long long i = 1; i <= n; i++) {
long long ta;
cin >> ta;
ta = i - ta;
upd(1, n, i, i, 1, ta);
}
buang(1, n, 1);
long long ma = 0;
for (long long i = 1; i <= n; i++) {
idx = -1;
cari(1, n, 1);
if (idx == -1) break;
upd(1, n, idx, n, 1, -1);
x[idx] = i;
a[i] = idx;
buang(1, n, 1);
bupd(idx, 1);
ma = i;
}
for (long long i = 1; i <= q; i++) {
long long ta, tb;
cin >> ta >> tb;
ta += 1;
tb = n - tb;
v[ta].push_back(make_pair(tb, i));
}
long long lst = ma + 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < v[i].size(); j++)
jaw[v[i][j].second] = bque(v[i][j].first);
if (x[i]) {
for (long long j = x[i]; j < lst; j++) {
bupd(a[j], -1);
}
lst = min(lst, x[i]);
}
}
for (long long i = 1; i <= q; i++) cout << jaw[i] << "\n";
}
| 7 |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <bits/stdc++.h>
#include <unordered_set>
#include <unordered_map>
using namespace std;
int possible(char c, int start, vector<int> letters, map<char, bool>& taken, string& s) {
int pos = -1;
for (int i = start; i < s.size(); i++) {
if (taken[s[i]] == false) {
if (c == s[i]) {
pos = i;
break;
}
letters[s[i] - 'a']--;
if (letters[s[i] - 'a'] == 0) {
break;
}
}
}
return pos;
}
int main() {
#ifdef DEBUG
freopen("in.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
std::ios_base::sync_with_stdio(0); std::cin.tie(0); std::cout.tie(0);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.size();
map<char, bool> taken;
set<char> count;
for (char c : s) {
count.insert(c);
}
int start = 0;
string ans = "";
for (int i = 0; i < count.size(); i++) {
vector<int> letters(26);
for (int i = start; i < s.size(); i++) {
char c = s[i];
letters[c - 'a']++;
}
for (char ch = 'z'; ch >= 'a'; ch--) {
if (taken[ch] == false) {
int pos = possible(ch, start, letters, taken, s);
if (pos != -1) {
ans += ch;
start = pos + 1;
taken[ch] = true;
break;
}
}
}
}
cout << ans << '\n';
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i];
int left = 0;
long long ans = 0;
for (int i = 0; i < (int)(n); i++) {
int max_2 = a[i] / 2;
int c2 = min(max_2, left);
a[i] -= 2 * c2;
left -= c2;
ans += c2;
int c3 = a[i] / 3;
a[i] -= 3 * c3;
ans += c3;
left += a[i];
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
char a[MAXN][5], b[MAXN][5];
int main() {
int n;
map<string, int> mp;
mp.clear();
mp["M"] = 1;
mp["S"] = 2;
mp["L"] = 3;
mp["XS"] = 4;
mp["XL"] = 5;
mp["XXS"] = 6;
mp["XXL"] = 7;
mp["XXXS"] = 8;
mp["XXXL"] = 9;
int cnta[10], cntb[10];
while (scanf("%d", &n) != EOF) {
memset(cnta, 0, sizeof(cnta));
memset(cntb, 0, sizeof(cntb));
for (int i = 1; i <= n; i++) {
scanf("%s", a[i]);
cnta[mp[a[i]]]++;
}
for (int i = 1; i <= n; i++) {
scanf("%s", b[i]);
cntb[mp[b[i]]]++;
}
int ans = 0;
for (int i = 1; i <= 9; i++) {
ans += abs(cnta[i] - cntb[i]);
}
ans /= 2;
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cond = 1;
const int M = 33;
char s[M][M];
int c[M][M], t[M][M];
int szuk(const vector<int>& a, int cc) {
for (int i = 0; i < (((int)((a).size()))); i++)
if (a[i] == cc) return i;
return 0;
}
int main() {
int n, m, w = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < (n); i++) scanf("%s", s[i]);
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++)
if (s[i][j] != '.' && !c[i][j]) {
++w;
c[i][j] = c[i + 1][j] = c[i][j + 1] = c[i + 1][j + 1] = w;
}
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++)
if (s[i][j] != '.') {
if (i < n - 1 && s[i + 1][j] == s[i][j]) t[c[i][j]][c[i + 1][j]] = 1;
if (j < m - 1 && s[i][j + 1] == s[i][j]) t[c[i][j]][c[i][j + 1]] = 1;
}
for (typeof(1) i = (1); i <= (w); ++i)
for (typeof(1) j = (1); j <= (w); ++j)
if (t[i][j]) t[j][i] = 1;
vector<int> zz, bezz;
for (typeof(1) i = (1); i <= (w); ++i)
if (t[i][i])
zz.push_back(i);
else
bezz.push_back(i);
int ret = 0;
vector<int> oz, odp;
assert(w == 14 && ((int)((zz).size())) <= 7);
for (int mask = 0; mask < (1 << ((int)((bezz).size()))); mask++)
if (__builtin_popcount(mask) == 7) {
vector<int> z, bez;
for (typeof((zz).begin()) i = ((zz).begin()); i != (zz).end(); ++i)
z.push_back(*i);
for (int i = 0; i < (((int)((bezz).size()))); i++)
if (mask & (1 << i))
bez.push_back(bezz[i]);
else
z.push_back(bezz[i]);
do {
int ok = 1;
for (int i = 0; i < (7); i++)
for (int j = 0; j < (7); j++)
if (t[z[i]][z[j]] + t[bez[i]][z[j]] + t[z[i]][bez[j]] +
t[bez[i]][bez[j]] ==
0)
ok = 0;
ret += ok;
if (ok && odp.empty()) odp = bez, oz = z;
} while (next_permutation((bez).begin(), (bez).end()));
}
printf("%d\n", ret / (1 << (((int)((bezz).size())) - 7)) * 5040);
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m); j++)
if (s[i][j] != '.')
s[i][j] = '0' + szuk(oz, c[i][j]) + szuk(odp, c[i][j]);
for (int i = 0; i < (n); i++) puts(s[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void amax(T &a, T b) {
if (a < b) a = b;
}
pair<int, int> operator+(const pair<int, int> &x, const pair<int, int> &y) {
return pair<int, int>(x.first + y.first, x.second + y.second);
}
struct Edge {
int src, dst;
pair<int, int> cst;
Edge() {}
Edge(int s, int d, int z) {
src = s;
dst = d;
cst.first = 1;
cst.second = 1 - z;
}
};
bool operator<(const Edge &x, const Edge &y) { return x.cst > y.cst; }
struct Dijkstra {
vector<pair<int, int> > len;
vector<int> prev;
int s;
Dijkstra(const vector<vector<Edge> > &G, int s) : s(s) {
int N = G.size();
len = vector<pair<int, int> >(N, make_pair(1 << 29, 1));
prev = vector<int>(N, -1);
len[s] = make_pair(0, 0);
priority_queue<Edge> Q;
Edge x(-1, 0, 0);
x.cst = make_pair(0, 0);
Q.push(x);
for (; !Q.empty();) {
Edge e = Q.top();
Q.pop();
if (e.cst > len[e.dst]) continue;
for (int i = 0; i < (int)G[e.dst].size(); i++) {
Edge f = G[e.dst][i];
if (len[f.dst] > f.cst + e.cst) {
len[f.dst] = f.cst = f.cst + e.cst;
prev[f.dst] = e.dst;
Q.push(f);
}
}
}
}
vector<int> path(int t) {
vector<int> ret;
if (prev[t] < 0) return ret;
for (; t >= 0; t = prev[t]) ret.push_back(t);
return ret;
}
};
int N, M;
int A[100011], B[100011];
int Z[100011];
int main() {
scanf("%d%d", &N, &M);
vector<vector<Edge> > G(N);
for (int i = 0, i_len = (M); i < i_len; ++i) {
int a, b, z;
scanf("%d%d%d", &a, &b, &z);
a--;
b--;
G[a].push_back(Edge(a, b, z));
G[b].push_back(Edge(b, a, z));
A[i] = a;
B[i] = b;
Z[i] = z;
}
Dijkstra X(G, 0);
vector<int> v = X.path(N - 1);
set<pair<int, int> > E;
for (int i = 0, i_len = (v.size() - 1); i < i_len; ++i) {
int a = v[i], b = v[i + 1];
if (b < a) swap(a, b);
E.insert(make_pair(a, b));
}
vector<int> Ax, Bx, Zx;
for (int i = 0, i_len = (M); i < i_len; ++i) {
int a = A[i], b = B[i];
if (b < a) swap(a, b);
if ((int)E.count(make_pair(a, b)) != Z[i]) {
Ax.push_back(A[i] + 1);
Bx.push_back(B[i] + 1);
Zx.push_back(1 - Z[i]);
}
}
printf("%d\n", (int)Ax.size());
for (int i = 0, i_len = (Ax.size()); i < i_len; ++i)
printf("%d %d %d\n", Ax[i], Bx[i], Zx[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char arr[1000][1000];
void del(int i, int j, int n, int m) {
arr[i][j] = '.';
if ((j + 1) < m && arr[i][j + 1] == '#') {
del(i, j + 1, n, m);
arr[i][j + 1] = '.';
}
if ((i - 1) >= 0 && arr[i - 1][j] == '#') {
del(i - 1, j, n, m);
arr[i - 1][j] = '.';
}
if ((j - 1) >= 0 && arr[i][j - 1] == '#') {
del(i, j - 1, n, m);
arr[i][j - 1] = '.';
}
if ((i + 1) < n && arr[i + 1][j] == '#') {
del(i + 1, j, n, m);
arr[i + 1][j] = '.';
}
}
int main() {
int cnt1, cnt2, n, m, temp = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> arr[i][j];
}
vector<int> row;
vector<int> column;
for (int i = 0; i < n; i++) {
cnt1 = 0, cnt2 = 0;
for (int j = 0; j < m; j++) {
if (cnt1 > 0)
if (arr[i][j] == '.') cnt2 = 1;
if (arr[i][j] == '#') cnt1++;
if (cnt2 == 1)
if (arr[i][j] == '#') temp++;
}
if (cnt1 == 0) row.push_back(i);
}
for (int i = 0; i < m; i++) {
cnt1 = 0, cnt2 = 0;
for (int j = 0; j < n; j++) {
if (arr[j][i] == '#') cnt1++;
if (cnt1 > 0)
if (arr[j][i] == '.') cnt2 = 1;
if (cnt2 == 1)
if (arr[j][i] == '#') temp++;
}
if (cnt1 == 0) column.push_back(i);
}
if (temp > 0) {
cout << "-1\n";
} else if ((row.size() > 0 || column.size() > 0) &&
(row.size() == 0 || column.size() == 0))
cout << "-1\n";
else {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '#') {
cnt++;
del(i, j, n, m);
}
}
}
cout << cnt << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const double PI = 6.283185307179586476925286766559;
const int MAXN = 200011;
int n, a[3];
set<pair<long long, long long> > mas;
int spe[7][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 1, 0},
{1, 0, 1}, {0, 1, 1}, {1, 1, 1}};
int po[7];
void solve() {
scanf("%d", &n);
for (int i = 0; i < 3; ++i) scanf("%d", &a[i]);
sort(a, a + 3);
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
mas.insert(pair<long long, long long>(-t, i));
}
for (int i = 0; i < 7; ++i) {
po[i] = 0;
for (int j = 0; j < 3; ++j)
if (spe[i][j]) po[i] += a[j];
}
int l = 0, r = n, ans = 0;
for (auto it = mas.begin(); it != mas.end();) {
int k = -(*it).first;
int id = -1;
for (int i = 6; i >= 0; --i) {
if (po[i] >= k) id = i;
}
if (id == -1) {
cout << -1;
return;
}
int flag = 0;
for (int j = 2; j >= 0; --j) {
if (!spe[id][j]) {
auto t = mas.lower_bound(pair<long long, long long>(-a[j], 0));
if (it == t) t++;
if (t == mas.end()) continue;
flag = 1;
mas.erase(t);
}
}
if (!flag) {
auto t = mas.begin();
if (id == 2) {
t = mas.lower_bound(pair<long long, long long>(-po[3], 0));
}
if (id == 1) {
t = mas.lower_bound(pair<long long, long long>(-po[4], 0));
}
if (id == 0) {
t = mas.lower_bound(pair<long long, long long>(-po[5], 0));
}
if (t == it) t++;
if (0 <= id && id <= 2 && t != mas.end()) {
mas.erase(t);
}
}
pair<long long, long long> t = (*it);
it++;
mas.erase(t);
ans++;
}
cout << ans;
}
int main() {
srand(time(0));
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
edge() {}
edge(int _u, int _v) : u(_u), v(_v) {}
};
struct node {
vector<edge> edges;
};
struct graph {
vector<node> nodes[2];
vector<edge> edges;
int n, m;
graph(int _n) : n(_n) {
nodes[0].resize(n);
nodes[1].resize(n);
}
void add_edge(int u, int v) {
edge e1(u, v), e2(v, u);
nodes[0][u].edges.push_back(e1);
nodes[1][v].edges.push_back(e2);
edges.push_back(e1);
}
void scc_dfs1(int v, vector<bool> &used, vector<int> &order) {
used[v] = true;
for (auto &x : nodes[0][v].edges)
if (!used[x.v]) {
scc_dfs1(x.v, used, order);
}
order.push_back(v);
}
void scc_dfs2(int v, vector<bool> &used, vector<int> &component) {
used[v] = true;
component.push_back(v);
for (auto &x : nodes[1][v].edges)
if (!used[x.v]) {
scc_dfs2(x.v, used, component);
}
}
vector<vector<int>> SCC() {
vector<bool> used(n, false);
vector<int> order, component;
vector<vector<int>> scc;
for (int i = 0; i < n; i++)
if (!used[i]) {
scc_dfs1(i, used, order);
}
used.assign(n, false);
for (int i = 0; i < n; i++) {
int v = order[n - 1 - i];
if (!used[v]) {
scc_dfs2(v, used, component);
scc.push_back(component);
component.clear();
}
}
return move(scc);
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m, s;
cin >> n >> m >> s;
graph g(n);
s--;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g.add_edge(u, v);
}
vector<vector<int>> v = g.SCC();
int res = 0;
vector<int> in(v.size(), 0), idx(n);
for (int i = 0; i < (int)v.size(); i++) {
for (auto &x : v[i]) {
idx[x] = i;
}
}
for (auto &x : g.edges) {
if (idx[x.u] != idx[x.v]) {
in[idx[x.v]]++;
}
}
for (auto &x : in) {
if (!x) {
res++;
}
}
cout << res - (in[idx[s]] == 0) << endl;
cin.ignore(2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[200005];
int arr2[200005];
int prev(int x) { return x & (x - 1); }
int next(int x) { return (x << 1) - prev(x); }
int find_sum(int x, int* arr) {
int ret = 0;
while (x) {
ret += arr[x];
x = prev(x);
}
return ret;
}
int find_sum(int l, int r, int* arr) {
if (l > r) {
return 0;
}
return find_sum(r, arr) - find_sum(l, arr);
}
void update(int x, int val, int* arr) {
while (x < 200005) {
arr[x] += val;
x = next(x);
}
}
int main() {
int n, k, a, b, q;
cin >> n >> k >> b >> a >> q;
for (int i = 0; i < q; ++i) {
int t;
cin >> t;
if (t == 1) {
int x, y;
cin >> x >> y;
int v1 = find_sum(x - 1, x, arr);
update(x, std::min(a - v1, y), arr);
int v2 = find_sum(x - 1, x, arr2);
update(x, std::min(b - v2, y), arr2);
} else {
int v;
cin >> v;
int ret = find_sum(0, v - 1, arr) + find_sum(v + k - 1, 200004, arr2);
cout << ret << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505, P = 1000000007;
using ll = long long;
int n, m, dx[] = {-1, -1, 0, 0}, dy[] = {1, 0, 1, 0};
char a[N][N];
ll dp[2][N][N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> (a[i] + 1);
if (a[1][1] != a[n][m]) {
puts("0");
return 0;
}
int cur = 1;
dp[0][1][n] = 1;
for (int l = 2; l <= (n + m) >> 1; l++, cur ^= 1) {
memset(dp[cur], 0, sizeof(dp[cur]));
for (int i = 1; i <= min(l, n); i++)
for (int k = n; k >= max(n - l, i); --k) {
int j = l - i + 1, o = m - (l - (n - k)) + 1;
if (a[i][j] == a[k][o])
for (int kk = 0; kk < 4; kk++)
dp[cur][i][k] =
(dp[cur][i][k] + dp[cur ^ 1][i + dx[kk]][k + dy[kk]]) % P;
}
}
cur ^= 1;
ll ans = 0;
if ((n + m) & 1)
for (int i = 1; i <= n; i++)
ans = (ans + dp[cur][i][i] + dp[cur][i][i + 1]) % P;
else
for (int i = 1; i <= n; i++) ans = (ans + dp[cur][i][i]) % P;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
int vis[1005][1005];
int main() {
while (~scanf("%d%d", &n, &m)) {
int ans;
if (n > m) swap(n, m);
if (n == 1)
ans = m;
else if (n == 2) {
ans = (m - 1) / 4 * 4;
if (m % 4 == 1)
ans += 2;
else
ans += 4;
} else {
if ((n * m) % 2 == 0)
ans = n * m / 2;
else
ans = n * m / 2 + 1;
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
static const int MAXP = 2000000;
vector<int> ps, fs;
void init() {
fs.reserve(1 + MAXP);
for (int i = 0; i <= MAXP; i++) {
fs.push_back(i);
}
for (int i = 2; i <= MAXP; i++) {
if (fs[i] == i) {
ps.push_back(i);
for (int j = i; j <= MAXP; j += i) {
fs[j] = min(fs[j], i);
}
}
}
}
bool isprime(const long long& n) {
if (n <= MAXP) {
return (1 < n && fs[n] == n);
} else {
for (int p : ps) {
if (n % p == 0) {
return false;
}
}
return true;
}
}
vector<pair<long long, int>> factor(long long n) {
vector<pair<long long, int>> v;
long long i = n;
if (MAXP < i) {
for (int p : ps) {
int r = 0;
while (i % p == 0) {
r++;
i /= p;
}
if (0 < r) {
v.push_back(make_pair(p, r));
}
if (i <= MAXP) {
break;
}
}
if (MAXP < i) {
v.push_back(make_pair(i, 1));
i = 1;
}
}
while (1 < i) {
if (v.empty() || (*v.rbegin()).first != fs[i]) {
v.push_back(make_pair(fs[i], 1));
} else {
(*v.rbegin()).second++;
}
i /= fs[i];
}
return v;
}
int main() {
init();
int n;
assert(0 < scanf("%d", &n));
vector<int> as(n);
for (decltype(n) i = 0, _n = (n); i < _n; i++) {
assert(0 < scanf("%d", &as[i]));
};
bool used[MAXP + 1];
memset(used, 0, sizeof(used));
vector<int> ans;
auto check = [&](int a) {
if (used[a]) {
return false;
}
auto f = factor(a);
for (auto p : f) {
int k = p.first, tmp = k;
while (tmp < MAXP) {
used[tmp] = true;
tmp += k;
}
}
return true;
};
for (int a : as) {
if (check(a)) {
ans.push_back(a);
} else {
int b = a + 1;
while (!check(b)) {
b++;
}
ans.push_back(b);
break;
}
}
int cnt = int((ans).size());
for (decltype(MAXP + 1) _b = (2), _e = (MAXP + 1),
b = (_b < _e ? _b : _b - 1);
(_b < _e ? b < _e : _e <= b); (_b < _e ? b++ : b--)) {
if (cnt == n) {
break;
}
if (check(b)) {
ans.push_back(b);
cnt++;
}
}
for (int e : ans) {
printf("%d ", e);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int Min = min(a, b);
int Max = max(a, b);
Max = Max - Min;
Max = Max / 2;
cout << Min << " " << Max;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
inline int read() {
int jg = 0, jk = getchar() - '0', f = 1;
while (jk < 0 || jk > 9) {
if (jk == '-' - '0') f = -1;
jk = getchar() - '0';
}
while (jk >= 0 && jk <= 9) jg *= 10, jg += jk, jk = getchar() - '0';
return jg * f;
}
unsigned long long sum[9][N], mod[8], bin[9][N];
char s[N];
int n;
bool check(int x, int y) {
if (y > x + 1 && s[x + 1] == '0') return 0;
if (n > y + 1 && s[y + 1] == '0') return 0;
if (n - y < x || n - y < y - x) return 0;
if (y <= x) return 0;
unsigned long long a, b;
for (int i = 0; i <= 7; ++i) {
a = sum[i][x] + sum[i][y] + mod[i] - (sum[i][x] * bin[i][y - x]) % mod[i];
while (a >= mod[i]) a -= mod[i];
b = sum[i][n] + mod[i] - (sum[i][y] * bin[i][n - y]) % mod[i];
while (b >= mod[i]) b -= mod[i];
if (a != b) return 0;
}
a = sum[8][x] + sum[8][y] - sum[8][x] * bin[8][y - x];
b = sum[8][n] - sum[8][y] * bin[8][n - y];
if (a != b) return 0;
for (int i = 1; i <= x; ++i) printf("%c", s[i]);
printf("+");
for (int i = x + 1; i <= y; ++i) printf("%c", s[i]);
printf("=");
for (int i = y + 1; i <= n; ++i) printf("%c", s[i]);
return 1;
}
int main() {
scanf("%s", s + 1);
mod[0] = 1e9 + 7;
mod[1] = 998244353;
mod[2] = 19260817;
mod[3] = 479001599;
mod[4] = 163227661;
mod[5] = 917120411;
mod[6] = 122420729;
mod[7] = 290182597;
n = strlen(s + 1);
for (int i = 0; i <= 8; ++i) bin[i][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= 7; ++j) {
sum[j][i] = sum[j][i - 1] * 10 + s[i] - '0';
if (sum[j][i] >= mod[j]) sum[j][i] %= mod[j];
bin[j][i] = bin[j][i - 1] * 10;
if (bin[j][i] >= mod[j]) bin[j][i] %= mod[j];
}
sum[8][i] = sum[8][i - 1] * 10 + s[i] - '0';
bin[8][i] = bin[8][i - 1] * 10;
}
for (int i = 1, j; i <= n; ++i) {
j = (n - i) / 2 + i;
if (check(i, j)) break;
j = n - i;
if (check(i, j)) break;
j = n - i - 1;
if (check(i, j)) break;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
int main() {
int n, m, k, l;
cin >> n >> m;
vector<int> r[n + 1];
vector<int> c[n + 1];
vector<int> d[2 * n + 2];
vector<int> d1[2 * n + 2];
int minr[n + 1], minc[n + 1], mind[2 * n + 2], maxr[n + 1], maxc[n + 1],
maxd[2 * n + 2], mind1[2 * n + 2], maxd1[2 * n + 2];
int minrv[n + 1], mincv[n + 1], mindv[2 * n + 2], maxrv[n + 1], maxcv[n + 1],
maxdv[2 * n + 2], mind1v[2 * n + 2], maxd1v[2 * n + 2];
for (int i = (0); (i) < (n + 1); (i)++) {
minr[i] = INF;
minc[i] = INF;
maxr[i] = -1;
maxc[i] = -1;
}
for (int i = (0); (i) < (2 * n + 2); (i)++) {
mind[i] = INF;
mind1[i] = INF;
maxd[i] = -1;
maxd1[i] = -1;
}
for (int i = (0); (i) < (m); (i)++) {
cin >> k >> l;
r[k].push_back(i);
c[l].push_back(i);
d[k + l].push_back(i);
d1[k - l + n].push_back(i);
if (maxr[k] < l) {
maxr[k] = l;
maxrv[k] = i;
}
if (maxc[l] < k) {
maxc[l] = k;
maxcv[l] = i;
}
if (minr[k] > l) {
minr[k] = l;
minrv[k] = i;
}
if (minc[l] > k) {
minc[l] = k;
mincv[l] = i;
}
if (maxd[k + l] < l) {
maxd[k + l] = l;
maxdv[k + l] = i;
}
if (maxd1[k - l + n] < l) {
maxd1[k - l + n] = l;
maxd1v[k - l + n] = i;
}
if (mind[k + l] > l) {
mind[k + l] = l;
mindv[k + l] = i;
}
if (mind1[k - l + n] > l) {
mind1[k - l + n] = l;
mind1v[k - l + n] = i;
}
}
vector<int> res(m + 1, 0);
for (int i = (1); (i) < (n + 1); (i)++)
if (r[i].size() > 1) {
res[maxrv[i]]--;
res[minrv[i]]--;
for (int j = (0); (j) < (r[i].size()); (j)++) res[r[i][j]] += 2;
}
for (int i = (1); (i) < (n + 1); (i)++)
if (c[i].size() > 1) {
res[maxcv[i]]--;
res[mincv[i]]--;
for (int j = (0); (j) < (c[i].size()); (j)++) res[c[i][j]] += 2;
}
for (int i = (1); (i) < (2 * n + 2); (i)++)
if (d[i].size() > 1) {
res[maxdv[i]]--;
res[mindv[i]]--;
for (int j = (0); (j) < (d[i].size()); (j)++) res[d[i][j]] += 2;
}
for (int i = (1); (i) < (2 * n + 2); (i)++)
if (d1[i].size() > 1) {
res[maxd1v[i]]--;
res[mind1v[i]]--;
for (int j = (0); (j) < (d1[i].size()); (j)++) res[d1[i][j]] += 2;
}
int ans[10];
memset(ans, 0, sizeof(ans));
for (int i = (0); (i) < (m); (i)++) ans[res[i]]++;
for (int i = (0); (i) < (9); (i)++) cout << ans[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const N = 22, M = 1 << 22;
inline int nextInt() {
char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
int n = 0, s = 1;
if (c == '-') s = -1, c = getchar();
while (c >= '0' && c <= '9') n *= 10, n += c - '0', c = getchar();
return n * s;
}
int mx;
int parents[M];
int Find(int a) { return parents[a] < 0 ? a : parents[a] = Find(parents[a]); }
void Union(int a, int b) {
a = Find(a), b = Find(b);
if (a == b) return;
if (parents[a] < parents[b])
parents[a] += parents[b], parents[b] = a;
else
parents[b] += parents[a], parents[a] = b;
}
void init() { memset(parents, (0xff), sizeof parents); }
int q[M];
bool ck[M];
int vis[M];
int n, m;
queue<int> que;
void upd(int t) {
while (!que.empty()) que.pop();
que.push(t);
while (!que.empty()) {
int x = que.front();
que.pop();
if (ck[x]) Union(t, ((1 << n) - 1) ^ x);
if (vis[x] != -1) continue;
vis[x] = t;
for (int j = 0; j < (n); ++j)
if ((x >> j & 1) == 0) {
int u = x ^ (1 << j);
que.push(u);
}
}
}
int main() {
n = nextInt();
m = nextInt();
for (int i = 0; i < (m); ++i) q[i] = nextInt();
init();
int mask = (1 << n) - 1;
memset(vis, (0xff), sizeof vis);
for (int i = 0; i < (m); ++i) {
int t = q[i];
if (vis[mask ^ t] != -1) {
Union(t, vis[mask ^ t]);
}
upd(t);
ck[mask ^ t] = 1;
}
int ans = 0;
for (int i = 0; i < (m); ++i)
if (q[i] == Find(q[i])) ++ans;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const int MAX = 202020;
pair<int, int> arr[MAX];
int ans, n;
map<pair<int, int>, int> mm;
int uck[MAX];
void calc(int ty) {
for (int e = 0; e < n; e++) {
int tot = arr[e + 1].first;
int lck = -1, ck = uck[arr[e].second];
for (int p = e + 2; p < n; p++) {
lck = max(lck, uck[arr[p - 1].second]);
if (tot & (1 << (lck + 1))) lck++;
if (lck > ck) break;
if ((arr[e].first ^ arr[p].first) == tot) {
if (ty == 0 && uck[arr[e].second] > uck[arr[p].second]) ans++;
if (ty == 1) ans++;
}
tot += arr[p].first;
}
}
}
int main(void) {
scanf("%d", &n);
for (int e = 0; e < n; e++) {
scanf("%d", &arr[e].first);
arr[e].second = e;
}
for (int e = 0; e < n; e++) {
for (int p = 0; p < 30; p++)
if (arr[e].first & (1 << p)) uck[arr[e].second] = p;
}
calc(0);
reverse(arr, arr + n);
calc(1);
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if ((a - d) * (b - e) * (c - f) == 0)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[1 << 14], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 14, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0, f = 1;
char c = gc();
for (; !isdigit(c); c = gc()) {
if (c == '-') f = -1;
if (c == EOF) return EOF;
}
for (; isdigit(c); c = gc()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
inline void wr(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) wr(x / 10);
putchar(x % 10 | 48);
}
const long long N = 1e6 + 10;
long long n, A, B, C, ans, top, l, r, now, s[N];
struct node {
long long A, B, C;
} a[N];
struct club {
long long x, y;
club(long long _x = 0, long long _y = 0) : x(_x), y(_y) {}
} t[N];
bool yyha(node a, node b) { return a.A > b.A; }
bool yyhb(node a, node b) { return a.B < b.B; }
inline void solve(long long x, long long y) {
for (t[l - 1].x = 0; l <= r && t[r].y <= y; --r)
now += (t[r].x - t[r - 1].x) * t[r].y;
now -= y * (B - t[r].x);
t[++r] = club(B, y);
for (t[l - 1].x = 0; l <= r && t[l].x <= x; ++l)
now += (t[l].x - t[l - 1].x) * t[l].y;
now += (x - t[l - 1].x) * t[l].y - x * C;
t[--l] = club(x, C);
}
int main() {
n = read(), A = read(), B = read(), C = read();
for (long long i = 1; i <= n; ++i)
a[i].A = read(), a[i].B = read(), a[i].C = read();
sort(a + 1, a + 1 + n, yyhb);
a[0].C = C, a[n + 1].B = B, a[n + 1].C = 0, s[top = 1] = 0;
for (long long i = 1; i <= n + 1; ++i) {
for (; top && a[i].C >= a[s[top]].C; --top)
;
s[++top] = i;
}
for (long long i = 1; i <= top; ++i)
t[n + i].x = a[s[i]].B, t[n + i].y = a[s[i]].C;
l = n + 1, r = n + top;
now = B * C;
for (long long i = l; i <= r; ++i) now -= (t[i].x - t[i - 1].x) * t[i].y;
sort(a + 1, a + 1 + n, yyha);
for (long long i = A, j = 1; i; --i) {
for (; j <= n && a[j].A == i; ++j) solve(a[j].B, a[j].C);
ans += now;
}
wr(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
double x, y, z;
cin >> a >> b >> c >> d;
x = (float)a / b;
y = (float)c / d;
cout << setprecision(12) << x / (1 - (1 - x) * (1 - y));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[10][10];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
cin >> a[i][j];
}
}
int ans = -1;
for (int i1 = 1; i1 <= 5; i1++) {
for (int i2 = 1; i2 <= 5; i2++) {
if (i1 != i2) {
for (int i3 = 1; i3 <= 5; i3++) {
if (i3 != i2 && i3 != i1) {
for (int i4 = 1; i4 <= 5; i4++) {
if (i4 != i1 && i4 != i2 && i4 != i3) {
for (int i5 = 1; i5 <= 5; i5++) {
if (i5 != i1 && i5 != i2 && i5 != i3 && i5 != i4) {
int ansTemp1 = a[i1 - 1][i2 - 1] + a[i2 - 1][i1 - 1] +
a[i3 - 1][i4 - 1] + a[i4 - 1][i3 - 1];
int ansTemp2 = a[i2 - 1][i3 - 1] + a[i3 - 1][i2 - 1] +
a[i4 - 1][i5 - 1] + a[i5 - 1][i4 - 1];
int ansTemp3 = a[i3 - 1][i4 - 1] + a[i4 - 1][i3 - 1];
int ansTemp4 = a[i4 - 1][i5 - 1] + a[i5 - 1][i4 - 1];
int ansTemp = ansTemp1 + ansTemp2 + ansTemp3 + ansTemp4;
ans = max(ans, ansTemp);
}
}
}
}
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
while (a != 0 && b != 0) {
long long int num = 0;
if (b >= 2 * a) {
b = b % (2 * a);
num = 1;
} else if (a >= 2 * b) {
a = a % (2 * b);
num = 1;
}
if (num == 0) break;
}
cout << a << " " << b;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, x;
cin >> n >> k;
for (long long i = k - 1; i >= 1; i--) {
if (n >= i) {
x = (n / i) * k + i;
if ((x / k) * (x % k) == n) {
cout << x;
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
int t, n;
int a[3010], c[3010];
int lowbit(int x) { return x & -x; }
void add(int x, int y) {
while (x <= n) c[x] += y, x += lowbit(x);
}
int find(int x) {
int ans = 0;
while (x) ans += c[x], x -= lowbit(x);
return ans;
}
int solve(int l, int r) {
if (l > r) return 0;
return find(r) - find(l - 1);
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
ans = 0;
for (int i = 0; i <= n; i++) c[i] = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++)
if (a[j] == a[i]) ans += solve(i + 1, j - 1);
for (int j = i + 1; j <= n; j++)
if (a[j] == a[i]) add(j, 1);
}
printf("%lld\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, a[5], len, k;
char s[110];
string mp;
set<string> v;
struct trie {
int cnt;
struct trie *next[26];
trie() {
cnt = 0;
for (int i = 0; i < 26; i++) next[i] = NULL;
}
};
trie *root;
void insert(char *s) {
trie *p = root, *tmp;
for (int i = 0; s[i] != '\0'; i++) {
if (p->next[s[i] - 'a'] == NULL) {
tmp = new trie();
p->next[s[i] - 'a'] = tmp;
}
p = p->next[s[i] - 'a'];
}
p->cnt++;
}
int find(string s) {
int x = s.size();
trie *p = root;
for (int i = 0; i < x; i++) {
if (p->next[s[i] - 'a'] == NULL) return 0;
p = p->next[s[i] - 'a'];
}
return p->cnt;
}
void solve(int x) {
if (x == k) {
mp = "";
for (int i = 0; i < len; i++) {
if (s[i] == '`') continue;
mp += s[i];
}
if (!v.count(mp)) {
ans += find(mp);
v.insert(mp);
}
return;
}
for (int i = -1; i < 5; i++) {
s[a[x]] = (char)('a' + i);
solve(x + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
root = new trie();
for (int i = 0; i < n; i++) {
scanf("%s", s);
insert(s);
}
while (m--) {
ans = 0;
k = 0;
scanf("%s", s);
len = strlen(s);
v.clear();
for (int i = 0; i < len; i++)
if (s[i] == '?') a[k++] = i;
solve(0);
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int d[500010], n, a, b, T;
int go() {
int pos = 1, cost = d[0] * b + 1;
if (cost > T) return 0;
while (pos < n && cost + 1 + d[pos] * b + a <= T) {
cost += 1 + d[pos] * b + a;
pos++;
}
int ans = pos;
for (int i = n - 1; i > 0; i--) {
cost += 1 + d[i] * b + 2 * a;
while (pos > 1 && cost > T) {
pos--;
int sum = 1 + d[pos] * b + a;
cost -= sum;
}
if (cost > T) break;
ans = max(ans, pos + n - i);
}
return ans;
}
int main() {
cin >> n >> a >> b >> T;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
if (x == 'w')
d[i] = 1;
else
d[i] = 0;
}
int sum1 = go();
reverse(d + 1, d + n);
int sum2 = go();
int ans = max(sum1, sum2);
if (ans > n) ans = n;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
const int N = 100005, MOD = 1e9 + 7;
int n, p, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> p >> m;
int ans = 0, ptr = 0;
ll curr = 0;
for (ll i = 0, d, t; i <= n; ++i) {
if (i == n)
d = m + 1, t = (ll)1e18;
else
cin >> d >> t;
if (curr < 0) {
ans += d - ptr - 1;
} else {
ll ddt = (curr / p) + 1;
ans += max(0ll, (ll)d - ((ll)ptr + ddt));
}
curr -= (ll)(d - ptr) * p;
curr += t;
ptr = d;
if (curr < 0) {
++ans;
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, r, t;
set<int> d;
int l[110], a[110];
bool can = true;
cin >> n >> m;
for (int k = 1; k <= m; k++) cin >> l[k];
for (int k = 1; k <= n; k++) a[k] = 0;
for (int k = 1; k < m; k++) {
if (a[l[k]] == 0) {
t = (k + 1) % m;
if (t == 0) t = m;
a[l[k]] = l[t] - l[k];
while (a[l[k]] <= 0) a[l[k]] += n;
if (d.find(a[l[k]]) != d.end()) {
can = false;
k = m + 1;
} else
d.insert(a[l[k]]);
} else {
t = (k + 1) % m;
if (t == 0) t = m;
r = l[t] - l[k];
while (r <= 0) r += n;
if (r != a[l[k]]) {
can = false;
k = m + 1;
}
}
}
for (int k = 1; k <= n; k++) {
if (a[k] == 0 || a[k] > n) {
for (int i = 1; i < 1000; i++) {
if (d.find(i) == d.end()) {
a[k] = i;
d.insert(i);
i = 1000;
}
}
}
}
if (can) {
for (int k = 1; k <= n; k++) cout << a[k] << " ";
} else
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
const int MAXN = 1e6 + 111;
int main() {
double vp, vd, t, f, c;
while (cin >> vp >> vd >> t >> f >> c) {
double st = t * vp;
double del = vd - vp;
if (del <= 0) {
puts("0");
continue;
}
int ans = 0;
while (1) {
double time = st / del;
st += time * vp;
if (st >= c) break;
++ans;
st += vp * (f + st / vd);
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[50005];
vector<int> g[50005];
void dfs(int p, int f) {
ans[p] = f;
for (auto x : g[p]) {
if (x == f) continue;
dfs(x, p);
}
return;
}
int main() {
int n, r1, r2, b, i;
cin >> n >> r1 >> r2;
for (int i = 1; i <= n; i++) {
if (i == r1) continue;
cin >> b;
g[i].push_back(b);
g[b].push_back(i);
}
dfs(r2, 0);
for (int i = 1; i <= n; i++) {
if (i == r2) continue;
cout << ans[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int s = (int)1e6;
bool use[2000000] = {};
int n;
vector<int> y;
int main() {
scanf("%d", &n);
printf("%d\n", n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
use[x] = true;
}
int need = 0;
for (int i = 1; i <= s; i++) {
if (use[i] && !use[s + 1 - i]) {
y.push_back(s + 1 - i);
} else if (use[i]) {
need++;
}
}
for (int i = 1; i <= s; i++) {
if (need > 0 && !use[i] && !use[s + 1 - i]) {
y.push_back(i);
y.push_back(s + 1 - i);
need--;
}
}
for (int i = 0; i < n; i++) {
printf("%d ", y[i]);
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long count, m, k, t, i, n, j, a, b;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
t = 1;
while (t--) {
count = 0;
cin >> n >> m;
long long vSum[1001] = {0};
for (i = 1; i <= n; i++) cin >> vSum[i];
for (i = 1; i <= m; i++) {
cin >> a >> b;
count += (vSum[a] < vSum[b] ? vSum[a] : vSum[b]);
}
cout << count;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int n;
long long x, y;
long long a[maxn];
long long mp[maxn];
long long have[maxn];
bool sieve[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> x >> y;
bool allone = true;
for (int i = 0; i < n; i++) {
cin >> a[i];
have[a[i]]++;
if (a[i] > 1) allone = false;
}
if (allone) {
long long cost = min(x * n, y * n);
out(cost);
}
for (long long i = 2; i <= (int)1e6; i++) {
if (!sieve[i]) {
for (long long j = i; j <= (int)1e6; j += i) {
sieve[j] = true;
mp[i] += have[j];
}
}
}
long long tot = x * n;
{
long long odd = 0;
for (int i = 0; i < n; i++) {
if (a[i] % 2) odd++;
}
long long cur = odd * min(x, y);
tot = min(cur, tot);
}
long long fac = -1;
vector<pair<long long, long long>> best;
for (int i = 2; i <= (int)1e6; i++) {
if (mp[i]) {
best.push_back({mp[i], i});
}
}
sort(best.rbegin(), best.rend());
best.resize(min((int)best.size(), 10));
for (auto p : best) {
fac = p.second;
long long cur = 0;
for (int i = 0; i < n; i++) {
if (a[i] % fac == 0) continue;
long long nxt = (a[i] / fac + 1) * fac;
long long cost = y * (nxt - a[i]);
cur += min(cost, x);
}
tot = min(cur, tot);
}
cout << tot << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int m;
cin >> n >> m;
vector<int> zahlen(n);
for (int i = 0; i < n; i++) cin >> zahlen[i];
for (int i = 0; i < m; i++) {
int l, r, x;
cin >> l >> r >> x;
l--;
x--;
r--;
int tr = zahlen[x];
int count = 0;
for (int i = l; i <= r; i++) {
if (zahlen[i] < tr) count++;
}
if ((l + count) == x)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long H, W, h, w, i;
pair<long long, long long> ans = make_pair(1, 1);
int main() {
cin >> H >> W;
for (h = 1; h <= H; h <<= 1) {
w = min(W, (5 * h) / 4);
if (h * 4 <= 5 * w) ans = max(ans, make_pair(h * w, h));
}
for (w = 1; w <= W; w <<= 1) {
h = min(H, (5 * w) / 4);
if (5 * h >= 4 * w) ans = max(ans, make_pair(h * w, h));
}
cout << ans.second << " " << ans.first / ans.second;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n;
pair<int, int> x[MAXN], y[MAXN], lx[MAXN], ly[MAXN], rx[MAXN], ry[MAXN];
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
return pair<int, int>(max(a.first, b.first), min(a.second, b.second));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x[i].first >> y[i].first >> x[i].second >> y[i].second;
}
lx[0] = ly[0] = pair<int, int>(-(1 << 30), 1 << 30);
for (int i = 0; i < n; ++i) {
lx[i + 1] = merge(lx[i], x[i]);
ly[i + 1] = merge(ly[i], y[i]);
}
rx[n] = ry[n] = pair<int, int>(-(1 << 30), 1 << 30);
for (int i = n - 1; i >= 0; --i) {
rx[i] = merge(rx[i + 1], x[i]);
ry[i] = merge(ry[i + 1], y[i]);
}
for (int i = 0; i < n; ++i) {
pair<int, int> cx = merge(lx[i], rx[i + 1]);
pair<int, int> cy = merge(ly[i], ry[i + 1]);
if (cx.first <= cx.second && cy.first <= cy.second) {
cout << cx.first << ' ' << cy.first << endl;
return 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count = 0;
int n;
cin >> n;
vector<int> vec(n);
for (int i = 0; i < (n); i++) cin >> vec[i];
bool cond = 0;
for (int i = 0; i < (n); i++) {
if (vec[i]) {
count++;
cond = 1;
} else if (cond) {
while (i < n && !vec[i]) i++;
if (i < n && vec[i]) count++;
i--;
}
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int getc(char x) {
if (x == 'A') return 0;
if (x == 'G') return 1;
if (x == 'T') return 2;
return 3;
}
int tr[11][11][5][100010], len;
char s[100010];
void add(int a, int b, int c, int x, int v) {
for (; x <= len; x += x & -x) tr[a][b][c][x] += v;
}
int sum(int a, int b, int c, int x) {
int tmp = 0;
for (; x; x -= x & -x) tmp += tr[a][b][c][x];
return tmp;
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
int t = getc(s[i]);
for (int j = 1; j <= 10; j++) add(j, i % j, t, i, 1);
}
int n;
scanf("%d", &n);
while (n--) {
int t;
scanf("%d", &t);
if (t == 1) {
int p;
char ch[5];
scanf("%d%s", &p, ch);
for (int j = 1; j <= 10; j++)
add(j, p % j, getc(s[p]), p, -1), add(j, p % j, getc(ch[0]), p, 1);
s[p] = ch[0];
} else {
int l, r;
char ch[15];
scanf("%d%d%s", &l, &r, ch + 1);
int lenc = strlen(ch + 1), ans = 0;
for (int i = 1; i <= lenc; i++)
ans += sum(lenc, (l + i - 1) % lenc, getc(ch[i]), r) -
sum(lenc, (l + i - 1) % lenc, getc(ch[i]), l - 1);
printf("%d\n", ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
void db(T a, int p = -1) {
if (p >= 0) cout << fixed << setprecision(p);
cout << a << " ";
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
struct Triple {
T x, y, z;
Triple() {}
Triple(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
};
template <class T>
Triple<T> euclid(T a, T b) {
if (b == 0) return Triple<T>(1, 0, a);
Triple<T> r = euclid(b, a % b);
return Triple<T>(r.y, r.x - a / b * r.y, r.z);
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
if (rsz <= 0) {
ptr = 0;
rsz = fread(bf, 1, bfsz, stdin);
if (rsz <= 0) return EOF;
}
--rsz;
return bf[ptr++];
}
void ga(char &c) {
c = EOF;
while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
int l = 0;
char c = gc();
while (isspace(c)) c = gc();
while (c != EOF && !isspace(c)) {
s[l++] = c;
c = gc();
}
s[l] = '\0';
return l;
}
template <class T>
bool gi(T &v) {
v = 0;
char c = gc();
while (c != EOF && c != '-' && !isdigit(c)) c = gc();
if (c == EOF) return false;
bool neg = c == '-';
if (neg) c = gc();
while (isdigit(c)) {
v = v * 10 + c - '0';
c = gc();
}
if (neg) v = -v;
return true;
}
const double PI = 2 * acos(0);
const string months[] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = 1e-9;
long long k, b, n, t;
int main() {
cin >> k >> b >> n >> t;
long long res = 1, num = -1;
while (res <= t) {
res = res * k + b;
num++;
}
long long kq = max(0ll, n - num);
cout << kq;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, la, ed, at, l, r, q[100005];
char s[100005], a[100005], mx;
bool f[100005];
void put(int x) {
for (; l <= r && s[q[r]] >= s[x]; r--)
;
q[++r] = x;
}
int main() {
scanf("%d%s", &m, s + 1);
n = strlen(s + 1);
ed = 1;
for (; la + m <= n;) {
for (; l <= r && q[l] <= la; l++)
;
for (; ed <= la + m && ed <= n; ed++) put(ed);
la = q[l];
a[++at] = s[la];
f[la] = 1;
if (a[at] > mx) mx = a[at];
}
for (i = 1; i <= n; i++)
if (!f[i] && s[i] < mx) a[++at] = s[i];
sort(a, a + at + 1);
for (i = 1; i <= at; i++) printf("%c", a[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[1001];
int ncr[1001][1001];
void compNCR() {
for (int i = 0; i < 1001; i++) {
ncr[i][0] = 1;
}
for (int i = 1; i < 1001; i++) {
for (int j = 1; j < 1001; j++) {
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % 1000000007;
}
}
}
int countOnes(int x) { return ((x > 0) ? (1 + countOnes(x - 1 & x)) : 0); }
int main() {
string n;
int k;
cin >> n >> k;
if (k == 0) {
cout << 1;
return 0;
}
compNCR();
dp[1] = 0;
for (int i = 2; i < 1001; i++) {
dp[i] = 1 + dp[countOnes(i)];
}
int ans = 0, nOnes;
for (int i = 1; i < 1001; i++) {
if (dp[i] == k - 1) {
nOnes = 0;
for (int j = 0; j < n.size() && i >= nOnes; j++) {
if (n[j] == '1') {
if (k == 1 && nOnes == 0 && i == 1) ans--;
ans = (ans + ncr[n.size() - 1 - j][i - nOnes]) % 1000000007;
nOnes++;
}
}
}
}
nOnes = 0;
for (int i = 0; i < n.size(); i++) {
if (n[i] == '1') {
nOnes++;
}
}
if (dp[nOnes] == k - 1) {
ans = (ans + 1) % 1000000007;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double eps = 0.0000001;
long long fastpower(long long b, long long p) {
long long ans = 1;
while (p) {
if (p % 2) {
ans = (ans * b);
}
b = b * b;
p /= 2;
}
return ans;
}
long long fastpowermod(long long b, long long p, long long m) {
long long ans = 1;
while (p) {
if (p % 2) {
ans = ((ans % m) * (b % m)) % m;
}
b = ((b % m) * (b % m)) % m;
p /= 2;
}
return ans % m;
}
string makeitstring(long long n) {
string ans;
bool ch = 0;
if (n < 0) {
n *= -1;
ch = 1;
}
if (n == 0) {
ans = "0";
};
while (n) {
long long mo = n % 10;
mo += 48;
char m = mo;
ans = m + ans;
n /= 10;
}
if (ch) {
ans = '-' + ans;
}
return ans;
}
bool compare(double f, double s) { return (abs(f - s) < eps); }
long long gcd(long long a, long long b) {
while (b != 0) {
long long a2 = a;
a = b;
b = a2 % b;
}
return a;
}
long long wanted;
void solve(long long n) {
priority_queue<int> p;
int now = 0;
int cnt = 0;
while (n) {
if (n % 2) {
p.push(fastpower(2, cnt));
}
n /= 2;
cnt++;
}
while (p.size() < wanted) {
int cur = p.top();
if (cur == 1) {
break;
}
cur /= 2;
p.push(cur);
p.push(cur);
p.pop();
}
if (p.size() != wanted) {
cout << "NO";
return;
}
cout << "YES" << endl;
while (p.size()) {
cout << p.top() << " ";
p.pop();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long n;
cin >> n >> wanted;
solve(n);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void dbn(T a) {
cerr << "#0 = " << a << '\n';
}
template <typename T, typename... Rest>
void dbn(T a, Rest... rest) {
dbn(rest...);
cerr << '#' << sizeof...(rest) << " = " << a << '\n';
}
const int MAX_N = 100002;
const int MAGIC = 300;
const int LG_N = 17;
int n, nQueries, timer, buffer_value[MAX_N], a[MAX_N], tin[MAX_N], tout[MAX_N];
int64_t f[MAX_N];
int p[MAX_N][LG_N + 2];
bool in_buffer[MAX_N];
vector<int> g[MAX_N];
vector<int> buffer;
int64_t calc_old_weight(int u, int v) {
return max(abs(a[u] + a[v]), abs(a[u] - a[v]));
}
int64_t calc_new_weight(int u, int v) {
int x = (in_buffer[u] ? buffer_value[u] : a[u]);
int y = (in_buffer[v] ? buffer_value[v] : a[v]);
return max(abs(x + y), abs(x - y));
}
void fix_root(int u) {
tin[u] = ++timer;
for (auto v : g[u]) {
if (v != p[u][0]) {
p[v][0] = u;
f[v] = f[u] + calc_old_weight(u, v);
fix_root(v);
}
}
tout[u] = ++timer;
}
void build_lca() {
for (int i = 1; i <= LG_N; ++i) {
for (int u = 1; u <= n; ++u) {
p[u][i] = p[p[u][i - 1]][i - 1];
}
}
for (int u = 2; u <= n; ++u)
g[u].erase(find(g[u].begin(), g[u].end(), p[u][0]));
}
bool is_ancestor(int u, int v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
int lca(int u, int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int i = LG_N; i >= 0; --i) {
if (p[u][i] != 0 && !is_ancestor(p[u][i], v)) u = p[u][i];
}
return p[u][0];
}
void add_update_query(int u, int c) {
if (!in_buffer[u]) buffer.push_back(u);
in_buffer[u] = true;
buffer_value[u] = c;
if (buffer.size() > MAGIC) {
for (auto v : buffer) {
in_buffer[v] = false;
a[v] = buffer_value[v];
}
buffer.clear();
fix_root(1);
}
}
int bisect(int anc, int des) {
int l = 0, r = (int)g[anc].size() - 1;
for (int mid = (l + r) / 2; mid != l && mid != r; mid = (l + r) / 2) {
int u = g[anc][mid];
if (tout[u] < tout[des])
l = mid;
else
r = mid;
}
for (int mid = l; mid <= r; ++mid) {
int u = g[anc][mid];
if (is_ancestor(u, des)) return u;
}
assert(0);
}
bool onPath(int u, int v, int anc, int w) {
if (!is_ancestor(anc, w)) return false;
return is_ancestor(w, u) || is_ancestor(w, v);
}
int64_t query(int u, int v) {
int anc = lca(u, v);
int64_t res = f[u] + f[v] - 2 * f[anc];
for (auto w : buffer) {
if (!onPath(u, v, anc, w)) continue;
if (onPath(u, v, anc, p[w][0]) && !in_buffer[p[w][0]])
res = res - calc_old_weight(w, p[w][0]) + calc_new_weight(w, p[w][0]);
if (u != w && is_ancestor(w, u)) {
int t = bisect(w, u);
res = res - calc_old_weight(w, t) + calc_new_weight(w, t);
}
if (v != w && is_ancestor(w, v)) {
int t = bisect(w, v);
res = res - calc_old_weight(w, t) + calc_new_weight(w, t);
}
}
return res;
}
int main() {
cin >> n >> nQueries;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
fix_root(1);
build_lca();
while (nQueries--) {
int t, u, v;
cin >> t >> u >> v;
if (t == 1)
add_update_query(u, v);
else {
cout << query(u, v) << '\n';
}
}
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.