solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int m = max(3 * a / 10, a - a / 250 * c);
int v = max(3 * b / 10, b - b / 250 * d);
if (m == v)
cout << "Tie";
else if (m > v)
cout << "Misha";
else
cout << "Vasya";
return 0;
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t; cin >> t;
while (t--) {
int n; cin >> n;
vector<long long> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i];
}
array<long long, 2> small{ c[1], c[0] };
long long min_cost = n * (small[0] + small[1]);
long long total = 0;
for (int use = 3; use <= n; use++) {
if (c[use - 1] < small[use % 2]) {
total += small[use % 2];
small[use % 2] = c[use - 1];
} else {
total += c[use - 1];
}
long long cost = total + (n - use / 2 + 1) * small[(use + 1) % 2] + (n - (use + 1) / 2 + 1) * small[use % 2];
min_cost = min(min_cost, cost);
}
cout << min_cost << '\n';
}
return 0;
} | 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, i, j, n, m, k;
inline void die(long double first) {
printf("%.15lf\n", (double)first);
exit(0);
}
long double check(long double y1, long double y2, long double yw,
long double xb, long double yb, long double r,
long double xx) {
long double h = yw - r - yb;
double a = xx, b = xb - xx;
return yw - r - h / b * a;
}
struct line {
long double a, b, c;
line() : a(0), b(0), c(0) {}
line(pair<long double, long double> t1, pair<long double, long double> t2) {
a = t2.second - t1.second;
b = t1.first - t2.first;
c = -a * t1.first - b * t1.second;
long double s = sqrt(a * a + b * b);
a /= s;
b /= s;
c /= s;
}
inline long double dist(pair<long double, long double> t) {
return abs(a * t.first + b * t.second + c);
}
};
int main() {
long double y1, y2, yw, xb, yb, r;
cin >> y1 >> y2 >> yw >> xb >> yb >> r;
if (y1 > y2) swap(y1, y2);
long double bottom = y1 + r;
long double top = min(y2 - r, yw - r);
if (bottom > top + 1e-9) {
printf("-1\n");
exit(0);
}
long double low = 0.0, high = xb;
for (int _n((300)), hod(1); hod <= _n; hod++) {
long double xx = (low + high) / 2;
long double ff = check(y1, y2, yw, xb, yb, r, xx);
line l(make_pair(xx, yw - r), make_pair(0, ff));
if (ff + 1e-9 > bottom && l.dist(make_pair(0, y2)) + 1e-9 > r &&
ff < top + 1e-9) {
die(xx);
}
if (ff < bottom)
high = xx;
else
low = xx;
}
printf("-1\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<long long, int> > v(0);
int main() {
cin >> n >> m;
long long lev, l, r, tp;
long long tot = 0;
while (m--) {
scanf("%lld%lld%lld%lld", &lev, &l, &r, &tp);
r++;
while (lev < n) {
l *= 2;
r *= 2;
lev++;
}
if (tp == 1) tot++;
v.push_back(make_pair(l, tp + 1));
v.push_back(make_pair(r, -tp - 1));
}
tot++;
v.push_back(make_pair(1LL << (n - 1), 2));
v.push_back(make_pair(1LL << (n), -2));
long long ans = 0;
long long ansn = 0;
int nm = 0;
sort(v.begin(), v.end());
for (int i = 0; i < int(v.size()) - 1; i++) {
if (v[i].second == 2) tot--;
if (v[i].second == -2) tot++;
if (v[i].second == 1) nm--;
if (v[i].second == -1) nm++;
if (tot == 0 && nm == 0 && v[i].first < v[i + 1].first) {
ansn += v[i + 1].first - v[i].first;
ans = v[i].first;
}
}
if (ansn == 1)
cout << ans << endl;
else if (ansn > 1)
cout << "Data not sufficient!\n";
else
cout << "Game cheated!\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, net = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
string a;
int count = 0;
cin >> a;
vector<int> ar(11);
for (char x : a) {
ar[int(x) - 48]++;
}
for (int i = 0; i <= k; i++) {
if (ar[i] > 0) count++;
}
if (count == k + 1) net++;
}
cout << net << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, W;
scanf("%d%d", &N, &W);
vector<int> n;
int maxW = 0, mini = 0;
for (int i = 0; i < N; i++) {
int v;
scanf("%d", &v);
n.push_back(v);
maxW += v;
if (v < n[mini]) {
mini = i;
}
}
if (N == 1) {
if (W == n[0]) {
puts("Yes");
for (int i = 0; i < W; i++) {
printf("1 1%c", (i == W - 1) ? '\n' : ' ');
}
} else {
puts("No");
}
} else if (W == 1) {
if (n[mini] == 1) {
puts("Yes");
printf("%d", mini + 1);
for (int i = 0; i < n.size(); i++) {
if (i == mini) {
continue;
}
while (n[i]-- > 0) {
printf(" %d %d", i + 1, i + 1);
}
}
printf(" %d\n", mini + 1);
} else {
puts("No");
}
} else {
if (2 <= W && W <= maxW) {
puts("Yes");
int diff = maxW - W;
n[0]--;
n[1]--;
printf("1");
for (int i = 1; i < n.size(); i++) {
if (diff == 0) {
break;
}
while (n[i] > 0) {
printf(" %d %d", i + 1, i + 1);
n[i]--;
if (--diff == 0) {
break;
}
}
}
printf(" 1 2");
if (diff == 0) {
printf(" 2");
for (int i = 0; i < n.size(); i++) {
while (n[i] > 0) {
printf(" %d %d", i + 1, i + 1);
n[i]--;
}
}
} else {
while (diff > 0) {
printf(" 1 1");
diff--;
n[0]--;
}
printf(" 2");
while (n[0] > 0) {
printf(" 1 1");
n[0]--;
}
}
puts("");
} else {
puts("No");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x[50], y[50];
bool ok(int s1, int s2, int u1, int u2) {
int ts1 = s1, ts2 = s2;
int f[10];
memset(f, 0, sizeof(f));
for (int i = 0; i < u1; i++) {
f[s1 % 7]++;
s1 /= 7;
}
for (int i = 0; i < u2; i++) {
f[s2 % 7]++;
s2 /= 7;
}
for (int i = 0; i < 10; i++) {
if (f[i] > 1) return false;
}
return true;
}
int main() {
int n, m, a, b;
while (cin >> n >> m) {
int tn = n - 1, tm = m - 1;
int i = 0, j = 0;
while (tn > 0) {
++i;
tn /= 7;
}
while (tm > 0) {
++j;
tm /= 7;
}
i = max(i, 1);
j = max(j, 1);
if (i + j > 7)
cout << "0" << endl;
else {
int ans = 0;
for (int k = 0; k < n; k++) {
for (int s = 0; s < m; s++) {
if (ok(k, s, i, j)) ans++;
}
}
cout << ans << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long mod = 1009;
using namespace std;
int nnn, mm, goal, aa[200005];
vector<int> mjk[200005];
vector<int> lst;
vector<int> TMP;
namespace fftRR {
const int MN = (int)1e6;
int ffa[MN], ffb[MN];
long long ffres[MN];
int my_round(double x) {
if (x < 0) return -my_round(-x);
return (int)(x + 1e-3);
}
const double PI = acos((double)-1.0);
int rev[MN];
complex<double> wlen_pw[MN], fa[MN], fb[MN];
void fft(complex<double> a[], int n, bool invert) {
for (int i = 0; i < n; ++i)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int len = 2; len <= n; len <<= 1) {
double alpha = 2 * PI / len * (invert ? -1 : +1);
int len2 = len >> 1;
wlen_pw[0] = complex<double>(1, 0);
complex<double> wlen(cos(alpha), sin(alpha));
for (int i = 1; i < len2; ++i) wlen_pw[i] = wlen_pw[i - 1] * wlen;
for (int i = 0; i < n; i += len) {
complex<double> t, *pu = a + i, *pv = a + i + len2,
*pu_end = a + i + len2, *pw = wlen_pw;
for (; pu != pu_end; ++pu, ++pv, ++pw) {
t = *pv * *pw;
*pv = *pu - t;
*pu += t;
}
}
}
if (invert)
for (int i = 0; i < n; i++) a[i] /= n;
}
void calcRev(int n, int logn) {
for (int i = 0; i < n; i++) {
rev[i] = 0;
for (int j = 0; j < logn; j++)
if (i & (1 << j)) rev[i] |= 1 << (logn - 1 - j);
}
}
void mulpoly(int a[], int b[], long long c[], int na, int nb, int &n) {
int l = max(na, nb), logn = 0;
for (n = 1; n < l; n <<= 1) ++logn;
n <<= 1;
++logn;
calcRev(n, logn);
for (int i = 0; i < n; i++) fa[i] = fb[i] = complex<double>(0);
for (int i = 0; i < na; i++) fa[i] = complex<double>(a[i]);
for (int i = 0; i < nb; i++) fb[i] = complex<double>(b[i]);
fft(fa, n, false);
fft(fb, n, false);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, n, true);
for (int i = 0; i < n; i++) c[i] = (long long)(fa[i].real() + 0.5);
}
} // namespace fftRR
int main() {
iostream::sync_with_stdio(0);
cin >> nnn >> mm >> goal;
for (int i = 1; i <= nnn; i++) {
int x;
cin >> x;
++aa[x];
}
for (int i = 1; i <= mm; i++) {
if (!aa[i]) continue;
lst.push_back(i);
mjk[i].assign(aa[i] + 1, 1);
}
while (lst.size() > 1) {
sort(lst.begin(), lst.end(),
[&](int &x, int &y) { return mjk[x].size() < mjk[y].size(); });
vector<int> zzz;
for (int i = 0; i < ((int)lst.size() + 1) / 2; i++) {
int other = (int)lst.size() - 1 - i;
if (i == other) {
zzz.push_back(lst[i]);
continue;
}
for (int j = 0; j < mjk[lst[i]].size(); j++)
fftRR::ffa[j] = mjk[lst[i]][j];
for (int j = 0; j < mjk[lst[other]].size(); j++)
fftRR::ffb[j] = mjk[lst[other]][j];
for (int j = 0; j < mjk[lst[i]].size() + mjk[lst[other]].size() - 1; j++)
fftRR::ffres[j] = 0;
int tmp = 0;
fftRR::mulpoly(fftRR::ffa, fftRR::ffb, fftRR::ffres, mjk[lst[i]].size(),
mjk[lst[other]].size(), tmp);
mjk[lst[i]].assign(mjk[lst[i]].size() + mjk[lst[other]].size() - 1, 0);
for (int j = 0; j < mjk[lst[i]].size(); j++)
mjk[lst[i]][j] = fftRR::ffres[j] % mod;
zzz.push_back(lst[i]);
}
lst = zzz;
}
cout << mjk[lst[0]][goal];
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
long long power(long long a, long long b, long long p) {
if (!b) return 1;
long long t = power(a, b / 2, p);
t = t * t % p;
if (b & 1) t = t * a % p;
return t;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long px, py;
long long d = exgcd(b, a % b, px, py);
x = py;
y = px - a / b * py;
return d;
}
template <class T>
inline void freshmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
inline void freshmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
void print(const T &a) {
for (auto x : a) printf("%d ", x);
puts("");
}
const int MAXN = 15;
const int MAXM = 2010;
const int MAXK = 20;
const int INF = 1000000000;
const int MOD = 1000000007;
const int INV2 = (MOD + 1) / 2;
const double pi = 3.1415926535897932384626433;
int n, m;
int a[MAXN][MAXM];
int maxv[MAXM];
int p[MAXM];
int F[15][1 << 12];
int tmp[1 << 12];
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
}
for (int j = 1; j <= m; ++j) {
maxv[j] = 0;
for (int i = 0; i < n; ++i) freshmax(maxv[j], a[i][j]);
}
for (int j = 1; j <= m; ++j) p[j] = j;
sort(p + 1, p + m + 1, [&](int x, int y) { return maxv[x] > maxv[y]; });
for (int i = 0; i <= min(n, m); ++i)
for (int j = 0; j < 1 << n; ++j) F[i][j] = 0;
for (int k = 1; k <= min(n, m); ++k) {
int j = p[k];
for (int s = 0; s < 1 << n; ++s) {
tmp[s] = 0;
for (int d = 0; d < n; ++d) {
int sum = 0;
for (int i = 0; i < n; ++i)
if (s >> i & 1) sum += a[(i + d) % n][j];
freshmax(tmp[s], sum);
}
}
for (int s = 0; s < 1 << n; ++s) {
F[k][s] = F[k - 1][s];
for (int t = s; t; t = (t - 1) & s) {
freshmax(F[k][s], F[k - 1][s ^ t] + tmp[t]);
}
}
}
cout << F[min(n, m)][(1 << n) - 1] << endl;
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2010;
int seq[4];
int a[MAX];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < n; ++i) {
seq[3] = max(seq[2], seq[3]) + (a[i] == 2);
seq[2] = max(seq[1], seq[2]) + (a[i] == 1);
seq[1] = max(seq[1], seq[0]) + (a[i] == 2);
seq[0] += (a[i] == 1);
}
printf("%d\n", max(seq[3], seq[2]));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;pair <int, int> p[200100];int N,n[200100],d[200100];
int main() {cin>>N;for(int i=0;i<N;i++)cin>>p[i].first>>p[i].second;sort(p,p+N);d[N]=1;for(int i=N;i--;){int c=i+1;while(c<N&&p[c].first<p[i].first+p[i].second)c=n[c];d[i]=(d[i+1]+d[n[i]=c])%998244353;}cout<<d[0]<<"\n";} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector <string> ans;
string Str,str;
bool cal(){
bool alph[300]={};
alph['a']=1;
for(int i=0;i<str.size();i++){
int flg=0;
if(!alph[str[i]])flg=alph[str[i]]=1;
if(str[i]-flg!=Str[i])return 0;
}
return 1;
}
bool used[300];
void saiki(int idx){
while(used[str[idx]]||str[idx]=='z')idx++;
if(idx==(int)str.size()&&cal())ans.push_back(str);
if(idx==str.size())return;
saiki(idx+1);
str[idx]++;
used[str[idx]-1]=1;
saiki(idx+1);
used[str[idx]-1]=0;
str[idx]--;
}
int main(){
while(1){
cin>>Str;
str=Str;
if(Str=="#")break;
ans.clear();
saiki(0);
cout <<ans.size()<<endl;
int cnt=0;
sort(ans.begin(),ans.end());
if(ans.size()<=10)
for(int i=0;i<ans.size();i++)cout <<ans[i]<<endl;
else {
for(int i=0;i<5;i++)cout<<ans[i]<<endl;
for(int i=0;i<5;i++)cout<<ans[ans.size()-5+i]<<endl;
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string S,T;cin>>S>>T;
string SS=S+S;
//みぎにいくつ進めばたどり着けるか
vector<vector<long>>N(SS.length(),vector<long>(26,-1));
for(long c=0;c<26;c++){
long l=-1;
for(long i=SS.length()-1;i>=0;i--){
if(l!=-1)N[i][c]=l-i;
if(SS[i]-97==c)l=i;
}
}
long l=S.find(T[0]);//何番目のindexを見てるか
if(l==string::npos){cout<<-1;return 0;}
long ans=1+l;//進んだ総和
for(long i=1;i<T.length();i++){
if(N[l][T[i]-97]==-1){cout<<-1;return 0;}
ans+=N[l][T[i]-97];
l=(l+N[l][T[i]-97])%S.length();
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
priority_queue<pair<long long, long long> > q;
int n, m = 0;
pair<long long, long long> a[maxn * 2 + 5];
int main() {
scanf("%d", &n);
long long ansa = 0, ansb = 0;
for (int i = 1; i <= n; i++) {
long long x1, y1, x2, y2;
scanf("%lld%lld%lld%lld", &x1, &y1, &x2, &y2);
if (x1 + y1 < x2 + y2) {
if (x1 > y2) {
ansa += x1;
ansb += y2;
}
if (y1 > x2) {
ansa += x2;
ansb += y1;
}
continue;
}
a[++m] = pair<long long, long long>(x1, y1);
a[++m] = pair<long long, long long>(x2, y2);
}
n = m / 2;
for (int i = 1; i <= m; i += 2)
q.push(pair<long long, long long>(a[i].first + a[i].second, 1ll * i));
int u = 1;
while (!q.empty()) {
pair<long long, long long> k = q.top();
q.pop();
if (u) {
ansa += a[k.second].first;
} else {
ansb += a[k.second].second;
}
if (k.second & 1) {
q.push(pair<long long, long long>(
a[k.second + 1].first + a[k.second + 1].second,
1ll * (k.second + 1)));
}
u = !u;
}
printf("%lld\n", ansa - ansb);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 7;
int main() {
ios::sync_with_stdio(false);
long long n, k;
long long a, b, c;
cin >> n >> k;
a = n * 2;
b = n * 5;
c = n * 8;
if (a % k == 0)
a = a / k;
else
a = a / k + 1;
if (b % k == 0)
b = b / k;
else
b = b / k + 1;
if (c % k == 0)
c = c / k;
else
c = c / k + 1;
cout << a + b + c << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, a[55], b[55], min_a, min_b;
long long sum;
int main() {
cin >> t;
while (t--) {
cin >> n;
min_a = 1000000000;
min_b = 1000000000;
sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
min_a = min(min_a, a[i]);
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
min_b = min(min_b, b[i]);
}
for (int i = 1; i <= n; i++) {
if (a[i] == min_a && b[i] == min_b) continue;
int A = a[i] - min_a, B = b[i] - min_b;
if (a[i] > min_a && b[i] > min_b) {
if (A == B) {
sum += A;
a[i] -= A;
b[i] -= B;
} else if (A < B) {
sum += A;
a[i] -= A;
b[i] -= A;
} else {
sum += B;
a[i] -= B;
b[i] -= B;
}
A = a[i] - min_a, B = b[i] - min_b;
}
if (a[i] == min_a && b[i] > min_b) {
sum += B;
b[i] -= B;
} else if (a[i] > min_a && b[i] == min_b) {
sum += A;
a[i] -= A;
}
}
cout << sum << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int c, l = 0, x;
for (; !isdigit(c = getchar()); l = c)
if (c == EOF) return 1 << 31;
for (x = c - '0'; isdigit(c = getchar()); x = x * 10 + c - '0')
if (c == EOF) break;
return l == '-' ? -x : x;
}
const int N = 1200;
char B[N][N], A[N];
int ll, T, dp[2][N], sa[N], n, sa2[N], stl, f[12], g[12], c[32], len[N];
int main() {
scanf("%s%d", A, &n);
stl = strlen(A);
ll = strlen(A);
if (A[0] == '?') A[0] = '!';
for (int j = 0; ll - j - 1 > j; j++) swap(A[j], A[ll - j - 1]);
for (int i = 1; i <= n; i++) {
scanf("%s", B[i]);
int x = strlen(B[i]);
ll = max(ll, x);
len[i] = x;
for (int j = 0; x - j - 1 > j; j++) swap(B[i][j], B[i][x - j - 1]);
}
for (int i = 0; i <= ll; i++)
if (!A[i]) A[i] = '0';
for (int i = 0; i <= ll; i++) {
for (int j = 1; j <= n; j++)
if (!B[j][i]) B[j][i] = '0';
}
for (int i = 0; i <= 9; i++) scanf("%d", c + i);
for (int i = 10; i < 30; i++) c[i] = c[i - 10];
for (int i = 1; i <= n; i++) sa[i] = i;
memset(dp, 0x88, sizeof(dp));
int *x = sa, *y = sa2;
dp[0][0] = 0;
ll++;
for (int i = 0; i < ll; i++) {
T ^= 1;
memset(dp[T], 0x88, sizeof(dp[T]));
memset(f, 0, sizeof(f));
for (int j = 1; j <= n; j++) f[B[j][i] - '0']++;
for (int j = 1; j < 10; j++) f[j] += f[j - 1];
for (int j = n; j >= 1; j--) y[f[B[x[j]][i] - '0']--] = x[j];
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
int gg = 0;
for (int j = 1; j <= n; j++) f[B[j][i] - '0']++;
for (int j = 1; j <= n; j++)
if (len[j] <= i) gg++;
for (int j = 0; j <= n; j++) {
int ak = 0;
if (A[i] == '?' || A[i] == '!')
for (int k = 0; k < 10; k++) {
ak += f[10 - k];
if (A[i] == '!' && k == 0) continue;
int ans = 0;
for (int l = 0; l < 10; l++)
ans += c[k + l] * (f[l] - g[l]) + c[k + l + 1] * g[l];
dp[T][ak + g[9 - k]] = max(dp[T][ak + g[9 - k]], dp[!T][j] + ans);
}
else {
for (int k = 0; k < A[i] - '0'; k++) ak += f[10 - k];
int k = A[i] - '0';
ak += f[10 - k];
int ans = 0;
for (int l = 0; l < 10; l++)
if (i >= stl && l == 0)
ans += c[k + l] * (f[l] - g[l] - gg) + c[k + l + 1] * g[l];
else
ans += c[k + l] * (f[l] - g[l]) + c[k + l + 1] * g[l];
dp[T][ak + g[9 - k]] = max(dp[T][ak + g[9 - k]], dp[!T][j] + ans);
}
g[B[x[n - j]][i] - '0']++;
if (len[x[n - j]] <= i) gg--;
}
swap(x, y);
}
int ans = 0;
for (int i = 0; i <= n; i++) ans = max(ans, dp[T][i]);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, string> m;
int q;
int main(int argc, const char* argv[]) {
cin >> q;
for (int i = 0; i < q; i++) {
string o, n;
cin >> o >> n;
bool broken = false;
for (auto x : m) {
if (x.second == o) {
m[x.first] = n;
broken = true;
break;
}
}
if (!broken) {
m[o] = n;
}
}
cout << m.size() << endl;
for (auto x : m) {
cout << x.first << " " << x.second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9+7;
ll modpow(ll m, ll n){
if(n == 0) return 1;
else if(n % 2 == 0) return modpow(m * m % MOD, n/2);
else{
return modpow(m, n - 1) * m % MOD;
}
}
int main(){
int n, k; scanf("%d %d", &n, &k);
ll ans = 0;
vector<ll> data(k + 1, 0);
for(int g = k; g >= 1; g--){
ll cnt = modpow(k/g, n);
for(int i = g; i <= k; i += g){
(cnt += -data[i] + MOD) %= MOD;
}
data[g] = cnt;
(ans += (cnt * g)%MOD) %= MOD;
}
printf("%lld\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, a, b, c, d, i, j, k, l, n, m, x, y;
cin >> t;
while (t--) {
cin >> n;
set<long long int> s;
for (i = 0; i < n; i++) {
cin >> a;
s.insert(a);
}
b = s.size();
if (b == 1)
cout << n << endl;
else
cout << 1 << endl;
s.clear();
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
vector<long long int> graph[200010], backIn[200010], backOut[200010],
tree[200010];
long long int dep[200010], par[200010];
void dfs(long long int i, long long int p) {
par[i] = p;
dep[i] = dep[p] + 1;
for (long long int j : graph[i])
if (j - p) {
if (!dep[j]) {
tree[i].push_back(j);
dfs(j, i);
} else if (dep[j] < dep[i]) {
backIn[j].push_back(i);
backOut[i].push_back(j);
}
}
}
vector<tuple<long long int, long long int, long long int>> triples;
long long int root;
bool fillTriples(long long int i) {
vector<long long int> edges = backOut[i];
for (long long int j : tree[i])
if (!fillTriples(j)) edges.push_back(j);
for (long long int k = 0; k + 1 < edges.size(); k += 2)
triples.push_back({edges[k], i, edges[k + 1]});
if ((edges.size() & 1) && i != root)
triples.push_back({edges.back(), i, par[i]});
return edges.size() & 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n;
cin >> n;
long long int m;
cin >> m;
while (m--) {
long long int u;
cin >> u;
long long int v;
cin >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (long long int i = 1; i < (n + 1); ++i)
if (!dep[i]) {
dfs(i, i);
root = i;
fillTriples(i);
}
cout << triples.size() << '\n';
for (auto a : triples)
cout << get<0>(a) << ' ' << get<1>(a) << ' ' << get<2>(a) << '\n';
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<long double, long double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
const ll mod = 1000000007;
const ll inf = 1LL << 60;
const long double PI = acos(-1);
const long double eps = 1e-9;
template <class T>
inline bool chmax(T& a, T b) {
bool x = a < b;
if (x) a = b;
return x;
}
template <class T>
inline bool chmin(T& a, T b) {
bool x = a > b;
if (x) a = b;
return x;
}
void startupcpp() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
long double distance(ddatas x, ddatas y) {
long double a = x.first - y.first, b = x.second - y.second;
return sqrt(a * a + b * b);
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + mod) % mod;
}
ll moddevide(ll a, ll b) { return (a * modinv(b)) % mod; }
vec modncrlistp, modncrlistm;
ll modncr(ll n, ll r) {
if (n < r) return 0;
ll i, size = modncrlistp.size();
if (size <= n) {
modncrlistp.resize(n + 1);
modncrlistm.resize(n + 1);
if (!size) {
modncrlistp[0] = modncrlistm[0] = 1;
size++;
}
for (i = size; i < (ll)n + 1; ++i) {
modncrlistp[i] = modncrlistp[i - 1] * i % mod;
modncrlistm[i] = modinv(modncrlistp[i]);
}
}
return modncrlistp[n] * modncrlistm[r] % mod * modncrlistm[n - r] % mod;
}
ll modpow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {
if (!b) return abs(a);
return (a % b == 0) ? abs(b) : gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll countdigits(ll n) {
ll ans = 0;
while (n) {
n /= 10;
ans++;
}
return ans;
}
ll sumdigits(ll n) {
ll ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
void topcoder(vector<int>& v) {
string s;
while (1) {
cin >> s;
int i = s[0] == '{', x = 0;
while (s[i] >= '0' && s[i] <= '9') {
x = x * 10 + s[i] - '0';
++i;
}
v.emplace_back(x);
if (s[i] == '}') break;
}
}
void topcoder(string& s) {
string t;
cin >> t;
int i = 1;
while (t[i] != '"') {
s += t[i++];
}
}
vector<int> diviserlist(ll N) {
ll i;
vector<int> res;
for (i = 1; i * i < N; i++) {
if (N % i == 0) {
res.emplace_back(i);
res.emplace_back(N / i);
}
}
if (i * i == N) res.emplace_back(i);
sort((res).begin(), (res).end());
return res;
}
ll N, M, K;
int main() {
startupcpp();
int codeforces;
cin >> codeforces;
while (codeforces--) {
ll i, ok = 0, ng;
cin >> N >> M >> K;
ng = N = min(N, M);
K /= gcd(K, M - 1);
ll ans = 0;
while (ng - ok > 1) {
ll mid = (ok + ng) >> 1;
if (mid * K >= N) {
ng = mid;
} else
ok = mid;
}
cout << ok * N - ng * ok / 2 * K << "\n";
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1001001;
const LL INF=1e15;
void gg(){
puts("-1");
exit(0);
}
int n;
int a[N];
LL suf[N];
int main(){
ios::sync_with_stdio(false);
cin>>n;
for(int i=0;i<=n;i++){
cin>>a[i];
}
/**
* t=1;
* {
* ans+=t;
* t-=a[i];
* t=t...t*2;
* }
* assert(t==0);
*/
for(int i=n;i>=0;i--){
suf[i]=suf[i+1]+a[i];
}
LL t=1;
LL ans=0;
for(int i=0;i<=n;i++){
ans+=t;
t-=a[i];
if(t<0)gg();
LL s=suf[i+1];
assert(s>=t);
t*=2;
t=min(t,suf[i+1]);
}
cout<<ans<<endl;
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main(){
int r,g,b,n;
cin>>r>>g>>b>>n;
int ans=0;
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
int k=n-i*r-j*g;
if(k>=0&&k%b==0) ans++;
}
}
cout<<ans<<endl;
} | 0 |
#include <iostream>
using namespace std;
int main() {
string s;
int n, x;
cin >> s;
while (s != "-") {
cin >> n;
for (int i=0; i<n; i++) {
cin >> x;
s = s.substr(x) + s.substr(0, x);
}
cout << s << endl;
cin >> s;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, b, g;
int boy[101];
int girl[101];
int main() {
cin >> n >> m;
cin >> b;
int un = 0;
for (int i = 0; i < b; i++) {
int x;
cin >> x;
boy[x] = 1;
}
un = n - b;
cin >> g;
for (int i = 0; i < g; i++) {
int x;
cin >> x;
girl[x] = 1;
}
un += m - g;
for (int i = 0; i < 2 * n * m; i++)
if (boy[i % n] == 0 || girl[i % m] == 0) {
if (boy[i % n] || girl[i % m]) {
un--;
boy[i % n] = girl[i % m] = 1;
}
}
if (un <= 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int AbsDifference(int a, int b) {
if (a >= b) return a - b;
return b - a;
}
long long AbsDifference(long long a, long long b) {
if (a >= b) return a - b;
return b - a;
}
const int mod = 1000000007;
const int mod2 = 1000000009;
const int inf = 1 << 30;
const long long infLL = 1ll << 62;
const int impossible = -1;
struct stoyan_point {
int x, y;
int id;
};
struct stoyan_pointLL {
long long x, y;
int id;
};
struct stoyan_segment {
stoyan_point first, second;
int lenght;
bool type;
int id;
};
struct stoyan_segmentLL {
stoyan_pointLL first, second;
long long lenght;
bool type;
int id;
};
string translate(int number, int lenght, int k) {
string ans;
while (number) {
ans += char(('1') + number & 1);
number >>= 1;
}
reverse(ans.begin(), ans.end());
return ans;
}
vector<int> find_divisors(long long number) {
vector<int> ans;
int sq = sqrt(number), j;
for (j = 1; j <= sq; j++) {
if (number % j == 0) {
ans.push_back(j);
if (j * j != number) ans.push_back(number / j);
}
}
sort(ans.begin(), ans.end());
return ans;
}
int cnt_divisors(long long number) {
int ans = 0;
int sq = sqrt(number), j;
for (j = 1; j <= sq; j++) {
if (number % j == 0) {
ans++;
if (j * j != number) ans++;
}
}
return ans;
}
int n;
string s;
int x, y;
int where_last = 0;
int AnswerProblem;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
for (int i = 0; i < int(s.size()); i++) {
if (s[i] == 'R')
x++;
else
y++;
if (y > x) {
if (where_last == -1) {
AnswerProblem++;
}
where_last = 1;
}
if (y < x) {
if (where_last == 1) {
AnswerProblem++;
}
where_last = -1;
}
}
cout << AnswerProblem << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
struct Edge { int dst,weight; };
typedef pair<int,int> ii;
const int MAX_V = 1000;
int V,p[MAX_V],d[MAX_V];
vector<Edge> G[MAX_V];
ii visit(int prev,int cur) {
ii ret(0,cur);
rep(i,(int)G[cur].size()){
Edge e = G[cur][i];
if( e.dst != prev && G[e.dst].size() >= 2 ) {
ii t = visit(cur,e.dst);
t.first += e.weight;
if(ret.first < t.first ) ret = t;
}
}
return ret;
}
int longest_path(){
ii s = visit(-1,0);
ii t = visit(-1,s.second);
return t.first;
}
int coef_dfs(int cur,int prev){
int ret = 0;
rep(i,(int)G[cur].size()){
int next = G[cur][i].dst;
if( G[next].size() <= 1 || next == prev ) continue;
ret += coef_dfs(next,cur) + G[cur][i].weight;
}
return ret;
}
int main(){
while( cin >> V, V ){
int sum = 0;
rep(i,V) G[i].clear();
rep(i,V-1) { cin >> p[i]; --p[i]; }
rep(i,V-1) { cin >> d[i]; sum += d[i]; }
rep(i,V-1) { G[i+1].push_back((Edge){p[i],d[i]}); G[p[i]].push_back((Edge){i+1,d[i]}); }
int root = -1;
rep(i,V) if( G[i].size() > 1 ) { root = i; break; }
sum += coef_dfs(root,-1) * 2;
cout << sum - longest_path() << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
long long int a[maxn];
long long int sum, ave, ans;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) sum += a[i];
ave = sum / n;
for (int i = 1; i <= n; i++) {
ans += abs(a[i] - ave);
a[i + 1] += a[i] - ave;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int a[3];
for (int i = 0, _b = (2); i <= _b; i++) a[i] = y;
int res = 0;
while (a[0] < x) {
a[0] = min(a[1] + a[2] - 1, x);
res++;
sort(a, a + 3);
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const long long inf = (long long)1e9;
double PI = 3.14159265;
double eps = 1e-9;
long long t = 0;
long long pow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 1) {
return (pow(a, b - 1) * a);
}
if (b % 2 == 0) {
long long c = pow(a, b / 2);
return (c * c);
}
}
vector<pair<long long, long long>> reb;
long long dp[1 << 17];
long long krask[1 << 17];
vector<vector<long long>> g;
vector<long long> dep;
vector<vector<long long>> p;
vector<vector<long long>> dep2;
vector<long long> u;
vector<long long> tin, tout;
void dfs(long long v, long long k) {
tin[v] = t++;
p[v][0] = k;
for (long long i = 1; i < 20; i++) {
p[v][i] = p[p[v][i - 1]][i - 1];
}
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i];
if (dep[to] == -1) {
dep[to] = dep[v] + 1;
dep2[dep[to]].push_back(t);
dfs(to, v);
}
}
tout[v] = t;
}
long long parent(long long v, long long h) {
for (long long i = 0; i < 20; i++) {
if ((h & (1 << i))) {
v = p[v][i];
}
}
return v;
}
long long lca(long long a, long long b) {
if (dep[a] < dep[b]) swap(a, b);
a = parent(a, dep[a] - dep[b]);
if (a == b) return a;
for (long long i = 19; i >= 0; i--) {
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
}
return parent(a, 1);
}
struct stree {
vector<long long> t;
int n;
stree(vector<long long> a) {
n = 1;
while (n < a.size()) {
n *= 2;
}
t.resize(n + n);
for (int i = n; i < n + a.size(); i++) {
t[i] = a[i - n];
}
for (int i = n - 1; i > 0; i--) {
t[i] = t[i + i] + t[i + i + 1];
}
}
long long sum(long long l, long long r) {
long long sum = 0;
for (l += n, r += n; l <= r; l /= 2, r /= 2) {
if (l % 2 == 1) {
sum += t[l++];
}
if (r % 2 == 0) {
sum += t[r--];
}
}
return sum;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
vector<long long> a;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
stree d(a);
vector<long long> k;
k.resize(q);
long long gl = 0;
int pred = 0;
for (int i = 0; i < q; i++) {
cin >> k[i];
long long r = a.size(), l = gl - 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
long long sum = d.sum(gl, mid);
if (sum > k[i] + pred)
r = mid;
else {
l = mid;
}
}
if (r == a.size()) {
gl = 0;
pred = 0;
} else {
if (k[i] + pred < d.sum(gl, r - 1)) {
pred = k[i] + pred;
} else {
pred = k[i] + pred - d.sum(gl, r - 1);
gl = r;
}
}
cout << a.size() - gl << endl;
}
}
| 3 |
#include <iostream>
using namespace std;
int n,k,t=0;
bool prime(int o)
{
if(o<2)return false;
for(int i=2;i*i<=o;i++)if(o%i==0)return false;
return true;
}
int main()
{
cin>>n;
while(n--)
{
cin>>k;
if(prime(k))t++;
}
cout<<t<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
int ans = 1, n;
vector<int> v;
bool ispot(int x) {
while (x > 1) {
if (x & 1) return 0;
x /= 2;
}
return 1;
}
int main() {
scanf("%d", &n);
int ans2 = 0;
for (int i = 2; i < n + 1; i++) {
int cnt = 0;
if (n % i == 0) ans *= i;
while (n % i == 0) {
n /= i;
cnt++;
}
if (cnt) v.push_back(cnt);
}
for (auto x : v) {
ans2 = max(ans2, x);
}
int aux = 0;
for (auto x : v) {
if (ans2 != x) {
aux = 1;
break;
}
}
if (aux == 0 && !ispot(ans2)) aux++;
if (!ispot(ans2)) ans2 = ans2 << 1;
while (ans2 > 1) {
ans2 /= 2;
aux++;
}
printf("%d %d\n", ans, aux);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 5010;
const long long inf = 1e18;
using namespace std;
int n;
long long a[N], t[N], dp[N], mn[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]), t[i] = a[i];
for (int i = 0; i <= n; i++) dp[i] = inf;
sort(t + 1, t + 1 + n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[j] = min(dp[j - 1], min(mn[j - 1], mn[j]) + abs(a[i] - t[j]));
}
for (int j = 0; j <= n; j++) mn[j] = dp[j];
}
printf("%I64d\n", dp[n]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int lps[45];
long long dp[45][45];
string s;
void LPS() {
int i = 1, len = 0;
while (i < (int)s.size())
if (s[i] == s[len])
lps[i++] = ++len;
else if (len)
len = lps[len - 1];
else
i++;
}
int advance(int st, char c) {
while (1) {
if (st < (int)s.size() and s[st] == c) {
st++;
break;
}
if (st)
st = lps[st - 1];
else
break;
}
return st;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, i, j, st, last, l;
long long res = 0;
cin >> n >> s;
LPS();
for (last = 0; last < n; last++) {
l = n - 1 - last - max(0, (int)s.size() - last - 1);
memset(dp, 0, sizeof dp);
dp[0][(int)s.size()] = 1;
for (i = 0; i < l; i++)
for (j = 0; j <= (int)s.size(); j++) {
st = advance(j, '0');
if (st < (int)s.size()) dp[i + 1][st] += dp[i][j];
st = advance(j, '1');
if (st < (int)s.size()) dp[i + 1][st] += dp[i][j];
}
if (last + 1 < (int)s.size()) {
for (i = 0; i <= (int)s.size(); i++) {
for (j = 0, st = i; j < (int)s.size() - last - 1; j++) {
st = advance(st, s[j]);
if (st == (int)s.size()) break;
}
if (j == (int)s.size() - last - 1) res += dp[l][i];
}
} else
for (i = 0; i <= (int)s.size(); i++)
res += (1LL << (last + 1 - (int)s.size())) * dp[l][i];
}
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
const int INF = 1e9 + 7;
const int MAXN = int(2e5 + 7);
int n, n1, n2, ans, p[2007], pw[2007], a[2007], b[2007], base = 31;
set<int> st[2007];
string second, t1, t2;
int main() {
cin >> second >> t1 >> t2;
n = second.size(), n1 = t1.size(), n2 = t2.size();
pw[0] = 1;
for (int i = 0; i < n; i++) {
if (i) pw[i] = pw[i - 1] * base;
if (i) p[i] = p[i - 1] * base;
p[i] += (second[i] - 'a' + 1);
}
for (int i = 0; i < n - n1 + 1; i++)
if (second.substr(i, n1) == t1) a[i] = 1;
for (int i = 0; i < n - n2 + 1; i++)
if (second.substr(i, n2) == t2) b[i] = 1;
for (int i = 0; i < n; i++) {
if (!a[i]) continue;
for (int j = i; j < n; j++) {
if (!b[j] || i + n1 > j + n2) continue;
int r = j + n2 - 1, l = i - 1, len = r - l;
st[len].insert(p[r] - p[l] * pw[len]);
}
}
for (int i = 1; i < 2007; i++) ans += st[i].size();
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string simple = "", input;
for (int i = 0; i < 3; i++) {
cin >> input;
simple += input.at(0);
}
if (simple == "rss" || simple == "prr" || simple == "spp") {
cout << "F";
} else if (simple == "srs" || simple == "rpr" || simple == "psp") {
cout << "M";
} else if (simple == "ssr" || simple == "rrp" || simple == "pps") {
cout << "S";
} else {
cout << "?";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long freq[n + 1], ineq, impar, s, p;
memset(freq, 0, sizeof(freq));
long long vet[n];
for (int i = 0; i < n; i++) cin >> vet[i], freq[vet[i]]++;
impar = 0;
for (int i = 1; impar < 2 && i <= n; i++)
if (freq[i] % 2) impar++;
if (impar > 1) {
cout << "0" << endl;
return 0;
}
int ini = 0;
int fim = n - 1;
while (ini < fim && vet[ini] == vet[fim]) ini++, fim--;
if (ini >= fim) {
cout << ((n * (n + 1)) / 2) << endl;
return 0;
}
long long m = fim - ini + 1;
int palindrome = 0;
int a = ini + m / 2 - 1;
int b = ini + m / 2;
if (m % 2) b++, palindrome++;
while (a >= ini && vet[a] == vet[b]) a--, b++, palindrome += 2;
p = s = 1;
bool need[n + 1];
memset(freq, 0, sizeof(freq));
memset(need, false, sizeof(need));
ineq = 0;
int i, j;
for (i = ini, j = fim; i < j; i++, j--, p++) {
freq[vet[i]]--;
freq[vet[j]]++;
if (freq[vet[j]] == 1 && need[vet[j]] == false) {
ineq++;
need[vet[j]] = true;
}
if (freq[vet[i]] == 0 && need[vet[i]] == true) {
ineq--;
need[vet[i]] = false;
}
if (ineq == 0 && j - i - 1 <= palindrome) break;
}
if (ineq > 0) {
for (p = p - 1; ineq > 0 && i <= fim; i++, p++) {
freq[vet[i]] -= 2;
if (i == j) freq[vet[i]]++;
if (freq[vet[i]] <= 0 && need[vet[i]] == true) {
ineq--;
need[vet[i]] = false;
}
}
}
memset(freq, 0, sizeof(freq));
ineq = 0;
for (i = fim, j = ini; i > j; i--, j++, s++) {
freq[vet[i]]--;
freq[vet[j]]++;
if (freq[vet[j]] == 1 && need[vet[j]] == false) {
ineq++;
need[vet[j]] = true;
}
if (freq[vet[i]] == 0 && need[vet[i]] == true) {
ineq--;
need[vet[i]] = false;
}
if (ineq == 0 && i - j - 1 <= palindrome) break;
}
if (ineq > 0) {
for (s = s - 1; ineq > 0 && i >= ini; i--, s++) {
freq[vet[i]] -= 2;
if (i == j) freq[vet[i]]++;
if (freq[vet[i]] <= 0 && need[vet[i]] == true) {
ineq--;
need[vet[i]] = false;
}
}
}
cout << (((n - m) / 2 + 1) * ((n - m) / 2 + 2 * m + 1 - s - p)) << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define TR(X) ({ if(1) cerr << "Trace: " << (#X) << " = " << (X) << endl; })
ll n,m;
ll dp[100005], res[100005];
vector<ll> adj[100005];
void dfs1(ll cur, ll par) {
dp[cur] = 1;
for(ll nxt: adj[cur]) if(nxt != par){
dfs1(nxt, cur);
(dp[cur] *= (dp[nxt] + 1)) %= m;
}
}
void dfs2(ll cur, ll par, ll val) {
ll k = (ll) adj[cur].size();
vector<ll> vals(k), prfx(k, 1), sfx(k, 1);
for(ll i = 0; i < k; i++) {
if(adj[cur][i] != par) {
vals[i] = dp[adj[cur][i]] + 1;
} else {
vals[i] = val + 1;
}
}
res[cur] = 1;
for(ll i = 0; i < k; i++) (res[cur] *= vals[i]) %= m;
prfx[0] = vals[0];
sfx[k - 1] = vals[k - 1];
for(ll i = 1; i < k; i++) (prfx[i] = prfx[i - 1] * vals[i]) %= m;
for(ll i = k - 2; i >= 0; i--) (sfx[i] = vals[i] * sfx[i + 1]) %= m;
for(ll i = 0; i < k; i++) if(adj[cur][i] != par) {
ll nxtval = 1;
if(i > 0) (nxtval *= prfx[i - 1]) %= m;
if(i < k - 1) (nxtval *= sfx[i + 1]) %= m;
dfs2(adj[cur][i], cur, nxtval);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for(ll i = 0; i < n - 1; i++) {
ll a,b; cin >> a >> b;
a--; b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
if(n == 1) return cout << "1\n", 0;
dfs1(0, -1);
dfs2(0, -1, 0);
for(ll i = 0; i < n; i++) cout << res[i] << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
const float pi = 3.14159265358979323;
const long long inf = 1e18 + 5;
const long double eps = pow(2, -52);
int n, m;
string test;
map<string, int> p1, p2;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> test, p1[test]++;
for (int i = 0; i < m; i++) cin >> test, p2[test]++;
int common = 0;
map<string, int>::iterator it;
for (it = p1.begin(); it != p1.end(); it++)
if (p2.find(it->first) != p2.end()) common++;
int turn;
if (common % 2)
turn = 2;
else
turn = 1;
n -= common;
m -= common;
if (turn == 1) {
if (n > m)
cout << "YES";
else
cout << "NO";
} else {
if (n >= m)
cout << "YES";
else
cout << "NO";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int a, b;
while (t--) {
cin >> a >> b;
int d = 2;
int ans = 0;
a -= 2;
ans++;
while (a > 0) {
ans++;
a -= b;
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 1e3 + 10;
int main() {
int a, b, r;
cin >> a >> b >> r;
if (r * 2 > min(a, b))
cout << "Second" << endl;
else
cout << "First" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int nxt[100001];
char s[100001], t[100001];
int temp[100001];
int l, r;
bool check(int u) {
for (int i = 0; i < m; ++i) {
if (s[u + i] != t[i]) return 0;
}
return 1;
}
void pre_do() {
for (int i = 1; i <= n - m + 1; i++) {
temp[i] += check(i);
}
}
void putin() {
cin >> n >> m >> q;
scanf("%s%s", s + 1, t);
}
int main() {
putin();
pre_do();
for (int i = 1; i <= n; i++) {
temp[i] += temp[i - 1];
}
for (int i = 1; i <= q; i++) {
cin >> l >> r;
if (r - l + 1 < m)
cout << 0 << endl;
else
cout << temp[r - m + 1] - temp[l - 1] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const long long mod2 = mod * 1ll * mod;
const int CUTOFF = 100;
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline void add(long long& x, long long y, long long z) {
x += y * z;
if (x >= mod2) x -= mod2;
}
inline void naive_mul(vector<long long>& a, vector<long long>& b) {
vector<long long> c(a.size() + b.size() - 1);
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < b.size(); j++) add(c[i + j], a[i], b[j]);
for (int i = 0; i < c.size(); i++) c[i] %= mod;
a = c;
}
inline void ADD(long long& a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
inline int get(vector<long long>& v, int i) {
return ((i >= v.size()) ? 0 : v[i]);
}
void Karatsuba(vector<long long>& a, vector<long long>& b) {
int sa = a.size(), sc = 2 * sa - 1;
if (sa <= CUTOFF) {
naive_mul(a, b);
return;
}
int h = a.size() >> 1;
vector<long long> a2(a.begin(), a.begin() + h);
vector<long long> a1(a.begin() + h, a.end());
vector<long long> b2(b.begin(), b.begin() + h);
vector<long long> b1(b.begin() + h, b.end());
vector<long long> sma(max(a1.size(), a2.size()));
for (int i = 0; i < a1.size(); i++) {
sma[i] = add(get(a1, i), get(a2, i));
}
Karatsuba(a1, b1);
Karatsuba(a2, b2);
b1.resize(max(b1.size(), b2.size()));
for (int i = 0; i < b1.size(); i++) {
b1[i] = add(get(b1, i), get(b2, i));
}
Karatsuba(sma, b1);
int sz = sa + sa - 1;
a.clear();
a.resize(sz);
for (int i = 0; i < a1.size(); i++) ADD(a[i + (h << 1)], a1[i]);
for (int i = 0; i < a2.size(); i++) ADD(a[i], a2[i]);
for (int i = 0; i < sma.size(); i++) {
ADD(a[i + h], sub(sma[i], add(get(a1, i), get(a2, i))));
}
}
void karatsuba(vector<long long>& a, vector<long long>& b) {
int sa = a.size(), sb = b.size(), sc = a.size() + b.size() - 1;
if (sa * 1ll * sb <= CUTOFF * CUTOFF || min(sa, sb) <= 10) {
naive_mul(a, b);
return;
}
if (a.size() < b.size())
a.resize((int)b.size());
else
b.resize((int)a.size());
Karatsuba(a, b);
a.resize(sc);
}
const int MX = 2005;
vector<long long> poly_mul(vector<long long> a, vector<long long> b) {
karatsuba(a, b);
if (a.size() >= MX) a.resize(MX);
return a;
}
inline int powr(int a, long long b) {
int x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
vector<long long> P[MX];
long long powersq[MX * MX], powersp[MX * MX];
vector<long long> vec;
int f[MX][MX];
int dp[MX][MX];
int E[MX];
int main() {
int n, a, b;
cin >> n >> a >> b;
int p = mul(a, inv(b));
int q = sub(1, p);
powersp[0] = powersq[0] = 1;
for (int i = 1; i < MX * MX; i++) {
powersp[i] = mul(powersp[i - 1], p);
powersq[i] = mul(powersq[i - 1], q);
}
for (int i = 0; i < MX; i++) P[0].push_back(1);
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
f[i][0] = 1;
for (int j = 1; j <= i; j++) {
f[i][j] = add(mul(f[i - 1][j], powersq[j]),
mul(f[i - 1][j - 1], powersp[i - j]));
}
}
for (int i = 1; i <= n; i++) {
int sm = 0;
for (int j = 1; j < i; j++) {
dp[i][j] = mul(dp[j][j], f[i][j]);
sm = add(sm, dp[i][j]);
}
dp[i][i] = sub(1, sm);
}
E[1] = E[0] = 0;
for (int i = 2; i <= n; i++) {
int sm = 0;
for (int j = 1; j < i; j++) {
int v = add(E[j], add(E[i - j], add(j * (i - j), (j * (j - 1)) / 2)));
sm = add(sm, mul(dp[i][j], v));
}
sm = add(sm, mul(dp[i][i], (i * (i - 1)) / 2));
E[i] = mul(sm, inv(sub(1, dp[i][i])));
}
cout << E[n];
}
| 6 |
#include <iostream>
using namespace std;
int main() {
int X;
cin >> X;
cout << (X % 100 <= X / 100 * 5 ? 1 : 0) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << "[" << name << " : " << arg1 << "]" << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr << "[";
cerr.write(names, comma - names) << " : " << arg1 << "] | ";
__f(comma + 1, args...);
}
using ld = long double;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vs = vector<string>;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
cout << fixed << setprecision(10);
ll a, b;
cin >> a >> b;
if (b == 0) {
cout << 1 << '\n';
} else if (a == 0) {
cout << 0.5 << '\n';
} else {
ld ans = 0.5;
if (4 * b >= a)
ans += (ld)(a * a) / (16 * a * b);
else
ans += (ld)(a * b - 2 * b * b) / (2 * a * b);
cout << ans << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, dp[5005][5005], inv[5005], a[5005], f[5005], e[5005],
mod = 998244353, ans;
int main() {
cin >> n;
for (register int(i) = (1); (i) <= (n); (i)++) cin >> a[i];
stable_sort(a + 1, a + n + 1);
for (register int(i) = (1); (i) <= (n); (i)++)
f[i] = (a[i] != a[i - 1] ? i : f[i - 1]);
for (register int(i) = (n); (i) >= (1); (i)--)
e[i] = (a[i] != a[i + 1] ? i : e[i + 1]);
inv[1] = 1;
for (int i = 2; i <= n; i++) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (register int(i) = (1); (i) <= (n); (i)++) (dp[1][f[i]] += inv[n]) %= mod;
for (int i = 2; i <= n; i++) {
long long shengyuka = n - i + 1;
for (register int(j) = (1); (j) <= (n); (j)++)
if (dp[i - 1][j]) {
long long f = dp[i - 1][j], yin = e[j] - j;
(ans += f * inv[shengyuka] % mod * yin) %= mod;
(dp[i][e[j] + 1] += f * inv[shengyuka]) %= mod;
}
for (register int(j) = (1); (j) <= (n); (j)++) {
(dp[i][e[j] + 1] += dp[i][j]) %= mod;
(dp[i][j] *= (e[j] - j + 1)) %= mod;
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.141592653589793;
const int INF = 2000000000;
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return (a / GCD(a, b)) * b; }
int main() {
string str, ans;
cin >> str;
if (str.size() > 3 && str[0] == 'h' && str[1] == 't' && str[2] == 't' &&
str[3] == 'p') {
ans += "http://";
str.erase(str.begin());
str.erase(str.begin());
str.erase(str.begin());
str.erase(str.begin());
} else if (str.size() > 2 && str[0] == 'f' && str[1] == 't' &&
str[2] == 'p') {
ans += "ftp://";
str.erase(str.begin());
str.erase(str.begin());
str.erase(str.begin());
}
int i = 1;
ans += str[0];
while (str[i] != 'r' || str[i + 1] != 'u') {
ans += str[i];
i++;
}
ans += ".ru";
i += 2;
if (i < str.size()) {
ans += '/';
for (i; i < str.size(); ++i) ans += str[i];
}
cout << ans << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
using int64 = long long;
int main() {
int64 X;
cin >> X;
cout << (1LL << (2 + X)) - 2 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> P[100010];
map<int, vector<int>> m1, m2;
struct Vertical {
int x, t, id;
bool operator<(const Vertical& rhs) const { return x < rhs.x; }
};
struct Horizon {
int x, t, id;
bool operator<(const Horizon& rhs) const { return t < rhs.t; }
};
vector<Vertical> vertical;
vector<Horizon> horizon;
int final[100010];
int main() {
int n, w, h;
scanf("%d%d%d", &n, &w, &h);
for (int i = 1; i <= n; i++) {
int p, g, t;
scanf("%d%d%d", &p, &g, &t);
if (p == 1) {
P[i].first = g;
P[i].second = h;
vertical.push_back((Vertical){g, t, i});
} else {
P[i].first = w;
P[i].second = g;
horizon.push_back((Horizon){g, t, i});
}
final[i] = i;
}
sort(vertical.begin(), vertical.end());
sort(horizon.begin(), horizon.end());
for (int i = 0; i < vertical.size(); i++) {
m1[vertical[i].t - vertical[i].x].push_back(vertical[i].id);
}
for (int i = 0; i < horizon.size(); i++) {
m2[horizon[i].t - horizon[i].x].push_back(horizon[i].id);
}
for (auto it : m1) {
vector<int> v1, v2, v3, v4;
v1 = it.second;
v2 = m2[it.first];
if (v1.size() == 0 || v2.size() == 0) continue;
for (int i = 0; i < v1.size(); i++) {
v3.push_back(v1[i]);
}
for (int i = 0; i < v2.size(); i++) {
v3.push_back(v2[i]);
}
if (v1.size() >= v2.size()) {
for (int i = v2.size(); i < v1.size(); i++) v4.push_back(v1[i]);
for (int i = v2.size() - 1; i >= 0; i--) v4.push_back(v2[i]);
for (int i = v2.size() - 1; i >= 0; i--) v4.push_back(v1[i]);
} else {
for (int i = v1.size() - 1; i >= 0; i--) v4.push_back(v2[i]);
for (int i = v1.size(); i < v2.size(); i++) v4.push_back(v2[i]);
for (int i = v1.size() - 1; i >= 0; i--) v4.push_back(v1[i]);
}
for (int i = 0; i < v3.size(); i++) final[v3[i]] = v4[i];
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", P[final[i]].first, P[final[i]].second);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(T1 e1, T2 e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(T1 e1, T2 e2, T3 e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T>
void debug(vector<T> e) {
int i;
for (i = 0; i < (int)e.size(); i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<T> e, int n) {
int i;
for (i = 0; i < n; i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e) {
int i, j;
for (i = 0; i < (int)e.size(); i++) {
for (j = 0; j < (int)e[i].size(); j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<vector<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << "\t";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[110][110], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
template <class T>
void debug(T e[], int row) {
int i;
for (i = 0; i < row; i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void setmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline bool isPrime(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toLl(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool IsVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
long long Pow(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
int BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (int)R;
}
long long mulmod(long long a, long long b, long long c) {
long long x = 0, y = a % c;
while (b > 0) {
if (b % 2 == 1) {
x = (x + y) % c;
}
y = (y * 2) % c;
b /= 2;
}
return x % c;
}
void binprint(long long mask, long long n) {
long long i;
string s = "";
do {
s += (mask % 2 + '0');
mask /= 2;
} while (mask);
reverse(s.begin(), s.end());
s = string(max(n - (int)s.size(), 0LL), '0') + s;
for (i = (int)s.size() - n; i < (int)s.size(); i++) printf("%c", s[i]);
printf("\n");
}
void ASCII_Chart() {
int i, j, k;
printf("ASCII Chart:(30-129)\n");
for (i = 30; i < 50; i++) {
for (j = 0; j < 5; j++) {
k = i + j * 20;
printf("%3d---> '%c' ", k, k);
}
printf("\n");
}
}
vector<string> SubstringGenerate(string str) {
int i, j, len;
vector<string> store;
len = (int)str.size();
for (i = 0; i < len; i++)
for (j = i; j < len; j++) store.push_back(str.substr(i, j - i + 1));
return store;
}
double deg2rad(double x) { return (3.141592653589793 * x) / 180.0; }
double rad2deg(double x) { return (180.0 * x) / 3.141592653589793; }
int d1[] = {0, 1, 4, 5, 3, 2};
int d2[] = {4, 5, 2, 3, 1, 0};
map<string, int> mp;
void rec(string s) {
if (mp[s]) {
return;
}
string s1;
int i;
mp[s] = 1;
for (i = 0; i < 6; i++) {
s1 += s[d1[i]];
}
rec(s1);
s1 = "";
for (i = 0; i < 6; i++) {
s1 += s[d2[i]];
}
rec(s1);
}
int main() {
int i, j, test, Case = 1, cnt, a[10];
string s;
char str[10];
while (scanf("%s", str) == 1) {
mp.clear();
for (i = 0; i < 6; i++) {
a[i] = i;
}
cnt = 0;
do {
s = "";
for (i = 0; i < 6; i++) s += str[a[i]];
if (mp[s] == 0) {
cnt++;
}
rec(s);
} while (next_permutation(&a[0], &a[6]));
printf("%d\n", cnt);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 5e5 + 5;
void fun() {}
long long int md = 1e9 + 7;
long long int __gcd(long long int a, long long int b) {
if (b == 0) return a;
return __gcd(b, a % b);
}
long long int poww(long long int a, long long int b, long long int md) {
long long int res = 1;
while (b) {
if (b & 1) {
res = (1ll * res * a) % md;
}
a = (1ll * a * a) % md;
b >>= 1;
}
return res;
}
void ainp(long long int arr[], long long int n) {
for (long long int i = 0; i < n; i++) cin >> arr[i];
}
const long long int size = 1e5 + 1;
long long int mat[size][6];
long long int n, m, k;
long long int sparse[size][6][19];
long long int logarray[size];
void calclogarray() {
logarray[0] = 0;
logarray[1] = 0;
logarray[2] = 1;
for (long long int i = 3; i < size; i++) logarray[i] = logarray[i / 2] + 1;
}
void makesparse() {
for (long long int i = 1; i <= n; i++)
for (long long int j = 1; j <= m; j++) sparse[i][j][0] = mat[i][j];
for (long long int bits = 1; bits < 19; bits++)
for (long long int i = 1; i + (1 << bits) <= n + 1; i++)
for (long long int j = 1; j <= m; j++)
sparse[i][j][bits] = max(sparse[i][j][bits - 1],
sparse[i + (1 << (bits - 1))][j][bits - 1]);
}
bool check(long long int l, long long int r) {
long long int logg = logarray[r - l + 1];
long long int sum = 0;
for (long long int i = 1; i <= m; i++) {
sum += max(sparse[l][i][logg], sparse[r - (1 << logg) + 1][i][logg]);
}
if (sum > k) return false;
return true;
}
long long int midisokay(long long int mid) {
for (long long int l = 1; l <= n - mid + 1; l++) {
if (check(l, l + mid - 1)) return l;
}
return 0;
}
void output(long long int l, long long int r) {
long long int logg = logarray[r - l + 1];
for (long long int i = 1; i <= m; i++)
cout << max(sparse[l][i][logg], sparse[r - (1 << logg) + 1][i][logg])
<< " ";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
fun();
cin >> n >> m >> k;
calclogarray();
for (long long int i = 1; i <= n; i++)
for (long long int j = 1; j <= m; j++) cin >> mat[i][j];
makesparse();
long long int ans[6];
long long int low = 1, high = n;
long long int maxrange = 0;
long long int ll;
while (low <= high) {
long long int mid = (low + high) / 2;
if (long long int l = midisokay(mid)) {
low = mid + 1;
if (maxrange < (mid)) maxrange = mid, ll = l;
} else
high = mid - 1;
}
if (maxrange == 0)
for (long long int i = 0; i < m; i++) cout << "0 ";
else
output(ll, maxrange + ll - 1);
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
if (x[0] >= 'a' && x[0] <= 'z') x[0] -= 32;
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool rmn(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool rmx(T& a, T b) {
return a < b ? (a = b, true) : false;
}
const long long INFLL = 0x7f7f7f7f7f7f7f7f, MOD = 1e9 + 7;
const long long INF = 0x7f7f7f7f;
vector<vector<long long>> adj;
vector<long long> vis, color;
long long dx8[] = {0, 1, 1, 1, 0, -1, -1, -1},
dy8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dx4[] = {0, 1, 0, -1},
dy4[] = {1, 0, -1, 0};
inline long long mexp(long long x, long long n, long long m = MOD) {
long long res = 1;
x %= m;
while (n) {
if (n & 1) res = (res * x) % m;
n >>= 1;
x = (x * x) % m;
}
return res;
}
inline long long gcd(long long a, long long b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
while (a > 0 && b > 0) {
if (a > b)
a %= b;
else
b %= a;
}
return a + b;
}
template <long long MOD>
struct Modular {
long long value;
static const long long MOD_value = MOD;
Modular(long long v = 0) {
value = v % MOD;
if (value < 0) value += MOD;
}
Modular(long long a, long long b) : value(0) {
*this += a;
*this /= b;
}
Modular& operator+=(Modular const& b) {
value += b.value;
if (value >= MOD) value -= MOD;
return *this;
}
Modular& operator-=(Modular const& b) {
value -= b.value;
if (value < 0) value += MOD;
return *this;
}
Modular& operator*=(Modular const& b) {
value = (long long)value * b.value % MOD;
return *this;
}
friend Modular mexp(Modular a, long long e) {
Modular res = 1;
while (e) {
if (e & 1) res *= a;
a *= a;
e >>= 1;
}
return res;
}
friend Modular inverse(Modular a) { return mexp(a, MOD - 2); }
Modular& operator/=(Modular const& b) { return *this *= inverse(b); }
friend Modular operator+(Modular a, Modular const b) { return a += b; }
friend Modular operator-(Modular a, Modular const b) { return a -= b; }
friend Modular operator-(Modular const a) { return 0 - a; }
friend Modular operator*(Modular a, Modular const b) { return a *= b; }
friend Modular operator/(Modular a, Modular const b) { return a /= b; }
friend std::ostream& operator<<(std::ostream& os, Modular const& a) {
return os << a.value;
}
friend bool operator==(Modular const& a, Modular const& b) {
return a.value == b.value;
}
friend bool operator!=(Modular const& a, Modular const& b) {
return a.value != b.value;
}
};
vector<long long> val;
Modular<MOD> ans = 0;
void dfs(long long u, long long p, unordered_map<long long, long long> cur) {
unordered_map<long long, long long> nxt;
cur[0]++;
for (auto& [n, ct] : cur) {
long long g = gcd(val[u], n);
nxt[g] += ct;
ans += g * ct;
}
cur = nxt;
for (auto v : adj[u]) {
if (v == p) continue;
dfs(v, u, cur);
}
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cerr << fixed;
cout << setprecision(10);
cerr << setprecision(3);
mt19937 genr(chrono::high_resolution_clock::now().time_since_epoch().count());
long long n;
cin >> n;
val.resize(n);
for (long long i = 0; i < n; ++i) cin >> val[i];
adj.resize(n);
for (long long i = 0; i < n - 1; ++i) {
long long u, v;
cin >> u >> v;
--u, --v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
dfs(0, -1, {});
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
char g[N][N];
int id[N][N];
int cnt = 1;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int amt[N * N];
int sz[N * N];
int sum;
int n, k;
void dfs(int i, int j, int idx) {
if (g[i][j] == 'X' or id[i][j]) return;
id[i][j] = idx;
sz[idx]++;
for (int k = 0; k < 4; k++) dfs(i + dx[k], j + dy[k], idx);
}
void add(int c, int l, int r, bool row, bool in, bool rem = false) {
for (int i = l; i <= r; i++) {
int idx;
if (row)
idx = id[c][i];
else
idx = id[i][c];
if (idx == 0) {
if (in) sum = sum + !rem - rem;
} else {
amt[idx] = amt[idx] + !rem - rem;
if (amt[idx] == 1 and !rem) sum += sz[idx];
if (amt[idx] == 0 and rem) sum -= sz[idx];
}
}
}
void addEnv(int i, int j, bool rem = false) {
add(i - 1, j, j + k - 1, true, false, rem);
add(i + k, j, j + k - 1, true, false, rem);
add(j - 1, i, i + k - 1, false, false, rem);
add(j + k, i, i + k - 1, false, false, rem);
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> g[i][j];
for (int i = 0; i <= n + 1; i++)
g[i][0] = 'X', g[i][n + 1] = 'X', g[0][i] = 'X', g[n + 1][i] = 'X';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (!id[i][j] and g[i][j] != 'X') dfs(i, j, cnt++);
add(0, 1, k, true, false, false);
add(k + 1, 1, k, true, false, false);
add(0, 1, k, false, false, false);
add(k + 1, 1, k, false, false, false);
for (int i = 1; i <= k; i++) add(i, 1, k, true, true, false);
int ans = sum;
int dir = 1;
for (int i = 1; i <= n - k + 1;) {
int lim = n - k + 1, bg = 1;
int j;
if (dir == -1) swap(lim, bg);
for (j = bg; j != lim;) {
addEnv(i, j, true);
if (dir == 1)
add(j, i, i + k - 1, false, true, true),
add(j + k, i, i + k - 1, false, true, false);
else
add(j + k - 1, i, i + k - 1, false, true, true),
add(j - 1, i, i + k - 1, false, true, false);
j += dir;
addEnv(i, j, false);
ans = max(ans, sum);
}
if (i == n - k + 1) break;
addEnv(i, j, true);
add(i, j, j + k - 1, true, true, true),
add(i + k, j, j + k - 1, true, true, false);
i++;
dir = -dir;
addEnv(i, j, false);
ans = max(ans, sum);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q,h,s,d,n,x,y,ans;
cin>>q>>h>>s>>d>>n;
x=min(8*q,min(4*h,min(2*s,d)));
y=min(4*q,min(2*h,s));
ans=(n/2)*x+(n%2)*y;
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 10;
const int MOD = 1e9 + 7;
int c[MAXN * 32][MAXN];
map<int, int> p;
int main() {
int n, a;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
for (int j = 2; j * j <= a; ++j) {
while (a % j == 0) {
++p[j];
a /= j;
}
}
if (a > 1) {
++p[a];
}
}
for (int i = 0; i < n * 32; ++i) {
c[i][0] = 1;
}
for (int i = 1; i < n * 32; ++i) {
for (int j = 1; j < n; ++j) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
}
long long ans = 1;
for (auto it : p) {
ans = (ans * c[it.second + n - 1][n - 1]) % MOD;
}
printf("%d\n", int(ans));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100005;
int n, m, q;
ll a[N], k[N], s[N];
int main() {
scanf("%d%d", &n, &q);
a[m = 1] = n;
for (ll x; q--;) {
scanf("%lld", &x);
while (m && a[m] >= x) --m;
a[++m] = x;
}
k[m] = 1;
for (int i = m; i; --i) {
ll now = a[i];
int pos = i;
for (;;) {
pos = upper_bound(a + 1, a + pos, now) - a - 1;
if (!pos) {
s[now] += k[i];
break;
}
k[pos] += now / a[pos] * k[i];
now %= a[pos];
}
}
for (int i = n; i; --i) s[i] += s[i + 1];
for (int i = 1; i <= n; ++i) printf("%lld\n", s[i]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < 1130; i++) cout << 4;
cout << 5 << endl;
for (int i = 0; i < 1130; i++) cout << 5;
cout << 5 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
set<unsigned long long> val[2];
unsigned long long n, m;
void sos(vector<unsigned long long>& arr, unsigned long long n,
unsigned long long idx, unsigned long long sum, unsigned long long t) {
if (idx == n) {
val[t].insert(sum);
return;
}
sos(arr, n, idx + 1, sum, t);
sos(arr, n, idx + 1, (sum + arr[idx]) % m, t);
}
int main() {
fast();
cin >> n >> m;
vector<unsigned long long> arr(n);
for (unsigned long long i = 0; i < n; i++) {
cin >> arr[i];
arr[i] %= m;
}
sos(arr, n / 2 + n % 2, 0, 0, 0);
sos(arr, n, n / 2 + n % 2, 0, 1);
unsigned long long ans = 0;
for (set<unsigned long long>::iterator itr = val[0].begin();
itr != val[0].end(); ++itr) {
unsigned long long ele = *itr;
set<unsigned long long>::iterator it = val[1].lower_bound(m - ele);
if (it == val[1].begin()) continue;
it--;
ans = max(ans, (ele + *it) % m);
}
cout << ans;
}
| 5 |
#include<cstdio>
#include<cstring>
#include<vector>
#define int long long
using namespace std;
vector<int>e[30];
int tree[1001000],n,R[200100],vis[200100],ans;
char S[200100];
void modify(int t,int l,int r,int pos){
if(l==r){
tree[t]++;
return;
}
int mid=(l+r)/2;
if(pos<=mid)modify(t*2,l,mid,pos);
else modify(t*2+1,mid+1,r,pos);
tree[t]=tree[t*2]+tree[t*2+1];
}
int query(int t,int l,int r,int L,int R){
if(L>r||l>R)return 0;
if(L<=l&&r<=R)return tree[t];
int mid=(l+r)/2;
return query(t*2,l,mid,L,R)+query(t*2+1,mid+1,r,L,R);
}
signed main(){
scanf("%s",S+1);
n=strlen(S+1);
for(int i=1;i<=n;i++)
e[S[i]-'a'].push_back(i);
int x=0;
for(int i=0;i<=25;i++){
if(e[i].size()&1)x++;
for(int j=0,k=e[i].size()-1;j<k;j++,k--)
R[e[i][j]]=e[i][k];
}
if(x>1)return puts("-1"),0;
for(int i=1;i<=n;i++){
int nxt=R[i];
if(vis[i])continue;
if(!nxt)continue;
ans+=i-1-query(1,1,n,1,i);
ans+=n-nxt-query(1,1,n,nxt,n);
modify(1,1,n,i);
modify(1,1,n,nxt);
vis[i]=vis[nxt]=1;
}
printf("%lld\n",ans);
} | 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 100010
int n,ans;
struct node
{
int x,id;
}a[MAXN];
bool cmp(node A,node B)
{
return A.x<B.x;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i].x);
a[i].id=i;
}
sort(a+1,a+1+n,cmp);
for(int i=1;i<=n;i++)
ans+=((a[i].id&1)!=(i&1));
printf("%d\n",ans/2);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
char S[110];
scanf("%s", S);
int len = strlen(S);
sort(S, S + len);
for (int i = 0; i < len - 1; i++) {
if (S[i + 1] - S[i] != 1) {
printf("NO\n");
return;
}
}
printf("YES\n");
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long m, n, k, t, a[200005];
vector<pair<long long, long long> > sp[200005];
bool safe(long long pos, long long minn) {
long long f = 1;
for (pair<long long, long long> p : sp[pos]) {
if (p.second > minn) f = 0;
}
return f;
}
bool cmp(pair<long long, long long> lp, pair<long long, long long> rp) {
if (lp.first != rp.first)
return lp.first < rp.first;
else
return lp.second > rp.second;
}
bool solve(long long idx) {
vector<pair<long long, long long> > v;
long long tim = n + 1;
for (int i = 1; i <= n; ++i) {
for (pair<long long, long long> p : sp[i]) {
long long f = 0;
if (p.second > a[idx]) {
f = 1;
v.push_back(make_pair(i, p.first));
}
}
}
if (v.empty()) return 1;
sort(v.begin(), v.end());
vector<pair<long long, long long> > temp;
temp.push_back(v[0]);
for (int i = 1; i < v.size(); ++i) {
pair<long long, long long> lst = temp.back();
if (v[i].first > lst.second)
temp.push_back(v[i]);
else if (v[i].second <= lst.second)
continue;
else {
temp.pop_back();
lst.second = v[i].second;
temp.push_back(lst);
}
}
for (pair<long long, long long> p : temp) tim += 2 * (p.second - p.first + 1);
return tim <= t;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> m >> n >> k >> t;
for (int i = 0; i < m; ++i) {
cin >> a[i];
}
sort(a, a + m, greater<long long>());
for (int i = 0; i < k; ++i) {
long long l, r, d;
cin >> l >> r >> d;
sp[l].push_back(make_pair(r, d));
}
long long low = 0, high = m - 1, ans = -1;
while (low <= high) {
long long mid = (low + high) / 2;
if (solve(mid)) {
ans = mid;
low = mid + 1;
} else
high = mid - 1;
}
cout << ans + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007, maxN = 2 * 100000;
int f[maxN + 1] = {1, 1};
int mod_pow(int a) {
int res = 1, n = M - 2;
a %= M;
while (n) {
if (n & 1) res = (long long)res * a % M;
a = (long long)a * a % M;
n >>= 1;
}
return res;
}
int c(int n, int k) {
int res = f[n];
res = (long long)res * mod_pow(f[k]) % M;
res = (long long)res * mod_pow(f[n - k]) % M;
return res;
}
int main() {
int n;
for (int i = (2); i <= (maxN); ++i) f[i] = (long long)i * f[i - 1] % M;
cin >> n;
printf("%lld\n", (2LL * c(2 * n - 1, n - 1) - n + M) % M);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
const int M = 1e3 + 9;
const int INFINT = 1e9 + 9;
const long long INFLL = 1e18 + 9;
const long long MOD = 10000000000007ll;
vector<int> gr[N];
int cnt[N];
int dfs(int v) {
cnt[v] = 0;
for (auto i : gr[v]) {
if (cnt[i] == -1) cnt[v] += dfs(i);
}
return cnt[v] + 1;
}
bool used[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < (int)n - 1; ++i) {
int first, second;
cin >> first >> second;
--first, --second;
gr[first].push_back(second);
gr[second].push_back(first);
}
for (int i = 0; i < (int)n; ++i) cnt[i] = -1;
dfs(0);
set<pair<int, pair<int, int>>> s;
s.insert({cnt[0], {0, 1}});
for (int i = 0; i < (int)n; ++i) used[i] = false;
long long ans = 0;
for (int w = 0; w < (int)n - k; ++w) {
pair<int, pair<int, int>> best = *s.rbegin();
ans += best.first;
int v = best.second.first;
used[v] = true;
s.erase(best);
for (auto i : gr[v]) {
if (!used[i])
s.insert({cnt[i] - best.second.second, {i, best.second.second + 1}});
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
struct pt {
int x, y;
pt(int _x = 0, int _y = 0) {
x = _x;
y = _y;
}
bool operator<(const pt &rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
pt operator+(const pt &a, const pt &b) { return (pt){a.x + b.x, a.y + b.y}; }
pt operator-(const pt &a, const pt &b) { return (pt){a.x - b.x, a.y - b.y}; }
bool operator==(const pt &a, const pt &b) {
return !(a.x - b.x) && !(a.y - b.y);
}
bool operator!=(const pt &a, const pt &b) { return !(a == b); }
int dot(const pt &a, const pt &b) { return a.x * b.x + a.y * b.y; }
int cross(const pt &a, const pt &b) { return a.x * b.y - a.y * b.x; }
int cross(const pt &a, const pt &b, const pt &c) { return cross(b - a, c - a); }
int dis2(const pt &a, const pt &b) { return dot(a - b, a - b); }
int dis2(const pt &a) { return dis2(pt(0, 0), a); }
pt st[maxn];
void convex_hull(vector<pt> &v, vector<pt> &p) {
p.clear();
sort(v.begin(), v.end());
int n = v.size();
int sz = 0;
for (int i = 0; i < n; i++) {
while (sz >= 2 && cross(st[sz - 2], st[sz - 1], v[i]) <= 0) sz--;
st[sz++] = v[i];
}
for (int i = 0; i < sz; i++) p.push_back(st[i]);
sz = 0;
for (int i = 0; i < n; i++) {
while (sz >= 2 && cross(st[sz - 2], st[sz - 1], v[i]) >= 0) sz--;
st[sz++] = v[i];
}
for (int i = sz - 1; i >= 0; i--) {
if (i == sz - 1 && st[i] == p.back()) continue;
if (i == 0 && st[i] == p[0]) continue;
p.push_back(st[i]);
}
}
vector<pt> p, q;
int len2[50];
pt ans[8], now[8], pts;
int n, ansval, sqs;
void dfs(int x, int las) {
if (las == 0) {
int val = n * sqs - dis2(pts);
if (val > ansval) {
ansval = val;
for (int i = 0; i < n; i++) ans[i] = now[i];
}
return;
}
for (int i = x; i < q.size(); i++) {
pts = pts + q[i];
sqs += len2[i];
now[las - 1] = q[i];
dfs(i, las - 1);
pts = pts - q[i];
sqs -= len2[i];
}
}
int main() {
int r;
scanf("%d%d", &n, &r);
for (int i = -r; i <= r; i++)
for (int j = -r; j <= r; j++)
if (i * i + j * j <= r * r) p.push_back(pt(i, j));
convex_hull(p, q);
for (int i = 0; i < q.size(); i++) len2[i] = dis2(q[i]);
dfs(0, n);
printf("%d\n", ansval);
for (int i = 0; i < n; i++) printf("%d %d\n", ans[i].x, ans[i].y);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace DynamicTree {
unsigned int randxor() {
static unsigned int x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned int t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
struct D_NODE {
int lazy_for_dep;
int dep;
D_NODE *pr;
D_NODE *pair_of_end;
int __PRIORITY;
int size;
long long int lazy_for_dist;
long long int dist;
long long int have_dist;
D_NODE *lef;
D_NODE *rig;
int idx;
int MINT_DEP;
D_NODE *MINT;
int MAXT_DEP;
D_NODE *MAXT;
bool start_flag;
int NUMBER_OF_START_FLAG;
D_NODE() {
NUMBER_OF_START_FLAG;
start_flag = false;
lazy_for_dep = 0;
dep = 0;
lazy_for_dist = 0;
dist = 0;
lef = rig = NULL;
__PRIORITY = randxor();
pair_of_end = NULL;
MINT = NULL;
MINT_DEP = INT_MAX;
MAXT = NULL;
MAXT_DEP = INT_MIN;
pr = NULL;
size = 1;
}
};
const int MEMORY_SIZE = 2000000;
D_NODE dymmy[MEMORY_SIZE];
int ord = 0;
D_NODE *neww() {
if (ord < MEMORY_SIZE) {
ord++;
return &dymmy[ord - 1];
}
return new D_NODE();
}
const int VECTOR_SIZE = 1000000;
D_NODE *VEC[VECTOR_SIZE];
int VECTOR_CUR_INDEX = 0;
int get_size(D_NODE *b) {
if (b == NULL) {
return 0;
}
return b->size;
}
void update(D_NODE *B) {
if (B == NULL) {
return;
}
if (B->lazy_for_dep) {
B->dep += B->lazy_for_dep;
if (B->lef) {
B->lef->lazy_for_dep += B->lazy_for_dep;
}
if (B->rig) {
B->rig->lazy_for_dep += B->lazy_for_dep;
}
B->lazy_for_dep = 0;
}
if (B->lazy_for_dist) {
B->dist += B->lazy_for_dist;
if (B->lef) {
B->lef->lazy_for_dist += B->lazy_for_dist;
}
if (B->rig) {
B->rig->lazy_for_dist += B->lazy_for_dist;
}
B->lazy_for_dist = 0;
}
B->size = 1 + get_size(B->lef) + get_size(B->rig);
if (B->lef) {
B->lef->pr = B;
}
if (B->rig) {
B->rig->pr = B;
}
B->MINT = B;
B->MINT_DEP = B->dep;
if (B->lef && B->MINT_DEP > B->lef->MINT_DEP + B->lef->lazy_for_dep) {
B->MINT_DEP = B->lef->MINT_DEP + B->lef->lazy_for_dep;
B->MINT = B->lef->MINT;
}
if (B->rig && B->MINT_DEP > B->rig->MINT_DEP + B->rig->lazy_for_dep) {
B->MINT_DEP = B->rig->MINT_DEP + B->rig->lazy_for_dep;
B->MINT = B->rig->MINT;
}
B->MAXT = B;
B->MAXT_DEP = B->dep;
if (B->lef && B->MAXT_DEP < B->lef->MAXT_DEP + B->lef->lazy_for_dep) {
B->MAXT_DEP = B->lef->MAXT_DEP + B->lef->lazy_for_dep;
B->MAXT = B->lef->MAXT;
}
if (B->rig && B->MAXT_DEP < B->rig->MAXT_DEP + B->rig->lazy_for_dep) {
B->MAXT_DEP = B->rig->MAXT_DEP + B->rig->lazy_for_dep;
B->MAXT = B->rig->MAXT;
}
B->NUMBER_OF_START_FLAG = B->start_flag;
if (B->lef) {
B->NUMBER_OF_START_FLAG += B->lef->NUMBER_OF_START_FLAG;
}
if (B->rig) {
B->NUMBER_OF_START_FLAG += B->rig->NUMBER_OF_START_FLAG;
}
}
inline void all_update(D_NODE *f, bool B = false) {
update(f);
if (f->lef) {
all_update(f->lef, true);
}
if (f->rig) {
all_update(f->rig, true);
}
update(f);
}
inline void see(D_NODE *f, bool B = false) {
if (f->lef) {
see(f->lef, true);
}
cout << f->idx << " ";
if (f->rig) {
see(f->rig, true);
}
if (B == false) {
puts("");
}
}
D_NODE *find_root(D_NODE *a) {
while (a->pr != NULL) {
update(a);
a = a->pr;
}
return a;
}
void path_update(D_NODE *a, bool dep_only = false) {
VECTOR_CUR_INDEX = 0;
while (a != NULL) {
VEC[VECTOR_CUR_INDEX] = a;
VECTOR_CUR_INDEX++;
a = a->pr;
}
int k = VECTOR_CUR_INDEX - 1;
if (dep_only == false) {
for (int i = k; i >= 0; i--) {
update(VEC[i]);
}
}
for (int i = 0; i <= k; i++) {
update(VEC[i]);
}
}
inline D_NODE *merge(D_NODE *a, D_NODE *b) {
if (a != NULL) update(a);
if (b != NULL) update(b);
if (a == NULL) {
path_update(b);
return b;
}
if (b == NULL) {
path_update(a);
return a;
}
if (a->__PRIORITY > b->__PRIORITY) {
a->rig = merge(a->rig, b);
update(a);
return a;
} else {
b->lef = merge(a, b->lef);
update(b);
return b;
}
}
int calc_left_size(D_NODE *a) {
if (a == NULL) {
return 0;
}
path_update(a);
int sum = 1 + get_size(a->lef);
D_NODE *pre = a;
a = a->pr;
while (a != NULL) {
if (a->rig == pre) {
sum++;
sum += get_size(a->lef);
}
pre = a;
a = a->pr;
}
return sum;
}
inline void split_base_cnt(D_NODE *b, D_NODE *&l, D_NODE *&r, int x) {
if (b == NULL) {
D_NODE *L = NULL;
if (l) L = l->pr;
D_NODE *R = NULL;
if (r) R = r->pr;
l = r = NULL;
return;
}
update(b);
int __get_size = get_size(b->lef);
if (__get_size >= x) {
r = b;
update(b->lef);
split_base_cnt(b->lef, l, b->lef, x);
return;
}
if (__get_size + 1 == x) {
l = b;
r = b->rig;
l->rig = NULL;
path_update(l);
return;
}
l = b;
update(b->rig);
split_base_cnt(b->rig, b->rig, r, x - 1 - __get_size);
}
D_NODE *cut(D_NODE *&tree, D_NODE *root_of_new_subtree) {
if (root_of_new_subtree == NULL) {
cout << "error cut" << endl;
exit(0);
return NULL;
}
D_NODE *star = root_of_new_subtree;
D_NODE *en = root_of_new_subtree->pair_of_end;
int __LEFT_SIZE = calc_left_size(star);
int cur_dep = root_of_new_subtree->dep;
long long int cur_dist = root_of_new_subtree->dist;
D_NODE *l1 = NULL;
D_NODE *l2 = NULL;
D_NODE *l3 = NULL;
split_base_cnt(tree, l1, l2, __LEFT_SIZE - 1);
if (l1) {
l1->pr = NULL;
}
if (l2) {
l2->pr = NULL;
}
if (tree) {
tree->pr = NULL;
}
int __RIGHT_SIZE = calc_left_size(en);
split_base_cnt(l2, l2, l3, __RIGHT_SIZE);
if (l2) {
l2->pr = NULL;
}
if (l3) {
l3->pr = NULL;
}
tree = merge(l1, l3);
if (tree) tree->pr = NULL;
if (l2) l2->pr = NULL;
if (l2) l2->lazy_for_dep += -cur_dep;
if (l2) l2->lazy_for_dist += -cur_dist;
update(l2);
return l2;
}
void add_distance(D_NODE *&tree, D_NODE *ap, long long int add) {
path_update(ap);
ap->have_dist += add;
D_NODE *star = ap;
D_NODE *en = star->pair_of_end;
int __LEFT_SIZE = calc_left_size(star);
D_NODE *l1;
D_NODE *l2;
D_NODE *l3;
split_base_cnt(tree, l1, l2, __LEFT_SIZE - 1);
int __RIGHT_SIZE = calc_left_size(en);
split_base_cnt(tree, l2, l3, __RIGHT_SIZE);
l2->lazy_for_dist += add;
update(l2);
tree = merge(l1, l2);
tree = merge(tree, l3);
tree->pr = NULL;
return;
}
void link(D_NODE *&tree, D_NODE *nex_parent, D_NODE *linked,
long long int subtree_add_dist = 1) {
if (linked == NULL) {
return;
}
path_update(nex_parent);
path_update(nex_parent->pair_of_end);
D_NODE *ne = neww();
(*ne) = (*nex_parent->pair_of_end);
ne->pr = NULL;
ne->lef = ne->rig = NULL;
ne->size = 1;
ne->MINT_DEP = ne->MAXT_DEP = ne->dep;
ne->MINT = ne->MAXT = ne;
update(ne);
update(linked);
linked->lazy_for_dist += nex_parent->dist + subtree_add_dist;
linked->lazy_for_dep += nex_parent->dep + 1;
update(linked);
linked = merge(ne, linked);
linked->pr = NULL;
int LEFT_SIZE = calc_left_size(nex_parent->pair_of_end);
LEFT_SIZE--;
D_NODE *l1 = NULL;
D_NODE *l2 = NULL;
split_base_cnt(tree, l1, l2, LEFT_SIZE);
if (l1) l1->pr = NULL;
if (l2) l2->pr = NULL;
tree = merge(l1, linked);
if (tree) {
tree->pr = NULL;
}
D_NODE *cp_ = tree;
tree = merge(tree, l2);
tree->pr = NULL;
}
D_NODE *LCA(D_NODE *&tree, D_NODE *a, D_NODE *b) {
if (a == b) return a;
tree->pr = NULL;
int lef1 = calc_left_size(a);
int rig1 = calc_left_size(a->pair_of_end);
int lef2 = calc_left_size(b);
int rig2 = calc_left_size(b->pair_of_end);
if (lef1 <= lef2 && rig2 <= rig1) {
return a;
}
if (lef2 <= lef1 && lef1 <= rig2) {
return b;
}
int mint = lef1;
if (lef1 > lef2) {
mint = lef2;
}
int maxt = rig1;
if (rig1 < rig2) {
maxt = rig2;
}
D_NODE *L1;
D_NODE *L2;
D_NODE *L3;
D_NODE *ANS;
split_base_cnt(tree, L1, L2, mint - 1);
split_base_cnt(L2, L2, L3, maxt - mint + 1);
if (L1) {
L1->pr = NULL;
}
if (L2) {
L2->pr = NULL;
}
if (L3) {
L3->pr = NULL;
}
ANS = L2->MINT;
tree = merge(L1, L2);
tree = merge(tree, L3);
if (tree) tree->pr = NULL;
return ANS;
}
long long int distance(D_NODE *&tree, D_NODE *a, D_NODE *b) {
if (a == b) {
return 0;
}
tree->pr = NULL;
D_NODE *LC = LCA(tree, a, b);
path_update(LC);
long long int ans = a->dist + b->dist - 2LL * LC->dist;
return ans;
}
void push_back(D_NODE *&tree, D_NODE *a) {
tree = merge(tree, a);
tree->pr = NULL;
}
D_NODE *go_up(D_NODE *tree, D_NODE *from, int x) {
if (x == 0) {
return from;
}
path_update(from);
int want_dep = from->dep - x;
update(from);
update(from->lef);
if (from->lef && from->lef->MINT_DEP <= want_dep &&
want_dep <= from->lef->MAXT_DEP) {
from = from->lef;
while (1) {
update(from);
update(from->rig);
if (from->rig && from->rig->MINT_DEP <= want_dep &&
from->rig->MAXT_DEP >= want_dep) {
from = from->rig;
continue;
}
if (from->dep == want_dep) {
return from;
}
from = from->lef;
continue;
}
}
D_NODE *pre = from;
from = from->pr;
while (1) {
update(from);
update(from->lef);
if (from->lef == pre) {
pre = from;
from = from->pr;
continue;
}
if (from->dep == want_dep) {
return from;
}
if (from->lef && from->lef->MINT_DEP <= want_dep &&
want_dep <= from->lef->MAXT_DEP) {
from = from->lef;
while (1) {
update(from);
update(from->rig);
if (from->rig && from->rig->MINT_DEP <= want_dep &&
from->rig->MAXT_DEP >= want_dep) {
from = from->rig;
continue;
}
if (from->dep == want_dep) {
return from;
}
from = from->lef;
continue;
}
} else {
pre = from;
from = from->pr;
}
}
}
D_NODE *Find_least_vertex(D_NODE *tree, int k) {
D_NODE *a = tree;
update(a);
while (1) {
update(a);
if (a->rig) {
update(a->rig);
if (a->rig->MAXT_DEP >= k && a->rig->MINT_DEP <= k) {
a = a->rig;
continue;
}
}
if (a->dep == k) {
return a;
}
a = a->lef;
}
return a;
}
vector<int> v[100002];
int dep[100002];
int star[100002];
int en[100002];
vector<int> vv;
int siz = 0;
D_NODE *linkk[100002];
inline void dfs(int b, int h = 0, int p = -1) {
dep[b] = h;
star[b] = siz;
siz++;
vv.push_back(b);
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] == p) {
continue;
}
dfs(v[b][i], h + 1, b);
en[b] = siz;
siz++;
vv.push_back(b);
}
if (siz - 1 == star[b]) {
vv.push_back(b);
en[b] = siz;
siz++;
}
}
void make(D_NODE *&root) {
dfs(0);
for (int i = 0; i < vv.size(); i++) {
DynamicTree::D_NODE *add = DynamicTree::neww();
add->dep = dep[vv[i]];
add->idx = vv[i];
add->MINT = add;
add->MINT_DEP = dep[vv[i]];
add->MAXT_DEP = dep[vv[i]];
add->MAXT = add;
add->dist = dep[vv[i]];
add->have_dist = 1;
add->size = 1;
if (star[vv[i]] == i) {
add->start_flag = true;
add->NUMBER_OF_START_FLAG = 1;
linkk[vv[i]] = add;
push_back(root, add);
} else {
linkk[vv[i]]->pair_of_end = add;
push_back(root, add);
}
}
}
} // namespace DynamicTree
DynamicTree::D_NODE *root;
int n;
int m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int a;
scanf("%d", &a);
a--;
DynamicTree::v[i].push_back(a);
}
}
DynamicTree::make(root);
int cc = 0;
while (m--) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
cc++;
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
printf("%lld\n", DynamicTree::distance(root, DynamicTree::linkk[a],
DynamicTree::linkk[b]));
continue;
}
if (ty == 2) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b = DynamicTree::go_up(root, DynamicTree::linkk[a], b)->idx;
DynamicTree::D_NODE *nw = DynamicTree::cut(root, DynamicTree::linkk[a]);
DynamicTree::link(root, DynamicTree::linkk[b], nw);
continue;
}
int k;
scanf("%d", &k);
cc++;
DynamicTree::D_NODE *ans = DynamicTree::Find_least_vertex(root, k);
printf("%d\n", ans->idx + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long d[100010];
vector<int> e[100010], ec[100010];
int u[300010], v[300010], w[300010], qu[300010], qv[300010], qk[300010],
be[100010];
long long ans[300010];
int par[100010];
int find(int x) { return par[x] == x ? x : (par[x] = find(par[x])); }
const int C = 340;
vector<int> qd[C];
int main() {
int n, m, k, q;
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
--u[i];
--v[i];
e[u[i]].push_back(v[i]);
ec[u[i]].push_back(w[i]);
e[v[i]].push_back(u[i]);
ec[v[i]].push_back(w[i]);
}
for (int i = 0; i < q; i++) {
scanf("%d%d", &qu[i], &qv[i]);
--qu[i], --qv[i];
}
for (int i = 0; i < n; i++) {
d[i] = 1ll << 60;
}
priority_queue<pair<long long, int> > qq;
for (int i = 0; i < k; i++) {
d[i] = 0;
be[i] = i;
par[i] = i;
qq.push(make_pair(0, i));
}
vector<pair<long long, pair<int, int> > > fvv;
while (qq.size()) {
long long co = -qq.top().first;
int tv = qq.top().second;
qq.pop();
if (d[tv] != co) continue;
for (int i = 0; i < e[tv].size(); i++) {
int to = e[tv][i];
if (d[to] > co + ec[tv][i]) {
d[to] = co + ec[tv][i];
be[to] = be[tv];
qq.push(make_pair(-co - ec[tv][i], to));
}
}
}
for (int i = 0; i < m; i++) {
if (be[u[i]] != be[v[i]]) {
fvv.push_back(pair<long long, pair<int, int> >(
d[u[i]] + d[v[i]] + w[i], make_pair(be[u[i]], be[v[i]])));
}
}
sort(fvv.begin(), fvv.end());
vector<long long> f;
vector<vector<pair<int, int> > > fv;
for (int i = 0; i < fvv.size(); i++) {
if (!f.size() || f.back() != fvv[i].first) {
if (fv.size() && !fv.back().size()) {
f.pop_back();
fv.pop_back();
}
f.push_back(fvv[i].first);
fv.push_back(vector<pair<int, int> >());
}
int su = find(fvv[i].second.first), sv = find(fvv[i].second.second);
if (su == sv) continue;
fv.back().push_back(fvv[i].second);
par[su] = sv;
}
for (int i = 0; i < k; i++) {
par[i] = i;
}
int la = 0;
for (int i = 0; i <= f.size(); i++) {
if (i && i % C == 0) {
for (int j = 0; j < q; j++) {
if (qk[j]) continue;
if (find(qu[j]) == find(qv[j])) {
qd[i / C - 1].push_back(j);
qk[j] = 1;
}
}
la = i / C;
}
if (i == f.size()) continue;
for (int j = 0; j < fv[i].size(); j++) {
int tu = fv[i][j].first, tv = fv[i][j].second;
tu = find(tu);
tv = find(tv);
par[tu] = tv;
}
}
for (int i = 0; i < q; i++) {
if (!qk[i]) qd[la].push_back(i);
}
for (int i = 0; i < k; i++) {
par[i] = i;
}
for (int i = 0; i < f.size(); i++) {
for (int j = 0; j < fv[i].size(); j++) {
int tu = fv[i][j].first, tv = fv[i][j].second;
tu = find(tu);
tv = find(tv);
par[tu] = tv;
}
for (int j = 0; j < qd[i / C].size(); j++) {
int z = qd[i / C][j];
if (ans[z]) continue;
if (find(qu[z]) == find(qv[z])) {
ans[z] = f[i];
}
}
}
for (int i = 0; i < q; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, max = -1, n, b, price;
int a[2222];
cin >> n >> b;
for (i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << b;
return 0;
}
for (i = 0; i < n - 1; i++)
for (j = i; j < n; j++) {
price = b + (b / a[i]) * (a[j] - a[i]);
if (price > max) max = price;
}
cout << max;
return 0;
}
| 2 |
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 2e5 + 10;
struct Sec{
int l, r;
void read() {
scanf("%d%d", &l, &r);
}
bool operator < (const Sec &A) const {
return l == A.l ? r < A.r : l < A.l;
}
Sec operator + (const Sec &A) const {
return (Sec) { max(l, A.l), min(r, A.r) };
}
}da[maxn], presec[maxn], sufsec[maxn];
int n;
int len(Sec s) {
return max(0, s.r - s.l + 1);
}
int main()
{
int ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
da[i].read();
ans = max(ans, da[i].r - da[i].l + 1);
}
sort(da + 1, da + n + 1);
presec[0] = (Sec) { -(1 << 30), (1 << 30) };
sufsec[n + 1] = (Sec) { -(1 << 30), (1 << 30) };
for (int i = 1; i <= n; ++i)
presec[i] = presec[i - 1] + da[i];
for (int i = n; i; --i)
sufsec[i] = sufsec[i + 1] + da[i];
for (int i = 1; i <= n; ++i)
ans = max(ans, len(presec[i - 1]) + len(sufsec[i]));
for (int i = 1; i <= n; ++i)
ans = max(ans, len(presec[i - 1] + sufsec[i + 1]) + len(da[i]));
printf("%d\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define range(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) range(i,0,n)
#define clr(a,b) memset((a), (b) ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF =1LL << 62;
const int inf =1 << 29;
pii pos[26][2];
int num[26];
string in[510];
int main(void){
int m,n;
cin >> m >> n;
rep(i,m) cin >> in[i];
rep(i,m)rep(j,n){
if(in[i][j]=='.')
continue;
int cur=in[i][j]-'A';
pos[cur][num[cur]].first=i;
pos[cur][num[cur]++].second=j;
}
int ans=0;
rep(loop,26*26)rep(i,26) if(num[i]==2){
bool ok=false;
if(pos[i][0].first==pos[i][1].first){
ok=(pos[i][0].second+1!=pos[i][1].second);
for(int j=pos[i][0].second+1;j<pos[i][1].second;++j)
if(in[pos[i][0].first][j]!='.')
ok=false;
}else if(pos[i][0].second==pos[i][1].second){
ok=(pos[i][0].first+1!=pos[i][1].first);
for(int j=pos[i][0].first+1;j<pos[i][1].first;++j)
if(in[j][pos[i][0].second]!='.')
ok=false;
}else{
if(in[pos[i][1].first][pos[i][0].second]=='.'){
ok=true;
for(int j=min(pos[i][0].first,pos[i][1].first)+1;j<max(pos[i][0].first,pos[i][1].first);++j)
if(in[j][pos[i][0].second]!='.')
ok=false;
for(int j=min(pos[i][0].second,pos[i][1].second)+1;j<max(pos[i][0].second,pos[i][1].second);++j)
if(in[pos[i][1].first][j]!='.')
ok=false;
}
if(!ok&&in[pos[i][0].first][pos[i][1].second]=='.'){
ok=true;
for(int j=min(pos[i][0].first,pos[i][1].first)+1;j<max(pos[i][0].first,pos[i][1].first);++j)
if(in[j][pos[i][1].second]!='.')
ok=false;
for(int j=min(pos[i][0].second,pos[i][1].second)+1;j<max(pos[i][0].second,pos[i][1].second);++j)
if(in[pos[i][0].first][j]!='.')
ok=false;
}
}
if(ok){
in[pos[i][0].first][pos[i][0].second]='.';
in[pos[i][1].first][pos[i][1].second]='.';
ans+=2,num[i]=0;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, a = 0;
string s;
scanf("%d", &n);
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'x') {
a++;
if (a > 2) ans++;
} else
a = 0;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (cin >> n >> k) {
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(((v).rbegin()), ((v).rend()));
int j = 0, ans = 0;
while (j < n) ans += (v[j] * 2 - 2), j += k;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
int a[MAX];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
long long ans = 0, ans2 = 0;
for (int i = 1; i < n; ++i) {
if (a[i] + a[i - 1] < k) {
int dif = k - (a[i] + a[i - 1]);
ans += dif;
a[i] += dif;
}
}
printf("%lld\n", ans);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
}
| 2 |
#include <iostream>
#include <cstring>
using namespace std;
int n,m,x,y,f[210000],cnt[210000];
int find(int k)
{
if(f[k]==k)return k;
return f[k]=find(f[k]);
}
int main(void)
{
cin>>n>>m;
for(int i=1;i<=n;i++)f[i]=i;
for(int i=1;i<=m;i++)
{
cin>>x>>y;
f[find(x)]=find(y);
}
int ans=0;
for(int i=1;i<=n;i++)
{
int fi=find(i);
cnt[fi]++;
ans=max(cnt[fi],ans);
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long n = (long long)s.length();
stack<char> A;
if (n % 2 == 1) {
cout << "No\n";
return 0;
}
for (int i = 0; i < n; i++) {
if (A.empty())
A.push(s[i]);
else if (A.top() == s[i])
A.pop();
else
A.push(s[i]);
}
if (A.empty())
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
| 2 |
#include <cstdio>
#include <algorithm>
int main() {
int tc; scanf("%d", &tc);
for(int tci = 0; tci < tc; tci++) {
int n,k; scanf("%d%d", &n, &k);
int *a = new int[n];
for(int i = 0; i < n; i++) scanf("%d", a+i);
for(int i = 0; i < n-1; i++) a[i] = a[i+1] - a[i];
std::sort(a,a+n-1);
int s = 0;
for(int i = 0; i < n-k; i++) s += a[i];
printf("%d\n", s);
delete[] a;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1020;
int n, m;
int vis[MAXN][MAXN], g[MAXN][MAXN], ans;
char s[MAXN];
struct A {
int x, y, z;
} Ans[MAXN * MAXN];
vector<int> vx, vy;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
for (int j = 0; j <= m - 1; j++) {
if (s[j] == '.')
g[i][j + 1] = 0;
else
g[i][j + 1] = 1;
if (g[i][j + 1] == 1) {
vx.push_back(i);
vy.push_back(j + 1);
}
}
}
if (g[1][1] || g[1][m] || g[n][1] || g[n][m]) {
printf("-1");
return 0;
}
for (int i = 0; i < vx.size(); i++) {
int x = vx[i], y = vy[i];
bool flag = 0;
int now = 0;
for (int j = 1; j <= min(n, m); j++) {
if (x - j <= 0 || y - j <= 0 || x + j > n || y + j > m) break;
for (int k = 1; k <= j; k++) {
if (g[x + k][y] + g[x - k][y] + g[x][y + k] + g[x][y - k] != 4) {
flag = 1;
break;
}
}
if (!flag) now = j;
if (flag) break;
}
int j = now;
if (!j) continue;
vis[x][y] = 1;
for (int k = 1; k <= j; k++) {
vis[x + k][y] = 1, vis[x - k][y] = 1;
vis[x][y + k] = 1, vis[x][y - k] = 1;
}
Ans[++ans].x = x, Ans[ans].y = y, Ans[ans].z = j;
}
for (int i = 0; i < vx.size(); i++) {
int x = vx[i], y = vy[i];
if (!vis[x][y]) {
printf("-1");
return 0;
}
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) {
printf("%d %d %d\n", Ans[i].x, Ans[i].y, Ans[i].z);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long MOD = 1000000007;
int n, m;
int sumv, sume;
vector<pair<int, int> > e[555];
int value[555];
int sum[555];
vector<pair<pair<int, int>, int> > g;
bool used[555];
bool cmp(const pair<pair<int, int>, int>& a,
const pair<pair<int, int>, int>& b) {
if (a.first.first * b.first.second > a.first.second * b.first.first)
return true;
else if (a.first.first * b.first.second == a.first.second * b.first.first &&
a.first.first > b.first.first)
return true;
else
return false;
}
int main() {
int i, j, x, y, z;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) {
e[i].clear();
}
for (i = 1; i <= n; i++) {
scanf("%d", &x);
value[i] = x;
}
double ans = 0;
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
e[x].push_back(make_pair(y, z));
e[y].push_back(make_pair(x, z));
ans = max(ans, 1.0 * (value[x] + value[y]) / z);
}
printf("%.10f\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 3;
const int K = 20;
const int inf = (int)1e9 + 7;
const double eps = 1e-10;
struct lem {
int m, v, n;
lem() {}
lem(int m, int v, int n) : m(m), v(v), n(n) {}
bool operator<(const lem& a) const {
if (m == a.m) {
return v < a.v;
} else {
return m < a.m;
}
}
};
int n, k, h;
int ans[N];
lem a[N];
bool check(double x) {
int s = 1;
for (int i = 0; i < n; ++i) {
if (x * a[i].v >= (double)s * h) {
ans[s++ - 1] = a[i].n;
}
}
return (s > k);
}
int main() {
scanf("%d%d%d", &n, &k, &h);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].m);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].v);
a[i].n = i + 1;
}
sort(a, a + n);
double l = 0, r = (double)h * k, m;
for (int q = 0; q < 100; ++q) {
if (check(m = (l + r) / 2)) {
r = m;
} else {
l = m;
}
}
check(r);
for (int i = 0; i < k; ++i) {
printf("%d ", ans[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1234567890;
const int linf = 1234567890987654321;
const long double eps = 1e-9;
int main() {
int n;
int t;
cin >> n >> t;
t *= 2;
vector<pair<int, int> > coords;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
a *= 2;
coords.push_back(make_pair(a - b, a + b));
}
sort(coords.begin(), coords.end());
int ans = 2;
for (int i = 1; i < coords.size(); i++) {
int a = coords[i - 1].second;
int b = coords[i].first;
if (b - a == t) ans++;
if (b - a > t) ans += 2;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
struct num {
int cost, idx;
};
vector<num> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i].cost;
v[i].idx = i + 1;
}
sort(v.rbegin(), v.rend(), [&](const num &lhs, const num &rhs) {
if (lhs.cost == rhs.cost) {
return lhs.idx < rhs.idx;
}
return lhs.cost < rhs.cost;
});
set<int> unused;
for (int i = 1; i <= n; ++i) {
unused.insert(i + k);
}
long long ans = 0;
vector<int> ans_(v.size(), 0);
for (int i = 0; i < v.size(); ++i) {
if (unused.count(v[i].idx) == 1) {
unused.erase(v[i].idx);
ans_[v[i].idx - 1] = v[i].idx;
} else {
long long cur = *(unused.upper_bound(v[i].idx));
ans += (cur - v[i].idx) * v[i].cost;
ans_[v[i].idx - 1] = cur;
unused.erase(cur);
}
}
cout << ans << "\n";
for (int i = 0; i < ans_.size(); ++i) {
cout << ans_[i] << ' ';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cnt[27];
int main() {
int n;
scanf("%d", &n);
getchar();
for (int i = 0; i < n; i++) {
char ch = getchar();
cnt[ch - 'a']++;
}
int cntsingle = 0;
int cntdouble = 0;
for (int i = 0; i < 26; i++) {
if (!cnt[i]) continue;
if (cnt[i] == 1)
cntsingle++;
else
cntdouble++;
}
if (n == 1)
printf("Yes\n");
else if (cntsingle > 0 && cntdouble == 0)
printf("No\n");
else
printf("Yes\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, i, A[310], B[310], j;
vector<int> SOL;
int main() {
cin >> N;
for (i = 1; i <= N; i++) cin >> A[i];
for (i = 1; i <= N; i++) cin >> B[i];
for (i = 1; i <= N; i++) {
if (A[i] == B[i]) continue;
for (j = i + 1; j <= N; j++)
if (B[j] == A[i]) break;
for (j = j - 1; j >= i; j--) {
SOL.push_back(j);
swap(B[j], B[j + 1]);
}
}
cout << SOL.size() << "\n";
for (i = 0; i < SOL.size(); i++) cout << SOL[i] << " " << SOL[i] + 1 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double l, d, v1, v2;
int main() {
cin >> d >> l >> v1 >> v2;
cout << setprecision(20) << fixed << (double)(l - d) / (v1 + v2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, cost;
cin >> n >> cost;
long long a[n + 1], b[n + 1];
for (int i = 1; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) cin >> b[i];
long long dp[4][n + 1];
memset(dp, 0, sizeof(dp));
dp[0][1] = a[1];
dp[1][1] = cost + b[1];
dp[2][1] = -1;
dp[3][1] = -1;
dp[0][2] = dp[0][1] + a[2];
dp[1][2] = dp[0][1] + cost + b[2];
dp[2][2] = dp[1][1] + b[2];
dp[3][2] = dp[1][1] + a[2];
for (int index = 3; index < n; index++) {
dp[0][index] = a[index] + min(dp[0][index - 1], dp[3][index - 1]);
dp[1][index] = cost + b[index] + min(dp[0][index - 1], dp[3][index - 1]);
dp[2][index] = b[index] + min(dp[1][index - 1], dp[2][index - 1]);
dp[3][index] = a[index] + min(dp[1][index - 1], dp[2][index - 1]);
}
for (int i = 0; i < n; i++) {
long long mi = INT_MAX;
for (int j = 0; j < 4; j++) {
if (dp[j][i] != -1) mi = min(dp[j][i], mi);
}
cout << mi << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int OFFSET = 2000005;
int per[MAXN + OFFSET];
int main() {
int n, i, j, k;
scanf("%d", &n);
int head, tail;
for (i = 0, j = 1; j <= n; j++, i++) {
per[i] = j;
}
head = 0;
tail = 0 + n;
for (k = 2; k <= n; k++) {
if (n % k) {
per[tail] = per[head + k * (n / k)];
i = head + k * (n / k);
} else {
i = tail;
}
for (; i - k >= head; i -= k) {
per[i] = per[i - k];
}
head++;
tail++;
}
for (i = head; i < tail; i++) {
printf("%d ", per[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
inline bool isValid(int x, int y, int z) {
if (x > n or x <= 0 or y > n or y <= 0 or z > n or z <= 0) {
return false;
}
return true;
}
int main() {
int a[101], k, x, i;
cin >> n >> k >> x;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
int temp_ans, ans = 0, flag, y, index1, index2;
for (i = 1; i < n; i++) {
temp_ans = 0;
flag = 0;
if (a[i] == x and a[i + 1] == x) {
temp_ans = 2;
index1 = i;
index2 = i + 1;
while (true) {
flag = 0;
if (isValid(index1 - 1, index1 - 2, index2 + 1)) {
y = a[index1 - 1];
if (a[index1 - 1] == y and a[index1 - 2] == y and
a[index2 + 1] == y) {
temp_ans += 3;
flag = 1;
}
}
if (isValid(index1 - 1, index2 + 1, index2 + 2)) {
y = a[index1 - 1];
if (a[index1 - 1] == y and a[index2 + 1] == y and
a[index2 + 2] == y) {
if (flag == 1) {
temp_ans += 1;
flag = 3;
} else {
temp_ans += 3;
flag = 2;
}
}
}
ans = max(ans, temp_ans);
if (flag == 1) {
index1 = index1 - 2;
index2 = index2 + 1;
} else if (flag == 2) {
index1 = index1 - 1;
index2 = index2 + 2;
} else if (flag == 3) {
index1 = index1 - 2;
index2 = index2 + 2;
} else {
break;
}
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long qread() {
char c = getchar();
int neg = 1;
long long val = 0;
while (c != '-' && !isdigit(c)) c = getchar();
if (c == '-') c = getchar(), neg = -1;
while (isdigit(c)) val = (val << 3) + (val << 1) + c - '0', c = getchar();
return neg * val;
}
const int N = 1010, INF = 0x3f3f3f3f;
int n, m;
string a[N];
deque<pair<int, int> > q;
int d[3][N][N];
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int main() {
n = qread();
m = qread();
for (int i = 0; i < (int)n; i++) cin >> a[i];
memset(d, -1, sizeof d);
for (int p = 0; p < (int)3; p++) {
for (int x = 0; x < (int)n; x++)
for (int y = 0; y < (int)m; y++)
if (a[x][y] - '1' == p) {
d[p][x][y] = 0;
q.push_back(make_pair(x, y));
}
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop_front();
for (int i = 0; i < (int)4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (!(-1 < nx && nx < n && -1 < ny && ny < m && a[nx][ny] != '#'))
continue;
int nd = d[p][x][y] + (a[nx][ny] == '.');
if (d[p][nx][ny] == -1 || d[p][nx][ny] > nd) {
d[p][nx][ny] = nd;
a[nx][ny] == '.' ? q.push_back(make_pair(nx, ny))
: q.push_front(make_pair(nx, ny));
}
}
}
}
int ans = INF;
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++)
if ([i, j]() {
for (int x = 0; x < (int)3; x++)
if (d[x][i][j] == -1) return false;
return true;
}())
ans = min(ans, [i, j]() {
int r = 0;
for (int x = 0; x < (int)3; x++) r += d[x][i][j];
return r - 2 * (a[i][j] == '.');
}());
cout << (ans == INF ? -1 : ans) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int bs(int t, int p) {
int lo = 0, hi = p - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == t)
return mid;
else {
if (a[mid] > t) {
hi = mid - 1;
} else {
lo = mid + 1;
}
}
}
return -1;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int x = 0, y = 0;
int dp[100005];
for (int i = 0; i < n; i++) {
int r;
if (a[i] % k != 0)
r = -1;
else
r = bs(a[i] / k, i);
if (r == -1) {
x++;
dp[i] = 0;
} else {
if (dp[r] == 0) {
y++;
dp[i] = 1;
} else {
x++;
dp[i] = 0;
}
}
}
cout << max(x, y);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define nl "\n"
#define pb push_back
#define rep(i,s,n) for(int i=s;i<n;i++)
#define fill_arr(arr) for(auto &x:arr) cin>>x;
int mod = 1e9+7;
vector<vector<int>> A;
vector<int> path;
int get_size(int u,int *vis){
*(vis+u)=1;
int cnt=1;
for(int x: A[u]){
if(x>0 &&(*(vis+x))==0){
cnt+=get_size(x,vis);
}
}
return cnt;
}
bool dfs(int u,int target,int *vis){
*(vis+u)=1;
if(u==target){
path.pb(u);
*(vis+u)=1;
return true;
}
bool flag = false;
for(int x: A[u]){
if((x>0) && ((*(vis+x))==0)){
bool check = dfs(x,target,vis);
if (check) flag = true;
else *(vis+x)=0;
}
}
if(flag) path.pb(u);
return flag;
}
int gcd(int a, int b, int& x, int& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int x1, y1;
int d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
void solve(){
int n;
cin>>n;
A.clear();
rep(i,0,n+1) A.pb({0});
rep(i,0,n-1){
int u,v;
cin>>u>>v;
A[u].pb(v);
A[v].pb(u);
}
int arr[n+1][n+1];
rep(i,1,n+1){arr[i][0]=0; arr[0][i]=1;}
rep(i,1,n+1){
rep(j,1,n+1){
int val = ((1ll*arr[i-1][j])+arr[i][j-1])%mod;
if(val&1) val+=mod;
arr[i][j] = (val/2)%mod;
}
}
int ans=0;
int x,y;
int denom = n;
gcd(denom,mod,x,y);
rep(i,2,n+1){
rep(j,1,i){
int vis[n+1];
int *p;
p = (int *) vis;
rep(k,0,n+1) vis[k]=0;
path.clear();
vis[0]=1;
dfs(j,i,p);
rep(k,0,path.size()-1){
int a = k;
int b = path.size()-a-1;
int numer = (1ll*get_size(path[k],p)*arr[a][b])%mod;
ans = ((ans%mod)+((1ll*(x%mod)*(numer%mod))%mod))%mod;
ans = (ans+mod)%mod;
}
}
}
cout<<ans<<nl;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t,x,y;
// cin>>t;
t=1;
while(t--)
solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long bigmod(long long b, long long p, long long m) {
if (p == 0) return 1;
if (p % 2 == 0) {
long long temp = bigmod(b, p / 2, m);
return (temp * temp) % m;
}
return (bigmod(b, p - 1, m) * (b % m)) % m;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool is_prime(long long n) {
if (n < 2 || (!n % 2 && n != 2)) return false;
for (long long i = 3; i * i <= sqrt(n); i += 2)
if (!n % i) return false;
return true;
}
string s, res = "";
int a[26] = {0}, i;
char c = 'a';
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
for (i = 0; i < s.length(); i++) c = max(c, s[i]);
i = 0;
int tt = 0;
for (char h = c; h >= 'a'; h--) {
for (i = tt; i < s.length(); i++) {
if (s[i] == h) {
tt = i;
res += h;
}
}
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int d[300050];
pair<int, int> d2[300050];
bool chk[300050];
int ans_chk[300050];
vector<int> ANS;
int main() {
int N, i, j;
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%d", &d[i]);
d2[i].first = d[i];
d2[i].second = i;
}
sort(d2 + 1, d2 + N + 1);
for (i = 1; i <= N; i++) {
int t1 = d2[i].second;
if (chk[t1]) continue;
chk[t1] = true;
int st, en;
for (j = t1 - 1; j >= 1; j--) {
if (d[j] % d[t1] != 0) break;
chk[j] = true;
}
st = j + 1;
for (j = t1 + 1; j <= N; j++) {
if (d[j] % d[t1] != 0) break;
chk[j] = true;
}
en = j - 1;
ans_chk[st] = en - st;
}
int max = 0;
for (i = 1; i <= N; i++)
if (ans_chk[i] > max) max = ans_chk[i];
for (i = 1; i <= N; i++)
if (ans_chk[i] == max) ANS.push_back(i);
printf("%d %d\n", ANS.size(), max);
for (i = 0; i < ANS.size(); i++) printf("%d ", ANS[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, s;
cin >> a >> b >> s;
int x = abs(a) + abs(b);
if (s >= x && s % 2 == x % 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const double eps = (1e-6);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
set<int> s;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
s.insert(x);
if ((int)(s).size() > 3) {
cout << "NO\n";
return 0;
}
}
if ((int)(s).size() < 3) {
cout << "YES\n";
return 0;
}
vector<int> v;
for (auto item : s) {
v.push_back(item);
}
if (v[2] - v[1] == v[1] - v[0]) {
cout << "YES\n";
} else
cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 2e5 + 5;
long long t[N], a[N], b[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
int cnta = 0, cntb = 0;
set<pair<long long, long long> > ab, aa, bb;
for (int i = 1; i <= n; ++i) {
cin >> t[i] >> a[i] >> b[i];
cnta += a[i], cntb += b[i];
if (a[i] && b[i]) ab.insert({t[i], i});
if (a[i] && !b[i]) aa.insert({t[i], i});
if (!a[i] && b[i]) bb.insert({t[i], i});
}
if (cnta < k || cntb < k) cout << -1, exit(0);
long long ans = 0;
int taken = 0;
vector<pair<long long, long long> > checkab, checka, checkb;
while (k--) {
if (!aa.size() || !bb.size())
checkab.push_back(*ab.begin()), ans += ab.begin()->first, taken++,
ab.erase(ab.begin());
else if (ab.size() &&
ab.begin()->first < aa.begin()->first + bb.begin()->first) {
checkab.push_back(*ab.begin()), ans += ab.begin()->first, taken++,
ab.erase(ab.begin());
} else {
checka.push_back(*aa.begin()), checkb.push_back(*bb.begin()),
ans += aa.begin()->first + bb.begin()->first, taken += 2,
aa.erase(aa.begin()), bb.erase(bb.begin());
}
}
if (taken <= m) {
m -= taken;
set<pair<long long, long long> > can;
vector<bool> used(n + 5, 0);
for (pair<long long, long long> cur : checkab) used[cur.second] = true;
for (pair<long long, long long> cur : checka) used[cur.second] = true;
for (pair<long long, long long> cur : checkb) used[cur.second] = true;
for (int i = 1; i <= n; ++i) {
if (!used[i]) can.insert({t[i], i});
}
int mn = min((int)aa.size(), (int)bb.size());
vector<int> dop;
while (m && can.size()) {
bool ok = false;
if (!aa.size() || !bb.size() || !checkab.size()) {
pair<long long, long long> cur = *can.begin();
ans += cur.first;
dop.push_back(cur.second);
can.erase(can.begin());
ok = 1;
} else if (aa.begin()->first + bb.begin()->first - checkab.back().first <=
can.begin()->first) {
ans -= checkab.back().first;
can.insert(checkab.back());
checkab.pop_back();
ans += aa.begin()->first + bb.begin()->first;
can.erase(*aa.begin());
can.erase(*bb.begin());
checka.push_back(*aa.begin()), checkb.push_back(*bb.begin());
aa.erase(aa.begin()), bb.erase(bb.begin());
ok = 1;
} else {
pair<long long, long long> cur = *can.begin();
ans += cur.first;
dop.push_back(cur.second);
if (aa.count(cur)) aa.erase(cur);
if (bb.count(cur)) bb.erase(cur);
can.erase(can.begin());
ok = 1;
}
if (ok) {
m--;
continue;
}
break;
}
if (m) cout << -1, exit(0);
cout << ans << "\n";
for (pair<long long, long long> cur : checkab) cout << cur.second << " ";
for (pair<long long, long long> cur : checka) cout << cur.second << " ";
for (pair<long long, long long> cur : checkb) cout << cur.second << " ";
for (int cur : dop) cout << cur << " ";
exit(0);
}
m = taken - m;
if (min((int)checka.size(), (int)ab.size() - (int)checkab.size()) < m)
cout << -1, exit(0);
while (m--) {
ans -= (checka.back().first + checkb.back().first);
ans += ab.begin()->first;
checka.pop_back(), checkb.pop_back(), checkab.push_back(*ab.begin()),
ab.erase(ab.begin());
}
cout << ans << "\n";
for (pair<long long, long long> cur : checkab) cout << cur.second << " ";
for (pair<long long, long long> cur : checka) cout << cur.second << " ";
for (pair<long long, long long> cur : checkb) cout << cur.second << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25;
const int MAXS = 1 << 20;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int n, u, dp[MAXS];
long long a[MAXN];
int bit[MAXN], cnt[MAXS];
long long sum[MAXS];
int tot, fcnt, gcnt, pos[MAXN];
long long f[MAXS], g[MAXS];
void work(int tot, int *pos, int &fcnt, long long *f) {
fcnt = 0;
for (int s = 0; s < (1 << tot); s++) {
long long tmp = 0;
for (int i = 1; i <= tot; i++)
if (bit[i] & s) tmp += a[pos[i]];
f[++fcnt] = 2 * tmp;
}
sort(f + 1, f + fcnt + 1);
}
bool check(int s) {
if (cnt[s] == 1) return sum[s] == 0;
tot = 0;
if ((sum[s] + cnt[s]) % 2 == 0) return false;
for (int i = 1; i <= n; i++)
if (bit[i] & s) pos[++tot] = i;
work(tot / 2, pos, fcnt, f);
work(tot - tot / 2, pos + tot / 2, gcnt, g);
int lft = 1 + 2 * (abs(sum[s]) < cnt[s]);
long long L = sum[s] - cnt[s] + 1, R = sum[s] + cnt[s] - 1;
for (int i = fcnt, j = 1; i >= 1; i--) {
while (j <= gcnt && g[j] + f[i] < L) j++;
for (int k = j; k <= gcnt && g[k] + f[i] <= R; k++)
if (--lft == 0) return true;
}
return false;
}
int main() {
read(n), u = (1 << n) - 1;
for (int i = 1; i <= n; i++) read(a[i]), bit[i] = 1 << (i - 1);
for (int s = 0; s <= u; s++) {
for (int i = 1; i <= n; i++)
if (bit[i] & s) {
cnt[s]++;
sum[s] += a[i];
}
}
for (int s = 1; s <= u; s++)
if (dp[s] == 0 && check(s)) {
dp[s] = 1;
int x = u ^ s;
for (int t = x; t != 0; t = (t - 1) & x) chkmax(dp[s ^ t], dp[t] + dp[s]);
}
cout << n - dp[u] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int N = 1e9 + 7;
void solve() {
long long int n, x, y;
cin >> n >> x >> y;
vector<pair<long long int, long long int> > a(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
long long int l = a[0].first, r = a[0].second, cost = 0;
multiset<long long int> pq;
pq.insert(r);
cost = (cost + x + y * (r - l)) % N;
for (long long int i = 2; i <= n; i++) {
l = a[i - 1].first;
r = a[i - 1].second;
auto itr = pq.lower_bound(l);
if (itr == pq.begin()) {
pq.insert(r);
cost = (cost + x + y * (r - l)) % N;
} else {
itr--;
cost = (cost + y * (r - l) + min(x, y * (l - (*itr)))) % N;
pq.erase(itr);
pq.insert(r);
}
}
cout << cost << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double DP[2][1005];
int result[1005];
int main() {
ios_base::sync_with_stdio(0);
int K, Q;
scanf("%d%d", &K, &Q);
DP[0][0] = 1.0;
int curp = 0;
int i = 1;
while (curp < 1000) {
DP[i % 2][0] = 0.0;
for (int j = (1); j < (K + 1); ++j) {
DP[i % 2][j] =
DP[1 - i % 2][j] * j / K + DP[1 - i % 2][j - 1] * (K - j + 1) / K;
}
int p = min((int)(DP[i % 2][K] * 2000), 1000);
while (curp < p) {
result[++curp] = i;
}
++i;
}
for (int i = 0; i < (Q); ++i) {
int p;
scanf("%d", &p);
printf("%d\n", result[p]);
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.