solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
int num[N];
bool vis[N];
vector<int> v;
int n, k;
int main() {
scanf("%d %d", &n, &k);
int mn = 1e9 + 100;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
if (num[i] < mn) {
mn = num[i];
vis[i] = true;
v.push_back(i);
}
}
v.push_back(n + 1);
num[n + 1] = 0;
int cnt = 0;
int mx = 0;
for (int i = 1; i < v.size(); i++) {
mx = max(mx, v[i] - v[i - 1]);
if (v[i] - v[i - 1] > k) cnt++;
}
if (cnt >= 2) {
puts("NO");
} else if (cnt == 0) {
puts("YES");
} else {
int tmp = -1;
for (int i = 1; i < v.size(); i++) {
if (v[i] - v[i - 1] > k) tmp = i;
}
bool ans = false;
if (tmp != v.size() - 1 && v[tmp + 1] - v[tmp - 1] <= 2 * k) ans = true;
if (tmp == 0 && v[1] <= 2 * k) tmp = true;
for (int i = v[tmp] + 1; i <= n; i++) {
if (vis[i]) continue;
if (num[i] < num[v[tmp - 1]] && num[i] > num[v[tmp]]) ans = true;
}
if (ans)
puts("YES");
else
puts("NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long fac[13];
int n, nunknown;
int a[100000];
int r[100000];
bool done[100000];
int todo[12], ntodo;
int sumtodo[1 << 12], cnttodo[1 << 12];
int cnt[100001];
bool twoswaps;
long long cur;
int nval;
int atval[100001];
int nxtval[1000000];
int prvval[1000000];
long long val[1000000];
long long invval[1000000];
long long mypow(long long x, long long n) {
if (n == 0) return 1;
if (n % 2 == 1) return x * mypow(x, n - 1) % MOD;
return mypow(x * x % MOD, n / 2);
}
long long inverse(long long a) { return mypow(a, MOD - 2); }
long long calcnext(int n, int k, long long pval, long long ppval) {
return (ppval * (k - 1) % MOD + pval) * n % MOD;
}
long long calc() {
long long ret = twoswaps ? cur : 1;
return ret;
}
long long go(int left, int depth) {
if (left == 0) return calc();
long long ret = 0;
for (int nleft = 0; nleft < left - nleft;
nleft = (nleft + (1 << ntodo) - left) & left) {
int now = left - nleft, i = sumtodo[now], j = cnt[i] + 1;
++cnt[i];
int at = atval[i];
long long pcur = cur;
cur = cur * invval[at] % MOD;
if (nxtval[at] == -1) {
long long nxt = j == 1 ? i : calcnext(i, j, val[at], val[prvval[at]]);
{
val[nval] = nxt;
invval[nval] = inverse(nxt);
nxtval[nval] = -1;
prvval[nval] = at;
nxtval[at] = nval;
++nval;
}
}
cur = cur * val[nxtval[at]] % MOD;
atval[i] = nxtval[at];
bool ptwoswaps = twoswaps;
if (i > 2) twoswaps = true;
long long sub = go(nleft, depth + 1);
twoswaps = ptwoswaps;
atval[i] = at;
cur = pcur;
--cnt[i];
ret += fac[cnttodo[now] - 1] * sub % MOD;
}
return ret % MOD;
}
void run() {
scanf("%d%d", &n, &nunknown);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
for (int i = (0); i < (n); ++i) --a[i];
memset(r, -1, sizeof(r));
for (int i = (0); i < (n); ++i)
if (a[i] != -1) r[a[i]] = i;
memset(done, false, sizeof(done));
memset(cnt, 0, sizeof(cnt));
ntodo = 0;
for (int i = (0); i < (n); ++i)
if (a[i] == -1) {
int ccnt = 0;
for (int at = i; at != -1; at = r[at]) {
done[at] = true;
++ccnt;
}
todo[ntodo++] = ccnt;
}
for (int i = (0); i < (n); ++i)
if (!done[i]) {
int ccnt = 0;
for (int at = i; !done[at]; at = r[at]) {
done[at] = true;
++ccnt;
}
cnt[ccnt]++;
}
sumtodo[0] = 0;
for (int i = (0); i < (ntodo); ++i)
for (int j = (0); j < (1 << i); ++j)
sumtodo[j | (1 << i)] = sumtodo[j] + todo[i];
cnttodo[0] = 0;
for (int i = (0); i < (ntodo); ++i)
for (int j = (0); j < (1 << i); ++j) cnttodo[j | (1 << i)] = cnttodo[j] + 1;
cur = 1;
twoswaps = false;
nval = 0;
memset(atval, -1, sizeof(atval));
for (int i = (1); i <= (n); ++i) {
if (cnt[i] > 0 && i > 2) twoswaps = true;
{
val[nval] = 1;
invval[nval] = 1;
nxtval[nval] = prvval[nval] = -1;
atval[i] = nval;
++nval;
}
for (int j = (1); j <= (cnt[i]); ++j) {
int at = atval[i];
long long nxt = j == 1 ? i : calcnext(i, j, val[at], val[prvval[at]]);
{
val[nval] = nxt;
invval[nval] = inverse(nxt);
nxtval[nval] = -1;
prvval[nval] = at;
nxtval[at] = nval;
atval[i] = nval;
++nval;
}
}
cur = cur * val[atval[i]] % MOD;
}
long long ret = go((1 << ntodo) - 1, 0);
cout << ret << endl;
}
int main() {
fac[0] = 1;
for (int i = (1); i <= (12); ++i) fac[i] = fac[i - 1] * i;
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, Q;
int dp[10005];
vector<int> Adj0[10005], Adj1[10005];
bool ans[10005];
void printDP() {
cout << "%%%%%%% coutDP" << endl;
for (int i = 1; i <= N; i++) cout << dp[i] << " ";
cout << endl;
}
int main() {
cin >> N >> Q;
int l, r, x;
for (int i = 1; i <= Q; i++) {
cin >> l >> r >> x;
Adj0[l].push_back(x);
Adj1[r + 1].push_back(x);
}
dp[0] = 1;
for (int i = 1; i <= N; i++) {
for (int k = 0; k < Adj1[i].size(); k++) {
x = Adj1[i][k];
for (int j = 1; j <= N; j++) {
if (x <= j) dp[j] -= dp[j - x];
}
}
for (int k = 0; k < Adj0[i].size(); k++) {
x = Adj0[i][k];
for (int j = N; j >= 1; j--) {
if (x <= j) dp[j] += dp[j - x];
ans[j] |= dp[j];
}
}
}
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (ans[i]) cnt++;
}
cout << cnt << endl;
for (int i = 1; i <= N; i++) {
if (ans[i]) cout << i << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int x, i;
scanf("%d", &x);
if (x < 0) x = -x;
for (i = 0; i * (i + 1) < 2 * x; i++)
;
if ((i % 4 == 0 && x % 2 == 1) || (i % 4 == 2 && x % 2 == 0))
i++;
else if ((i % 4 == 1 && x % 2 == 0) || (i % 4 == 3 && x % 2 == 1))
i += 2;
printf("%d", i);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, t, i, d, a, b;
int main() {
cin >> t;
for (i = 1; i <= t; i++) {
cin >> a >> b;
d = abs(a - b);
if (d % 10 == 0)
cout << d / 10 << endl;
else
cout << d / 10 + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long N, A[200005];
vector<long long> v, v2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (long long i = 0; i < N; i++) {
cin >> A[i];
if (A[i] == 0) {
v.push_back(i);
v2.push_back(-i);
}
}
sort(v.begin(), v.end());
sort(v2.begin(), v2.end());
for (long long i = 0; i < N; i++) {
auto it = lower_bound(v.begin(), v.end(), i);
auto it2 = lower_bound(v2.begin(), v2.end(), -i);
long long best = 1e9;
if (it != v.end()) {
best = min(best, abs(*it - i));
}
if (it2 != v2.end()) {
best = min(best, abs(*it2 + i));
}
cout << best << " \n"[i == N - 1];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const double PI = 2 * acos(0.0);
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
istream &operator>>(istream &in, pair<int, int> &a) {
in >> a.first >> a.second;
return in;
}
ostream &operator<<(ostream &out, pair<int, int> &a) {
out << a.first << ' ' << a.second;
return out;
}
istream &operator>>(istream &in, pair<double, double> &a) {
in >> a.first >> a.second;
return in;
}
ostream &operator<<(ostream &out, pair<double, double> &a) {
out << a.first << ' ' << a.second;
return out;
}
template <class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template <class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< "}";
}
template <class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< ", " << get<3>(a) << "}";
}
template <class T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
for (int i = 0; i < int(a.size()); ++i)
out << a[i] << vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
void print(int n, int k, vector<tuple<int, int, int, int> > kek) {
ofstream cout("output.txt");
cout << n << ' ' << k << '\n';
for (auto p : kek) {
int r, x, y, z;
tie(r, x, y, z) = p;
cout << x << ' ' << y << ' ' << z << ' ' << r << '\n';
}
cout.close();
exit(0);
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
smain();
}
const int M1 = 1000000093, p1 = 27162;
const int M2 = 1000000087, p2 = 241;
const double pi = atan2(1, 0) * 2, EPS = 1e-9;
const int pw = 10, N = 2e5 + 10, oo = 1e9 + 100, B = 1100, M = 998244353;
const int NN = 1e4;
const int RND = 37542135;
template <class KEY, class VAL, int N>
struct HashTable {
pair<KEY, VAL> hmap[NN];
HashTable(KEY a, KEY b) {
for (int i = 0; i < int(NN); ++i) hmap[i] = {a, b};
}
int has1(KEY v) { return (v ^ RND) % NN; }
int h1(KEY v, int i) { return (has1(v) + i) % NN; }
int find(KEY v) {
int pos, i = 0;
do {
pos = h1(v, i);
if (hmap[pos].first == v) return pos;
i++;
} while (hmap[pos].first != -1 && i != NN);
assert(i != NN);
return pos;
}
VAL get(KEY key) {
int pos = find(key);
return hmap[pos].second;
}
void set(KEY key, VAL val) {
int lol = find(key);
hmap[lol] = {key, val};
}
};
vector<int> vertices1[N];
vector<int> vertices2[N];
vector<int> bvertices[N];
int used[N], used2[N], TIMER = 1;
long long trans(long long a, long long b) { return (a << 18) | b; }
void dfs(int v, int col) {
used[v] = col;
for (int u : vertices2[v]) {
if (!used[u]) dfs(u, col);
}
}
void dfs2(int v) {
used2[v] = TIMER;
for (int u : bvertices[v]) {
if (used2[u] != TIMER) dfs2(u);
}
}
void smain() {
int n, m;
cin >> n >> m;
vector<tuple<int, int, int> > quer(m);
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
quer[i] = make_tuple(a, b, c);
}
int last = 0;
vector<int> vertex;
vertex.reserve(4 * B);
vector<pair<int, int> > edges;
edges.reserve(B);
for (int i = 0; i <= n; ++i) bvertices[i].reserve(B / 10);
for (int i = 0; i < m; i += B) {
vertex.clear();
HashTable<long long, int, NN> abused(-1, 0);
for (int i = 0; i <= n; ++i) {
bvertices[i].clear();
vertices2[i].clear();
vertices2[i].reserve(((int)((vertices1[i]).size())));
}
for (int j = i; j < min(m, i + B); ++j) {
int a, b, c;
tie(a, b, c) = quer[j];
if (a == 1) {
if (b > c) swap(b, c);
abused.set(trans(b, c), 1);
vertex.push_back(b);
vertex.push_back(c);
b++, c++;
if (b == n + 1) b = 1;
if (c == n + 1) c = 1;
if (b > c) swap(b, c);
vertex.push_back(b);
vertex.push_back(c);
abused.set(trans(b, c), 1);
} else {
vertex.push_back(b);
vertex.push_back(c);
b++, c++;
if (b == n + 1) b = 1;
if (c == n + 1) c = 1;
vertex.push_back(b);
vertex.push_back(c);
}
}
for (int v = 1; v <= n; ++v)
for (int &u : vertices1[v])
if (!abused.get(trans(min(v, u), max(v, u)))) {
vertices2[v].push_back(u);
}
int col = 1;
fill(used, used + N, 0);
for (auto &v : vertex)
if (!used[v]) dfs(v, col++);
edges.clear();
for (int v = 1; v <= n; ++v)
for (int &u : vertices1[v])
if (abused.get(trans(v, u))) {
if (used[u] != used[v]) {
bvertices[used[v]].push_back(used[u]);
bvertices[used[u]].push_back(used[v]);
}
edges.push_back(make_pair(min(v, u), (max(v, u))));
}
for (int j = i; j < min(m, i + B); ++j) {
int a, b, c;
tie(a, b, c) = quer[j];
if (last) b++, c++;
if (b == n + 1) b = 1;
if (c == n + 1) c = 1;
if (b > c) swap(b, c);
if (a == 1) {
if (find(edges.begin(), edges.end(), make_pair(b, (c))) !=
edges.end()) {
edges.erase(find(edges.begin(), edges.end(), make_pair(b, (c))));
if (used[b] != used[c]) {
bvertices[used[b]].erase(find(bvertices[used[b]].begin(),
bvertices[used[b]].end(), used[c]));
bvertices[used[c]].erase(find(bvertices[used[c]].begin(),
bvertices[used[c]].end(), used[b]));
}
} else {
edges.push_back(make_pair(b, (c)));
if (used[b] != used[c]) {
bvertices[used[b]].push_back(used[c]);
bvertices[used[c]].push_back(used[b]);
}
}
} else {
if (used[b] == used[c]) {
cout << '1';
last = 1;
} else {
dfs2(used[b]);
if (used2[used[c]] == TIMER) {
cout << '1';
last = 1;
} else {
cout << '0';
last = 0;
}
TIMER++;
}
}
}
for (int i = 1; i <= n; ++i) vertices1[i] = vertices2[i];
for (auto &p : edges) {
vertices1[p.first].push_back(p.second);
vertices1[p.second].push_back(p.first);
}
}
}
| 6 |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e12;
struct S{
double l, r, m, p;
int c;
};
int k;
double r, l, p, e, t;
const double EPS = 1e-10;
bool cross(double al, double ar){
double left = t - e;
double right = t + e;
if(ar < left || right < al) return false;
return true;
}
bool inside(double al, double ar){
double left = t - e;
double right = t + e;
if(left - EPS <= al && ar - EPS <= right) return true;
return false;
}
signed main(){
cin >> k >> l >> r >> p >> e >> t;
S init = {l, r, (l + r) / 2.0, 1.0, 0};
queue<S> q;
q.push(init);
double ans = 0.0;
while(!q.empty()){
S s = q.front(); q.pop();
// cout << s.l << ' ' << s.r << ' ' << s.m << ' ' << s.p << ' ' << s.c << endl;
if(cross(s.l, s.r) == false) continue;
if((s.c == k && inside(s.m, s.m)) || inside(s.l, s.r)){
ans += s.p;
// cout << "o" << endl;
continue;
}
if(s.c == k) continue;
S left, right;
left.l = s.l;
left.r = s.m;
left.m = (left.l + left.r) / 2.0;
left.p = s.p * p;
if(s.m > t) left.p = s.p * (1.0 - p);
left.c = s.c + 1;
right.l = s.m;
right.r = s.r;
right.m = (right.l + right.r) / 2.0;
right.p = s.p * (1.0 - p);
if(s.m > t) right.p = s.p * p;
right.c = s.c + 1;
q.push(left);
q.push(right);
}
printf("%.10f\n", ans);
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(l i=0;i<(l)(n);i++)
#define l int64_t
#define A(a) (a).begin(),(a).end()
#define mp make_pair
l O=1e9+7;
l N,M,X,Y,Z,K,a=0;
vector<l> p,m;
l r(l X){return p[X]==X?X:p[X]=r(p[X]);}
void u(l X,l Y){X=r(X);Y=r(Y);p[X]=Y;}
l mo(l a,l n){l r=1;while(n){if(n&1)r=r*a%O;a=a*a%O;n/=2;}return r;}
int main(){
cin>>N>>M>>K;
p.resize(N),m.resize(M);
vector<tuple<l,l,l>> e(M);
rep(i,M){cin>>X>>Y>>Z;
e[i]=make_tuple(Z,X-1,Y-1);
}
sort(A(e));
rep(i,M){
tie(m[i],Y,Z)=e[i];
rep(i,N)p[i]=i;
u(Y,Z);
rep(j,M){
tie(Z,X,Y)=e[j],m[i]+=(r(X)!=r(Y))*Z,u(X,Y);
}
}
sort(A(m));
rep(i,M)if(i&&m[i]==K)a+=mo(2,M-i);
cout<<a%O;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const int maxn = (int)1e6 + 5;
const long long INF = 0x7fffffff;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-8;
void f() {}
template <typename T>
void read(T &w) {
char c, k = 1;
while (!isdigit(c = getchar())) c == '-' ? k = -1 : k = k;
w = c & 15;
while (isdigit(c = getchar())) w = w * 10 + (c & 15);
w *= k;
}
template <typename T>
void output(T x) {
if (x < 0) putchar('-'), x = -x;
int ss[55], sp = 0;
do ss[++sp] = x % 10;
while (x /= 10);
while (sp) putchar(48 + ss[sp--]);
}
vector<int> prim;
int a[100];
;
inline long long ksm(long long x, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = (res * x % mod);
x = (x * x % mod);
n >>= 1;
}
return res % mod;
}
int main() {
f();
long long n, x;
read(x);
read(n);
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
prim.emplace_back(i);
while (x % i == 0) x /= i;
}
}
if (x != 1) prim.emplace_back(x);
long long ans = 1;
for (auto au : prim) {
long long k = au;
while (k <= n) {
ans = (ans * ksm(au, n / k, mod)) % mod;
if (n / k < au) {
break;
}
k = k * au;
}
}
printf("%lld\n", ans % mod);
return 0;
}
| 3 |
#include<cstdio>
#include<map>
#include<algorithm>
using namespace std;
#define MAXN 100000
long long h,w,ans[10];
int n,x[MAXN+5],y[MAXN+5];
map<pair<int,int>,int>Map;
void Updata(int x,int y) {
if(x<3||x>h||y<3||y>w) return ;
int cnt=0;
for(int i=-2;i<=0;i++)
for(int j=-2;j<=0;j++)
cnt+=Map[make_pair(x+i,y+j)];
ans[cnt]++;
}
int main() {
scanf("%lld %lld %d",&h,&w,&n);
ans[0]=(h-2)*(w-2);
for(int i=1;i<=n;i++) {
scanf("%d %d",&x[i],&y[i]);
Map[make_pair(x[i],y[i])]++;
}
for(int i=1;i<=n;i++)
for(int j=0;j<=2;j++)
for(int k=0;k<=2;k++)
Updata(x[i]+j,y[i]+k);
for(int i=1;i<=9;i++)
ans[i]/=i,ans[0]-=ans[i];
for(int i=0;i<=9;i++)
printf("%lld\n",ans[i]);
return 0;
} | 0 |
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll Q,n,a,b,ans;
priority_queue<ll> que;
priority_queue<ll,vector<ll>,greater<ll>> que2;
int main(void){
cin>>Q;
while(Q--){
cin>>n;
if(n==1){
cin>>a>>b;
ans+=b;
que.push(a);
que2.push(a);
ll q1=que.top();
ll q2=que2.top();
ans+=abs(q1-q2);
if(q1>q2){
que.pop();
que2.pop();
que.push(q2);
que2.push(q1);
}
}
else{
cout<<que.top()<<" "<<ans<<endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
bool iscon(char c) {
if (c != 'a' && c != 'e' && c != 'u' && c != 'i' && c != 'o') {
return 1;
}
return 0;
}
string ans = "";
int lst = 0;
void solve(int ind) {
for (int i = ind; i < s.length() - 2; i++) {
ans += s[i];
char c1 = s[i];
char c2 = s[i + 1];
char c3 = s[i + 2];
lst = max(lst, i + 1);
if (iscon(c1) && iscon(c2) && iscon(c3)) {
if (c1 == c2 && c2 == c3) {
continue;
} else {
ans += s[i + 1];
ans += ' ';
solve(i + 2);
lst = max(lst, i + 2);
break;
}
}
}
}
int main() {
cin >> s;
if (s.length() < 3) {
cout << s;
return 0;
}
solve(0);
for (int i = lst; i < s.length(); i++) {
ans += s[i];
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return b * a / gcd(a, b);
}
long long int abs1(long long int a) {
if (a < 0)
return -1 * a;
else
return a;
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
int main() {
ios_base::sync_with_stdio(false);
long long int a, b;
cin >> a >> b;
long long int count = 0;
while (1) {
if (b == 0) break;
if (a == 0) break;
long long int c = a;
a = a > b ? a : b;
b = c < b ? c : b;
count += (a / b);
a = a % b;
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v) in >> x;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
out << "[" << p.first << ", " << p.second << "]"
<< "\n";
return out;
}
inline int gc() {
static const int BUF = 1e7;
static char buf[BUF], *bg = buf + BUF, *ed = bg;
if (bg == ed) fread(bg = buf, 1, BUF, stdin);
return *bg++;
}
inline int ri() {
int x = 0, f = 1, c = gc();
for (; c < 48 || c > 57; f = c == '-' ? -1 : f, c = gc())
;
for (; c > 47 && c < 58; x = x * 10 + c - 48, c = gc())
;
return x * f;
}
const double EPS = 1e-10;
const long long inf = 0x7fffffff;
const long long infLL = 0x7fffffffffffffffLL;
const long long mod = 1e9 + 7;
const int maxN = 1e3 + 7;
const long long ONE = 1;
const long long evenBits = 0xaaaaaaaaaaaaaaaa;
const long long oddBits = 0x5555555555555555;
int n;
long long dp[maxN][maxN];
long long ans;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
;
cin >> n;
dp[n][n] = 0;
for (int k = (2 * n - 1); k >= (0); --k) {
int tmp = min(n, k);
for (int l = (tmp); l >= ((k + 1) / 2); --l) {
int r = k - l;
if (l < n) dp[l][r] += dp[l + 1][r];
dp[l][r] += dp[l][r + 1];
dp[l][r] += (l + r) % 2;
dp[l][r] %= mod;
}
}
cout << dp[0][0] << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,L;cin>>N>>L;
int ans=0;
for(int i=0;i<N;i++)ans+=L+i;
if(L>0)ans-=L;
else if(L+N-1<0)ans-=L+N-1;
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
bool possible(long long x1, long long y1, long long x2, long long y2) {
if ((x1 + x2) <= a && max(y1, y2) <= b) {
return true;
} else if (max(x1, x2) <= a && (y1 + y2) <= b) {
return true;
} else if (max(x1, y2) <= a && (y1 + x2) <= b) {
return true;
} else if ((x1 + y2) <= a && max(y1, x2) <= b) {
return true;
} else if (max(y1, x2) <= a && (x1 + y2) <= b) {
return true;
} else if ((y1 + x2) <= a && max(x1, y2) <= b) {
return true;
} else if ((y1 + y2) <= a && max(x1, x2) <= b) {
return true;
} else if (max(y1, y2) <= a && (x1 + x2) <= b) {
return true;
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> a >> b;
vector<pair<long long, long long> > inp;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
inp.push_back({x, y});
}
long long lmax = -1, gmax = -1;
n = inp.size();
for (long long i = 0; i < n - 1; i++) {
lmax = -1;
for (long long j = i + 1; j < n; j++) {
long long x1 = inp[i].first, y1 = inp[i].second;
long long x2 = inp[j].first, y2 = inp[j].second;
if (possible(x1, y1, x2, y2)) {
long long prod = (x1 * y1) + (x2 * y2);
lmax = max(prod, lmax);
}
}
gmax = max(gmax, lmax);
}
if (gmax == -1) {
cout << "0" << endl;
} else {
cout << gmax << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long q, n, p[200001], e[200001], x, a, y, b, k;
bool good(long long m) {
long long res = 0;
for (long long i = 0; i < m; i++) e[i] = -1;
long long o = a * b / gcd(a, b), gi = 0;
for (long long i = o - 1; i < m; i += o) {
e[i] = p[gi];
gi++;
}
for (long long i = a - 1; i < m; i += a) {
if (e[i] == -1) {
e[i] = p[gi];
gi++;
}
}
for (long long i = b - 1; i < m; i += b) {
if (e[i] == -1) {
e[i] = p[gi];
gi++;
}
}
for (long long i = 0; i < m; i++) {
if ((i + 1) % a == 0) res += e[i] / 100 * x;
if ((i + 1) % b == 0) res += e[i] / 100 * y;
}
return res >= k;
}
void solve() {
cin >> q;
for (long long cq = 0; cq < q; cq++) {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> p[i];
}
cin >> x >> a >> y >> b >> k;
if (x < y) {
swap(a, b);
swap(x, y);
}
sort(p, p + n);
reverse(p, p + n);
long long l = 0, r = n + 1;
while (l + 1 < r) {
long long m = (r + l) / 2;
if (good(m))
r = m;
else
l = m;
}
if (r == n + 1)
cout << -1 << '\n';
else
cout << r << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, s, cnt[5007];
bool g[5007], vis[5007];
vector<long long int> adj[5007];
void dfs(long long int x) {
if (!g[x]) {
cnt[x] = 1;
}
vis[x] = 1;
for (long long int i : adj[x]) {
if (!vis[i]) {
dfs(i);
cnt[x] += cnt[i];
}
}
}
void dfs2(long long int x) {
g[x] = 1;
vis[x] = 1;
for (long long int i : adj[x]) {
if (!vis[i]) {
dfs2(i);
}
}
}
bool comp(long long int x, long long int y) { return cnt[x] > cnt[y]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> s;
for (long long int i = 0; i < m; ++i) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
}
queue<long long int> ben;
ben.push(s);
while (!ben.empty()) {
long long int f = ben.front();
ben.pop();
g[f] = 1;
for (long long int i : adj[f]) {
if (!g[i]) {
g[i] = 1;
ben.push(i);
}
}
}
vector<long long int> v;
for (long long int i = 1; i <= n; ++i) {
if (g[i]) continue;
v.push_back(i);
memset(vis, 0, sizeof(vis));
dfs(i);
}
long long int ans = 0;
sort(v.begin(), v.end(), comp);
for (long long int i = 0; i < (long long int)v.size(); ++i) {
if (g[v[i]]) continue;
memset(vis, 0, sizeof(vis));
dfs2(v[i]);
ans++;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> pos_diff(5002, 0);
vector<int> neg_diff(10010, 0);
long double all1 = 0;
long double all2 = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) {
continue;
}
int a1 = a[i];
int a2 = a[j];
int d = a1 - a2;
if (d > 0) {
++pos_diff[d];
++all1;
}
if (d < 0) {
++neg_diff[-d];
++all2;
}
}
}
for (int i = 10008; i >= 0; --i) {
neg_diff[i] += neg_diff[i + 1];
}
long double ans = 0;
for (int i = 0; i < 5001; ++i) {
for (int j = 0; j < 5001; ++j) {
int d_sum = i + j;
ans += static_cast<long double>(pos_diff[i]) / all1 *
static_cast<long double>(pos_diff[j]) / all1 *
static_cast<long double>(neg_diff[d_sum + 1]) / all2;
}
}
cout << setprecision(16) << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1000 + 10;
int const M = (1 << 16) + 10;
int const inf = 0x7f7f7f7f;
int a[5], n;
char mp[5][N];
int dp[2][M];
vector<int> p[5];
void Init() {
for (int i = 1; i <= 4; i++) {
for (int j = 0; j + i <= 4; j++) {
int v = (1 << 16) - 1;
for (int r = j; r < j + i; r++)
for (int k = 0; k < i; k++) v ^= (1 << (4 * k + r));
p[i].push_back(v);
}
}
}
void solve() {
int state = 0;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
if (mp[i][j] == '*') state |= 1 << (4 * j + i);
memset(dp, inf, sizeof(dp));
int up = (1 << 0) + (1 << 1) + (1 << 2) + (1 << 3);
dp[0][state] = 0;
for (int i = 0; i < n; i++) {
int id = i & 1;
for (int j = (1 << 16) - 1; j >= 0; j--) {
if (dp[id][j] == inf) continue;
if (!(j & up)) {
int tmp = j >> 4;
for (int k = 0; k < 4; k++)
if (mp[k][i + 4] == '*') tmp |= 1 << (4 * 3 + k);
dp[id ^ 1][tmp] = dp[id][j];
}
for (int k = 1; k <= 4; k++) {
for (int l = 0; l < p[k].size(); l++)
dp[id][j & p[k][l]] = min(dp[id][j & p[k][l]], dp[id][j] + a[k]);
}
}
memset(dp[id], inf, sizeof(dp[id]));
}
printf("%d\n", dp[n & 1][0]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 4; i++) scanf("%d", &a[i]);
for (int i = 0; i < 4; i++) scanf(" %s", mp[i]);
Init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, s0, s1, a[100010];
bool check(int k) {
int l = a[n] - k, r = a[n] + k;
for (int i = n - 1; i >= 1; i--) {
if (l <= a[i] && a[i] <= r) l = a[i] - k, r = a[i] + k;
int l0 = a[i] - k, r0 = a[i] + k;
l = max(l, l0);
r = min(r, r0);
if (l > r) return false;
}
if ((l <= s0 && s0 <= r) || (l <= s1 && s1 <= r)) return true;
return false;
}
int main() {
scanf("%d %d %d", &n, &s1, &s0);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l = abs(s0 - s1), r = 1e9, ans;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1024;
const long long INF = 1e18;
int N, M;
long long rare[MAXN][MAXN];
long long row[MAXN], col[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15);
cin >> N >> M;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> rare[i][j];
row[i] += rare[i][j];
col[j] += rare[i][j];
}
}
long long xc = INF, bx = -1;
for (int x = 0; x <= N; x++) {
long long mc = 0;
for (int r = 0; r < N; r++) {
long long d = 4 * abs(x - r);
if (r < x)
d -= 2;
else
d += 2;
mc += d * d * row[r];
}
if (mc < xc) {
xc = mc;
bx = x;
}
}
long long yc = INF, by = -1;
for (int y = 0; y <= M; y++) {
long long mc = 0;
for (int c = 0; c < M; c++) {
long long d = 4 * abs(y - c);
if (c < y)
d -= 2;
else
d += 2;
mc += d * d * col[c];
}
if (mc < yc) {
yc = mc;
by = y;
}
}
cout << xc + yc << "\n";
cout << bx << " " << by << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
map<int, int> cnt, tmp_cnt;
vector<int> used;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
cnt[a[i]]++;
tmp_cnt[a[i]]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
for (int k = 0; k < (int)used.size(); k++)
tmp_cnt[used[k]] = cnt[used[k]];
used.clear();
int last = a[i], last_sec = a[j];
tmp_cnt[last]--;
tmp_cnt[last_sec]--;
used.push_back(last);
used.push_back(last_sec);
int len = 2;
while (tmp_cnt[last + last_sec]) {
if (last == 0 && last_sec == 0) {
len += tmp_cnt[0];
break;
}
int next_last = last + last_sec;
tmp_cnt[next_last]--;
last_sec = last;
last = next_last;
len++;
used.push_back(last);
}
ans = max(ans, len);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, t, n1 = 0;
cin >> n;
multiset<int> a;
for (i = 0; i < n; ++i) {
cin >> t;
a.insert(t);
if (t == 1) n1++;
}
if (n1 == 1 && n == 1) {
cout << "2" << endl;
return 0;
}
cout << "1";
multiset<int>::iterator it = a.begin();
for (i = 1; i < n; ++i, ++it) {
if (n1 == n && i == n - 1) {
cout << " 2";
} else {
cout << " " << *it;
}
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][2010];
int N, K;
int main() {
cin >> N >> K;
for (int i = 1; i <= N; i++) dp[1][i] = 1;
for (int i = 1; i < K; i++) {
for (int j = 1; j <= N; j++) dp[(i + 1) % 2][j] = 0;
for (int j = 1; j <= N; j++) {
for (int k = 1; k * j <= N; k++)
dp[(i + 1) % 2][k * j] =
(dp[(i + 1) % 2][k * j] + dp[i % 2][j]) % 1000000007;
}
}
int ans = 0;
for (int i = 1; i <= N; i++) ans = (ans + dp[K % 2][i]) % 1000000007;
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool equal(string s) {
int n = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'a') n++;
}
if (n * 2 != s.length()) return false;
return true;
}
string s, s1, sex;
int n, d, k;
int main() {
cin >> k;
cin >> s;
n = s.length();
sex = s;
for (int i = 2; i <= n; i = i + 2) {
for (int j = 0; j <= n - i; j++) {
s1 = s.substr(j, i);
if (equal(s1)) {
while (s.find(s1) != -1) {
s.erase(s.find(s1), 1);
d++;
}
}
}
}
cout << "25";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long c[1000001];
long long a, b, k, m;
vector<long long> v;
int main() {
cin >> a >> b >> k;
for (int i = 2; i <= b; i++) {
if (c[i] == 0) {
if (i >= a) v.push_back(i);
for (int j = i * 2; j <= b; j += i) c[j] = 1;
}
}
if (v.size() < k) {
cout << -1;
exit(0);
}
m = v[k - 1] - a + 1;
for (int i = 0; i + k < v.size(); i++) {
m = max(m, v[i + k] - v[i]);
}
m = max(m, b - v[v.size() - k] + 1);
cout << m;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n % 10 == 9)
cout << n / 10 + 1 << '\n';
else
cout << n / 10 << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<long long> v;
string s;
int type[100100];
long long num[100100];
long long dat[400100][5];
int cnt[400100];
int branches;
void combine(int a, int b, int c) {
cnt[a] = cnt[b] + cnt[c];
for (int i = 0; i < 5; i++) dat[a][i] = dat[b][i];
int g = cnt[b] % 5;
for (int i = 0; i < 5; i++) dat[a][(i + g) % 5] += dat[c][i];
}
void ac_the_problem(int pos) {
if (type[pos] == 2) {
cout << dat[1][2] << endl;
return;
}
int val = num[pos] + branches;
cnt[val] = (1 - type[pos]);
dat[val][0] = (1 - type[pos]) * (v[val - branches]);
for (; val >>= 1;) {
combine(val, (val << 1) | 0, (val << 1) | 1);
}
}
int main() {
cin >> q;
for (int i = 0; i < q; i++) {
cin >> s;
if (s == "add") {
type[i] = 0;
cin >> num[i];
v.push_back(num[i]);
} else if (s == "del") {
type[i] = 1;
cin >> num[i];
} else {
type[i] = 2;
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
n = v.size();
for (int i = 0; i < q; i++) {
if (num[i]) num[i] = lower_bound(v.begin(), v.end(), num[i]) - v.begin();
}
branches = 1;
while (branches < n + 5) branches *= 2;
for (int i = 0; i < q; i++) {
ac_the_problem(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool func(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first)
return false;
else if (a.first == b.first) {
if (a.second >= b.second)
return false;
else
return true;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n, i, ans;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort((a).begin(), (a).end(), func);
ans = a[0].second;
for (int i = 0; i < n; i++) {
if (a[i].second < ans)
ans = a[i].first;
else
ans = a[i].second;
}
cout << ans;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, k, l;
cin >> n >> k;
for (int i = k - 1; i >= 0; i--) {
if (n % i == 0) {
cout << i + (n / i) * k;
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f(int a) {
int ret = 0;
while (a != 0) {
ret++;
a /= 10;
}
return ret;
}
const int dydis = 100000;
long long blockSz[dydis] = {0};
vector<int> toVec(int a) {
vector<int> ret;
while (a != 0) {
ret.push_back(a % 10);
a /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
int fnd(int kel) {
int viso = 0;
for (int i = 1; i < dydis; i++) {
vector<int> st = toVec(i);
for (int j = 0; j < st.size(); j++) {
if (j + viso == kel) return st[j];
}
viso += st.size();
}
return -1;
}
int main() {
blockSz[1] = 1;
for (int i = 2; i < dydis; i++) {
blockSz[i] = blockSz[i - 1] + f(i);
}
int t;
cin >> t;
while (t--) {
int a;
cin >> a;
if (a == 1) {
cout << 1 << "\n";
continue;
}
long long s = 0;
int pilnu = 0;
for (int i = 1; i < dydis; i++) {
long long bus = s + blockSz[i];
if (bus >= a) {
pilnu = i - 1;
break;
}
s += blockSz[i];
}
cout << fnd(a - s - 1) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const int MOD = 1e9 + 9;
const int oo = 2e9 + 1e8;
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
int main() {
long long n, cnt, ret;
scanf("%I64d", &n);
ret = 1, cnt = 0;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i, cnt++;
if (cnt <= 2) ret *= i;
}
if (cnt > 1) break;
}
if (n != 1) {
cnt++;
if (cnt <= 2) ret *= n;
}
if (cnt < 2)
puts("1\n0");
else if (cnt == 2)
puts("2");
else
printf("1\n%I64d\n", ret);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
vector<int> va;
vector<int> vb;
int a, b, c, d;
int ta = 0, tb = 0;
cin >> a >> c >> b >> d;
int aa = a, bb = b;
while (a) {
va.push_back(a % 10);
a /= 10;
ta++;
}
reverse(va.begin(), va.end());
while (b) {
vb.push_back(b % 10);
b /= 10;
tb++;
}
int h = min(va.size(), vb.size());
reverse(vb.begin(), vb.end());
ta += c;
tb += d;
if (ta > tb) {
cout << ">" << endl;
continue;
} else if (tb > ta) {
cout << "<" << endl;
continue;
} else {
int f = 0;
for (int i = 0; i < h; i++) {
if (va[i] > vb[i]) {
f = 1;
break;
} else if (vb[i] > va[i]) {
f = 2;
break;
}
}
if (f == 0) {
if (va.size() >= vb.size()) {
for (int i = h; i < va.size(); i++) {
if (va[i] > 0) {
f = 1;
break;
}
}
} else {
for (int i = h; i < vb.size(); i++) {
if (vb[i] > 0) {
f = 2;
break;
}
}
}
if (f == 0) {
cout << "=" << endl;
continue;
}
}
if (f == 1)
cout << ">" << endl;
else if (f == 2)
cout << "<" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, k;
int main(){
cin>>n>>k>>s;
s[k-1]+=32;
cout<<s<<endl;
}
| 0 |
#include <stdio.h>
long long pre[100005];
long long find_root(long long x)
{
if(pre[x] == x)
return x;
return find_root(pre[x]);
}
int main()
{
long long n, q;
while(scanf("%lld%lld", &n, &q), n || q)
{
pre[1] = 1;
for(long long i = 2; i <= n; i++)
scanf("%lld", &pre[i]);
char a;
long long b;
long long ans = 0ll;
while(q--)
{
scanf(" %c%lld", &a, &b);
if(a == 'Q')
ans += find_root(b);
else
pre[b] = b;
}
printf("%lld\n", ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int d;
cin >> n >> d;
string s;
cin >> s;
int b[n];
int k[n];
for (int i = 0; i < n; i++) {
b[i] = n + 1;
}
b[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (s[i] == '0')
break;
else if (i <= j + d && s[i] != '0' && s[j] != '0') {
b[i] = min(b[i], b[j] + 1);
}
}
}
if (b[n - 1] == n + 1)
cout << -1;
else
cout << b[n - 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-9;
long long t1, t2, x1, x2, t0;
long long a1 = 0, a2 = 0;
double diff = 1e20;
long long rate = 0;
long long up = 1LL << 30, dn = 1;
long long Comp(long long a1, long long b1, long long a2, long long b2) {
return a1 * b2 - b1 * a2;
}
int main() {
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t0 == t1 && t0 == t2) {
a1 = x1;
a2 = x2;
} else if (t0 == t1) {
a1 = x1;
} else if (t0 == t2) {
a2 = x2;
} else {
for (long long y1 = 0; y1 <= x1; y1++) {
long long R = t0 * y1 - t1 * y1;
long long L = t2 - t0;
long long Y = (R + L - 1) / L;
if (L < 0) {
L *= -1;
R *= -1;
Y = min(x2, R / L);
} else {
Y = (R + L - 1) / L;
}
if (Y > x2) continue;
double d = 1. * (t1 * y1 + t2 * Y) / (y1 + Y) - t0;
R = t1 * y1 + t2 * Y;
L = y1 + Y;
long long nr = y1 + Y;
if ((Comp(up, dn, R, L) == 0 && nr > rate) || Comp(up, dn, R, L) > 0) {
rate = nr;
diff = d;
a1 = y1;
a2 = Y;
up = R;
dn = L;
}
}
swap(x1, x2);
swap(t1, t2);
bool sw = 0;
for (long long y1 = 0; y1 <= x1; y1++) {
long long R = t0 * y1 - t1 * y1;
long long L = t2 - t0;
long long Y = R / L;
if (L < 0) {
L *= -1;
R *= -1;
Y = min(x2, R / L);
} else {
Y = (R + L - 1) / L;
}
if (Y > x2) continue;
double d = 1. * (t1 * y1 + t2 * Y) / (y1 + Y) - t0;
R = t1 * y1 + t2 * Y;
L = y1 + Y;
long long nr = y1 + Y;
if ((Comp(up, dn, R, L) == 0 && nr > rate) || Comp(up, dn, R, L) > 0) {
sw = 1;
rate = nr;
diff = d;
a1 = y1;
a2 = Y;
up = R;
dn = L;
}
}
if (sw) swap(a1, a2);
}
cout << a1 << " " << a2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int _2[4], _3[4], c[4];
long long a[4];
int main() {
for (int i = 0; i < 4; ++i) {
cin >> a[i];
}
for (int i = 0; i < 4; ++i) {
while ((2 * a[i]) % 3 == 0) ++_3[i], a[i] = (2 * a[i]) / 3;
}
for (int i = 0; i < 4; ++i) {
while (a[i] % 2 == 0) ++_2[i], a[i] /= 2;
}
if (a[0] * a[1] != a[2] * a[3]) {
cout << -1 << endl;
} else {
c[0] = c[2] = min(_2[0] + _2[1], _2[2] + _2[3]);
c[1] = c[3] = min(_3[0] + _3[1], _3[2] + _3[3]);
for (int i = 0; i < 2; ++i) {
while (c[0] && _2[i]) {
--c[0];
--_2[i];
a[i] *= 2;
}
}
for (int i = 0; i < 2; ++i) {
while (c[1] && _3[i]) {
--c[1];
--_3[i];
a[i] = (a[i] / 2) * 3;
}
}
for (int i = 2; i < 4; ++i) {
while (c[2] && _2[i]) {
--c[2];
--_2[i];
a[i] *= 2;
}
}
for (int i = 2; i < 4; ++i) {
while (c[3] && _3[i]) {
--c[3];
--_3[i];
a[i] = (a[i] / 2) * 3;
}
}
cout << abs(_2[0] + _2[1] - _2[2] - _2[3]) +
abs(_3[0] + _3[1] - _3[2] - _3[3])
<< endl;
cout << a[0] << " " << a[1] << endl;
cout << a[2] << " " << a[3] << endl;
}
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
int n, a[100];
int al = 0;
cin >> n;
for (int i = 0;i < n;i++) {
cin >> a[i];
al += a[i];
}
sort(a, a+n);
for (int i = n-2;i >= 0;i-=2) {
al -= 2*a[i];
}
cout << al << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
scanf("%d", &n);
k = 0;
bool flag = true;
for (; n; n--) {
int dist;
string dir;
scanf("%d", &dist);
cin >> dir;
if (dir == "North") {
k -= dist;
if (k < 0) {
flag = false;
break;
}
} else if (dir == "South") {
k += dist;
if (k > 20000) {
flag = false;
break;
}
} else if (k == 0 || k == 20000) {
flag = false;
break;
}
}
if (k != 0) flag = false;
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 105;
int n, a[maxN], res1, res2, cnt;
bool cmp(int a, int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int m, x;
scanf("%d", &m);
if (m % 2 == 1) {
for (int j = 1; j <= (m - 1) / 2; ++j) scanf("%d", &x), res1 += x;
scanf("%d", &a[++cnt]);
for (int j = (m - 1) / 2 + 2; j <= m; ++j) scanf("%d", &x), res2 += x;
} else {
for (int j = 1; j <= m / 2; ++j) scanf("%d", &x), res1 += x;
for (int j = m / 2 + 1; j <= m; ++j) scanf("%d", &x), res2 += x;
}
}
sort(a + 1, a + cnt + 1, cmp);
for (int i = 1; i <= cnt; ++i)
if (i % 2 == 1)
res1 += a[i];
else
res2 += a[i];
cout << res1 << " " << res2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
deque<long> dq;
long a;
long long s1 = 0, s2 = 0, s3 = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
dq.push_back(a);
}
int l = dq.size();
while (l > 0) {
if (s1 == s2) {
s3 = s1;
s1 = s1 + dq.front();
dq.pop_front();
l--;
}
if ((s1 < s2) && (l > 0)) {
s1 = s1 + dq.front();
dq.pop_front();
l--;
}
if ((s2 < s1) && (l > 0)) {
s2 = s2 + dq.back();
dq.pop_back();
l--;
}
if (s1 == s2) {
s3 = s1;
s1 = s1 + dq.front();
dq.pop_front();
l--;
}
if (l == 0) break;
}
cout << s3 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc, o;
scanf("%d", &tc);
for (o = 1; o <= tc; o++) {
long long n, m, a, b, c, d, e, f, g, p, q, r, fr, sc, tr, sz, tz, sz1, sz2,
i, j, k, mx = -9, mn = 999999999999;
string str, ttr, ntr;
long long x = 0, y = 0, cnt = 0, res = -3, ttl = -3, 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, tct;
vector<string> vst;
set<long long> st, nt, tt;
map<long long, long long> mp, nq, qr, mp1, mp2;
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &a);
v.push_back(a);
}
for (i = 0; i < n; i++) {
fr = v[i];
mp[fr]++;
if (mp[fr] == 1) {
if (fr > mx) {
mx = fr;
}
} else {
y++;
if (y == 2) {
flg = 9;
break;
}
mp.clear();
if (mx == i) {
p = i + 1 - 1;
} else {
flg = 9;
break;
}
mp[fr]++;
mx = fr;
}
}
if (flg == 0) {
q = n - p;
if (q == mx && p != 0 && p != n) {
vct.push_back(make_pair(p, q));
res = p;
ttl = q;
}
}
flg = 0;
mx = -9;
mp.clear();
y = 0;
for (i = n - 1; i >= 0; i--) {
fr = v[i];
mp[fr]++;
if (mp[fr] == 1) {
if (fr > mx) {
mx = fr;
}
} else {
y++;
if (y == 2) {
flg = 9;
break;
}
mp.clear();
if (mx == n - i - 1) {
p = n - i - 1;
} else {
flg = 9;
break;
}
mp[fr]++;
mx = fr;
}
}
if (flg == 0) {
q = n - p;
if (q == mx && q != n && q != 0 && q != res) {
vct.push_back(make_pair(q, p));
}
}
sz = vct.size();
printf("%lld\n", sz);
for (i = 0; i < sz; i++) {
f = vct[i].first;
g = vct[i].second;
if (i == 0) {
printf("%lld %lld\n", f, g);
} else {
printf("%lld %lld\n", f, g);
}
}
v.clear();
vct.clear();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct ac {
int x, y;
} t[202400];
bool cmp(const ac &a, const ac &b) {
if (a.x != b.x) {
return a.x < b.x;
} else {
return a.y < b.y;
}
}
bool wfHas(int x, int y) {
int l = 0, r = m - 1, mid;
while (l < r) {
mid = (l + r) / 2;
if (t[mid].x == x && t[mid].y == y) {
return true;
}
if (x < t[mid].x || x == t[mid].x && y < t[mid].y) {
r = mid;
} else {
l = mid + 1;
}
}
return (t[l].x == x && t[l].y == y);
}
bool wf(int k) {
int i, x, y;
for (i = 0; i < m; i++) {
x = t[i].x + k;
y = t[i].y + k;
if (x > n) x -= n;
if (y > n) y -= n;
if (x > y) {
x ^= y;
y ^= x;
x ^= y;
}
if (!wfHas(x, y)) {
return false;
}
}
return true;
}
void solve() {
int i, k;
int x, y;
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
if (x > y) {
k = x;
x = y;
y = k;
}
t[i].x = x;
t[i].y = y;
}
sort(t, t + m, cmp);
if (wf(1)) {
printf("Yes\n");
return;
}
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (wf(i) || wf(n / i)) {
printf("Yes\n");
return;
}
}
}
printf("No\n");
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, i;
scanf("%d", &n);
if (n % 4 == 0) {
for (i = 1; i <= n / 2; i += 2) {
printf("%d %d ", i + 1, n + 1 - i);
}
for (i = n / 2 + 2; i < n; i += 2) {
printf("%d %d ", n + 1 - i, i - 1);
}
printf("%d %d\n", n + 1 - i, i - 1);
} else if (n == 1) {
printf("1\n");
} else if (n % 4 == 1) {
for (i = 1; i <= n / 2; i += 2) {
printf("%d %d ", i + 1, n + 1 - i);
}
printf("%d ", (n + 1) / 2);
for (i = n / 2 + 3; i < n; i += 2) {
printf("%d %d ", n + 1 - i, i - 1);
}
printf("%d %d\n", n + 1 - i, i - 1);
} else {
printf("-1\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int circRight(int a, unsigned m) {
return (a >> m) | (a << (CHAR_BIT - m));
}
inline int circLeft(int a, unsigned m) {
return (a << m) | (a >> (CHAR_BIT - m));
}
const int ERR = 1e-5;
const int MOD = 1000000007;
const int MAX = 100005;
int main() {
int n, k;
cin >> n >> k;
int arr[n], minVal = INT_MAX, maxVal = INT_MIN;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
if (arr[i] > maxVal) {
maxVal = arr[i];
}
if (arr[i] < minVal) {
minVal = arr[i];
}
}
if (maxVal - minVal > k) {
cout << "NO" << endl;
;
return 0;
} else {
cout << "YES" << endl;
;
vector<int> v[n];
for (int i = 0; i < n; ++i) {
int color = 1, count = 0;
while (arr[i] && count < minVal) {
v[i].push_back(color);
arr[i]--;
count++;
}
while (arr[i]) {
v[i].push_back(color);
color++;
arr[i]--;
}
for (int j = 0; j < v[i].size(); ++j) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n;
int x[100001], y[100001];
long long s, ds, bds;
long double ans;
long long cj(long long x1, long long y1, long long x2, long long y2) {
return x1 * y2 - x2 * y1;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int abs(int a) { return a < 0 ? -a : a; }
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
for (i = 2; i <= n; i++) {
s += cj(x[i - 1], y[i - 1], x[i], y[i]);
bds += gcd(abs(x[i] - x[i - 1]), abs(y[i] - y[i - 1]));
}
s += cj(x[n], y[n], x[1], y[1]);
bds += gcd(abs(x[1] - x[n]), abs(y[1] - y[n]));
ds = (s + 2 - bds) / 2;
long double tn =
(n <= 100 ? (expl(n * logl(2)) - 1 - n - 1ll * n * (n - 1) / 2) : 0);
for (i = 1; i <= n; i++) {
long long ts = 0, tbds = 0, tds = 0;
for (j = 1; j <= 60 && j < n; j++) {
int xp1 = x[(i + j - 1) % n + 1], yp1 = y[(i + j - 1) % n + 1],
xp2 = x[(i + j - 2) % n + 1], yp2 = y[(i + j - 2) % n + 1];
ts += cj(xp2 - x[i], yp2 - y[i], xp1 - x[i], yp1 - y[i]);
tbds += gcd(abs(xp1 - xp2), abs(yp1 - yp2));
tbds -= gcd(abs(xp2 - x[i]), abs(yp2 - y[i]));
tbds += gcd(abs(xp1 - x[i]), abs(yp1 - y[i]));
tds = (ts + 2 - tbds) / 2;
long double tt =
(tds + gcd(abs(xp1 - x[i]), abs(yp1 - y[i])) - 1) *
((1 + (n <= 100
? (n + 1 + 1ll * n * (n - 1) / 2 - (1ll << j + 1)) / tn
: 0)) /
(1ll << j + 1));
ans += tt;
}
}
printf("%.10lf\n", ds - (double)ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int c=200002, sok=2e9;
long long t[c], kom[c], h[c], ki[c], n, m, maxi;
priority_queue<pair<long long, int> > q;
vector<pair<long long, int> > ans;
// atlag, kezd
int holvan(int a) {
if (!ki[a]) {
return a;
}
return ki[a]=holvan(ki[a]);
}
void unio(int a, int b) {
a=holvan(a), b=holvan(b);
ki[b]=a;
h[a]+=h[b];
//cout << "unio " << a << " " << b << "\n";
}
void pb(int l, int r) {
long long sum=kom[r]-kom[l-1], d=(r-l+1), atl=(sum-1)/d;
//cout << l << " " << r << " " << atl << "\n";
q.push({atl, l});
}
int main()
{
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i=1; i<=n; i++) {
cin >> t[i];
kom[i]=kom[i-1]+t[i], h[i]=1;
if (i<n) {
pb(i, i);
}
}
ans.push_back({sok, 0});
n--;
while (q.size()>0) {
long long ert=q.top().first, id=q.top().second;
q.pop();
if (!ki[id]) {
maxi=max(maxi, h[id]+h[id+h[id]]-1);
ans.push_back({ert, maxi});
int kov=id+h[id];
//cout << "valt " << id << " " << ert << " " << maxi << "\n";
//cout << "kov " << kov << "\n";
if (kov!=n+1) {
unio(id, kov);
pb(id, id+h[id]-1);
//cout << "ujhossz " << id << " " << h[id] << "\n";
}
}
}
reverse(ans.begin(), ans.end());
for (auto x:ans) {
//cout << x.first << " " << x.second << "\n";
}
int si=ans.size();
for (int i=si-2; i>=0; i--) {
ans[i].first=min(ans[i].first, ans[i+1].first);
}
for (int i=1; i<=m; i++) {
int x;
cin >> x;
int lo=-1, hi=ans.size(), mid;
while (hi-lo>1) {
mid=(lo+hi)/2;
if (ans[mid].first>=x) {
hi=mid;
} else {
lo=mid;
}
}
cout << ans[hi].second << " ";
}
cout << "\n";
return 0;
}
/*
22 18 7 5 4 2 1 1 1 1 1 1
*/
/*
19 1
39 2 6 3 12 4 1 5 3 2 12 3 1 41 1 5 19 2 6
15
*/
/*
6 1
41 1 5 19 2 6
15
*/
| 2 |
#include <bits/stdc++.h>
int main() {
int a[100][100], b[100][100];
int na, ma, nb, mb;
scanf("%d%d", &na, &ma);
for (int i = 0; i < na; i++)
for (int j = 0; j < ma; j++) scanf("%1d", &a[i][j]);
scanf("%d%d", &nb, &mb);
for (int i = 0; i < nb; i++)
for (int j = 0; j < mb; j++) scanf("%1d", &b[i][j]);
int ansx = 0, ansy = 0, max = 0;
for (int x = -na; x < nb; x++)
for (int y = -ma; y < mb; y++) {
int sum = 0;
for (int i = 0; i < na && (i + x < nb); i++) {
if (i + x < 0) {
i -= (i + x + 1);
continue;
}
for (int j = 0; j < ma && (j + y < mb); j++) {
if (j + y < 0) {
j -= (j + y + 1);
continue;
}
sum += a[i][j] * b[i + x][j + y];
}
}
if (sum > max) {
max = sum;
ansx = x;
ansy = y;
}
}
printf("%d %d", ansx, ansy);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, A[100100], C[100100];
long long p, q;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
sort(A + 1, A + n + 1);
for (int i = 1; i <= n; i++) C[i] = C[i - 1] + A[i];
p = C[n];
q = n;
for (int i = 1; i <= n; i++) {
p += (i - 1) * A[i] - C[i - 1] - (n - i) * A[i] + (C[n] - C[i]);
}
long long g = gcd(p, q);
p /= g;
q /= g;
cout << p << " " << q << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
string s,t,u;
cin >> s >> t;
cin >> a >> b >> u;
if(u==s)a--;
else b--;
cout << a << " " << b ;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return (POW(B, printf / 2) * POW(B, printf / 2));
}
template <typename T>
inline T Bigmod(T b, T p, T m) {
if (p == 0)
return 1;
else if (!(p & 1))
return (Bigmod(b, p / 2, m) * Bigmod(b, p / 2, m)) % m;
else
return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T>
inline T Dis(T x1, T y1, T x2, T y2) {
return sqrt((x1 - x2 * x1 - x2) + (y1 - y2 * y1 - y2));
}
template <typename T>
inline T Angle(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
inline T DIFF(T a, T b) {
T d = a - b;
if (d < 0)
return -d;
else
return d;
}
template <typename T>
inline T ABS(T a) {
if (a < 0)
return -a;
else
return a;
}
template <typename 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 <typename 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 <typename T>
inline T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int cdigittoint(char ch) { return ch - '0'; }
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
map<string, long long int> a;
vector<string> s;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string x, x1, x2;
cin >> x;
if (x.size() == 4) {
x1 += x[0];
x1 += x[1];
x2 += x[2];
x2 += "L";
s.push_back(x1);
s.push_back(x2);
} else
s.push_back(x);
}
for (int i = 0; i < s.size(); i++) {
a[s[i]]++;
}
cout << (a["UL"] + a["DR"] + 1) * (a["UR"] + a["DL"] + 1) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll gcd(ll x,ll y){
if(!y)return x;
return gcd(y,x%y);
}
int main(){
ll t1,A,B,C,D,hh,x,y;
scanf("%lld",&t1);
while(t1--){
scanf("%lld%lld%lld%lld",&A,&B,&C,&D);C++;
if(B>D){
puts("No");continue;
}
if(A<C){
if(A<B){
puts("No");continue;
}
A=C+D-B-(A-C)%(D-B);
}
x=(A-C)%B;y=D-B;
hh=gcd(y,B);x=x%hh;
if(x+C>=B)puts("Yes");
else puts("No");
}
}
/*
B>D 不行
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
string t = "";
string l = "()";
int auxk = k;
while (auxk > 1) {
t += l;
auxk--;
}
int szt = t.size();
for (int i = 0; i < (n - szt) / 2; i++) t += '(';
for (int i = 0; i < (n - szt) / 2; i++) t += ')';
vector<pair<int, int> > ans;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
for (int j = i + 1; j < n; j++) {
if (s[j] == t[i]) {
int a = i, b = j;
while (a <= b) {
swap(s[a], s[b]);
a++;
b--;
}
ans.push_back(pair<int, int>(i + 1, j + 1));
break;
}
}
}
}
cout << ans.size() << '\n';
for (auto &e : ans) {
cout << e.first << " " << e.second << '\n';
}
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int getnum(const string& s, char arr[], int k) {
int ans = 0;
for (int i = 0; i < k; ++i) {
ans *= 10;
ans += s[arr[i]];
}
return ans;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
char arr[100];
string sarr[10];
for (int i = 0; i < n; ++i) {
scanf("%s", arr);
sarr[i] = arr;
}
for (int i = 0; i < k; ++i) {
arr[i] = i;
}
int fact = 1;
for (int i = 2; i <= k; ++i) fact *= i;
int ans = 1000000000;
for (int i = 0; i < fact; ++i) {
int M = 0;
int m = 1000000000;
for (int i = 0; i < n; ++i) {
int a = getnum(sarr[i], arr, k);
if (a > M) M = a;
if (a < m) m = a;
}
if (M - m < ans) ans = M - m;
next_permutation(arr, arr + k);
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n;
int A[MAXN], sol[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
sort(A, A + n);
sol[0] = A[n - 1];
sol[n - 1] = A[n - 3];
sol[1] = A[n - 2];
for (int i = 2; i < n - 1; i++) {
sol[i] = A[n - i - 2];
}
for (int i = 0; i < n; i++) {
int x = (i + 1 + n) % n;
int y = (i - 1 + n) % n;
if (sol[x] + sol[y] <= sol[i]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << sol[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int a, b, yue[100000], l[10100], h[10100], p[10100], ans[10100], gs, c, n;
void qsort(int x, int y) {
int i, j, t, mid;
i = x;
j = y;
mid = yue[(i + j) / 2];
do {
while (yue[i] < mid) i++;
while (yue[j] > mid) j--;
if (i <= j) {
t = yue[i];
yue[i] = yue[j];
yue[j] = t;
i++;
j--;
}
} while (i <= j);
if (i < y) qsort(i, y);
if (x < j) qsort(x, j);
}
void qsort1(int x, int y) {
int i, j, t, mid;
i = x;
j = y;
mid = h[(i + j) / 2];
do {
while (h[i] > mid) i++;
while (h[j] < mid) j--;
if (i <= j) {
t = h[i];
h[i] = h[j];
h[j] = t;
t = l[i];
l[i] = l[j];
l[j] = t;
t = p[i];
p[i] = p[j];
p[j] = t;
i++;
j--;
}
} while (i <= j);
if (i < y) qsort1(i, y);
if (x < j) qsort1(x, j);
}
int gcd(int a, int b) {
if (a > b) {
int t;
t = a;
a = b;
b = t;
}
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int main() {
int i, j;
while (scanf("%d %d", &a, &b) != EOF) {
c = gcd(a, b);
for (i = 1; i * i <= c; i++)
if (c % i == 0) {
gs++;
yue[gs] = i;
gs++;
yue[gs] = c / i;
}
qsort(1, gs);
scanf("%d", &n);
for (i = 0; i < n; i++) {
p[i] = i;
scanf("%d %d", &l[i], &h[i]);
}
qsort1(0, n - 1);
j = gs;
for (i = 0; i < n; i++) {
while (yue[j] > h[i]) j--;
if (yue[j] < l[i])
ans[p[i]] = -1;
else
ans[p[i]] = yue[j];
}
for (i = 0; i < n; i++) printf("%d\n", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool right(int ds_ab, int ds_bc, int ds_ac) {
if (ds_ab == (ds_ac + ds_bc)) {
return true;
}
if (ds_bc == (ds_ac + ds_ab)) {
return true;
}
if (ds_ac == (ds_ab + ds_bc)) {
return true;
}
return false;
}
int main() {
vector<pair<int, int> > coor;
for (int i = 0; i < 3; i++) {
int x, y;
cin >> x >> y;
coor.push_back(make_pair(x, y));
}
int ds_ab =
(((coor[1].first - coor[0].first) * (coor[1].first - coor[0].first)) +
(coor[1].second - coor[0].second) * (coor[1].second - coor[0].second));
int ds_bc =
(((coor[2].first - coor[1].first) * (coor[2].first - coor[1].first)) +
(coor[2].second - coor[1].second) * (coor[2].second - coor[1].second));
int ds_ac =
(((coor[2].first - coor[0].first) * (coor[2].first - coor[0].first)) +
(coor[2].second - coor[0].second) * (coor[2].second - coor[0].second));
if (ds_ab <= 0 || ds_bc <= 0 || ds_ac <= 0) {
cout << "NEITHER" << endl;
return 0;
}
if (right(ds_ab, ds_bc, ds_ac)) {
cout << "RIGHT" << endl;
return 0;
}
for (int i = 0; i < 3; i++) {
coor[i].first--;
ds_ab =
((coor[1].first - coor[0].first) * (coor[1].first - coor[0].first) +
(coor[1].second - coor[0].second) * (coor[1].second - coor[0].second));
ds_bc =
((coor[2].first - coor[1].first) * (coor[2].first - coor[1].first) +
(coor[2].second - coor[1].second) * (coor[2].second - coor[1].second));
ds_ac =
((coor[2].first - coor[0].first) * (coor[2].first - coor[0].first) +
(coor[2].second - coor[0].second) * (coor[2].second - coor[0].second));
if (ds_ab <= 0 || ds_bc <= 0 || ds_ac <= 0) {
coor[i].first++;
continue;
}
if (right(ds_ab, ds_bc, ds_ac)) {
cout << "ALMOST" << endl;
return 0;
}
coor[i].first++;
}
for (int i = 0; i < 3; i++) {
coor[i].first++;
ds_ab =
((coor[1].first - coor[0].first) * (coor[1].first - coor[0].first) +
(coor[1].second - coor[0].second) * (coor[1].second - coor[0].second));
ds_bc =
((coor[2].first - coor[1].first) * (coor[2].first - coor[1].first) +
(coor[2].second - coor[1].second) * (coor[2].second - coor[1].second));
ds_ac =
((coor[2].first - coor[0].first) * (coor[2].first - coor[0].first) +
(coor[2].second - coor[0].second) * (coor[2].second - coor[0].second));
if (ds_ab <= 0 || ds_bc <= 0 || ds_ac <= 0) {
coor[i].first--;
continue;
}
if (right(ds_ab, ds_bc, ds_ac)) {
cout << "ALMOST" << endl;
return 0;
}
coor[i].first--;
}
for (int i = 0; i < 3; i++) {
coor[i].second++;
ds_ab =
((coor[1].first - coor[0].first) * (coor[1].first - coor[0].first) +
(coor[1].second - coor[0].second) * (coor[1].second - coor[0].second));
ds_bc =
((coor[2].first - coor[1].first) * (coor[2].first - coor[1].first) +
(coor[2].second - coor[1].second) * (coor[2].second - coor[1].second));
ds_ac =
((coor[2].first - coor[0].first) * (coor[2].first - coor[0].first) +
(coor[2].second - coor[0].second) * (coor[2].second - coor[0].second));
if (ds_ab <= 0 || ds_bc <= 0 || ds_ac <= 0) {
coor[i].second--;
continue;
}
if (right(ds_ab, ds_bc, ds_ac)) {
cout << "ALMOST" << endl;
return 0;
}
coor[i].second--;
}
for (int i = 0; i < 3; i++) {
coor[i].second--;
ds_ab =
((coor[1].first - coor[0].first) * (coor[1].first - coor[0].first) +
(coor[1].second - coor[0].second) * (coor[1].second - coor[0].second));
ds_bc =
((coor[2].first - coor[1].first) * (coor[2].first - coor[1].first) +
(coor[2].second - coor[1].second) * (coor[2].second - coor[1].second));
ds_ac =
((coor[2].first - coor[0].first) * (coor[2].first - coor[0].first) +
(coor[2].second - coor[0].second) * (coor[2].second - coor[0].second));
if (ds_ab <= 0 || ds_bc <= 0 || ds_ac <= 0) {
coor[i].second++;
continue;
}
if (right(ds_ab, ds_bc, ds_ac)) {
cout << "ALMOST" << endl;
return 0;
}
coor[i].second++;
}
cout << "NEITHER" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, x;
void read() { scanf("%d%d%d", &l, &r, &x); }
};
vector<node> level[7001];
int n, m;
const int maxnum = 1000000;
int many[maxnum];
void init() {
for (int i = 1; i < maxnum; i++) {
many[i] = many[i - 1];
if (i & (i - 1)) continue;
many[i]++;
}
for (int i = 1; i < maxnum; i++) {
many[i] += i;
}
}
int main() {
scanf("%d%d", &n, &m);
init();
while (m--) {
int ope;
scanf("%d", &ope);
if (ope == 1) {
int t;
node tmp;
scanf("%d", &t);
tmp.read();
level[t].push_back(tmp);
} else {
int t, v;
scanf("%d%d", &t, &v);
set<int> s;
int L = v, R = v;
for (int i = t; i <= n; i++) {
for (int j = 0; j < level[i].size(); j++) {
node tmp = level[i][j];
if (tmp.l > R || tmp.r < L) continue;
s.insert(tmp.x);
}
L = many[L - 1] + 1;
R = many[R];
}
printf("%d\n", s.size());
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> S_vec(n);
for (int i = 0; i < n; ++i)
cin >> S_vec.at(i);
int q;
cin >> q;
int cnt = 0;
int t;
for (int i = 0; i < q; ++i) {
cin >> t;
auto it = lower_bound(S_vec.begin(), S_vec.end(), t);
if (it != S_vec.end() && *it == t)
++cnt;
}
cout << cnt << endl;
}
| 0 |
#include <iostream>
using namespace std;
int fib(int n);
int main() {
int n;
int dp[45];
dp[0] = 1;
dp[1] = 1;
cin >> n;
for(int i = 2; i <= n; i++) {
dp[i] = dp[i-1] + dp[i-2];
}
cout << dp[n] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int len[27][27] = {0};
int main() {
string s;
char ch[20];
int n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%s", ch);
s = ch;
for (int j = 0; j <= 'z' - 'a'; j++) {
int t;
if (j != s[0] - 'a' && len[j][s[0] - 'a'] == 0) continue;
t = len[j][s[0] - 'a'] + s.length();
len[j][s[s.length() - 1] - 'a'] = max(t, len[j][s[s.length() - 1] - 'a']);
ans = max(len[j][j], ans);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (b > a) {
if ((b - a) % 2 == 1)
cout << "1" << endl;
else
cout << "2" << endl;
} else if (b < a) {
if ((a - b) % 2 == 0)
cout << "1" << endl;
else
cout << "2" << endl;
} else
cout << "0" << endl;
}
}
| 1 |
#include<iostream>
using namespace std;
typedef long long ll;
#define INF 1LL<<60
ll f(ll b, ll n){
if(b<2) return INF;
ll ret=0;
while(n>=b){
ret+=n%b;
n/=b;
}
return ret+n;
}
int main(){
ll n,s;
cin >> n >> s;
if(s==n){
cout << n+1 << endl;
return 0;
}
ll ans=INF;
for(ll i=2;i*i<=n;i++){
if(f(i,n)==s) ans=min(ans,i);
}
for(ll i=1;i*i<n;i++){
ll b=(n-s)/i+1;
if(f(b,n)==s) ans=min(ans,b);
}
if(ans==INF) cout << -1 << endl;
else cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int N, M;
bool grid[500][500];
int X1, X2, Y1, Y2;
int main() {
std::cin >> N >> M;
bool flag = false;
int lastx, lasty;
for (int i = 0; i < N; i++) {
char ch;
for (int j = 0; j < M; j++) {
std::cin >> ch;
if (ch == '.') grid[i][j] = false;
if (ch == 'X') {
grid[i][j] = true;
if (!flag) {
flag = true;
X1 = i;
Y1 = j;
}
lastx = i;
lasty = j;
}
}
}
X2 = lastx;
Y2 = lasty;
if (X1 > X2 || Y1 > Y2) {
std::cout << "NO\n";
return 0;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (grid[i][j] && (i < X1 || i > X2 || j < Y1 || j > Y2) ||
!grid[i][j] && (i >= X1 && i <= X2 && j >= Y1 && j <= Y2)) {
std::cout << "NO\n";
return 0;
}
}
}
std::cout << "YES\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n >= 30 ? "Yes" : "No") << endl;
}
| 0 |
#include<bits/stdc++.h>
#define to edge[i].v
#define mp make_pair
#define rint register int
#define debug(x) cerr<<#x<<"="<<x<<endl
#define fgx cerr<<"-------------"<<endl
#define N 1000000
using namespace std;
typedef long long ll;
typedef long double db;
typedef pair<int,int> pii;
unordered_map<ll,int> f; int head[N],tot,n,ans[N],mx[N],fa[N];
struct Edge{int v,next;}edge[N];
inline void add(int x,int y){edge[++tot]=Edge{y,head[x]};head[x]=tot;}
inline int Q(int x,int y)
{ if(f.count((ll)x*(n+1)+y)) return f[(ll)x*(n+1)+y];
if(x>=y) return f[(ll)x*(n+1)+y]=0;
int ans=1; for(rint i=head[x];i;i=edge[i].next) if(to!=fa[x]) ans+=Q(to,y);
return f[(ll)x*(n+1)+y]=ans;
}
void _(int x){for(rint i=head[x];i;i=edge[i].next)if(to!=fa[x])fa[to]=x,_(to);}
void dfs(int x,int la=0)
{ if(x==1) ans[x]=1;
else
{ int s=1; for(rint i=head[x];i;i=edge[i].next) if(to!=la) s+=Q(to,mx[x]);
if(x<mx[la]) s-=Q(x,mx[la]); ans[x]=ans[la]+s;
}
for(rint i=head[x];i;i=edge[i].next) if(to!=la) mx[to]=max(mx[x],x),dfs(to,x);
}
int main()
{ int x,y; cin>>n; for(rint i=1;i<n;i++) scanf("%d%d",&x,&y),add(x,y),add(y,x);
_(1); dfs(1); for(rint i=2;i<=n;i++) printf("%d ",ans[i]-1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long N = 400005;
long long pos[N], dfn[N], tin[N], tout[N], dep[N], vd[N << 2], vl[N << 2],
vr[N << 2], maxd[N << 2], vlca[N << 2], lm[N << 2], mr[N << 2], lmr[N << 2],
tag[N << 2], head[N], vet[N], next[N], len[N], val[N], num, fa[N][20],
deep[N], s[N << 2], t[N << 2];
long long n, m, x, y, c, tot, q, w, d, k, lans;
char opt[5];
void add(long long u, long long v, long long c) {
num++;
vet[num] = v, len[num] = c;
next[num] = head[u];
head[u] = num;
}
void dfs(long long u, long long fa) {
dfn[++tot] = u;
tin[u] = tot;
for (long long i = head[u]; i; i = next[i]) {
long long v = vet[i];
if (v == fa) continue;
pos[(i + 1) / 2] = v, dep[v] = dep[u] + len[i];
dfs(v, u);
dfn[++tot] = u;
}
tout[u] = tot;
}
void doAdd(long long p, long long l, long long r, long long x) {
maxd[p] += x;
vlca[p] -= 2 * x;
lm[p] -= x, mr[p] -= x;
tag[p] += x;
}
void pushDown(long long p, long long l, long long r) {
long long mid = l + (r - l) / 2;
doAdd(p + p, l, mid, tag[p]), doAdd(p + p + 1, mid + 1, r, tag[p]);
tag[p] = 0;
}
void pushUp(long long p) {
maxd[p] = std::max(maxd[p + p], maxd[p + p + 1]);
vlca[p] = std::max(vlca[p + p], vlca[p + p + 1]);
lm[p] = std::max(std::max(lm[p + p], lm[p + p + 1]),
maxd[p + p] + vlca[p + p + 1]);
mr[p] = std::max(std::max(mr[p + p], mr[p + p + 1]),
vlca[p + p] + maxd[p + p + 1]);
lmr[p] = std::max(
std::max(lmr[p + p], lmr[p + p + 1]),
std::max(lm[p + p] + maxd[p + p + 1], maxd[p + p] + mr[p + p + 1]));
}
void build(long long p, long long l, long long r) {
if (l == r) {
maxd[p] = dep[dfn[l]], vlca[p] = -2 * dep[dfn[l]];
lm[p] = mr[p] = -dep[dfn[l]], lmr[p] = 0;
s[p] = t[p] = dfn[l];
vl[p] = vr[p] = vd[p] = dfn[l];
return;
}
long long mid = l + (r - l) / 2;
build(p + p, l, mid);
build(p + p + 1, mid + 1, r);
pushUp(p);
}
void update(long long p, long long l, long long r, long long x, long long y,
long long z) {
if (l == x && r == y) {
doAdd(p, l, r, z);
return;
}
long long mid = l + (r - l) / 2;
pushDown(p, l, r);
if (y <= mid)
update(p + p, l, mid, x, y, z);
else if (x > mid)
update(p + p + 1, mid + 1, r, x, y, z);
else
update(p + p, l, mid, x, mid, z),
update(p + p + 1, mid + 1, r, mid + 1, y, z);
pushUp(p);
}
long long Query(long long p, long long l, long long r, long long x) {
if (l == r) return maxd[p];
long long mid = l + (r - l) / 2;
pushDown(p, l, r);
if (x <= mid)
return Query(p + p, l, mid, x);
else
return Query(p + p + 1, mid + 1, r, x);
}
signed main() {
scanf("%lld%lld%lld", &n, &q, &w);
for (long long i = 1; i < n; i++) {
scanf("%lld%lld%lld", &x, &y, &c);
val[i] = c;
add(x, y, c), add(y, x, c);
}
dfs(1, 0);
build(1, 1, tot);
while (q--) {
scanf("%lld%lld", &d, &k);
d = (d + lans % (n - 1)) % (n - 1) + 1;
k = (k + lans % w) % w;
update(1, 1, tot, tin[pos[d]], tout[pos[d]], k - val[d]);
val[d] = k;
lans = lmr[1];
printf("%lld\n", lans);
}
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int w, n;
int a[31];
cin >> w >> n;
for (int i = 1; i <= w; i++){
a[i] = i;
}
int x, y;
char t;
for (int i = 0; i < n; i++){
cin >> x >> t >> y;
swap(a[x], a[y]);
}
for (int i = 1; i <= w; i++){
cout << a[i] << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d\n", &t);
while (t--) {
long n;
int flag = 1;
scanf("%ld\n", &n);
string s;
getline(cin, s);
vector<char> t(n), b(n);
for (int i = 0; i < n; i++) {
if ((s[i] == '2') || (s[i] == '0')) {
if (flag) {
t[i] = char((s[i] - '0') / 2 + '0');
b[i] = char((s[i] - '0') / 2 + '0');
} else {
t[i] = s[i];
b[i] = '0';
}
} else {
if (flag) {
b[i] = '1';
t[i] = '0';
flag = 0;
} else {
b[i] = '0';
t[i] = '1';
}
}
}
for (char c : b) {
cout << c;
}
cout << endl;
for (char c : t) {
cout << c;
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "white" << endl;
cout << 1 << " " << 2 << endl;
} else {
cout << "black" << endl;
}
return 0;
}
| 4 |
#include<stdio.h>
#include<algorithm>
using namespace std;
int now[30];
int to[30];
int main(){
int a,b;
int T=0;
while(scanf("%d%d",&a,&b),a){
for(int i=0;i<30;i++)now[i]=0;
now[0]=a;
int t=0;
while(1){
t++;
for(int i=0;i<a;i++){
to[i]=0;
}
for(int i=0;i<a;i++){
to[i+1]+=now[i]/2;
to[i]+=now[i]%2;
to[0]+=now[i]/2;
}
for(int i=0;i<a;i++)now[i]=to[i];
if(to[b])break;
}
printf("Case %d: %d\n",++T,t);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int pow(int a, int b) {
int ans = 1;
for (int i = 0; i < b; i++) {
ans = ans * a;
}
return ans;
}
int main(int argc, char const *argv[]) {
for (int I = 0; I < 1; I++) {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
int t = 0;
for (int i = 0; i < n - 1; i++) {
if (v[i] == 0) {
cout << t << endl;
continue;
}
int diff = n - i - 1;
int temp;
for (int j = 0; j < diff; j++) {
if (diff == pow(2, j)) {
temp = i + pow(2, j);
break;
} else if (diff < pow(2, j)) {
temp = i + pow(2, j - 1);
break;
}
}
t = t + v[i];
v[temp] += v[i];
v[i] = 0;
cout << t << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
class pa3 {
public:
int x, y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-10);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-10)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-10)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-10)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-10)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-10)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-10)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-10)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-10));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
int beki(int wa, int rr, int warukazu) {
if (rr == 0) return 1ll;
if (rr == 1) return wa % warukazu;
if (rr % 2 == 1) return (beki(wa, rr - 1, warukazu) * wa) % warukazu;
int zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
struct Segmax {
private:
public:
int cor = (1 << 17);
vector<pair<int, int> > vec;
void shoki1() {
vec.resize(2 * cor + 3, make_pair(0, 0));
for (int i = cor; i < 2 * cor; i++) vec[i].second = i - cor;
}
void shoki2() {
for (int i = cor - 1; i > 0; i--) {
if (vec[2 * i].first >= vec[2 * i + 1].first)
vec[i] = vec[2 * i];
else
vec[i] = vec[2 * i + 1];
}
}
void updadd(int x, int w) {
x += cor;
vec[x].first += w;
while (1) {
x /= 2;
if (x == 0) break;
if (vec[2 * x].first >= vec[2 * x + 1].first)
vec[x] = vec[2 * x];
else
vec[x] = vec[2 * x + 1];
}
}
void updchan(int x, int w) {
x += cor;
vec[x].first = w;
while (1) {
x /= 2;
if (x == 0) break;
if (vec[2 * x].first >= vec[2 * x + 1].first)
vec[x] = vec[2 * x];
else
vec[x] = vec[2 * x + 1];
}
}
pair<int, int> segmax(int a, int b, int k = 1, int l = 0, int r = -10) {
if (r < 0) r = cor;
if (a <= l && r <= b) {
return vec[k];
}
if (r <= a || b <= l) {
return make_pair(-(1ll << 31), -1);
}
pair<int, int> v1 = segmax(a, b, k * 2, l, (l + r) / 2),
v2 = segmax(a, b, k * 2 + 1, (l + r) / 2, r);
if (v1.first >= v2.first)
return v1;
else
return v2;
}
};
Segmax seg[350];
map<int, int> ma;
int cnt = 1;
set<pair<int, int> > se[100001];
int wa[100010] = {0};
void ishoku(int r, int id) {
seg[id].shoki1();
for (auto it = se[r].begin(); it != se[r].end(); it++) {
seg[id].vec[seg[id].cor + (*it).first].first = (*it).second;
}
seg[id].shoki2();
}
signed main() {
int th = 300;
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
int ans = 0;
cin >> n >> m;
for (int idf = 0; idf < m; idf++) {
int s, t, v;
cin >> s >> t >> v;
int val;
if (wa[s] == 0) {
val = 0;
for (auto it = se[s].begin(); it != se[s].end(); it++) {
if ((*it).first >= v) break;
val = max(val, (*it).second);
}
} else {
val = seg[wa[s]].segmax(0ll, v).first;
}
ans = max(ans, val + 1);
if (wa[t] == 0) {
se[t].insert(make_pair(v, val + 1));
if (se[t].size() >= th) {
ma[t] = cnt;
cnt++;
ishoku(t, cnt - 1);
wa[t] = cnt - 1;
se[t].clear();
}
} else {
if ((seg[wa[t]].vec[seg[wa[t]].cor + v]).first < val + 1)
seg[wa[t]].updchan(v, val + 1);
}
}
cout << ans << endl;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string a;
long double b,s=0.000000;
int c;
cin>>c;
while(c--){
cin>>b>>a;
if(a[0]=='J')
s=s+b;
else{
s=s+(b*380000.0);
}
}
cout<<s<<endl;
return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b, c;
cin >> a >> b >> c;
cout << (2 * max(a, max(b, c)) == (a + b + c) ? "Yes" : "No") << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string ans[] = {"abc", "acb"};
string a[2][3] = {{"ab", "bc", "ca"}, {"ac", "ba", "cb"}};
string s[2];
void prin1(string s, int n) {
for (int i = 0; i < n; i++) cout << s;
exit(0);
}
void prin(char x, int n) {
for (int i = 0; i < n; i++) cout << x;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
cin >> s[0] >> s[1];
cout << "YES"
<< "\n";
for (int i = 0; i < 2; i++) {
int c = 0;
for (int j = 0; j < 3; j++) {
if (s[0] == a[i][j] || s[1] == a[i][j]) c++;
}
if (c == 0) prin1(ans[i], n);
}
if (s[0][0] == s[1][0]) {
prin(s[0][1], n), prin(s[1][1], n), prin(s[1][0], n);
exit(0);
}
if (s[0][1] == s[1][1]) {
prin(s[1][1], n), prin(s[0][0], n), prin(s[1][0], n);
exit(0);
}
if (s[0][1] == s[1][0]) {
if (s[0] == "ab" || s[0] == "ba")
prin(s[0][0], n), prin('c', n), prin(s[0][1], n);
else if (s[0] == "bc" || s[0] == "cb")
prin(s[0][0], n), prin('a', n), prin(s[0][1], n);
else if (s[0] == "ca" || s[0] == "ac")
prin(s[0][0], n), prin('b', n), prin(s[0][1], n);
}
return 0;
}
| 5 |
#include<stdio.h>
#include<iostream>
#include<string>
#include<math.h>
using namespace std;
bool G[80001]={};
int main(){
for(int i=3;i<80000;i+=2){G[i]=true;
for(int j=3;j*j<=i;j++)
if(i%j==0){G[i]=false;break;}
}
G[2]=true;
int N;
while(cin>>N){
for(int i=N-1;i>0;i--)
if(G[i]==true){cout<<i;
break;
}
cout<<" ";
for(int i=N+1;i<80000;i++)
if(G[i]==true){cout<<i<<endl;
break;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,K;
cin >> N >> K;
vector<int> A(N);
for(int i=0;i<N;i++) cin >> A[i];
for(int i=K;i<N;i++){
if(A[i]>A[i-K]) cout << "Yes" << endl;
else cout << "No" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string cadena1;
int cont = 0, cont1 = 0;
getline(cin, cadena1);
for (int i = 0; i < cadena1.size(); i++) {
if (cadena1[i] == cadena1[i + 1]) {
cont1++;
}
if (cadena1[i] != cadena1[i + 1]) {
cont++;
cont1 = 0;
}
if (cont1 == 5) {
cont++;
cont1 = 0;
}
}
cout << cont;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int intlog(double x) { return (int)(log(x) / log(2)); }
bool check(long long int x) {
long long int n = x, y = 0;
while (x > 0) {
y = y * 10 + x % 10;
x = x / 10;
}
if (y == n) {
return true;
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long int> mark(2000005, 1);
mark[1] = 0;
for (long long int i = 2; i * i < 2000005; i++) {
if (mark[i]) {
for (long long int j = i * i; j < 2000005; j += i) {
mark[j] = 0;
}
}
}
vector<long long int> prime(2000005, 0);
for (long long int i = 1; i < 2000005; i++) {
prime[i] = prime[i - 1] + mark[i];
}
vector<long long int> palin(2000005, 0);
for (long long int i = 1; i < 2000005; i++) {
if (check(i)) {
palin[i] = palin[i - 1] + 1;
} else {
palin[i] = palin[i - 1];
}
}
long long int p, q;
cin >> p >> q;
long long int ans = 0;
for (long long int i = 1; i < 2000005; i++) {
if (q * prime[i] <= p * palin[i]) {
ans = i;
}
}
if (ans) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, i;
} p[110];
int cmp(node x, node y) { return x.a < y.a; }
int main() {
int n, k, num;
while (scanf("%d %d", &n, &k) != EOF) {
num = 0;
int i;
for (i = 0; i < n; i++) {
cin >> p[i].a;
p[i].i = i + 1;
}
sort(p, p + n, cmp);
for (i = 0; i < n; i++)
if (k >= p[i].a) {
k -= p[i].a;
} else
break;
num = i;
cout << num << "\n";
if (num == 0) continue;
for (i = 0; i < num - 1; i++) {
cout << p[i].i << " ";
}
cout << p[i].i << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 998244353;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto& x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int expo(int a, int n) {
int ans = 1;
for (; n; n >>= 1, a = (a * 1LL * a) % inf)
if (n & 1) ans = (ans * 1LL * a) % inf;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, a;
cin >> n >> m >> a;
vector<int> b(m);
for (auto i = (0); i <= (m - 1); ++i) cin >> b[i];
int l = 2 * (n / 2.0 - b.back());
int s = b[0];
for (auto i = (1); i <= (m - 1); ++i) b[i] -= s, s += b[i];
int ans = 1;
int i2 = expo(2, inf - 2);
for (int k : b) {
int x = expo(a, k);
ans = (ans * 1LL * x) % inf;
ans = (ans * 1LL * (x + 1)) % inf;
ans = (ans * 1LL * i2) % inf;
}
cout << (ans * 1LL * expo(a, l)) % inf;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3;
int n;
struct point {
int x, y;
};
struct rr {
point dl, gd;
} rec[maxn + 10];
bool srt_x1(rr a, rr b) { return a.dl.x < b.dl.x; }
bool srt_x2(rr a, rr b) { return a.gd.x < b.gd.x; }
bool srt_y1(rr a, rr b) { return a.dl.y < b.dl.y; }
bool srt_y2(rr a, rr b) { return a.gd.y < b.gd.y; }
int try_vert_cut1(int l, int r) {
sort(rec + l, rec + r + 1, srt_x1);
int maxx = rec[l].gd.x;
for (int i = l + 1; i <= r; i++) {
if (maxx <= rec[i].dl.x) return i - 1;
maxx = max(maxx, rec[i].gd.x);
}
return -1;
}
int try_vert_cut2(int l, int r) {
sort(rec + l, rec + r + 1, srt_x2);
int maxx = rec[r].dl.x;
for (int i = r - 1; i >= l; i--) {
if (maxx >= rec[i].gd.x) return i + 1;
maxx = min(maxx, rec[i].dl.x);
}
return -1;
}
int try_hor_cut1(int l, int r) {
sort(rec + l, rec + r + 1, srt_y1);
int maxx = rec[l].gd.y;
for (int i = l + 1; i <= r; i++) {
if (maxx <= rec[i].dl.y) return i - 1;
maxx = max(maxx, rec[i].gd.y);
}
return -1;
}
int try_hor_cut2(int l, int r) {
sort(rec + l, rec + r + 1, srt_y2);
int maxx = rec[r].dl.y;
for (int i = r - 1; i >= l; i--) {
if (maxx >= rec[i].gd.y) return i + 1;
maxx = min(maxx, rec[i].dl.y);
}
return -1;
}
bool go(int l, int r) {
if (l == r) return 1;
int x = try_vert_cut1(l, r);
if (x != -1) return (go(l, x) & go(x + 1, r));
x = try_vert_cut2(l, r);
if (x != -1) return (go(l, x) & go(x + 1, r));
x = try_hor_cut1(l, r);
if (x != -1) return (go(l, x) & go(x + 1, r));
x = try_hor_cut2(l, r);
if (x != -1) return (go(l, x) & go(x + 1, r));
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d %d %d %d", &rec[i].dl.x, &rec[i].dl.y, &rec[i].gd.x,
&rec[i].gd.y);
if (go(1, n))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, x1, y1, x2, y2, max;
cin >> x >> y;
max = abs(x) + abs(y);
if (x > 0 and y > 0) {
x2 = max;
y2 = 0;
x1 = 0;
y1 = max;
} else if (x < 0 and y > 0) {
x1 = -max;
y1 = 0;
x2 = 0;
y2 = max;
} else if (x > 0 and y < 0) {
x2 = max;
y2 = 0;
x1 = 0;
y1 = -max;
} else {
x1 = -max;
y1 = 0;
x2 = 0;
y2 = -max;
}
cout << x1 << " " << y1 << " " << x2 << " " << y2 << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100003;
int a[MAX_N];
int sg_val[MAX_N];
int get_sg(int x, int k) {
if (k % 2 == 0) {
if (x >= 3) {
if (x % 2 == 0)
return 1;
else
return 0;
} else if (x == 0)
return 0;
else if (x == 1)
return 1;
else if (x == 2)
return 2;
} else if (k % 2 == 1) {
if (x > 4) {
if (x % 2 == 1)
return 0;
else {
if (get_sg(x / 2, k) == 1)
return 2;
else
return 1;
}
} else if (x == 0)
return 0;
else if (x == 1)
return 1;
else if (x == 2)
return 0;
else if (x == 3)
return 1;
else if (x == 4)
return 2;
}
}
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
int maxa = -1;
for (int x = 0; n > x; x++) {
scanf("%d", &a[x]);
if (maxa < a[x]) maxa = a[x];
}
memset(sg_val, 0, sizeof(sg_val));
int SG = get_sg(a[0], k);
for (int x = 1; n > x; x++) {
int t = get_sg(a[x], k);
SG ^= get_sg(a[x], k);
}
printf("%s\n", (SG == 0 ? "Nicky" : "Kevin"));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
const long long M = 21;
long long INF = 1e18;
long long n;
long long d[(1 << M)];
long long cnt[M][M];
vector<long long> col[M];
int32_t main() {
ios::sync_with_stdio(0);
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
x--;
col[x].push_back(i);
}
for (long long i = 0; i < 20; i++) {
for (long long j = 0; j < 20; j++) {
if (i == j) {
continue;
}
if ((long long)col[i].size() == 0 || (long long)col[j].size() == 0) {
continue;
}
long long pos2 = 0;
for (long long pos1 = 0; pos1 < (long long)col[i].size(); pos1++) {
while (1) {
if (pos2 == (long long)col[j].size() - 1 ||
col[j][pos2 + 1] > col[i][pos1]) {
break;
}
pos2++;
}
if (col[i][pos1] > col[j][pos2]) {
cnt[i][j] += pos2 + 1;
}
}
}
}
for (long long mask = 0; mask < (1 << 20); mask++) {
d[mask] = INF;
}
d[0] = 0;
for (long long mask = 0; mask < (1 << 20); mask++) {
vector<long long> was;
for (long long i = 0; i < 20; i++) {
if (mask & (1 << i)) {
was.push_back(i);
}
}
for (long long i = 0; i < 20; i++) {
if (mask & (1 << i)) {
continue;
}
long long sum = 0;
for (long long j = 0; j < (long long)was.size(); j++) {
sum += cnt[was[j]][i];
}
long long nmask = mask | (1 << i);
d[nmask] = min(d[nmask], d[mask] + sum);
}
}
cout << d[(1 << 20) - 1] << endl;
}
| 5 |
#include <iostream>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
int a=n*(n-1)/2 + m*(m-1)/2;
cout<<a<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int m1, m2;
if (n <= 2)
cout << "-1\n";
else if (n % 2 == 1)
cout << (n * n) / 2 << " " << (n * n) / 2 + 1 << endl;
else if (n % 4 == 0)
cout << (n / 4) * 3 << " " << (n / 4) * 5 << endl;
else {
n /= 2;
long long int a = (n * n) / 2;
cout << 2 * a << " " << (2 * a) + 2 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 1000010;
std::vector<int> e[N];
bool vis[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0, u, v; i < m; ++i) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
}
std::stack<int> stack;
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
vis[i] = true;
stack.push(i);
for (auto v : e[i]) {
vis[v] = true;
}
}
}
memset(vis, 0, sizeof(vis));
std::vector<int> ans;
while (!stack.empty()) {
int u = stack.top();
stack.pop();
if (!vis[u]) {
ans.push_back(u);
for (auto v : e[u]) {
vis[v] = true;
}
}
}
int sz = ans.size();
printf("%d\n", sz);
for (int i = 0; i < sz; ++i) {
printf("%d%c", ans[i], " \n"[i == sz - 1]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, maxx = 0, x, sum = 0;
long long ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
sum += x;
maxx = maxx > x ? maxx : x;
}
ans = sum % (n - 1) != 0 ? 1 : 0;
ans += sum / (n - 1);
cout << max(maxx, ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i,n) for (ll i = 0, i##_len = (n); i < i##_len; i++)
int main() {
ll n; cin >> n;
vector<ll> a(n);
REP(i, n) cin >> a[i];
vector<ll> dp(n-1, -1);
for (ll ai : a) {
if (dp[ai % (n-1)] == -1) {
dp[ai % (n-1)] = ai;
} else {
cout << ai << " ";
cout << dp[ai % (n-1)] << endl;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int onecount[n];
memset(onecount, 0, sizeof(int) * n);
for (int i = 0; i < n; i++) {
while (arr[i] > 0) {
onecount[i] += (arr[i] % 2);
arr[i] /= 2;
}
}
int oddcount = 0;
int evencount = 0;
long long ans = 0;
int cumonecount[n + 1];
cumonecount[n] = 0;
int cum = 0;
for (int i = n - 1; i >= 0; i--) {
cum += onecount[i];
cumonecount[i] = cum;
}
for (int i = n - 2; i >= 0; i--) {
if (cumonecount[i + 2] % 2 == 0) {
evencount++;
} else {
oddcount++;
}
if (cumonecount[i] % 2 == 0) {
ans += evencount;
} else {
ans += oddcount;
}
}
for (int i = n - 1; i >= 0; i--) {
int sum = 0;
int max = 0;
for (int j = i; j < min(n, i + 62); j++) {
sum += onecount[j];
if (onecount[j] > max) max = onecount[j];
if (j > i && max > (sum - max)) {
if ((cumonecount[i] - cumonecount[j + 1]) % 2 == 0) {
ans--;
}
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int f;
int n, m;
char a;
int main() {
cin >> n >> m;
for (int j = 0; j < n; j++) {
for (int i = 0; i < m; i++) {
cin >> a;
if (a == 'C' || a == 'M' || a == 'Y') {
f = 1;
break;
}
}
if (f == 1) {
break;
}
}
if (f == 1)
cout << "#Color" << endl;
else
cout << "#Black&White" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, x2, y1, y2;
cin >> x1 >> y1;
cin >> x2 >> y2;
cout << max(abs(x2 - x1), abs(y2 - y1)) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(n);
map<long long, long long> m;
long long cnt = 0;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) {
m[a[i]]++;
cnt = max(cnt, m[a[i]]);
}
cout << cnt << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
#pragma GCC optimize("03")
using namespace std;
template <typename T>
struct ST {
vector<T> st;
int sz;
bool ty;
ST(int n, int tyy) : sz(n), st(4 * n), ty(tyy) {}
T merge(T v1, T v2) {
if (ty) return min(v1, v2);
return max(v1, v2);
}
void up(int p, T v) { st[p] = v; }
void build(T *arr) { build(1, 0, sz - 1, arr); }
void build(int p, int l, int r, T *arr) {
if (l == r) {
st[p] = arr[l];
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid, arr);
build((p << 1) + 1, mid + 1, r, arr);
st[p] = merge(st[p << 1], st[(p << 1) + 1]);
}
void build(vector<T> &arr) { build(1, 0, sz - 1, arr); }
void build(int p, int l, int r, vector<T> &arr) {
if (l == r) {
st[p] = arr[l];
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid, arr);
build((p << 1) + 1, mid + 1, r, arr);
st[p] = merge(st[p << 1], st[(p << 1) + 1]);
}
void update(int pos, T v) { update(1, 0, sz - 1, pos, v); }
void update(int p, int l, int r, int pos, T v) {
if (pos <= l && r <= pos) {
up(p, v);
return;
}
int mid = (l + r) >> 1;
if (pos <= mid) update(p << 1, l, mid, pos, v);
if (pos > mid) update((p << 1) + 1, mid + 1, r, pos, v);
st[p] = merge(st[p << 1], st[(p << 1) + 1]);
}
T query(int L, int R) { return query(1, 0, sz - 1, L, R); }
T query(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return st[p];
int mid = (l + r) >> 1;
if (R <= mid) return query(p << 1, l, mid, L, R);
if (L > mid) return query((p << 1) + 1, mid + 1, r, L, R);
return merge(query(p << 1, l, mid, L, R),
query((p << 1) + 1, mid + 1, r, L, R));
}
};
set<int> psi[(long long)(2e5 + 5)];
set<int> psp[(long long)(2e5 + 5)];
map<pair<long long, long long>, int> mki;
map<pair<long long, long long>, int> mkp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
bool ok = 1;
vector<int> ini(n, 1e9);
ST<int> sti(n, 1);
sti.build(ini);
vector<int> ini2(n, -1);
ST<int> stp(n, 0);
stp.build(ini2);
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
y = (y - 1) / 2;
if (x & 1) {
x = (x - 1) / 2;
mki[pair<long long, long long>(x, y)] =
1 - mki[pair<long long, long long>(x, y)];
if (mki[pair<long long, long long>(x, y)])
psi[x].insert(y);
else
psi[x].erase(y);
y = 1e9;
if (psi[x].size()) y = *(psi[x].begin());
sti.update(x, y);
ok &= (y > stp.query(x, n - 1));
} else {
x = (x - 1) / 2;
mkp[pair<long long, long long>(x, y)] =
1 - mkp[pair<long long, long long>(x, y)];
if (mkp[pair<long long, long long>(x, y)])
psp[x].insert(-y);
else
psp[x].erase(-y);
y = -1;
if (psp[x].size()) y = -(*(psp[x].begin()));
stp.update(x, y);
ok &= (y < sti.query(0, x));
}
if (ok)
cout << ("YES") << '\n';
else
cout << ("NO") << '\n';
}
return 0;
}
| 6 |
#include <stdio.h>
#include <algorithm>
long long n, m, x, ans;
long long a[2000];
long long dp[2001];
long long e[2001];
int main() {
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
scanf("%lld", a + i);
a[i] = a[i] * 10000 + i;
}
std::sort(a, a + n);
for (long long i = n - 1; i >= 0; i--) {
for (long long j = 0; j <= m; j++) {
x = a[i] / 10000 * (a[i] % 10000 - j);
if (e[j + 1] < x + dp[j])e[j + 1] = x + dp[j];
x = a[i] / 10000 * (n - 1 - m + j - a[i] % 10000);
if (e[j] < x + dp[j])e[j] = x + dp[j];
}
for (long long j = 0; j <= m + 1; j++) {
dp[j] = e[j];
e[j] = 0;
}
m++;
}
for (long long i = 0; i <= n; i++) {
if (dp[i] > ans)ans = dp[i];
}
printf("%lld\n", ans);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.