solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
double x, y, a[maxn], b[maxn], p, q, l, r;
int n;
double f(double x) {
double y = 1;
for (int i = 0; i < n; ++i) y = min(y, (1.0 - x * a[i]) / b[i]);
return p * x + q * y;
}
int main() {
scanf("%d%lf%lf", &n, &p, &q);
l = 0;
r = 1;
for (int i = 0; i < n; ++i) {
scanf("%lf%lf", a + i, b + i);
r = max(r, a[i]);
}
r = 1 / r;
while (fabs(l - r) >= 1e-12) {
double mid1 = l + (r - l) / 3, mid2 = r - (r - l) / 3;
if (f(mid1) <= f(mid2) + 1e-12) {
l = mid1;
} else
r = mid2;
}
printf("%.6lf\n", f(l));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct plan {
int val;
int idx;
} plans[2005];
bool comp(struct plan i, struct plan j) {
if (i.val == j.val) return (i.idx < j.idx);
return (i.val < j.val);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> plans[i].val;
plans[i].idx = i + 1;
}
if (n < 3)
cout << "NO";
else if (n == 3) {
if ((plans[0].val == plans[1].val) && (plans[1].val == plans[2].val)) {
cout << "YES\n";
cout << "1 2 3\n";
cout << "2 1 3\n";
cout << "3 1 2\n";
} else {
cout << "NO";
}
} else {
int cnt = 0;
sort(plans, plans + n, comp);
for (int i = 0; i < n - 1; i++) {
if (plans[i].val == plans[i + 1].val) cnt++;
}
if (cnt < 2)
cout << "NO";
else {
cout << "YES\n";
int index = 0;
for (int i = 0; i < n; i++) {
cout << plans[i].idx << " ";
}
cout << endl;
for (; index < n - 1; index++) {
if (plans[index].val == plans[index + 1].val) {
swap(plans[index].idx, plans[index + 1].idx);
index++;
break;
}
}
for (int i = 0; i < n; i++) {
cout << plans[i].idx << " ";
}
cout << endl;
for (; index < n - 1; index++) {
if (plans[index].val == plans[index + 1].val) {
swap(plans[index].idx, plans[index + 1].idx);
break;
}
}
for (int i = 0; i < n; i++) {
cout << plans[i].idx << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string a;
bool check(int i, int j) {
for (int s = i; s <= j; s++) {
if (a[s] != a[j - s + i]) return 0;
}
return 1;
}
int ans;
int main() {
cin >> a;
for (int i = 0; i < a.length(); i++) {
for (int j = i; j < a.length(); j++) {
if (!check(i, j)) ans = max(ans, j - i + 1);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
const int MAXM = 200011;
int n, m;
int x[MAXN], y[MAXN];
vector<int> r[MAXM];
int g[MAXM] = {0};
int last(int i) {
int j = i - 1;
if (j == 0) j = n;
return abs(x[j] - x[i] + y[j] - y[i]);
}
int next(int i) {
int j = i + 1;
if (j > n) j = 1;
return abs(x[j] - x[i] + y[j] - y[i]);
}
bool qwe(int p) {
for (int i = 0; i < MAXM; i++) g[i] = r[i].size();
while (p <= n) {
int rast = last(p) + next(p);
if (rast >= MAXM || g[rast] == 0) return false;
g[rast]--;
p += 2;
}
return true;
}
void make(int p) {
int f[MAXN] = {0};
while (p <= n) {
int rast = last(p) + next(p);
int l = r[rast].size();
f[p] = r[rast][l - 1];
r[rast].pop_back();
p += 2;
}
for (int i = 1; i <= n; i++)
if (f[i] != 0)
cout << f[i] << " ";
else
cout << "-1 ";
return;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
for (int i = 1; i <= m; i++) {
int u;
cin >> u;
r[u].push_back(i);
}
if (qwe(1) == true) {
cout << "YES" << endl;
make(1);
return 0;
}
if (qwe(2) == true) {
cout << "YES" << endl;
make(2);
return 0;
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned ll
#define uint unsigned
#define pii pair<int,int>
#define pll pair<ll,ll>
#define PB push_back
#define fi first
#define se second
#define For(i,j,k) for (int i=(int)(j);i<=(int)(k);i++)
#define Rep(i,j,k) for (int i=(int)(j);i>=(int)(k);i--)
#define CLR(a,v) memset(a,v,sizeof(a));
#define CPY(a,b) memcpy(a,b,sizeof(a));
using namespace std;
const int N=55;
vector<int> e1[N],e2[N],e3[N];
int q[N],deg[N],n,ans,sum;
int vis[N][N],banx,bany;
int fa1[N],fa2[N],spe[N];
bool topo(){
int h=0,t=0;
For(i,1,n) if (!deg[i]) q[++t]=i;
while (h!=t){
int x=q[++h];
For(i,0,e3[x].size()-1)
if (!--deg[e3[x][i]])
q[++t]=e3[x][i];
}
return t==n;
}
void dfs1(int x,int fl){
sum-=fl; spe[x]=fl;
For(i,0,e1[x].size()-1)
if (e1[x][i]!=fa1[x]&&vis[x][e1[x][i]]!=-1){
fa1[e1[x][i]]=x;
dfs1(e1[x][i],vis[x][e1[x][i]]&fl);
}
}
void dfs2(int x){
For(i,0,e2[x].size()-1)
if (e2[x][i]!=fa2[x]){
fa2[e2[x][i]]=x;
dfs2(e2[x][i]);
}
}
int check(int id){
memset(fa1,0,sizeof(fa1));
memset(fa2,0,sizeof(fa2));
memset(deg,0,sizeof(deg));
int fl=vis[banx][bany]; sum=n;
vis[banx][bany]=vis[bany][banx]=-1;
dfs1(id,1); dfs2(id);
For(i,1,n) e3[i].clear();
For(i,1,n) if (!spe[i]){
if (!spe[fa1[i]]){
e3[i].PB(fa1[i]);
++deg[fa1[i]];
}
if (!spe[fa2[i]]){
e3[fa2[i]].PB(i);
++deg[i];
}
}
if (!topo()) sum=1<<30;
vis[banx][bany]=vis[bany][banx]=fl;
//printf("QUERY %d %d\n",id,sum);
return sum;
}
void solve(){
scanf("%d",&n);
For(i,1,n) e1[i].clear();
For(i,1,n) e2[i].clear();
memset(vis,0,sizeof(vis));
For(i,1,n-1){
int x,y;
scanf("%d%d",&x,&y);
e1[x].PB(y); e1[y].PB(x);
}
For(i,1,n-1){
int x,y;
scanf("%d%d",&x,&y);
e2[x].PB(y); e2[y].PB(x);
vis[x][y]=vis[y][x]=1;
}
int ans=1<<30;
banx=bany=0;
For(i,1,n) ans=min(ans,check(i));
For(i,1,n) if (e1[i].size()==1){
int opp=e1[i][0];
For(j,1,n) if (j!=i&&j!=opp){
banx=i,bany=opp;
e1[i].PB(j); e1[j].PB(i);
ans=min(ans,check(i)+1);
e1[i].pop_back();
e1[j].pop_back();
}
}
if (ans>1<<29)
ans=-1;
printf("%d\n",ans);
}
int main(){
int T;
scanf("%d",&T);
while (T--) solve();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 3e5 + 10;
int n, m;
long long sum[maxn];
vector<int> pos, neg;
vector<pair<int, int> > ans;
vector<long long> s;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, d;
scanf("%d%d%d", &u, &v, &d);
sum[u] += d;
sum[v] -= d;
}
for (int i = 1; i <= n; ++i) {
if (sum[i] > 0) pos.push_back(i);
if (sum[i] < 0) neg.push_back(i);
}
int i = 0, j = 0;
while (i < pos.size() && j < neg.size()) {
if (sum[pos[i]] + sum[neg[j]] == 0) {
ans.push_back(make_pair(pos[i], neg[j]));
s.push_back(sum[pos[i]]);
++i;
++j;
} else if (sum[pos[i]] + sum[neg[j]] < 0) {
sum[neg[j]] += sum[pos[i]];
ans.push_back(make_pair(pos[i], neg[j]));
s.push_back(sum[pos[i]]);
++i;
} else {
sum[pos[i]] += sum[neg[j]];
ans.push_back(make_pair(pos[i], neg[j]));
s.push_back(-sum[neg[j]]);
++j;
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i)
printf("%d %d %I64d\n", ans[i].first, ans[i].second, s[i]);
return 0;
}
| 4 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
#define Seg_Max_N (1<<18)
using Value = int;
const Value ini = -1e9;
struct segtree {
int N;
vector<Value>dat;
segtree() {}
segtree(int n) :dat(2 * Seg_Max_N) {
N = 1;
while (N < n) N *= 2;
for (int i = 0; i < 2 * N - 1; i++) {
dat[i] = ini;
}
}
Value connect(const Value&l, const Value&r) {
return max(l,r);
}
// update k th element
void update(int k, Value a) {
k += N - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
const Value al(dat[k * 2 + 1]);
const Value ar(dat[k * 2 + 2]);
dat[k] = connect(al, ar);
}
}
// min [a, b)
Value query(int a, int b) { return query(a, b, 0, 0, N); }
Value query(int a, int b, int k, int l, int r) {
if (r <= a or b <= l) return ini;
if (a <= l and r <= b) return dat[k];
const int m = (l + r) / 2;
const Value al(query(a, b, k * 2 + 1, l, m));
const Value ar(query(a, b, k * 2 + 2, m, r));
return connect(al, ar);
}
};
int solve(vector<int>b) {
int num = 0;
int ans=0;
int pre = -1;
for (auto a : b) {
if (a > pre) {
num++;
ans=max(ans,num);
pre = a;
}
else if (a == pre) {
}
else {
pre = a;
num = 1;
}
}
return ans;
}
template<typename T> struct Compress {
map<T, int>mp;
map<int, T>revmp;
Compress(vector<T>vs) {
setmp(vs);
}
Compress() :mp(), revmp() {
}
void setmp(vector<T>vs) {
sort(vs.begin(), vs.end());
vs.erase(unique(vs.begin(), vs.end()), vs.end());
for (int i = 0; i < static_cast<int>(vs.size()); ++i) {
mp[vs[i]] = i;
revmp[i] = vs[i];
}
}
};
int main() {
long long int N;cin>>N;
long long int ans=1;
long long int plus=1;
while (true) {
if (N % 2) {
ans+=plus;
plus*=2;
N/=2;
}
else {
break;
}
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int N, Q;
int A[3 << 17];
const int B = 19;
vector<int> G[B][B];
int main() {
scanf("%d%d", &N, &Q);
for (int i = 0; i < B; i++)
for (int j = i + 1; j < B; j++) G[i][j].assign(N, N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
for (int j = 0; j < B; j++)
if (A[i] >> j & 1)
for (int k = j + 1; k < B; k++)
if (A[i] >> k & 1) {
G[j][k][i] = i;
}
}
for (int i = 0; i < B; i++)
for (int j = i + 1; j < B; j++) {
for (int k = N - 1; k--;) {
if (G[i][j][k] == N) G[i][j][k] = G[i][j][k + 1];
}
}
for (; Q--;) {
int st, go;
scanf("%d%d", &st, &go);
st--, go--;
if (A[st] == 0 || A[go] == 0) {
puts("Fou");
continue;
}
if (A[st] & A[go]) {
puts("Shi");
continue;
}
vector<int> dist(B, N);
priority_queue<pair<int, int> > P;
for (int i = 0; i < B; i++)
if (A[st] >> i & 1) {
dist[i] = st;
P.push(make_pair(-st, i));
}
int ans = N;
while (!P.empty()) {
int cost = -P.top().first, u = P.top().second;
P.pop();
if (dist[u] < cost) continue;
if (A[go] >> u & 1) {
ans = cost;
break;
}
for (int v = 0; v < B; v++)
if (dist[v] > dist[u]) {
int nu = u, nv = v;
if (nu > nv) swap(nu, nv);
int nxt = G[nu][nv][dist[u]];
if (dist[v] > nxt) {
dist[v] = nxt;
P.push(make_pair(-dist[v], v));
}
}
}
puts(ans <= go ? "Shi" : "Fou");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int getDiff(pair<int, int> x) { return (x.second - x.first); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
string s;
cin >> s;
int n = s.length();
int i, j;
string rev = s;
reverse(rev.begin(), rev.end());
if (rev.compare(s) == 0) {
cout << s << "\n";
continue;
}
string suf = "", pref = "";
for (i = 0, j = n - 1; i < j; i++, j--) {
if (s[i] == s[j]) {
pref.push_back(s[i]);
suf.push_back(s[j]);
} else
break;
}
int l = j;
string temp = "";
string temp2 = "";
pair<int, int> points1, points2;
points1 = {i, i};
for (int k = i; k <= j; k++) {
temp += s[k];
temp2 = s[k] + temp2;
if (temp.compare(temp2) == 0) {
points1.second = k;
}
}
temp = "";
temp2 = "";
points2 = {j, j};
for (int k = j; k >= i; k--) {
temp = s[k] + temp;
temp2 += s[k];
if (temp.compare(temp2) == 0) {
points2.first = k;
}
}
if (getDiff(points2) > getDiff(points1)) {
temp = string(s, points2.first, getDiff(points2) + 1);
} else if (getDiff(points2) < getDiff(points1)) {
temp = string(s, points1.first, getDiff(points1) + 1);
} else
temp = string(s, i, getDiff(points1) + 1);
reverse(pref.begin(), pref.end());
cout << (suf + temp + pref) << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 710;
const int MODD = 1000000007;
char s[MAXN];
int n, m[MAXN], dp[MAXN][MAXN][3][3];
int gao(int l, int r, int cl, int cr) {
if (l > r) return 1;
int &ret = dp[l][r][cl][cr];
if (ret != -1) return ret;
ret = 0;
int mm = m[l];
if (mm == r) {
for (int c = 0; c < 2; ++c) {
if (c != cl) ret = (ret + gao(l + 1, r - 1, c, 2)) % MODD;
if (c != cr) ret = (ret + gao(l + 1, r - 1, 2, c)) % MODD;
}
} else {
for (int c = 0; c < 2; ++c) {
if (c != cl)
ret = (ret + gao(l + 1, mm - 1, c, 2) * 1LL * gao(mm + 1, r, 2, cr)) %
MODD;
ret =
(ret + gao(l + 1, mm - 1, 2, c) * 1LL * gao(mm + 1, r, c, cr)) % MODD;
}
}
return ret;
}
int main() {
while (scanf("%s", s) != EOF) {
stack<int> S;
n = strlen(s);
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; ++i) {
if (s[i] == '(') {
S.push(i);
} else {
int ii = S.top();
S.pop();
m[ii] = i;
m[i] = ii;
}
}
printf("%d\n", gao(0, n - 1, 2, 2));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int A[1000001];
int B[1000001];
long long swap_count;
void merge(int start, int end) {
int mid = (start + end) / 2;
int i = start;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= end) {
if (A[i] <= A[j])
B[k++] = A[i++];
else {
B[k++] = A[j++];
swap_count += mid - i + 1;
}
}
while (j <= end) {
B[k++] = A[j++];
swap_count += mid - i + 1;
}
while (i <= mid) B[k++] = A[i++];
for (int i = start; i <= end; i++) {
A[i] = B[i - start];
}
}
void sort(int start, int end) {
if (start == end) return;
int mid = (start + end) / 2;
sort(start, mid);
sort(mid + 1, end);
merge(start, end);
}
int main() {
cin.tie(NULL);
std::ios::sync_with_stdio(false);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> A[i];
}
sort(1, N);
if (N % 2 == 0) {
if (swap_count % 2 == 0)
cout << "Petr";
else
cout << "Um_nik";
} else {
if (swap_count % 2 == 0)
cout << "Um_nik";
else
cout << "Petr";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s, o;
cin >> s;
int n = s.size();
while (n == 2) {
cout << s << endl;
break;
}
for (int i = 0; i < n; i += 2) {
o.push_back(s[i]);
}
o.push_back(s[n - 1]);
if (n != 2) cout << o << endl;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
while (T--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B;
cin>>A>>B;
cout<<(A+B)%(24)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long setBit(long long mask, int p) { return (mask | (1 << p)); }
long long resetBit(long long mask, int p) { return (mask & ~(1 << p)); }
long long flipBit(long long mask, int p) { return (mask ^ (1 << p)); }
bool check(long long mask, int p) { return (mask & (1 << p)); }
int msb(long long N) { return N ? 63 - __builtin_clzll(N) : -1; }
int lsb(long long N) { return __builtin_ffs(N) - 1; }
int countOn(long long mask) { return __builtin_popcountll(mask); }
int countOff(long long mask) { return msb(mask) - countOn(mask) + 1; }
long long bigmod(long long N, long long P) {
if (P == 0) return 1;
if (P % 2 == 0) {
long long ret = bigmod(N, P / 2) % 1000000007;
return (ret * ret) % 1000000007;
}
return ((N % 1000000007) * (bigmod(N, P - 1) % 1000000007)) % 1000000007;
}
long long modInverse(long long a) { return bigmod(a, 1000000007 - 2); }
mt19937_64 mt_rnd_64(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long l, long long r) {
return (mt_rnd_64() % (r - l + 1)) + l;
}
int main() {
long long a, b, n, m;
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld", &a);
scanf("%lld", &b);
scanf("%lld", &n);
scanf("%lld", &m);
if ((a + b) < (n + m)) {
printf("No\n");
continue;
}
long long smol = min(a, b), big = max(a, b);
if (smol < m) {
printf("No\n");
continue;
}
smol -= m;
if ((smol + big) < n) {
printf("No\n");
continue;
}
printf("Yes\n");
}
}
| 3 |
#include <bits/stdc++.h>
int take() {
int n;
scanf("%d", &n);
return n;
}
double ttake() {
double n;
scanf("%lf", &n);
return n;
}
long long takes() {
long long n;
scanf("%lld", &n);
return n;
}
int cas;
using namespace std;
bool approximatelyEqual(float a, float b, float epsilon) {
return fabs(a - b) <= ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool essentiallyEqual(float a, float b, float epsilon) {
return fabs(a - b) <= ((fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool definitelyGreaterThan(float a, float b, float epsilon) {
return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool definitelyLessThan(float a, float b, float epsilon) {
return (b - a) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
int main() {
int tc = 1;
while (tc--) {
int n = take(), m = take(), dp[m + 1][n + 1];
for (int i = 1; i <= n; i += 1) dp[1][i] = take();
for (int i = 2; i <= m; i += 1) {
for (int k = 1; k <= n; k += 1) dp[i][take()] = k;
}
long long ans = 0;
int l = 1, h = 0, prev[m + 1];
for (int i = 1; i <= m; i += 1) prev[i] = -1;
while (l <= n) {
h = max(h, l);
long long f = 1;
while (h <= n) {
int u = dp[1][h], ok = 0;
for (int i = 2; i <= m; i += 1) {
if (dp[i][u] == prev[i] + 1 || prev[i] == -1)
prev[i] = dp[i][u], ok++;
else
break;
}
if (ok != m - 1) break;
h++;
ans += f;
f++;
}
if (l != h)
l = h;
else
l = h + 1;
for (int i = 1; i <= m; i += 1) prev[i] = -1;
}
cout << ans << "\n";
}
{ return 0; };
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, j = 0, c = 0;
string a, b;
cin >> n >> k;
cin >> a;
b.append(a, 0, k);
for (j = 0; j < n; j++) {
if (b[j % k] < a[j]) {
c = 1;
break;
}
if (b[j % k] > a[j]) {
break;
}
}
if (c != 1) {
cout << n << endl;
for (j = 0; j < n; j++) {
cout << b[j % k];
}
return 0;
} else {
j = k - 1;
c = 0;
while (j >= 0) {
if (b[j] != '9') {
c++;
break;
}
j--;
}
if (c == 0) {
cout << n + 1 << endl;
for (j = 0; j < n + 1; j++) {
cout << "1";
}
return 0;
} else {
b[j] = b[j] + 1;
j++;
while (j < k) {
b[j] = '0';
j++;
}
cout << n << endl;
for (j = 0; j < n; j++) {
cout << b[j % k];
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res[300000], cur = 0;
pair<int, int> a[300000];
cin.sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first, a[i].second = i;
sort(a, a + n);
for (int i = 0; i < n; i++) {
cur = max(a[i].first, cur + 1);
res[a[i].second] = cur;
}
for (int i = 0; i < n; i++) cout << res[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int a[N], cnt[20];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
int x;
scanf("%d", &x);
a[i] |= x << j;
}
++cnt[a[i]];
}
for (int i = 0; i < 1 << k; i++) {
for (int j = 0; j < 1 << k; j++) {
if (cnt[j] && cnt[i] && (i & j) == 0) {
printf("YES");
return 0;
}
}
}
printf("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100005];
int sum[100005];
int ll, rr;
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
cnt[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &cnt[i]);
sum[i] = sum[i - 1] + cnt[i];
}
sum[n + 1] = sum[n];
int ll = -1, rr = -1;
int cntt;
int rm = (n / 2) * b;
int lm = (n * b) - rm;
cntt = 0;
for (int i = 1; i <= n; i++) {
cntt += cnt[i];
if (cntt >= lm) {
ll = i;
break;
}
}
cntt = 0;
for (int i = n; i >= 1; i--) {
cntt += cnt[i];
if (cntt >= rm) {
rr = i;
break;
}
}
int ss = 1, ee = n, lp = 0, rp = n + 1, tm = 0;
int prvl = 0, prvr = 0;
int nl = 0, nr = 0;
while (ss <= ee) {
int nlp = min(ll, lp + (m + 1));
int nrp = max(rr, rp - (m + 1));
if (sum[nlp] - prvl < b) {
nl++;
} else {
prvl += b;
}
if (ss < ee) {
if ((n * b - sum[nrp - 1]) - prvr < b) {
nr++;
} else {
prvr += b;
}
}
lp = nlp;
rp = nrp;
tm += 1;
ss++;
ee--;
}
printf("%d\n", max(nl, nr));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char ar[6][8] = {{'3', '3', '-', '4', '4', '-', '3', '3'},
{'3', '3', '-', '4', '4', '-', '3', '3'},
{'2', '2', '-', '3', '3', '-', '2', '2'},
{'2', '2', '-', '3', '3', '-', '2', '2'},
{'1', '1', '-', '2', '2', '-', '1', '1'},
{'1', '1', '-', '2', '2', '-', '1', '1'}};
char ar1[6][8];
int in = -1, jn = -1, mx = -1;
for (int i = 0; i < 6; i++) {
char c;
for (int j = 0; j < 8; j++) {
cin >> c;
if (c == '.' && ar[i][j] - '0' > mx) {
mx = ar[i][j] - '0';
in = i;
jn = j;
}
ar1[i][j] = c;
}
}
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 8; j++) {
if (i == in && j == jn) {
cout << 'P';
} else {
cout << ar1[i][j];
}
}
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> ini[2001000], fim[2001000];
string s[2001000];
char ss[2001000];
set<pair<int, int> > st;
char ans[2001000];
int len;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s %d", ss, &k);
s[i] = (string)ss;
for (int j = 0; j < k; ++j) {
int x;
scanf("%d", &x);
x--;
ini[x].push_back(i);
fim[x + s[i].size()].push_back(i);
len = max(len, (int)(x + s[i].size()));
}
}
ans[len] = 0;
for (int i = 0; i < len; ++i) {
for (int j = 0; j < ini[i].size(); ++j) {
st.insert(make_pair(ini[i][j], i));
}
for (int j = 0; j < fim[i].size(); ++j) {
st.erase(make_pair(fim[i][j], i - s[fim[i][j]].size()));
}
if (st.empty()) {
ans[i] = 'a';
} else {
int id = st.begin()->first;
int pos = i - st.begin()->second;
ans[i] = s[id][pos];
}
}
printf("%s\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 80000 * 4 + 5;
int T;
long long R;
char c;
long long len;
int stk[maxn];
int t[maxn];
int to[maxn];
long long mark[maxn];
vector<int> G[maxn];
long long dfs(int u) {
if (t[u] == 0) return 1ll;
long long ret = (t[u] == 1) ? 0ll : maxn;
for (int v : G[u]) {
if (t[u] == 1) ret += dfs(v);
if (t[u] == 2) {
long long val = dfs(v);
if (val < ret) to[u] = v, ret = val;
}
}
return ret;
}
void dfs2(int u) {
if (t[u] == 0) mark[u] = 1ll;
if (t[u] == 1)
for (int v : G[u]) dfs2(v);
if (t[u] == 2) dfs2(to[u]);
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%lld", &R);
len = 0;
int top = 0;
while (1) {
c = getchar();
if (c == '\n') break;
if (c == '(') {
if (top) G[stk[top]].push_back(len + 1);
stk[++top] = ++len;
G[len].clear();
}
if (c == ')') --top;
if (c == '*')
t[++len] = 0, G[stk[top]].push_back(len), G[len].clear(),
mark[len] = 0ll;
if (c == 'P') t[stk[top]] = 1;
if (c == 'S') t[stk[top]] = 2;
}
long long ret = dfs(1);
dfs2(1);
printf("REVOLTING ");
for (int i = 1; i <= len; i++)
if (t[i] == 0) printf("%lld ", ret * R * mark[i]);
printf("\n");
}
return 0;
}
| 5 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define F first
#define S second
#define INF 1 << 30
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int main(){
int n, k;
while(scanf("%d%d", &n, &k) && n+k){
int c[128];
rep(i, n) scanf("%d", c+i);
int t = 0;
int ck = 1;
rep(i, k) ck *= c[i];
t = max(t, ck);
rep(i, n-k){
ck /= c[i];
ck *= c[i+k];
t = max(t, ck);
}
int res = 0;
rep(i, n) rep(j, n){ //REP(j, i+1, n){
swap(c[i], c[j]);
int ck = 1;
rep(l, k) ck *= c[l];
res = max(res, ck);
rep(l, n-k){
ck /= c[l];
ck *= c[l+k];
res = max(res, ck);
// printf("%d:%d %d:%d\n", l, c[l], l+k, c[l+k]);
}
swap(c[i], c[j]);
}
// printf("%d %d\n", res, t);
if(res < t) puts("NO GAME");
else printf("%d\n", res-t);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e5 + 99;
int n;
int cnt[MAXN];
int good[MAXN];
int main() {
int q;
cin >> q;
while (q--) {
cin >> n;
for (int i = 0; i <= n; i++) {
cnt[i] = good[i] = 0;
}
for (int i = 0; i < n; i++) {
int t, g;
cin >> t >> g;
cnt[t]++;
if (g) good[t]++;
}
vector<vector<int>> v(n + 1);
for (int i = 0; i <= n; i++) {
if (cnt[i]) {
v[cnt[i]].push_back(good[i]);
}
}
multiset<int> s;
int ans, bns;
ans = bns = 0;
for (int i = n; i > 0; i--) {
for (auto g : v[i]) s.insert(g);
if (!s.empty()) {
int cur_god = *s.rbegin();
s.erase(s.find(cur_god));
ans += i;
bns += min(i, cur_god);
}
}
cout << ans << ' ' << bns << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
vector<int> e[MAXN];
vector<int> p[MAXN];
int n, m;
int res[MAXN];
int step, tl[MAXN], tr[MAXN];
struct node {
int l, r, flag, s;
} t[1000000];
void dfs1(int u, int fa) {
tl[u] = step++;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == fa) continue;
dfs1(v, u);
}
tr[u] = step - 1;
}
void build(int k, int l, int r) {
t[k].l = l;
t[k].r = r;
t[k].flag = t[k].s = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
void modify(int k, int l, int r) {
if (t[k].l == l && t[k].r == r) {
t[k].flag--;
if (t[k].flag == 0) t[k].s = t[k << 1].s + t[k << 1 | 1].s;
return;
}
int mid = (t[k].l + t[k].r) >> 1;
if (r <= mid)
modify(k << 1, l, r);
else if (l > mid)
modify(k << 1 | 1, l, r);
else {
modify(k << 1, l, mid);
modify(k << 1 | 1, mid + 1, r);
}
if (t[k].flag == 0) t[k].s = t[k << 1].s + t[k << 1 | 1].s;
}
void insert(int k, int l, int r) {
if (t[k].l == l && t[k].r == r) {
t[k].flag++;
t[k].s = r - l + 1;
return;
}
int mid = (t[k].l + t[k].r) >> 1;
if (r <= mid)
insert(k << 1, l, r);
else if (l > mid)
insert(k << 1 | 1, l, r);
else {
insert(k << 1, l, mid);
insert(k << 1 | 1, mid + 1, r);
}
if (t[k].flag == 0) t[k].s = t[k << 1].s + t[k << 1 | 1].s;
}
void dfs2(int u, int fa) {
if (p[u].size() > 0) insert(1, tl[u], tr[u]);
for (int i = 0; i < p[u].size(); i++) {
int v = p[u][i];
insert(1, tl[v], tr[v]);
}
res[u] = t[1].s;
if (res[u] > 0) res[u]--;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == fa) continue;
dfs2(v, u);
}
if (p[u].size() > 0) modify(1, tl[u], tr[u]);
for (int i = 0; i < p[u].size(); i++) {
int v = p[u][i];
modify(1, tl[v], tr[v]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
p[a].push_back(b);
p[b].push_back(a);
}
step = 0;
dfs1(0, -1);
build(1, 0, n - 1);
dfs2(0, -1);
for (int i = 0; i < n; i++) printf("%d%c", res[i], (i == n - 1) ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string toString(long long x) {
stringstream ss;
ss << x;
return ss.str();
}
int main() {
long long l, r;
cin >> l >> r;
long long answer = 0;
for (l; l % 10 != 0 && l <= r; ++l) {
string s = toString(l);
if (s[0] == s[s.size() - 1]) {
++answer;
}
}
if (l <= r) {
answer += (r - l) / 10;
for (long long i = r - r % 10; i <= r; ++i) {
string s = toString(i);
if (s[0] == s[s.size() - 1]) {
++answer;
}
}
}
cout << answer << endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
int c[] = {4, 1, 4, 1, 2, 1, 2, 1, 4, 1, 4, 1, 2, 1, 2, 1};
int s[] = {41412121,
14121214,
41212141,
12121414,
21214141,
12141412,
21414121,
14141212 };
void printv(int v[], int len) {
int ifs = 1;
for (int i = 0; i < len; i++) {
if (ifs == 0)
cout << " ";
cout << v[i];
ifs = 0;
}
cout << endl;
}
void solve(int p[8]) {
int ans = 0;
int minl = 50000000;
for (int i = 0; i < 8; i++) {
int l = 0;
for (int j = 0; j < 8; j++) {
l += ((p[j] - c[i + j]) > 0 ? p[j] - c[i + j] : 0);
}
if (minl > l) {
ans = i;
minl = l;
}
else if (minl == l) {
if (s[ans] > s[i]) {
ans = i;
minl = l;
}
}
}
printv(&c[ans], 8);
}
int main() {
int p[8];
while (cin >> p[0]) {
for (int i = 1; i < 8; i++)
cin >> p[i];
solve(p);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<ll> noneleg;
ll pw(ll a, ll e) {
ll ans = 1;
while (e) {
if (e & 1) ans *= a;
e /= 2;
a = a * a;
}
return ans;
}
bool isx2(ll x) {
ll tmp = round(sqrt(x));
return tmp * tmp == x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
for (int i = 3; i <= 64; ++i) {
ll mx = (ll)floor(pow(1E18, 1.0 / i) + 0.01);
for (ll x = 2; x <= mx; ++x) {
ll tmp = pw(x, i);
if (!isx2(tmp)) {
noneleg.push_back(tmp);
}
}
}
sort(noneleg.begin(), noneleg.end());
noneleg.erase(unique(noneleg.begin(), noneleg.end()), noneleg.end());
ll T, N;
cin >> T;
while (T--) {
cin >> N;
ll x2 = floor(sqrt(N));
if (N == (x2 + 1) * (x2 + 1)) x2++;
ll others =
upper_bound(noneleg.begin(), noneleg.end(), N) - noneleg.begin();
cout << N - x2 - others << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int MAXM = 5e6 + 5;
const double eps = 1e-10;
const long long MOD = 998244353;
int x, y;
int cnt;
int judger(int c, int d) {
int aa = x ^ c, bb = y ^ d;
if (aa < bb)
return -1;
else if (aa == bb)
return 0;
else
return 1;
}
int read() {
int x;
cin >> x;
if (x == -2) {
exit(0);
}
return x;
}
void q(int c, int d) {
cout << "? " << c << " " << d << endl;
fflush(stdout);
}
int push(int c, int d) {
++cnt;
if (cnt == 63) {
puts("WA");
exit(0);
}
q(c, d);
int res = read();
return res;
}
int a[70];
int b[70];
int r1[70], r2[70], r3[70], r4[70];
int main() {
x = 3;
y = 1;
int la = push(0, 0), pre = 0;
for (int i = 29; i >= 0; --i) {
int x1 = 1 << i;
int r1 = push(pre + x1, 0);
int r2 = push(pre, x1);
int res;
if (r1 != r2) {
res = 0;
if (r1 == -1) {
a[i] = b[i] = 1;
} else
a[i] = b[i] = 0;
} else {
if (la == 1) {
a[i] = 1;
b[i] = 0;
} else {
a[i] = 0;
b[i] = 1;
}
la = r1;
pre += x1;
}
}
int a1 = 0, b1 = 0;
for (int i = 29; i >= 0; --i) {
a1 = (a1 << 1) + a[i];
b1 = (b1 << 1) + b[i];
}
printf("! %d %d\n", a1, b1);
if (a1 != x || b1 != y) {
printf("WA\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
int c[2][1005];
int dp[1005][2][1005];
int main() {
cin >> n >> m >> x >> y;
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) {
char t;
cin >> t;
if (t == '#')
c[0][j]++;
else
c[1][j]++;
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[1][0][1] = c[0][1];
dp[1][1][1] = c[1][1];
for (int i = 2; i <= m; i++) {
for (int col = 0; col < 2; col++) {
for (int len = 2; len <= y; len++) {
dp[i][col][len] = dp[i - 1][col][len - 1] + c[col][i];
}
for (int len = x; len <= y; len++) {
dp[i][col][1] = min(dp[i][col][1], dp[i - 1][!col][len]);
}
dp[i][col][1] += c[col][i];
}
}
for (int i = 1; i <= m; i++)
if (0) cerr << c[0][i] << " ";
if (0) cerr << endl;
for (int i = 1; i <= m; i++)
if (0) cerr << c[1][i] << " ";
if (0) cerr << endl;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= y; j++)
if (0) cerr << dp[i][0][j] << "," << dp[i][1][j] << " ";
if (0) cerr << endl;
}
int ans = 0x3f3f3f3f;
for (int i = x; i <= y; i++)
for (int col = 0; col < 2; col++) ans = min(ans, dp[m][col][i]);
cout << ans;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N=305;
int f[N][N],s[N][N],C[N][N],n,m,p;
int main()
{
scanf("%d%d%d",&n,&m,&p);
C[0][0]=1;
for(int i=1;i<=n;i++)
{
C[i][0]=C[i][i]=1;
for(int j=1;j<n;j++)C[i][j]=(C[i-1][j-1]+C[i-1][j])%p;
}
for(int i=0;i<=m;i++)f[1][i]=1,s[1][i]=m-i+1;
for(int i=2;i<=n+1;i++)
{
for(int j=0;j<=m;j++)
for(int l=1;l<i;l++)
f[i][j]=(f[i][j]+1ll*C[i-2][l-1]*f[i-l][j]%p*s[l][j+1])%p;
for(int j=m;j>=0;j--)s[i][j]=(s[i][j+1]+f[i][j])%p;
}
printf("%d\n",f[n+1][0]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string st1, st2, ans;
int tt[15], mmas[15];
void fin(int x) {
for (int i = x - 1; i >= 0; i--) {
if (tt[i]) {
tt[i]--;
ans += char(i + '0');
break;
}
}
for (int i = 9; i >= 0; i--) {
while (tt[i]--) {
ans += char(i + '0');
}
}
}
bool ccheck(int x) {
for (int i = 0; i <= 9; i++) {
mmas[i] = tt[i];
if (i == x) mmas[i]--;
}
string s = ans;
s += char(x + '0');
for (int i = 0; i <= 9; i++) {
while (mmas[i]--) {
s += char(i + '0');
}
}
return s <= st2;
}
int main() {
cin >> st1 >> st2;
for (int i = 0; i < (int)st1.size(); i++) {
int xx = st1[i] - '0';
tt[xx]++;
}
if ((int)st2.size() > (int)st1.size()) {
for (int i = 9; i >= 0; i--) {
while (tt[i]--) {
cout << i;
}
}
cout << endl;
return 0;
}
for (int i = 0; i < (int)st2.size(); i++) {
int xx = st2[i] - '0';
if (tt[xx]) {
if (ccheck(xx))
ans += st2[i];
else {
fin(xx);
break;
}
tt[xx]--;
} else {
fin(xx);
break;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long int b[n];
b[0] = a[0];
long long int cnt = 0;
for (long long int i = 1; i < n; i++) {
if (b[i - 1] > a[i]) {
cnt++;
b[i] = b[i - 1];
} else {
b[i] = b[i - 1] + a[i];
}
}
cout << n - cnt << '\n';
}
| 4 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;
const int MAXN = 3000 + 10;
int N;
char str[MAXN << 1];
int apos[MAXN]= {0}, bpos[MAXN]= {0};
int an = 0, bn = 0;
string f[MAXN], g[MAXN];
// f[i]: 强制选第i对a、b，对i...n对a、b的最大串
// g[i]: max (f[i], f[i + 1], ..., f[n])
int main () {
scanf ("%d%s", & N, str + 1);
for (int i = 1; i <= N << 1; i ++) {
if (str[i] == 'a') apos[++ an] = i;
if (str[i] == 'b') bpos[++ bn] = i;
}
for (int i = N; i >= 1; i --) {
if (apos[i] < bpos[i]) {
int j = i;
while (j <= N && apos[j] < bpos[i]) j ++;
f[i] = "ab" + g[j];
}
else {
int j = i;
while (j <= N && bpos[j] < apos[i]) j ++;
for (int k = 1; k <= j - i; k ++) f[i] += 'b';
f[i] += 'a' + (i + 1 == j ? g[i + 1] : f[i + 1]).substr(j - i - 1, string::npos);
}
g[i] = max (f[i], g[i + 1]);
}
cout << g[1] << endl;
return 0;
}
/*
3
aababb
*/
/*
9
abbbaababaababbaba
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
set<int>::iterator it;
int n;
int st[300005], top;
signed main() {
scanf("%d", &n);
char ss[10];
int ans = 0;
bool flag = 0;
int now = 0;
for (int i = 1; i <= 2 * n; i++) {
scanf("%s", ss);
if (ss[0] == 'a') {
int tmp;
scanf("%d", &tmp);
st[++top] = tmp;
if (s.size()) {
it = s.begin();
if ((*it) < tmp) flag = 1;
}
s.insert(tmp);
} else {
now++;
if (top && st[top] == now) {
top--;
} else {
if (flag) ans++, flag = 0, top = 0;
}
it = s.begin();
s.erase(it);
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[105], g[105][105], d;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> d;
if (i - d >= 0) g[i - d][i] = g[i][i - d] = 1;
if (i + d < n) g[i + d][i] = g[i][i + d] = 1;
g[i][i] = 1;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!g[i][j] && g[i][k] && g[k][j]) g[i][j] = g[j][i] = 1;
for (int i = 0; i < n; i++)
if (!g[a[i] - 1][i]) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
map<int, int> mp;
for (int i : a) mp[i]++;
vector<pair<pair<int, int>, pair<int, int> > > v;
int itr = 0;
int pre_val = -1;
int from_val = -1;
int from_ind = -1;
for (auto p : mp) {
if (pre_val + 1 < p.first) {
if (pre_val >= 0) {
v.push_back({{from_ind, itr - 1}, {from_val, pre_val}});
}
from_val = p.first;
from_ind = itr;
} else if (pre_val + 1 == p.first && p.second == 1) {
v.push_back({{from_ind, itr}, {from_val, p.first}});
from_ind = itr;
from_val = p.first;
}
itr += p.second;
pre_val = p.first;
}
v.push_back({{from_ind, itr - 1}, {from_val, pre_val}});
int answer = 0;
int l = 0;
int r = 0;
int from = 0;
int to = 0;
for (auto p : v) {
if (answer < p.first.second - p.first.first + 1) {
answer = p.first.second - p.first.first + 1;
from = p.second.first;
to = p.second.second;
l = p.first.first;
r = p.second.second;
}
}
cout << answer << endl;
for (int i = from; i <= to; i++) {
mp[i]--;
cout << i << " ";
}
for (int i = to; i >= from; i--) {
while (mp[i]--) {
cout << i << " ";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1002;
int n, m;
char table[MAX][MAX];
struct UnionFind {
int n, p[2 * MAX], w[2 * MAX];
UnionFind(int _n) {
n = _n;
for (int i = 0; i < n; i++) w[i] = 1;
for (int i = 0; i < n; i++) p[i] = i;
}
void uni(int i, int j) {
int u = root(i), v = root(j);
if (u == v) return;
if (w[u] > w[v]) {
p[v] = u;
w[u] += w[v];
} else {
p[u] = v;
w[v] += w[u];
}
}
bool connected(int i, int j) {
int u = root(i), v = root(j);
if (u == v)
return true;
else
return false;
}
int root(int k) {
while (p[k] != k) k = p[k];
return k;
}
} uf(2 * MAX);
vector<int> adj[2 * MAX];
int val[2 * MAX], outdeg[2 * MAX];
bool comp[2 * MAX], cycle;
void dfs(int v, int k) {
val[v] = k;
comp[v] = false;
for (int w : adj[v]) {
if (val[w] <= val[v] && comp[w])
dfs(w, k + 1);
else if (!comp[w]) {
cycle = true;
return;
}
}
comp[v] = true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> table[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (table[i][j] == '=') uf.uni(i, j + n);
memset(outdeg, 0, sizeof(outdeg));
for (int i = 0; i < m + n; i++) comp[i] = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int u = uf.root(i), v = uf.root(j + n);
if (table[i][j] == '<') {
adj[u].push_back(v);
outdeg[v]++;
}
if (table[i][j] == '>') {
adj[v].push_back(u);
outdeg[u]++;
}
}
for (int i = 0; i < m + n; i++) val[i] = 1;
vector<int> s;
for (int i = 0; i < m + n; i++)
if (outdeg[i] == 0 && adj[i].size() > 0) s.push_back(i);
if (s.size() == 0) {
s.push_back(uf.root(0));
}
for (int i : s) dfs(i, 1);
if (cycle) {
cout << "No";
return 0;
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << val[uf.root(i)] << " ";
cout << "\n";
for (int i = 0; i < m; i++) cout << val[uf.root(i + n)] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int a[60][60][60], n, m, r, s, t, c, min[59][60][60];
int main() {
scanf("%d%d%d", &n, &m, &r);
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) scanf("%d", &a[i][j][k]);
for (int i = 0; i < m; i++)
for (int l = 0; l < n; l++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
if (a[i][j][k] > a[i][j][l] + a[i][l][k])
a[i][j][k] = a[i][j][l] + a[i][l][k];
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) {
min[0][j][k] = a[0][j][k];
for (int i = 1; i < m; i++)
if (min[0][j][k] > a[i][j][k]) min[0][j][k] = a[i][j][k];
}
for (int i = 1; i <= 58; i++) {
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) min[i][j][k] = min[i - 1][j][k];
for (int w = 0; w < n; w++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
if (min[i][j][k] > min[0][j][w] + min[i - 1][w][k])
min[i][j][k] = min[0][j][w] + min[i - 1][w][k];
}
while (r > 0) {
scanf("%d%d%d", &s, &t, &c);
printf("%d\n", c < 58 ? min[c][s - 1][t - 1] : min[58][s - 1][t - 1]);
--r;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
FILE *f, *g;
struct cp {
int f, c, z;
};
cp a[150][150];
vector<int> e[150];
int n, m, l, sum;
int v[150], bf[27], bf2[27];
int tt[150];
char t[150];
int flw, sol;
int H[150], pos[150];
int dist[150];
bool inq[150];
int con[150];
void fa_muchie(int x, int y, int cap, int cost) {
a[x][y].c = cap;
a[x][y].z = cost, a[y][x].z = -cost;
e[x].push_back(y);
e[y].push_back(x);
}
void read() {
int i, j, ax, x, y, nn;
char c;
scanf("%s", t);
scanf("%d", &nn);
scanf("%c", &c);
while (c != '\n') scanf("%c", &c);
n = nn + 28, m = 0;
for (i = 0, ax = strlen(t); i < ax; i++) bf[t[i] - 'a' + 1]++;
for (i = 1; i <= 26; i++) {
if (bf[i] > 0) fa_muchie(nn + i + 1, n, bf[i], 0);
}
for (i = 1; i <= nn; i++) {
scanf("%s", &t);
scanf("%d", &v[i]);
fa_muchie(1, i + 1, v[i], i);
for (j = 1; j <= 26; j++) bf2[j] = 0;
for (j = 0, ax = strlen(t); j < ax; j++) bf2[t[j] - 'a' + 1]++;
for (j = 1; j <= 26; j++)
if (bf2[j] > 0 && bf[j] > 0) {
fa_muchie(i + 1, nn + j + 1, bf2[j], 0);
}
if (i < n) {
scanf("%c", &c);
while (c != '\n') scanf("%c", &c);
}
}
}
void bellman_ford() {
int i, j, x, ok = 1;
vector<int> q;
q.clear();
for (i = 1; i <= n; i++) dist[i] = 10000000;
q.push_back(1);
inq[1] = true;
dist[1] = 0;
for (i = 0; i < q.size() && ok; i++) {
x = q[i];
inq[x] = false;
for (j = 0; j < e[x].size(); j++)
if (a[x][e[x][j]].c - a[x][e[x][j]].f > 0 &&
dist[x] + a[x][e[x][j]].z < dist[e[x][j]]) {
dist[e[x][j]] = dist[x] + a[x][e[x][j]].z;
if (inq[e[x][j]] == false) {
if (con[e[x][j]] > n)
ok = 0;
else {
q.push_back(e[x][j]);
inq[e[x][j]] = true;
con[e[x][j]]++;
}
}
}
}
sum = dist[n];
}
void up(int x) {
int ax;
while (x / 2 && dist[H[x / 2]] > dist[H[x]]) {
ax = H[x];
H[x] = H[x / 2];
H[x / 2] = ax;
pos[H[x]] = x;
pos[H[x / 2]] = x / 2;
x /= 2;
}
}
void down(int x) {
int ax, y = 0;
while (x != y) {
y = x;
if (y * 2 < l && dist[H[y * 2]] < dist[H[x]]) x = y * 2;
if (y * 2 + 1 < l && dist[H[y * 2 + 1]] < dist[H[x]]) x = y * 2 + 1;
ax = H[x];
H[x] = H[y];
H[y] = ax;
pos[H[x]] = x;
pos[H[y]] = y;
}
}
void cut() {
H[1] = H[l];
pos[H[1]] = 1;
l--;
down(1);
}
int dijkstra() {
int i, j, r = 1, x, mn;
for (i = 1; i <= n; i++)
for (j = 0; j < e[i].size(); j++)
if (dist[i] != 10000000 && dist[e[i][j]] != 10000000)
a[i][e[i][j]].z += dist[i] - dist[e[i][j]];
l = n;
for (i = 1; i <= l; i++) {
H[i] = i;
pos[i] = i;
dist[i] = 10000000;
tt[i] = -1;
}
dist[1] = 0;
for (; l && dist[H[1]] != 10000000; cut()) {
x = H[1];
for (j = 0; j < e[x].size(); j++)
if (a[x][e[x][j]].c - a[x][e[x][j]].f > 0 &&
dist[x] + a[x][e[x][j]].z < dist[e[x][j]]) {
tt[e[x][j]] = x;
dist[e[x][j]] = dist[x] + a[x][e[x][j]].z;
up(pos[e[x][j]]);
}
}
if (dist[n] != 10000000) {
for (mn = 10000000, i = n; i != 1; i = tt[i])
mn = min(mn, a[tt[i]][i].c - a[tt[i]][i].f);
for (i = n; i != 1; i = tt[i]) {
a[tt[i]][i].f += mn;
a[i][tt[i]].f -= mn;
}
flw += mn;
sum += dist[n];
sol = sol + mn * sum;
return 1;
}
return 0;
}
int flow() {
int ok, i;
while (dijkstra())
;
for (i = n - 26, ok = 1; i < n; i++)
if (a[i][n].c - a[i][n].f != 0) return -1;
return sol;
}
int main() {
read();
bellman_ford();
printf("%d", flow());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> a >> b;
n--;
a--;
b--;
if (a / m == b / m) {
cout << 1;
} else if (b == n) {
cout << (a % m == 0 ? 1 : 2);
} else {
int ans = 1;
if (a % m != 0) {
ans++;
}
if (b % m != m - 1) {
ans++;
}
if (a % m != 0 && b % m != m - 1) {
if (a / m + 1 == b / m) {
ans--;
} else if ((a % m - 1 + m) % m == b % m) {
ans--;
}
}
cout << ans;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, a, b, h;
cin >> n >> a >> b >> h;
int mini = INT_MAX;
string s;
cin >> s;
int count0 = 0, count1 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0')
count0++;
else
count1++;
}
long long int ans = a * count0 + b * count1;
ans = min(ans, 1ll * (n * a + count1 * h));
ans = min(ans, 1ll * (n * b + count0 * h));
cout << ans << endl;
}
}
| 1 |
#pragma GCC optimize("O3")
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <ctime>
#include <cstring>
#include <stack>
#include <ctime>
#include <iomanip>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
//#include <ext/pb_ds/assoc_container.hpp>
#define fi first
#define se second
#define th third
#define en "\n"
#define sqrt(n) sqrt((long double) n)
#define ALL(c) (c).begin() , (c).end()
#define MOD 998244353
#define MEM0(a) memset(a,0,sizeof(a))
#define FAST() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define FILES(name) name!=""?freopen(name".in","r",stdin),freopen(name".out","w",stdout):0
#define elif else if
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#define SZ(a) ((long long)((a).size()))
#define WHAT_IS(x) cerr << #x << " is " << x << en
#define TIMER (clock()*1.0/CLOCKS_PER_SEC)
#define int long long
using namespace std;
template<class A, class B, class C> struct triple { A first; B second; C third;
bool operator<(const triple& t) const { if (first != t.first) return first < t.first; if (second != t.second) return second < t.second; return third < t.third; } };
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef set<int> seti;
typedef long double ld;
typedef pair<ld, ld> pdd;
typedef triple<int, int, int> tiii;
const ld EPS=0.000000001;
const ld INFD32=1000000000;
const ll INF64=1000000000000000000;
const ll INF32=1000000000;
const ll one=1;
bool iss_ll(ll __1,ll __2){ return INF64/__1>=__2;}
bool equal(double _1,double _2){ return (abs(_1-_2)<EPS);}
bool iss_sqr(const int &__1){ll __2=sqrt(__1); return __2*__2==__1;};
bool iss_prime(ll __1){for (int i=2; i*i<=__1; ++i) if (!(__1%i)) return 0; return 1;}
int gcd(int __1,int __2){ while (__1 && __2) if (__1>__2) __1=__1%__2; else __2=__2%__1; return __1+__2;}
int lcm(int __1,int __2){ return __1*__2/(gcd(__1, __2));}
int sq_cube(ll x){if (x==0) return 1;int l=0,r=2e6;while (l+1<r){int m=(l+r)/2;if (m*m*m>x) r=m;else l=m;}return l;}
ll bp(ll a,ll b,ll md){ll res=1;while (b) {if (b&1) res*=a;a*=a;a%=md;res%=md;b>>=1;}return res;}
ll inv(ll x,ll md) {return bp(x, md - 2, md);}
void update_by_mod(int &x,int md){
x%=md;
if (x<0) x+=md;
}
void update_by_mod(int &x,int &y,int md){
update_by_mod(x,md);
update_by_mod(y,md);
}
void update_by_mod(int &x,int &y,int &z,int md){
update_by_mod(x,md);
update_by_mod(y,md);
update_by_mod(z,md);
}
void update_by_mod(int &x,int &y,int &z,int &a,int md){
update_by_mod(x,md);
update_by_mod(y,md);
update_by_mod(z,md);
update_by_mod(a,md);
}
template <class T>
T sqr(T x){
return x*x;
}
/*
#define maxN 444
int fact[maxN],rfact[maxN];
void bld(int md) {
fact[0] = 1;
for (int i = 1; i < maxN; ++i) {
fact[i] = fact[i - 1] * i % md;
}
rfact[maxN - 1] = bp(fact[maxN - 1], md - 2, md);
for (int i = maxN - 2; i >= 0; --i) {
rfact[i] = rfact[i + 1] * (i + 1) % md;
}
}
int C(int n,int k,int md) {
if (k > n) return 0;
int res = fact[n];
res *= rfact[k];
res %= md;
res *= rfact[n - k];
res %= md;
return res;
}
*/
#define maxN 500500
void preCalc(){
}
int cnt[maxN];
void solve() {
int n,k;
cin>>n>>k;
if (n%2 && k%2==0){
cout<<-1<<en;
return;
}
if (n%k==0){
int ans=0;
for (int j=0; j<n/k; ++j){
cout<<"? ";
for (int i=j*k+1; i<=k*(j+1); ++i){
cout<<i<<" ";
}
cout<<endl;
int x;
cin>>x;
ans^=x;
}
cout<<"! "<<ans<<endl;
return;
}
for (int i=0; i<n; ++i) cnt[i]=1;
int sum=n;
int pos=0;
while (sum%k || sum/k<3){
cnt[pos]+=2;
pos++;
pos%=n;
sum+=2;
}
//cout<<sum<<en;
vpii VEC;
int ans=0;
for (int i=0; i<n; ++i){
VEC.push_back({cnt[i],i+1});
}
SORT(VEC);
while (VEC.front().first!=0 || VEC.back().first!=0){
SORT(VEC);
REVERSE(VEC);
cout<<"? ";
for (int j=0; j<k; ++j){
VEC[j].first--;
cout<<VEC[j].second<<" ";
}
cout<<endl;
int x;
cin>>x;
ans^=x;
SORT(VEC);
if (VEC.front().first<0){
for (int i=0; i<k; ++i) VEC[i].first+=2;
}
SORT(VEC);
}
cout<<"! "<<ans<<endl;
}
signed main(void) {
//look at the end
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
//cerr<<TIMER<<en;
preCalc();
int t = 1;
//cin >> t;
for (int i = 1; i <= t; ++i) {
//cout<<"Case #"<<i<<": ";
solve();
}
cerr<<TIMER<<en;
return 0;
}
//check special cases for example (n==1)
//check size arrays | 5 |
#include <bits/stdc++.h>
using namespace std;
long long q[2000];
int len;
void init() {
q[0] = 4;
q[1] = 7;
int h = 0, t = 2;
while (h < t) {
if ((long long)q[h] * 10 <= 1000000000) {
q[t++] = q[h] * 10 + 4;
q[t++] = q[h] * 10 + 7;
}
h++;
}
len = t;
q[len++] = 4444444444;
sort(q, q + len);
}
int main(int argc, char* argv[]) {
init();
int l, r;
scanf("%d%d", &l, &r);
long long ans = 0;
for (int i = 0; i < len; i++) {
if (q[i] <= r) {
if (q[i] >= l) {
if (i > 0) {
if (q[i - 1] >= l)
ans += q[i] * (q[i] - q[i - 1]);
else
ans += q[i] * (q[i] - l + 1);
} else {
ans += q[i] * (q[i] - l + 1);
}
}
} else {
if (i > 0) {
if (q[i - 1] < r) {
if (q[i - 1] >= l)
ans += q[i] * (r - q[i - 1]);
else
ans += q[i] * (r - l + 1);
}
} else {
ans += q[i] * (r - l + 1);
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include<stdio.h>
#include<string.h>
int main(){
int taro[105],hanako[105],nt,nh,i,j,d=0,d2;
int min=100000,mint=-1,minh=-1;
while(1){
scanf("%d %d",&nt,&nh);
if(nt==0 && nh==0)
break;
d=0;
min=100000;
mint=-1;
minh=-1;
for(i=0;i<nt;i++){
scanf("%d",&taro[i]);
d+=taro[i];
}
for(i=0;i<nh;i++){
scanf("%d",&hanako[i]);
d-=hanako[i];
}
//printf(":%d\n",d);
for(i=0;i<nt;i++){
for(j=0;j<nh;j++){
d2=-taro[i]+hanako[j];
//printf(":%d",d2);
if(d==d2*(-2) && min>=taro[i]+hanako[j]){
min=taro[i]+hanako[j];
mint=i;
minh=j;
}
}
}
if(mint==-1){
printf("-1\n");
}else{
printf("%d %d\n",taro[mint],hanako[minh]);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, max_i = (n); i < max_i; i++)
#define REPI(i, a, b) for (int i = (a), max_i = (b); i < max_i; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define fi first
#define se second
#define int long long
using namespace std;
using ll = long long;
using II = pair<int, int>; using VII = vector<II>;
using VI = vector<int>; using VVI = vector<VI>; using VVVI = vector<VVI>;
template <class T = int> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template <class T = int> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
template <class T> ostream& operator<<(ostream &s, const vector<T>& d) { int n = d.size(); REP (i, n) s << d[i] << " "; return s; }
template <class T> ostream& operator<<(ostream &s, const vector<vector<T>>& dd) { for (vector<T> d: dd) s << d << endl; return s; }
template <class T, class S> ostream& operator<<(ostream &s, const pair<T, S>& p) { s << "{" << p.first << ", " << p.second << "}"; return s; }
#ifdef _MY_DEBUG
#define dump(...) cerr << "\t" << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" << endl << "\t", dump_func(__VA_ARGS__);
#else
#define dump(...)
#endif
void dump_func() { cerr << endl; }
template <class Head, class... Tail> void dump_func(Head&& h, Tail&&... t) { cerr << h << (sizeof...(Tail) == 0 ? "" : ", "), dump_func(forward<Tail>(t)...); }
struct Fast { Fast() { cin.tie(0); ios::sync_with_stdio(false); } } fast;
const int MOD = 1e9 + 7;
bool check(VI& pp, VI& f, int k, int del = -1) {
dump(pp, f, del);
int i_f = (int)f.size() - k;
if (del >= i_f) i_f--;
REP (i, k) {
if (i_f < 0 | i_f >= f.size()) return false;
while (i_f == del) i_f++;
if (i_f < 0 | i_f >= f.size()) return false;
if (pp[i] >= f[i_f]) return false;
i_f++;
}
return true;
}
signed main() {
int n; cin >> n;
VI p(n), f(n);
REP (i, n) cin >> p[i];
REP (i, n) cin >> f[i];
sort(ALL(f));
int acc = 0;
{
VI pp = p; sort(ALL(pp));
REP (i, n) {
if (check(pp, f, i + 1)) {
acc = max(acc, i + 1);
}
}
}
VI ans;
REP (i, n) {
dump(i);
const int op = p.front();
p.erase(p.begin());
VI pp = p; sort(ALL(pp));
int l = 0, r = f.size();
bool win = f.back() > op;
if (win) {
l = upper_bound(ALL(f), op) - f.begin();
}
dump(f, l);
while (r - l > 1) {
int m = (l + r) / 2;
dump(m);
bool ok = check(pp, f, (win ? acc - 1 : acc), m);
dump(ok)
(ok ? l : r) = m;
}
if (win) acc--;
ans.push_back(f[l]);
f.erase(f.begin() + l);
}
REP (i, n) {
cout << ans[i] << (i == n - 1 ? "\n" : " ");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 1;
int a[MAXN];
set<int> st;
map<int, int> cnt;
void findAndErase(int k) {
set<int>::iterator it = st.find(k);
if (it != st.end()) st.erase(it);
}
void add(int k) {
if (cnt[k] == 1)
findAndErase(k);
else if (!cnt[k])
st.insert(k);
cnt[k]++;
}
void del(int k) {
cnt[k]--;
if (!cnt[k]) findAndErase(k);
if (cnt[k] == 1) st.insert(k);
}
int main() {
int n, k, t, toAdd, toDel;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> t;
a[i] = -t;
}
for (int i = 0; i < k; i++) add(a[i]);
for (int i = k; i <= n; i++) {
toAdd = a[i], toDel = a[i - k];
if (st.size())
cout << -(*st.begin()) << endl;
else
cout << "Nothing" << endl;
del(toDel);
add(toAdd);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
long long ans = 1;
for (int i = 0; i < n; ++i) {
if (a[i] >= ans) ans++;
}
cout << ans;
}
| 2 |
#include <cstdio>
typedef long long ll;
const int Maxn=300;
ll a[Maxn+5];
int n;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
}
ll sum=0;
for(int i=3;i<=n;i++){
sum^=a[i];
}
ll d=(a[1]+a[2])-sum;
if(d<0||(d&1)){
puts("-1");
return 0;
}
d>>=1;
if(d>a[1]||(d&sum)>0){
puts("-1");
return 0;
}
ll ans=d;
for(int i=59;i>=0;i--){
if((sum>>i)&1){
if(ans+(1ll<<i)<=a[1]){
ans+=(1ll<<i);
}
}
}
if(ans==0){
puts("-1");
}
else{
printf("%lld\n",a[1]-ans);
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define MAXN 150
using namespace std;
int a[MAXN*1000],arr[MAXN][MAXN],r=1,c=1,dir=1;
int main(){
int h,w;
cin>>h>>w;
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<n;i++){
while(a[i]){
arr[r][c]=i+1;
a[i]--;
if(dir==1){
if(c==w){
r++;
dir=-1;
}
else{
c++;
}
}
else{
if(c==1){
r++;
dir=1;
}
else{
c--;
}
}
}
}
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
cout<<arr[i][j]<<" ";
}cout<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
string s1, s2;
cin >> s1 >> s2;
long long i, n = s1.size(), k1 = 0, k2 = 0, flag = 0, cnt = 0;
for (i = 0; i < n; i++) {
if (s1[i] == '4' && s2[i] == '7')
k1++;
else if (s1[i] == '7' && s2[i] == '4')
k2++;
}
if (k1 >= k2) {
cnt = k2 + (k1 - k2);
} else {
cnt = k1 + (k2 - k1);
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < 1 << n; ++i) {
int res = 0;
for (int j = 0; j < n; ++j) {
if ((i >> j) & 1)
res = (res + a[j]) % 360;
else
res = (res - a[j] + 360) % 360;
}
if (res == 0) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 2 |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
class BIT {
public:
BIT(int _n): n(_n) {
x = vector<int>(_n);
}
void Insert(int a, int b) {
for (int i = a; i < n; i += (i & -i)) x[i] += b;
}
int Query(int a) {
int ans = 0;
for (int i = a; i > 0; i -= (i & -i)) ans += x[i];
return ans;
}
int n;
vector<int> x;
};
using LL = long long;
char cc[4] = {'A', 'N', 'T', 'O'};
vector<int> x[4];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int times;
cin >> times;
while (times--) {
for (int i = 0; i < 4; ++i) x[i].clear();
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'A') {
x[0].push_back(i + 1);
} else
if (s[i] == 'N') {
x[1].push_back(i + 1);
} else
if (s[i] == 'T') {
x[2].push_back(i + 1);
} else
if (s[i] == 'O') {
x[3].push_back(i + 1);
}
}
vector<int> p {0, 1, 2, 3};
vector<int> ans;
LL cnt = -1;
do {
BIT bit(n + 5);
LL now = 0;
for (int i = 0; i < 4; ++i) {
for (int j : x[p[i]]) {
now += bit.Query(n) - bit.Query(j - 1);
bit.Insert(j, 1);
}
}
if (now > cnt) {
cnt = now;
ans = p;
}
} while (next_permutation(p.begin(), p.end()));
string anss;
for (int i : ans) {
for (int j : x[p[i]]) {
anss.push_back(cc[i]);
}
}
cout << anss << '\n';
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int a[3005], b[3005], c[3005], d[3005], e[3005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) cin >> c[i];
d[1] = a[1], e[1] = b[1];
for (int i = 2; i <= n; i++) {
d[i] = max(a[i] + e[i - 1], b[i] + d[i - 1]);
e[i] = max(b[i] + e[i - 1], c[i] + d[i - 1]);
}
cout << d[n];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
void exgcd(long long a, long long b, long long &d, long long &first,
long long &second) {
b ? exgcd(b, a % b, d, second, first),
second -= a / b *first : first = 1, second = 0, d = a;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
const long long INF = 1e9;
const int N = 4e5 + 10;
int a, b, h, w, n, t, ans;
int f[N];
void dfs(int d, int h, int w) {
if (d - 1 >= ans) return;
int hh = h, ww = w, ret = 0;
while (hh < a) hh <<= 1, ++ret;
while (ww < b) ww <<= 1, ++ret;
if (ret <= t) ans = min(ans, d - 1 + ret);
if (d > n) return;
if (h < a) dfs(d + 1, min((long long)h * f[d], INF), w);
if (w < b) dfs(d + 1, h, min((long long)w * f[d], INF));
}
int main() {
scanf("%d%d%d%d%d", &a, &b, &h, &w, &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", f + i);
if (f[i] == 2) ++t, --i, --n;
}
sort(f + 1, f + 1 + n, greater<int>());
ans = INF, dfs(1, h, w), dfs(1, w, h);
printf("%d\n", ans == INF ? -1 : ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int x;
int y;
} Point;
int main() {
string input;
getline(cin, input);
int pointsCount = atol(input.c_str());
int *points = new int[pointsCount];
getline(cin, input);
stringstream pointsStream(input);
for (int i = 0; i < pointsCount; i++) {
string temp;
if (pointsStream.good()) {
pointsStream >> temp;
points[i] = atoi(temp.c_str());
}
}
Point current;
current.x = current.y = 0;
Point yMax;
yMax.x = yMax.y = 0;
Point yMin;
yMin.x = yMin.y = 0;
Point xMax;
xMax.x = xMax.y = 0;
for (int i = 0; i < pointsCount; i++) {
current.x += points[i];
if (i % 2 == 0) {
current.y += points[i];
} else {
current.y -= points[i];
}
if (current.y > yMax.y) {
yMax = current;
}
if (current.y < yMin.y) {
yMin = current;
}
if (current.x > xMax.x) {
xMax = current;
}
}
int width = xMax.x;
int height = yMax.y - yMin.y;
char **cardio = new char *[width];
for (int i = 0; i < width; i++) {
cardio[i] = new char[height];
}
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
cardio[x][y] = ' ';
}
}
current.x = 0;
current.y = height + yMin.y - 1;
for (int i = 0; i < pointsCount; i++) {
for (int j = 0; j < points[i]; j++) {
if (i % 2 == 0) {
cardio[current.x][current.y] = '/';
if (j != points[i] - 1) {
current.y--;
}
} else {
cardio[current.x][current.y] = '\\';
if (j != points[i] - 1) {
current.y++;
}
}
current.x++;
}
}
for (int j = 0; j < height; j++) {
for (int i = 0; i < width; i++) {
printf("%c", cardio[i][j]);
}
printf("\n");
}
for (int i = 0; i < width; i++) {
delete[] cardio[i];
}
delete[] cardio;
delete[] points;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1;
const int inf = 1e9 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x, y, z;
cin >> x;
cout << x / 2 + 1 << endl;
for (int i = 1; i <= x; i++) {
if (i & 1)
cout << i / 2 + 1 << " " << i / 2 + 1 << endl;
else
cout << i / 2 << " " << i / 2 + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int SZ = 55555;
string s;
void solve() {
int k;
cin >> k >> s;
s += 'A';
int l = -1, ans = 0;
for (int i = 0; i <= k; ++i) {
if (s[i] == 'A') {
if (l >= 0) {
ans = max(i - l - 1, ans);
}
l = i;
}
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 1 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e9;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
int in[13]={0};
int n;
int q[13];
int w[3]={0,1,-1};
bool f(int c){
if(c==12){
int sum=0;
rep(i,12)sum+=q[i]*w[in[i]];
if(n==sum){
string s="";
rep(i,12)if(in[i]==0)s="0"+s;
else if(in[i]==1)s="+"+s;
else s="-"+s;
while(s[0]=='0')s=s.substr(1);
cout<<s<<endl;
return 1;
}
return 0;
}
rep(i,3){
in[c]=i;
if(f(c+1))return 1;
}
return 0;
}
int main(){
int t=1;
rep(i,13){
q[i]=t;
t*=3;
}
cin>>n;
f(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const char s[4][100] = {"What are you doing while sending \"",
"\"? Are you busy? Will you send \"", "\"?",
"What are you doing at the end of the world? Are you "
"busy? Will you save us?"};
long long c[100010] = {75};
char dfs(int n, long long x) {
if (x > c[n]) return '.';
if (n == 0) return s[3][x - 1];
if (x <= 34)
return s[0][x - 1];
else if (x <= 34 + c[n - 1])
return dfs(n - 1, x - 34);
else if (x <= 34 + c[n - 1] + 32)
return s[1][x - 34 - c[n - 1] - 1];
else if (x <= 34 + c[n - 1] + 32 + c[n - 1])
return dfs(n - 1, x - 34 - c[n - 1] - 32);
return s[2][x - 34 - c[n - 1] - 32 - c[n - 1] - 1];
}
int main() {
long long b;
int n, a;
ios::sync_with_stdio(false);
for (int i = 1; i <= 54; i++) c[i] = c[i - 1] * 2 + 68;
for (int i = 55; i <= 100000; i++) c[i] = c[i - 1];
cin >> n;
while (n--) {
cin >> a >> b;
putchar(dfs(a, b));
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long A[100005], P[100005], N, S, G;
long long g(long long a, long long b) { return b == 0 ? a : g(b, a % b); }
int main() {
cin >> N;
for (long long i = 0; i < N; i++) {
cin >> A[i];
S += A[i];
}
sort(A, A + N);
for (long long i = 1; i < N; i++) {
P[i] = P[i - 1] + (A[i] - A[i - 1]) * i;
S += 2 * P[i];
}
G = g(N, S);
N /= G, S /= G;
cout << S << " " << N;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int v, r, d;
node() {}
node(int V, int R, int D) : v(V), r(R), d(D) {}
} nodes[1009 * 1009];
struct jibancanyang {
int n, m, q;
int f(int i, int j) { return i * (m + 1) + j; }
int g(int i, int j) {
int k = 0;
while (i--) k = nodes[k].d;
while (j--) k = nodes[k].r;
return k;
}
void print() {
int k = 0;
for (int i = 0; i < n; ++i) {
k = nodes[k].d;
for (int j = 0, t = k; j < m; ++j) {
t = nodes[t].r;
printf("%d ", nodes[t].v);
}
puts("");
}
}
void build() {
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
nodes[f(i, j)] = node(0, f(i, j + 1), f(i + 1, j));
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &nodes[f(i, j)].v);
}
}
while (q--) {
int a, b, x, y, l, w;
scanf("%d%d%d%d%d%d", &a, &b, &x, &y, &w, &l);
a = g(a - 1, b - 1), b = g(x - 1, y - 1);
x = a, y = b;
for (int i = 0; i < l; ++i) {
a = nodes[a].r, b = nodes[b].r;
swap(nodes[a].d, nodes[b].d);
}
for (int i = 0; i < w; ++i) {
a = nodes[a].d, b = nodes[b].d;
swap(nodes[a].r, nodes[b].r);
}
for (int i = 0; i < w; ++i) {
x = nodes[x].d, y = nodes[y].d;
swap(nodes[x].r, nodes[y].r);
}
for (int i = 0; i < l; ++i) {
x = nodes[x].r, y = nodes[y].r;
swap(nodes[x].d, nodes[y].d);
}
}
print();
}
} ac;
int main() {
scanf("%d%d%d", &ac.n, &ac.m, &ac.q);
ac.build();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[101];
int E = 0, S = 0, e = 0, s = 0;
a[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] == 1)
E += 1;
else if (a[i] == -1)
S += 1;
}
int max = 0;
for (int b = 1; b <= n; ++b) {
e = E, s = S;
for (int i = (1 - b) / k; i <= (n - b) / k; ++i) {
int c = b + k * i;
if (c > 0 && c <= n && e >= 0 && s >= 0) {
if (a[c] == 1) {
a[c] == 0;
e -= 1;
} else if (a[c] == -1) {
a[c] == 0;
s -= 1;
}
}
}
int ans = abs(e - s);
if (ans > max) max = ans;
}
cout << max;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 5e3 + 3, M = 1e5 + 3, BIG = (long long)1e9 + 3,
MOD = 1e9 + 7, P = 29, P2 = 'z' - 'a' + 1, K = 4;
const double PI = 3.14159265359;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, s, f, ans = 0, ans_v = BIG;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
cin >> s >> f;
for (int i = 0; i < n; ++i) a.push_back(a[i]);
vector<long long> pref(a.size());
for (int i = 0; i < a.size(); ++i) pref[i] = (i > 0 ? pref[i - 1] : 0) + a[i];
long long sum_now = 0, sz = f - s;
ans = pref[sz - 1];
ans_v = s;
long long t = s;
for (int i = sz; i < a.size(); ++i) {
sum_now = pref[i] - pref[i - sz];
--t;
if (t == 0) t = n;
if (ans < sum_now || (ans == sum_now && t < ans_v)) {
ans = sum_now;
ans_v = t;
}
}
cout << ans_v;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
long long int n = s.length();
if (s[n - 1] == 'E') {
long long int count = 0;
for (long long int i = 0; i < n - 1; i++) {
if (s[i] == 'N') count++;
}
if (count == 1) {
cout << "NO";
return;
}
cout << "YES";
} else {
long long int count = 0;
for (long long int i = 0; i < n - 1; i++) {
if (s[i] == 'N') count++;
}
if (count == 0) {
cout << "NO";
return;
}
cout << "YES";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5 * (int)1e5 + 10;
vector<int> g[maxN];
long long c[maxN];
int n, m, k;
int sz = 1;
const int mod = (int)1e9 + 7;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
vector<pair<int, int> > edges[maxN];
int pw[maxN];
int p[maxN];
vector<int> roll_back;
int cnt = 0;
int find(int a) {
if (a == p[a]) return a;
p[a] = find(p[a]);
return p[a];
}
int cmp;
void unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
cnt++;
cmp--;
roll_back.push_back(a);
p[a] = b;
cnt++;
}
void go_back() {
while (!roll_back.empty()) {
p[roll_back.back()] = roll_back.back();
roll_back.pop_back();
}
cmp = n;
}
int main() {
srand(123 + 23123123 + 123123 - 123123);
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) p[i] = i;
cmp = n;
pw[0] = 1;
for (int i = 1; i < maxN; i++) pw[i] = mult(pw[i - 1], 2);
for (int i = 1; i <= n; i++) cin >> c[i];
vector<pair<long long, pair<int, int> > > all;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
all.emplace_back(make_pair(c[a] ^ c[b], make_pair(a, b)));
}
sort(all.begin(), all.end());
int i = 0;
while (i < all.size()) {
int j = i;
while ((j < all.size()) && all[j].first == all[i].first) j++;
j--;
for (int k = i; k <= j; k++) edges[sz].push_back(all[k].second);
sz++;
i = j + 1;
}
sz--;
int ans = mult(pw[n], sub(pw[k], sz));
for (int i = 1; i <= sz; i++) {
for (auto t : edges[i]) {
unite(t.first, t.second);
}
ans = sum(ans, pw[cmp]);
go_back();
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 7;
const long long INF = 1e9 + 7;
long long n, m;
long long fac[N];
int main() {
scanf("%I64d%I64d", &n, &m);
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % m;
long long ans = 0;
for (long long i = 1; i <= n; i++)
ans = (ans + (n - i + 1) * (n - i + 1) % m * fac[i] % m * fac[n - i]) % m;
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<int, int> > > edges;
vector<int> adj[100005];
vector<int> topo;
int n;
int visit[100005];
void dfs(int i) {
visit[i] = 1;
for (int j = 0; j < adj[i].size(); j++) {
if (visit[adj[i][j]] == 0) dfs(adj[i][j]);
}
topo.push_back(i);
}
bool find_topo(int ans) {
topo.clear();
for (int i = 1; i <= n; i++) {
visit[i] = 0;
adj[i].clear();
}
for (int i = 0; i < edges.size(); i++) {
if (edges[i].first > ans) {
adj[edges[i].second.first].push_back(edges[i].second.second);
}
}
for (int i = 1; i <= n; i++) {
if (visit[i] == 0) {
dfs(i);
}
}
reverse(topo.begin(), topo.end());
int ind[n + 2];
for (int i = 0; i < topo.size(); i++) ind[topo[i]] = i;
for (int i = 0; i < edges.size(); i++) {
if (edges[i].first > ans &&
ind[edges[i].second.first] > ind[edges[i].second.second])
return false;
}
return true;
}
void print(int ans) {
find_topo(ans);
int ind[n + 2];
for (int i = 0; i < topo.size(); i++) ind[topo[i]] = i;
vector<int> v;
for (int i = 0; i < edges.size(); i++) {
if (edges[i].first <= ans) {
if (ind[edges[i].second.first] > ind[edges[i].second.second])
v.push_back(i + 1);
}
}
cout << ans << " " << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
}
int main() {
int m, x, y, w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
edges.push_back(make_pair(w, make_pair(x, y)));
}
int l = 0;
int r = 1000000000;
int ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (find_topo(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
print(ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int intmax = 0x3f3f3f3f;
const long long i64max = 0x3f3f3f3f3f3f3f3fll;
double eps = 1e-6;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T checkmod(T n, T m) {
return (n % m + m) % m;
}
inline int rand(int a, int b) {
if (a >= b) return a;
return rand() % (b - a) + a;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T euclid(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclid(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclid(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclid(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T eularFunction(T n) {
vector<pair<T, int> > R = factorize(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline int dblcmp(T a, const T b) {
a -= b;
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
template <class T>
inline int sgn(T a) {
return a > eps ? 1 : (a < -eps ? -1 : 0);
}
struct vec2 {
double x, y;
vec2(double x = 0.0, double y = 0.0) : x(x), y(y) {}
vec2 operator+(const vec2 &b) const { return vec2(x + b.x, y + b.y); }
vec2 operator-(const vec2 &b) const { return vec2(x - b.x, y - b.y); }
vec2 operator*(const double &b) const { return vec2(x * b, y * b); }
vec2 operator/(const double &b) const { return vec2(x / b, y / b); }
double operator*(const vec2 &b) const { return x * b.x + y * b.y; }
double operator^(const vec2 &b) const { return x * b.y - y * b.x; }
double len() { return sqrt(x * x + y * y); }
vec2 unit() { return *this / len(); }
vec2 rotate(double r) {
vec2 t(sin(r), cos(r));
return vec2(*this ^ t, *this * t);
}
bool operator<(const vec2 &b) const {
if (dblcmp(x, b.x) != 0)
return dblcmp(x, b.x) < 0;
else
return dblcmp(y, b.y) < 0;
}
};
int score[4];
int ball[4];
int other[4];
map<string, int> m;
string name[5];
struct NODE {
int score, ball, other;
int id;
string name;
bool operator<(const NODE &b) const {
if (score != b.score) return score < b.score;
if (ball != b.ball) return ball < b.ball;
if (other != b.other) return other < b.other;
return name > b.name;
}
};
bool judge(int a, int b, int sa, int sb) {
NODE s[5];
for (int j = 0; j < 4; ++j) {
s[j].score = score[j];
s[j].ball = ball[j];
s[j].name = name[j];
s[j].other = other[j];
s[j].id = j;
}
if (sa == sb) {
s[a].score++;
s[b].score++;
s[a].other += sa;
s[b].other += sb;
} else {
s[a].score += 3;
s[a].ball += sa - sb;
s[b].ball -= sa - sb;
s[a].other += sa;
s[b].other += sb;
}
sort(s, s + 4);
if (s[2].id == a || s[3].id == a) {
return true;
}
return false;
}
void gao(int a, int b) {
NODE s[5];
for (int i = 1; i < 100; ++i) {
for (int j = 0; j < 100; ++j) {
if (judge(a, b, j + i, j)) {
printf("%d:%d\n", j + i, j);
return;
}
}
}
puts("IMPOSSIBLE");
}
int main() {
int time[4];
m["BERLAND"] = 0;
name[0] = "BERLAND";
int cnt = 1;
string a, b;
int sa, sb, ta, tb;
memset(time, 0, sizeof(time));
memset(score, 0, sizeof(score));
memset(ball, 0, sizeof(ball));
memset(other, 0, sizeof(other));
for (int i = 0; i < 5; ++i) {
cin >> a >> b;
scanf("%d:%d", &sa, &sb);
if (m.find(a) == m.end()) {
name[cnt] = a;
m[a] = cnt++;
}
if (m.find(b) == m.end()) {
name[cnt] = b;
m[b] = cnt++;
}
ta = m[a], tb = m[b];
time[ta]++, time[tb]++;
ball[ta] += sa - sb;
ball[tb] += sb - sa;
other[ta] += sa;
other[tb] += sb;
if (sa > sb) {
score[ta] += 3;
} else if (sa < sb) {
score[tb] += 3;
} else if (sa == sb) {
score[ta]++;
score[tb]++;
}
}
for (int i = 1; i < 4; ++i) {
if (time[i] == 2) {
gao(0, i);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, h2, a, b, day, night, i, j, k, l, cnt = 0;
scanf("%d %d", &h1, &h2);
scanf("%d %d", &a, &b);
int prevh1 = h1;
while (h1 < h2) {
h1 = h1 + a * 8;
if (h1 >= h2) {
break;
}
h1 = h1 - b * 12 + a * 4;
if (h1 <= prevh1) {
cnt = -1;
break;
}
cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 1 |
#include<cstdio>
#include<bitset>
using namespace std;
bitset<50001> pt;
void MakeTable(int n){
pt.reset();
pt.set(2);
int i;
for(i=3;i<=n;i+=2)pt.set(i);
i = 3;
while(i*i<=n){
for(int j=3*i;j<=n;j+=2*i)pt.reset(j);
while(!pt[++i]);
}
}
int main(){
int n,ans;
MakeTable(50000);
while(scanf("%d",&n) && n){
if(n&1)pt[n-2]?printf("1\n"):printf("0\n");
else{
ans = 0;
for(int i=0;i<=n/2;i++)
if(pt[i] && pt[n-i])ans++;
printf("%d\n",ans);
}
}
}
| 0 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
typedef long long LL;
const int N=200005;
int n,m1[N],m2[N],sz[N],low[N];char s[N];LL ans;
int pp,lnk[N],nxt[N*2],to[N*2];
void ae(int k1,int k2){to[++pp]=k2,nxt[pp]=lnk[k1],lnk[k1]=pp;}
void dfs(int k1,int k2){
sz[k1]=s[k1]&15;
if(s[k1]=='0')low[k1]=0X3F3F3F3F;
for(int i=lnk[k1];i;i=nxt[i])if(to[i]!=k2){
dfs(to[i],k1);
int len=m1[to[i]]+1;
if(len>m1[k1])m2[k1]=m1[k1],m1[k1]=len;
else m2[k1]=max(m2[k1],len);
sz[k1]+=sz[to[i]];
if(sz[to[i]])low[k1]=min(low[k1],m1[to[i]]+1);
}
}
void dfs2(int k1,int k2){
ans+=max(0,min(m1[k1]-1,m2[k1]+1)-low[k1]+1);
// fprintf(stderr,"%d %d %d %d %lld\n",k1,m1[k1],m2[k1],low[k1],ans);
for(int i=lnk[k1];i;i=nxt[i])if(to[i]!=k2){
int len=m1[k1]==m1[to[i]]+1?m2[k1]+1:m1[k1]+1;
if(len>m1[to[i]])m2[to[i]]=m1[to[i]],m1[to[i]]=len;
else m2[to[i]]=max(m2[to[i]],len);
if(sz[to[i]]<sz[1])low[to[i]]=min(low[to[i]],len);
dfs2(to[i],k1);
}
}
int main(){
scanf("%d",&n);
rep(i,2,n){
int k1,k2;scanf("%d%d",&k1,&k2);
ae(k1,k2),ae(k2,k1);
}
scanf("%s",s+1);
dfs(1,0),dfs2(1,0);
printf("%lld\n",ans+1);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, b1, a2, b2;
scanf("%d%d%d%d", &a1, &b1, &a2, &b2);
int valid = 0;
if (a1 <= b2 + 1 && b2 <= 2 * (a1 + 1)) valid = 1;
if (b1 <= a2 + 1 && a2 <= 2 * (b1 + 1)) valid = 1;
if (valid)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int infinite = INT_MAX - 10;
template <typename T>
T power(T x, T y) {
T temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else {
if (y > 0)
return x * temp * temp;
else
return (temp * temp) / x;
}
}
int countDigit(long long n) { return floor(log10(n) + 1); }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
class util {
public:
int t, l, r;
};
void solve() {
int n, m, s, f;
cin >> n >> m >> s >> f;
int t, l, r;
int step = 0, note = s;
vector<util> arr(m);
for (int i = 0; 0 < m ? i < m : i > m; 0 < m ? i += 1 : i -= 1) {
cin >> arr[i].t >> arr[i].l >> arr[i].r;
}
int i = 0;
while (true) {
++step;
t = arr[i].t, l = arr[i].l, r = arr[i].r;
if (note == f) break;
if (step != t) {
if (f > note)
note++, cout << "R";
else if (f < note)
note--, cout << "L";
} else {
if (note >= l and note <= r)
cout << "X";
else if (f > note) {
if (note + 1 >= l and note + 1 <= r)
cout << "X";
else
note++, cout << "R";
} else if (f < note) {
if (note - 1 >= l and note - 1 <= r)
cout << "X";
else
note--, cout << "L";
}
++i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
long long powmod(long long a, long long n, long long p) {
if (n == 0) {
return 1LL % p;
}
long long b = powmod(a, n / 2, p);
b = (b * b) % p;
if (n % 2 == 1) {
b = (b * a) % p;
}
return b;
}
long long inv(int a, int p) {
int x1 = 1, b1 = a;
int x2 = 0, b2 = p;
while (b2) {
int q = b1 / b2;
b1 -= q * b2;
x1 -= q * x2;
swap(x1, x2);
swap(b1, b2);
}
x1 %= p;
if (x1 < 0) {
x1 += p;
}
return x1;
}
long long calculate(long long x, long long n, long long p) {
x %= p;
if (x == 1) {
return powmod(2LL, n + 1, p);
}
long long rem = powmod(2LL, n + 1, p - 1);
long long A = (powmod(x, rem, p) + p - 1) % p;
long long B = inv(x - 1, p);
return (A * B) % p;
}
void solve() {
long long k;
long long l, r;
long long p;
scanf("%I64d%I64d%I64d%I64d", &k, &l, &r, &p);
if (p == 2) {
if (k % 2 == 0) {
printf("1\n");
} else {
printf("0\n");
}
return;
}
long long rem = powmod(2LL, l, p - 1);
long long x = powmod(k, rem, p);
long long score = calculate(x, r - l, p);
if (k % p == 0) {
score = 1;
}
if (k % 2 == 0) {
printf("%d\n", (int)(score % p));
} else {
if (p == 2LL) {
printf("0\n");
} else {
score *= inv(powmod(2LL, r - l, p), p);
score %= p;
printf("%d\n", (int)(score));
}
}
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 0;
long long x1, x2, y1, y2;
for (int i = 0; i < n; i++) {
cin >> x1 >> y1 >> x2 >> y2;
ans += (x2 - x1 + 1) * (y2 - y1 + 1);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b, c, d, e, f, g, h, p, q, r, fr, sc, tr,
sz = 0, tz, i, j, k, mx = LLONG_MIN, mn = LLONG_MAX;
long long x = 0, y = 0, cnt = 0, res = 0, ans = 0, sum = 0;
long long flg = 0, flag = 1, na = 0, as = 1;
vector<long long> u, v, w;
vector<pair<long long, long long> > vct;
vector<string> vst;
set<long long> st, nt, tt;
map<long long, long long> mp, nq, qr;
string str, ttr, ntr;
cin >> str;
n = str.size();
printf("4\n");
printf("R 2\n");
printf("R 2\n");
d = n + (n - 2);
printf("L %lld\n", d);
printf("L %lld\n", d - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template<typename T>
struct SegmetTree
{
int N;
vector<T> dat;
SegmetTree(int n) {
N = 1;
while (N < n) N *= 2;
dat.resize(N * 2 - 1, 0);
}
void update(int k, T a) {
k += N - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
T Max(int limit, int k, int l, int r) {
if (limit <= l) return 0;
if (r <= limit) return dat[k];
T vl = Max(limit, k * 2 + 1, l, (r + l) / 2);
T vr = Max(limit, k * 2 + 2, (r + l) / 2, r);
return max(vl, vr);
}
};
int main() {
long long int N; cin >> N;
SegmetTree<long long int> st(N + 1);
for (int i = 0; i < N; i++) {
int now;
cin >> now;
st.update(now, now + st.Max(now, 0, 0, (st.dat.size() + 1) / 2));
}
cout << (((N + 1) * N) / 2) - st.dat[0] << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long c[100];
int main() {
int n, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
c[a] = i;
}
if (n - max(c[1] + 1, c[n] + 1) > min(c[1] + 1, c[n] + 1) - 1)
cout << n - min(c[1] + 1, c[n] + 1);
else
cout << max(c[1] + 1, c[n] + 1) - 1;
}
| 1 |
// ※※※ 解答不能 ※※※
// tourist氏.
// https://atcoder.jp/contests/cf16-relay-open/submissions/8978522
#include <bits/stdc++.h>
using namespace std;
#define repx(i, a, b) for(int i = a; i < b; i++)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define a first
#define b second
int main(){
int n;
scanf("%d", &n);
vector<pair<int, int>> ret;
rep(i, n){
rep(j, n){
if((i + j) % 2 == 1 && (i % 3 == 0 || i == n - 1 || j == 0 || j == n - 1)) ret.emplace_back(i, j);
}
}
printf("%d\n", ret.size());
for(auto& p : ret) printf("%d %d\n", p.a, p.b);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
const int md = 1e9 + 7;
string mat[2], pat;
long long n, m, dp[2][maxn][2], pr[2][maxn][2], re, is[2][maxn][maxn],
ris[2][maxn][maxn];
long long sum(long long a, long long b) { return (a + b) % md; }
long long mul(long long a, long long b) { return (a * b) % md; }
void solve() {
memset(dp, 0, sizeof dp);
memset(is, 0, sizeof is);
memset(ris, 0, sizeof ris);
for (int r = 0; r < 2; ++r) {
for (int j = 0; j < m; ++j) {
is[r][0][j] = mat[r][0] == pat[j];
}
for (int i = 1; i < n; ++i) {
is[r][i][0] = mat[r][i] == pat[0];
for (int j = 1; j < m; ++j) {
if (mat[r][i] == pat[j]) is[r][i][j] = is[r][i - 1][j - 1] + 1;
}
}
for (int i = n - 1; i >= 0; i--) {
ris[r][i][0] = mat[r][i] == pat[0];
for (int j = 1; j < m; ++j) {
if (mat[r][i] == pat[j]) ris[r][i][j] = ris[r][i + 1][j - 1] + 1;
}
}
}
for (int i = 0; i < n; ++i) {
memcpy(pr, dp, sizeof dp);
memset(dp, 0, sizeof dp);
dp[0][0][0] = (mat[0][i] == pat[0]);
dp[1][0][0] = (mat[1][i] == pat[0]);
for (int j = 1; j < m; ++j) {
for (int r = 0; r < 2; ++r)
if (mat[r][i] == pat[j]) {
dp[r][j][0] = pr[r][j - 1][0];
dp[r][j][0] = sum(dp[r][j][0], pr[r][j - 1][1]);
int x = j + 1;
if (x % 2 == 0 && x / 2 > 1 && i >= x / 2 - 1) {
x /= 2;
dp[r][j][1] =
sum(dp[r][j][1],
(is[r][i][j] >= x) * (ris[r ^ 1][i - x + 1][j - x] >= x));
}
dp[r][j][1] += dp[r ^ 1][j - 1][0];
}
}
for (int j = 0; j < m; ++j) {
if (j == m - 1) {
re = sum(re, dp[0][j][0] + dp[0][j][1] + dp[1][j][1] + dp[1][j][0]);
continue;
}
for (int r = 0; r < 2; ++r) {
int x = m - 1 - j;
if (x % 2) continue;
x /= 2;
if (x == 1) continue;
int y = i + x;
if (y >= n) continue;
re = sum(re, dp[r][j][0] * (is[r][y][j + x] >= x) *
(ris[r ^ 1][i + 1][m - 1] >= x));
re = sum(re, dp[r][j][1] * (is[r][y][j + x] >= x) *
(ris[r ^ 1][i + 1][m - 1] >= x));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < 2; ++i) {
cin >> mat[i];
}
n = mat[0].size();
cin >> pat;
m = pat.size();
if (m == 1) {
for (auto u : mat[0]) {
if (u == pat[0]) {
re = re + 1;
}
}
for (auto u : mat[1]) {
if (u == pat[0]) {
re = re + 1;
}
}
cout << re << '\n';
return 0;
}
if (m == 2) {
for (int r = 0; r < 2; ++r) {
for (int i = 0; i < n; ++i) {
if (i > 0 && mat[r][i] == pat[1] && mat[r][i - 1] == pat[0]) {
re = re + 1;
}
if (i < n - 1 && mat[r][i] == pat[1] && mat[r][i + 1] == pat[0]) {
re = re + 1;
}
if (mat[r][i] == pat[1] && mat[r ^ 1][i] == pat[0]) {
re = re + 1;
}
}
}
cout << re << '\n';
return 0;
}
solve();
for (int r = 0; r < 2; ++r) {
reverse(mat[r].begin(), mat[r].end());
}
solve();
cout << re << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gli() {
long long a;
scanf("%I64d", &a);
return a;
}
int main() {
int o = gi();
gi();
int m = gi();
int c = gi();
printf((o == c && (!m || o)) ? "1\n" : "0\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)5e6 + 7;
const char no[] = "Poor Sereja!";
void minimize(int &x, const int &y) {
if (x > y) x = y;
}
void maximize(int &x, const int &y) {
if (x < y) x = y;
}
struct line {
int x1, y1, x2, y2;
line() {
x1 = 0;
y1 = 0;
x2 = 0;
y2 = 0;
}
line(const pair<int, int> &p, int d, bool t) {
if (t) {
x1 = p.first;
x2 = p.first;
y1 = p.second - 2 * d;
y2 = p.second + 2 * d;
} else {
y1 = p.second;
y2 = p.second;
x1 = p.first - 2 * d;
x2 = p.first + 2 * d;
}
}
bool intersect(const line &a) const {
if (a.x2 < x1) return (false);
if (a.x1 > x2) return (false);
if (a.y2 < y1) return (false);
if (a.y1 > y2) return (false);
return (true);
}
void join(const line &a) {
minimize(x1, a.x1);
maximize(x2, a.x2);
minimize(y1, a.y1);
maximize(y2, a.y2);
}
};
line lred[2020], lblue[2020];
pair<int, int> pred[2020], pblue[2020];
bool same[2020][2020];
int nred, nblue;
bool cmpx(const line &a, const line &b) {
if (a.x1 < b.x1) return (true);
if (a.x1 > b.x1) return (false);
return (a.y1 < b.y1);
}
bool cmpy(const line &a, const line &b) {
if (a.y1 < b.y1) return (true);
if (a.y1 > b.y1) return (false);
return (a.x1 < b.x1);
}
void init(void) {
scanf("%d", &nblue);
scanf("%d", &nred);
for (int i = (1); i <= (nblue); i = i + 1) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
pblue[i] = pair<int, int>(x + y, x - y);
}
for (int i = (1); i <= (nred); i = i + 1) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
pred[i] = pair<int, int>(x + y, x - y);
}
}
bool ok(int d) {
for (int i = (1); i <= (nblue); i = i + 1) lblue[i] = line(pblue[i], d, 1);
for (int i = (1); i <= (nred); i = i + 1) lred[i] = line(pred[i], d, 0);
memset(same, false, sizeof same);
sort(lblue + 1, lblue + nblue + 1, cmpx);
sort(lred + 1, lred + nred + 1, cmpy);
vector<line> ablue, ared;
for (int i = (1); i <= (nblue); i = i + 1) {
if (ablue.empty() || !ablue[ablue.size() - 1].intersect(lblue[i]))
ablue.push_back(lblue[i]);
else
ablue[ablue.size() - 1].join(lblue[i]);
}
for (int i = (1); i <= (nred); i = i + 1) {
if (ared.empty() || !ared[ared.size() - 1].intersect(lred[i]))
ared.push_back(lred[i]);
else
ared[ared.size() - 1].join(lred[i]);
}
for (int i = 0; i < (ablue.size()); i = i + 1) {
vector<int> interid;
for (int j = 0; j < (ared.size()); j = j + 1)
if (ablue[i].intersect(ared[j])) interid.push_back(j);
for (int j = 0; j < (interid.size()); j = j + 1)
for (int k = (j + 1); k <= (interid.size() - 1); k = k + 1) {
int x = interid[j];
int y = interid[k];
if (same[x][y]) return (true);
same[x][y] = true;
same[y][x] = true;
}
}
return (false);
}
void process(void) {
int l = 0;
int r = INF;
if (!ok(INF)) {
printf("%s", no);
return;
}
while (true) {
if (l == r) {
printf("%d", r);
return;
}
if (r - l == 1) {
if (ok(l))
printf("%d", l);
else
printf("%d", r);
return;
}
int m = (l + r) >> 1;
if (ok(m))
r = m;
else
l = m + 1;
}
}
int main(void) {
init();
process();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
set<long long int> s;
for (long long int i = 0; i < n; i++) s.insert(a[i]);
if (s.size() == 1)
cout << n << "\n";
else
cout << 1 << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int p[1001010];
int main() {
int n, k;
while (cin >> n >> k) {
if (3 * k > n)
cout << -1 << endl;
else {
int num = n / k, i, pos = 1, j = 1, s;
if (k % 2 == 0) {
for (j = 1; j <= k / 2; j++) {
if (j != 1) cout << " ";
cout << pos << " " << pos + 1;
for (s = 1; s <= num - 1; s++) cout << " " << pos;
for (s = 1; s <= num - 1; s++) cout << " " << pos + 1;
pos += 2;
}
if (k * num < n) {
for (s = 1; s <= n - k * num; s++) cout << " " << pos - 2;
}
cout << endl;
} else {
for (j = 1; j <= k / 2; j++) {
if (j != 1) cout << " ";
cout << pos << " " << pos + 1;
if (j == 1) {
for (s = 1; s < num - 1; s++) cout << " " << pos;
} else {
for (s = 1; s <= num - 1; s++) cout << " " << pos;
}
for (s = 1; s <= num - 1; s++) cout << " " << pos + 1;
pos += 2;
}
cout << " " << pos << " " << 1;
for (s = 1; s < num; s++) cout << " " << pos;
for (s = 1; s <= n - num * k; s++) cout << " " << pos;
cout << endl;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
#define ll long long
#define N 6005
using namespace std;
int n;
ll P, f[N][N*2];
void add(ll &a, ll b){
a += b;
if(a >= P) a -= P;
}
int main()
{
cin >> n >> P;
f[0][N] = 1;
n *= 3;
for(int i = 0; i <= n; i++){
for(int j = -i; j <= i; j++){
// 考虑从后往前逐位确定,除了每段的开头,位置x的方案为x
// 但每段开头必须是前缀最大值,所以只有一种方案
add(f[i+1][j+N+1], f[i][j+N]);
add(f[i+2][j+N-1], f[i][j+N]*(i+1)%P);
add(f[i+3][j+N], f[i][j+N]*(i+1)%P*(i+2)%P);
}
}
ll ans = 0;
for(int i = 0; i <= n; i++){
add(ans, f[n][i+N]);
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int DN=3005,M=1e9+7;
double n,a[DN],dp[DN],sum,p1,p2;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
dp[0]=1;
for(int h=1;h<=n;h++)
{
p1=a[h];
p2=1-a[h];
for(int i=n;i>=0;i--)
{
dp[i+1]+=dp[i]*p1;
dp[i]*=p2;
}
}
for(int i=n;i>n/2;i--)
sum+=dp[i];
cout<<fixed<<setprecision(12)<<sum;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline", "-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
using namespace std;
int n;
int ans;
string s;
int main() {
cin >> n >> s;
for (auto c : s) ans += c == '8';
cout << min(ans, n / 11) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
int temp = x - y;
if (z != 0 && abs(temp) <= z)
cout << "?";
else if (temp < 0)
cout << "-";
else if (temp > 0)
cout << "+";
else if (temp == 0)
cout << "0";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
std::stack<char> st;
bool ok = true;
int ans = 0;
for (int i = 0; ok && i < s.length(); ++i) {
switch (s[i]) {
case '(':
case '<':
case '{':
case '[':
st.push(s[i]);
break;
case ')':
if (st.empty()) {
ok = false;
} else {
if (st.top() != '(') ans++;
st.pop();
}
break;
case '>':
if (st.empty()) {
ok = false;
} else {
if (st.top() != '<') ans++;
st.pop();
}
break;
case '}':
if (st.empty()) {
ok = false;
} else {
if (st.top() != '{') ans++;
st.pop();
}
break;
case ']':
if (st.empty()) {
ok = false;
} else {
if (st.top() != '[') ans++;
st.pop();
}
break;
}
}
if (st.empty() && ok) {
std::cout << ans << '\n';
} else {
std::cout << "Impossible\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void remax(T &A, T B) {
if (A < B) A = B;
}
template <class T>
inline void remin(T &A, T B) {
if (A > B) A = B;
}
string ToString(long long num) {
string ret;
do {
ret += ((num % 10) + '0');
num /= 10;
} while (num);
reverse(ret.begin(), ret.end());
return ret;
}
long long ToNumber(string s) {
long long r = 0, p = 1;
for (int i = s.size() - 1; i >= 0; --i) r += (s[i] - '0') * p, p *= 10;
return r;
}
long long Gcd(long long a, long long b) {
while (a %= b ^= a ^= b ^= a)
;
return b;
}
long long Power(long long base, long long power) {
if (power < 0) return 0;
long long ret = 1;
while (power) {
if (power & 1) ret *= base;
power >>= 1;
base *= base;
}
return ret;
}
long long PowerMod(long long base, long long power, long long mod) {
if (!power) return 1;
if (power & 1) return (base * PowerMod(base, power - 1, mod)) % mod;
return PowerMod((base * base) % mod, power >> 1, mod);
}
int Log(long long num, long long base) {
int ret = 0;
while (num) {
++ret;
num /= base;
}
return ret;
}
int Count(long long mask) {
int ret = 0;
while (mask) {
if (mask & 1) ++ret;
mask >>= 1;
}
return ret;
}
pair<pair<int, int>, int> q[500000];
vector<int> adj[500000];
vector<int> vec[500000];
int low[500000];
int high[500000];
char ch[500001];
char lowLetter[500000];
int timer;
void dfs(int u = 0, int h = 0) {
vec[h].emplace_back(++timer);
low[u] = timer;
lowLetter[timer] = ch[u];
for (int &v : adj[u]) dfs(v, h + 1);
high[u] = timer;
}
inline void run() {
vector<int> acc[26];
bool ans[500000];
int n, m, done = ~0, p = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; ++i) {
int x;
scanf("%d", &x);
adj[--x].emplace_back(i);
}
scanf("%s", ch);
timer = ~0;
dfs();
for (int i = 0; i < m; ++i) {
scanf("%d%d", &q[i].first.second, &q[i].first.first);
--q[i].first.first;
--q[i].first.second;
q[i].second = i;
}
sort(q, q + m);
while (p < m) {
while (done < q[p].first.first) {
int sz = (int)vec[++done].size();
for (int i = 0; i < 26;) acc[i++].clear();
for (int i = 0; i < sz; ++i) {
for (int j = 0; j < 26; ++j)
if (i)
acc[j].push_back(acc[j][i - 1]);
else
acc[j].push_back(0);
++acc[lowLetter[vec[done][i]] - 'a'][i];
}
}
if (vec[q[p].first.first].empty()) {
ans[q[p++].second] = true;
continue;
}
int l =
upper_bound(vec[q[p].first.first].begin(), vec[q[p].first.first].end(),
low[q[p].first.second] - 1) -
vec[q[p].first.first].begin();
int r = upper_bound(vec[q[p].first.first].begin(),
vec[q[p].first.first].end(), high[q[p].first.second]) -
vec[q[p].first.first].begin() - 1;
if (r < l) {
ans[q[p++].second] = true;
continue;
}
int c = 0;
for (int i = 0; i < 26; ++i) {
int x = acc[i][r];
if (l) x -= acc[i][l - 1];
if ((x & 1)) {
++c;
if (c == 2) break;
}
}
if (c < 2)
ans[q[p].second] = true;
else
ans[q[p].second] = false;
++p;
}
for (int i = 0; i < m; ++i)
if (ans[i])
puts("Yes");
else
puts("No");
for (int i = 0; i < n; ++i) {
adj[i].clear();
vec[i].clear();
}
}
int main() {
FILE *input = stdin;
FILE *output = stdout;
while (!feof(input)) {
run();
break;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
typedef pair<int,int> pii;
#define endl '\n'
#define F first
#define S second
const int MAX_N=3e3+3;
const int MOD=1000000007;
int n;
char s[MAX_N];
ll dp[MAX_N][MAX_N];
ll ans;
int main()
{
scanf("%d",&n);
scanf("%s",s+2);
s[1]='<';
dp[0][0]=1;
for(int i=1;i<=n;i++)
{
if(s[i]=='<') for(int j=1;j<=i;j++) dp[i][j]=(dp[i][j-1]+dp[i-1][j-1])%MOD;
else for(int j=i;j>=1;j--) dp[i][j]=(dp[i][j+1]+dp[i-1][j])%MOD;
}
for(int i=1;i<=n;i++) ans=(ans+dp[n][i])%MOD;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX_N = 1e5 + 9;
vector<array<int, 3>> vc;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k, u, v, w;
cin >> n >> m >> k;
while (m--) {
cin >> u >> v >> w;
vc.push_back({u, v, w});
}
ll ans = 0;
while (k--) {
cin >> u;
for (auto i : vc)
if (u >= i[0] && u <= i[1]) ans += (u - i[0]) + i[2];
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
long long f[N];
char s[N];
int main() {
long long n, x, y;
scanf("%lld%lld%lld", &n, &x, &y);
scanf("%s", s + 1);
s[n + 1] = '1';
int cnt = 0;
for (int i = 2; i <= n + 1; ++i)
if (s[i] == '1' && s[i - 1] == '0') ++cnt;
if (cnt == 0) return puts("0"), 0;
printf("%lld", (cnt - 1) * min(x, y) + y);
return 0;
}
| 1 |
#include <cstdio>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;
struct C {
int a, b, c;
} l[40010];
double ans[2];
int comp(const C& x, const C& y) {
int xx = x.b * y.a;
int yy = y.b * x.a;
if (x.a * y.a < 0) {
return xx > yy;
} else {
return xx < yy;
}
}
int b[40010];
void add(int k) {
while (k < 40010) {
b[k]++;
k += k & -k;
}
}
int sum(int k) {
int res = 0;
while (k) {
res += b[k];
k -= k & -k;
}
return res;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &l[i].a, &l[i].b, &l[i].c);
}
long long tot = n * (n - 1ll) / 2;
long long h = tot / 2;
for (int z = 0; z < 2; z++) {
sort(l, l + n, comp);
double lo = -1e12, hi = 1e12;
for (int k = 0; k < 100; k++) {
if (hi - lo < 1e-10) break;
double mid = (lo + hi) / 2;
vector<pair<double, int> > s;
long long e = 0;
for (int i = 0; i < n; i++) {
double f = (l[i].c - l[i].b * mid) / l[i].a;
s.push_back((make_pair(f, i + 1)));
}
sort(s.begin(), s.end());
for (int i = 1; i <= n; i++) {
b[i] = 0;
}
for (int i = 0; i < n; i++) {
e += sum(s[i].second);
add(s[i].second);
}
if (e <= h) {
hi = mid;
} else {
lo = mid;
}
}
ans[z] = lo;
for (int i = 0; i < n; i++) {
swap(l[i].a, l[i].b);
}
}
printf("%.12f %.12f\n", ans[1], ans[0]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int INF = 0x3f3f3f3f;
const int N = 212345;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class num>
inline void rd(num& x) {
char c;
while (isspace(c = getchar()))
;
bool neg = false;
if (!isdigit(c))
neg = (c == '-'), x = 0;
else
x = c - '0';
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - '0';
if (neg) x = -x;
}
template <class T, class... Args>
inline void rd(T& x, Args&... args) {
rd(x);
rd(args...);
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int ans = INT_MAX;
for (int zeros = 0; zeros <= s.size(); zeros++) {
int tmp = 0;
for (int i = 0; i < zeros; i++)
if (s[i] == '1') tmp++;
for (int i = zeros; i < s.size(); i++)
if (s[i] == '0') tmp++;
ans = min(ans, tmp);
ans = min(ans, (int)s.size() - tmp);
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int base = 1000000000;
const int base_digits = 9;
struct bigint {
vector<int> a;
int sign;
bigint() : sign(1) {}
bigint(long long v) { *this = v; }
bigint(const string &s) { read(s); }
void operator=(const bigint &v) {
sign = v.sign;
a = v.a;
}
void operator=(long long v) {
sign = 1;
if (v < 0) sign = -1, v = -v;
for (; v > 0; v = v / base) a.push_back(v % base);
}
bigint operator+(const bigint &v) const {
if (sign == v.sign) {
bigint res = v;
for (int i = 0, carry = 0; i < (int)max(a.size(), v.a.size()) || carry;
++i) {
if (i == (int)res.a.size()) res.a.push_back(0);
res.a[i] += carry + (i < (int)a.size() ? a[i] : 0);
carry = res.a[i] >= base;
if (carry) res.a[i] -= base;
}
return res;
}
return *this - (-v);
}
bigint operator-(const bigint &v) const {
if (sign == v.sign) {
if (abs() >= v.abs()) {
bigint res = *this;
for (int i = 0, carry = 0; i < (int)v.a.size() || carry; ++i) {
res.a[i] -= carry + (i < (int)v.a.size() ? v.a[i] : 0);
carry = res.a[i] < 0;
if (carry) res.a[i] += base;
}
res.trim();
return res;
}
return -(v - *this);
}
return *this + (-v);
}
void operator*=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = 0, carry = 0; i < (int)a.size() || carry; ++i) {
if (i == (int)a.size()) a.push_back(0);
long long cur = a[i] * (long long)v + carry;
carry = (int)(cur / base);
a[i] = (int)(cur % base);
}
trim();
}
bigint operator*(int v) const {
bigint res = *this;
res *= v;
return res;
}
friend pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
int norm = base / (b1.a.back() + 1);
bigint a = a1.abs() * norm;
bigint b = b1.abs() * norm;
bigint q, r;
q.a.resize(a.a.size());
for (int i = a.a.size() - 1; i >= 0; i--) {
r *= base;
r += a.a[i];
int s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
int s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
int d = ((long long)base * s1 + s2) / b.a.back();
r -= b * d;
while (r < 0) r += b, --d;
q.a[i] = d;
}
q.sign = a1.sign * b1.sign;
r.sign = a1.sign;
q.trim();
r.trim();
return make_pair(q, r / norm);
}
bigint operator/(const bigint &v) const { return divmod(*this, v).first; }
bigint operator%(const bigint &v) const { return divmod(*this, v).second; }
void operator/=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = (int)a.size() - 1, rem = 0; i >= 0; --i) {
long long cur = a[i] + rem * (long long)base;
a[i] = (int)(cur / v);
rem = (int)(cur % v);
}
trim();
}
bigint operator/(int v) const {
bigint res = *this;
res /= v;
return res;
}
int operator%(int v) const {
if (v < 0) v = -v;
int m = 0;
for (int i = a.size() - 1; i >= 0; --i)
m = (a[i] + m * (long long)base) % v;
return m * sign;
}
void operator+=(const bigint &v) { *this = *this + v; }
void operator-=(const bigint &v) { *this = *this - v; }
void operator*=(const bigint &v) { *this = *this * v; }
void operator/=(const bigint &v) { *this = *this / v; }
bool operator<(const bigint &v) const {
if (sign != v.sign) return sign < v.sign;
if (a.size() != v.a.size()) return a.size() * sign < v.a.size() * v.sign;
for (int i = a.size() - 1; i >= 0; i--)
if (a[i] != v.a[i]) return a[i] * sign < v.a[i] * sign;
return false;
}
bool operator>(const bigint &v) const { return v < *this; }
bool operator<=(const bigint &v) const { return !(v < *this); }
bool operator>=(const bigint &v) const { return !(*this < v); }
bool operator==(const bigint &v) const {
return !(*this < v) && !(v < *this);
}
bool operator!=(const bigint &v) const { return *this < v || v < *this; }
void trim() {
while (!a.empty() && !a.back()) a.pop_back();
if (a.empty()) sign = 1;
}
bool isZero() const { return a.empty() || (a.size() == 1 && !a[0]); }
bigint operator-() const {
bigint res = *this;
res.sign = -sign;
return res;
}
bigint abs() const {
bigint res = *this;
res.sign *= res.sign;
return res;
}
long long longValue() const {
long long res = 0;
for (int i = a.size() - 1; i >= 0; i--) res = res * base + a[i];
return res * sign;
}
friend bigint gcd(const bigint &a, const bigint &b) {
return b.isZero() ? a : gcd(b, a % b);
}
friend bigint lcm(const bigint &a, const bigint &b) {
return a / gcd(a, b) * b;
}
void read(const string &s) {
sign = 1;
a.clear();
int pos = 0;
while (pos < (int)s.size() && (s[pos] == '-' || s[pos] == '+')) {
if (s[pos] == '-') sign = -sign;
++pos;
}
for (int i = s.size() - 1; i >= pos; i -= base_digits) {
int x = 0;
for (int j = max(pos, i - base_digits + 1); j <= i; j++)
x = x * 10 + s[j] - '0';
a.push_back(x);
}
trim();
}
int length() {
int l = 0, back = a.back();
while (back) {
l++;
back /= 10;
}
l += ((a.size() - 1) * base_digits);
return l;
}
friend istream &operator>>(istream &stream, bigint &v) {
string s;
stream >> s;
v.read(s);
return stream;
}
friend ostream &operator<<(ostream &stream, const bigint &v) {
if (v.sign == -1) stream << '-';
stream << (v.a.empty() ? 0 : v.a.back());
for (int i = (int)v.a.size() - 2; i >= 0; --i)
stream << setw(base_digits) << setfill('0') << v.a[i];
return stream;
}
static vector<int> convert_base(const vector<int> &a, int old_digits,
int new_digits) {
vector<long long> p(max(old_digits, new_digits) + 1);
p[0] = 1;
for (int i = 1; i < (int)p.size(); i++) p[i] = p[i - 1] * 10;
vector<int> res;
long long cur = 0;
int cur_digits = 0;
for (int i = 0; i < (int)a.size(); i++) {
cur += a[i] * p[cur_digits];
cur_digits += old_digits;
while (cur_digits >= new_digits) {
res.push_back(int(cur % p[new_digits]));
cur /= p[new_digits];
cur_digits -= new_digits;
}
}
res.push_back((int)cur);
while (!res.empty() && !res.back()) res.pop_back();
return res;
}
static vector<long long> karatsubaMultiply(const vector<long long> &a,
const vector<long long> &b) {
int n = a.size();
vector<long long> res(n + n);
if (n <= 32) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res[i + j] += a[i] * b[j];
return res;
}
int k = n >> 1;
vector<long long> a1(a.begin(), a.begin() + k);
vector<long long> a2(a.begin() + k, a.end());
vector<long long> b1(b.begin(), b.begin() + k);
vector<long long> b2(b.begin() + k, b.end());
vector<long long> a1b1 = karatsubaMultiply(a1, b1);
vector<long long> a2b2 = karatsubaMultiply(a2, b2);
for (int i = 0; i < k; i++) a2[i] += a1[i];
for (int i = 0; i < k; i++) b2[i] += b1[i];
vector<long long> r = karatsubaMultiply(a2, b2);
for (int i = 0; i < (int)a1b1.size(); i++) r[i] -= a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) r[i] -= a2b2[i];
for (int i = 0; i < (int)r.size(); i++) res[i + k] += r[i];
for (int i = 0; i < (int)a1b1.size(); i++) res[i] += a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) res[i + n] += a2b2[i];
return res;
}
bigint operator*(const bigint &v) const {
vector<int> a6 = convert_base(this->a, base_digits, 6);
vector<int> b6 = convert_base(v.a, base_digits, 6);
vector<long long> a(a6.begin(), a6.end());
vector<long long> b(b6.begin(), b6.end());
while (a.size() < b.size()) a.push_back(0);
while (b.size() < a.size()) b.push_back(0);
while (a.size() & (a.size() - 1)) a.push_back(0), b.push_back(0);
vector<long long> c = karatsubaMultiply(a, b);
bigint res;
res.sign = sign * v.sign;
for (int i = 0, carry = 0; i < (int)c.size(); i++) {
long long cur = c[i] + carry;
res.a.push_back((int)(cur % 1000000));
carry = (int)(cur / 1000000);
}
res.a = convert_base(res.a, 6, base_digits);
res.trim();
return res;
}
};
int main() {
long long va = 0;
long long k, b, n, t;
scanf("%lld", &k);
scanf("%lld", &b);
scanf("%lld", &n);
scanf("%lld", &t);
long long i;
va = 1;
long long co = n + 1;
while (va <= t) {
va = va * k + b;
co--;
}
if (co < 0) {
cout << "0\n";
} else {
cout << co << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x[111111];
int y[111111];
int main() {
int i, n, m, t;
long long xx = 0, yy = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &t);
x[t] = i;
y[t] = n - i + 1;
}
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &t);
xx += x[t];
yy += y[t];
}
cout << xx << ' ' << yy << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m;
int a[200];
int b[200];
while (~scanf("%d%d", &n, &k)) {
m = n;
for (int i = 0; i < k; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; i++) {
b[i] = i + 1;
}
int lea[200];
int res[200];
lea[0] = 0;
for (int i = 0; i < k; i++) {
res[i] = (lea[i] + a[i]) % m;
if (i != k - 1)
printf("%d ", b[res[i]]);
else
printf("%d\n", b[res[i]]);
for (int j = 0; j < m; j++) {
if (b[j] == b[res[i]]) {
lea[i + 1] = j;
for (int q = j; q < m - 1; q++) b[q] = b[q + 1];
break;
}
}
m--;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4e5 + 10;
struct Segment_Tree {
int n, ql, qr;
int mn[MAX << 2], tag[MAX << 2], cnt[MAX << 2], tag2[MAX << 2], qv;
long long ans[MAX << 2];
void pushup(int id) {
mn[id] = min(mn[(id << 1)], mn[(id << 1 | 1)]);
cnt[id] = 0;
if (mn[(id << 1)] == mn[id]) cnt[id] += cnt[(id << 1)];
if (mn[(id << 1 | 1)] == mn[id]) cnt[id] += cnt[(id << 1 | 1)];
ans[id] = ans[(id << 1)] + ans[(id << 1 | 1)];
}
void pushdown(int id) {
if (tag[id]) {
tag[(id << 1)] += tag[id];
tag[(id << 1 | 1)] += tag[id];
mn[(id << 1)] += tag[id];
mn[(id << 1 | 1)] += tag[id];
tag[id] = 0;
}
if (tag2[id]) {
if (mn[(id << 1)] == mn[id]) {
tag2[(id << 1)] += tag2[id];
ans[(id << 1)] += 1ll * tag2[id] * cnt[(id << 1)];
}
if (mn[(id << 1 | 1)] == mn[id]) {
tag2[(id << 1 | 1)] += tag2[id];
ans[(id << 1 | 1)] += 1ll * tag2[id] * cnt[(id << 1 | 1)];
}
tag2[id] = 0;
}
}
void build(int l, int r, int id) {
tag[id] = tag2[id] = cnt[id] = ans[id] = 0;
if (l == r) {
mn[id] = l;
cnt[id] = 1;
return;
}
int mid = (l + r) >> 1;
build(l, mid, (id << 1));
build(mid + 1, r, (id << 1 | 1));
pushup(id);
}
void update(int l, int r, int id) {
if (l >= ql && r <= qr) {
tag[id] += qv;
mn[id] += qv;
return;
}
pushdown(id);
int mid = (l + r) >> 1;
if (ql <= mid) update(l, mid, (id << 1));
if (qr > mid) update(mid + 1, r, (id << 1 | 1));
pushup(id);
}
long long res;
void query(int l, int r, int id) {
if (l >= ql && r <= qr) {
res += ans[id];
return;
}
pushdown(id);
int mid = (l + r) >> 1;
if (ql <= mid) query(l, mid, (id << 1));
if (qr > mid) query(mid + 1, r, (id << 1 | 1));
}
void build(int _n) {
n = _n;
build(1, n, 1);
}
void upd(int l, int r, int v) {
ql = l;
qr = r;
qv = v;
update(1, n, 1);
}
void updtag2() {
tag2[1]++;
ans[1] += cnt[1];
}
long long ask(int l, int r) {
ql = l;
qr = r;
res = 0;
query(1, n, 1);
return res;
}
} tr;
struct node {
int l, r, id;
};
vector<node> qst[MAX];
int a[MAX], stmax[MAX], top1, stmin[MAX], top2;
long long ans[MAX];
int main() {
int n, i, q = 1, l, r;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &l, &r);
a[l] = r;
}
qst[n].push_back(node{1, n, 1});
top1 = top2 = 0;
stmax[0] = stmin[0] = 0;
tr.build(n);
for (i = 1; i <= n; i++) {
tr.upd(1, n, -1);
while (top1 && a[stmax[top1]] < a[i]) {
tr.upd(stmax[top1 - 1] + 1, stmax[top1], abs(a[i] - a[stmax[top1]]));
top1--;
}
stmax[++top1] = i;
while (top2 && a[stmin[top2]] > a[i]) {
tr.upd(stmin[top2 - 1] + 1, stmin[top2], abs(a[i] - a[stmin[top2]]));
top2--;
}
stmin[++top2] = i;
tr.updtag2();
for (auto it : qst[i]) ans[it.id] = tr.ask(it.l, it.r);
}
for (i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.