solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int n, m, ans = inf, a[301000], tg[301000], sz[301000], dg[301000], f[301000],
vis[301000], pre[301000], q[301000], l, r;
vector<int> G[301000];
void try4() {
memset(vis, 0, sizeof(vis));
if (G[1].size() == 0) return;
for (auto p : G[1]) vis[p] = true;
for (int a = 2; a < n; ++a)
if (vis[a] == 1)
for (auto b : G[a])
if (b != 1 && vis[b] == 0) {
printf("4\n");
printf("%d %d %d %d %d", 1, a, b, 1, n);
exit(0);
}
}
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
int merge(int x, int y) {
int fx = find(x), fy = find(y);
f[fy] = fx, sz[fx] += sz[fy];
}
void try5() {
memset(vis, 0, sizeof(vis));
if (G[1].size() == 0) return;
int tp = 0;
for (auto p : G[1]) vis[p] = 1;
for (int i = 1; i <= n; ++i) f[i] = i, sz[i] = 1;
for (int i = 2; i <= n; ++i)
if (vis[i]) a[++tp] = i;
for (int i = 1; i <= tp; ++i)
for (auto p : G[a[i]])
if (p != 1) merge(a[i], p);
for (int i = 1; i <= tp; ++i) {
int id = a[i], siz = 0;
for (auto p : G[id])
if (p != 1) siz++, tg[p] = i;
if (siz == sz[find(id)]) continue;
for (auto p : G[id])
if (p != 1)
for (auto q : G[p])
if (q != 1 && q != id && tg[q] != i) {
printf("5\n");
printf("%d %d %d %d %d %d\n", 1, id, p, q, id, n);
exit(0);
}
}
}
void add(int u, int v) { G[u].push_back(v), G[v].push_back(u); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; ++i) scanf("%d%d", &u, &v), add(u, v);
q[r++] = 1, pre[1] = -1;
while (l < r) {
int u = q[l++];
for (auto p : G[u])
if (!pre[p]) pre[p] = u, q[r++] = p;
}
if (pre[n]) {
int sum = 0, nw = n;
while (pre[nw] != -1) nw = pre[nw], sum++;
ans = sum;
}
if (ans > 4) try4();
if (ans > 5) try5();
if (ans == inf) return puts("-1"), 0;
vector<int> seq;
while (n != -1) seq.push_back(n), n = pre[n];
printf("%d\n", ans);
reverse(seq.begin(), seq.end());
for (auto p : seq) printf("%d ", p);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
const int mod = 1e9 + 7;
int n;
string s, ans;
int main() {
cin >> n >> s;
string ans = "";
for (int i = n - 1; i >= 0; --i) {
int k = ans.length() + 1;
int pos = k / 2;
string t = "";
for (int j = 0; j < pos; ++j) t += ans[j];
t += s[i];
for (int j = pos; j < ans.length(); ++j) t += ans[j];
ans = t;
}
reverse(ans.begin(), ans.end());
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, ans;
multiset<int> S;
int main(){
int a;
scanf("%d", &N);
for (int i=1; i<=N; i++) {
scanf("%d", &a);
S.insert(a);
}
while (!S.empty()){
int t = *(--S.end()), k;
S.erase(--S.end());
for (k=1; k<=t; k<<=1);
if (S.find(k-t) != S.end()){
ans++;
S.erase(S.find(k-t));
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a;
cin >> b;
for (int i = 0; i < a.length(); i++) {
if (a[i] >= 65 && a[i] <= 90) a[i] += 32;
}
for (int i = 0; i < b.length(); i++) {
if (b[i] >= 65 && b[i] <= 90) b[i] += 32;
}
int flag = 0;
for (int i = 0; i < a.length(); i++) {
if (a[i] < b[i]) {
flag = -1;
break;
} else if (b[i] < a[i]) {
flag = 1;
break;
} else
flag = 0;
}
cout << flag;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long a, b, c;
long long abc[100005];
long long n, m, k;
cin >> n;
long long mi, ma;
mi = n / 7;
c = mi;
mi *= 2;
b = n % 7;
if (b == 0)
ma = mi;
else if (b == 1)
ma = mi + 1;
else
ma = mi + 2;
if (b == 6) mi++;
cout << mi << " " << ma;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
long long int t, i, j;
t = 1;
while (t--) {
long long int n, k;
cin >> n;
vector<long long int> a(n), pref(n + 1);
long long int sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
pref[i + 1] = a[i] + pref[i];
}
set<long long int> st;
st.insert(0);
long long int l = 0, r = 0, ans = 0;
while (l < n) {
while (r < n && !st.count(pref[r + 1])) {
r++;
st.insert(pref[r]);
}
ans += r - l;
st.erase(pref[l]);
l++;
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
struct node {
int lx, ly;
int val;
bool operator<(const node &rr) const {
return make_pair(this->lx, this->ly) < make_pair(rr.lx, rr.ly);
}
};
set<node> mp;
bool check(node cur) {
int lx = cur.lx, ly = cur.ly;
int sup = 0;
for (int i = -1; i <= 1; i++) {
sup += (mp.find({lx - i, ly - 1, 0}) != mp.end());
}
return (sup > 1);
}
bool free(node cur) {
int lx = cur.lx, ly = cur.ly;
bool flag = 1;
for (int j = -1; j <= 1; j++) {
auto it = mp.find({lx - j, ly + 1, 0});
if (it != mp.end()) {
if (!check(*it)) {
flag = 0;
break;
}
}
}
return flag;
}
struct cmp {
bool operator()(node ll, node rr) const { return ll.val < rr.val; }
};
int main() {
int m;
scanf("%d", &m);
vector<node> a(m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a[i].lx, &a[i].ly);
a[i].val = i;
mp.insert(a[i]);
}
set<node, cmp> s;
for (int i = 0; i < m; i++) {
if (free(a[i])) {
s.insert(a[i]);
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
node cur;
if (i & 1) {
auto it = s.begin();
while (!free(*it)) {
it = s.erase(it);
}
cur = *it;
} else {
auto it = s.end();
while (!free(*(--it))) {
it = s.erase(it);
}
cur = *it;
}
ans = (1ll * ans * m) % mod;
ans = (ans + cur.val) % mod;
mp.erase(cur);
s.erase(cur);
int lx = cur.lx, ly = cur.ly;
for (int j = -1; j <= 1; j++) {
auto jt = mp.find({lx + j, ly - 1, 0});
if (jt != mp.end()) {
if (free(*jt)) {
s.insert(*jt);
}
}
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int s;
cin >> s;
long long fib[s];
const int mod =1e9+7;
fib[0]=0;
fib[1]=0;
fib[2]=1;
for (int i = 3; i < s; i++)
{
fib[i]=(fib[i-1]+fib[i-3])%mod;
}
cout << fib[s-1];
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int normalize(vector<int> &a) {
int n = a.size();
int x = -1, y = -1;
for (int i = 0; i < n; i++) {
if (a[i] == 0) x = i;
if (a[i] == 1) y = i;
}
if (x < y) {
for (int i = x; i < y - 1; i++) swap(a[i], a[i + 1]);
return y - 1;
} else {
for (int i = x; i >= y + 1; i--) swap(a[i], a[i - 1]);
return y;
}
}
void print(vector<int> &a, int x) {
int n = a.size();
for (int i = 0; i < n; i++) {
if (i) cout << " ";
cout << a[(i + x) % n];
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int x = normalize(a), y = normalize(b);
bool ok = true;
for (int i = 0; i < n; i++)
if (a[(x + i) % n] != b[(y + i) % n]) ok = false;
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int inf = 0x3f3f3f3f;
const int maxn = 4e5+7 ;
const ll mod = 1000000007;
#define mst(x, a) memset( x,a,sizeof(x) )
#define rep(i, a, b) for(int i=(a);i<=(b);++i)
#define dep(i, a, b) for(int i=(a);i>=(b);--i)
inline ll read() {
ll x = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || '9' < ch)
f |= ch == '-', ch = getchar();
while ('0' <= ch && ch <= '9')
x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
void out(ll x) {
int stackk[20];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int top = 0;
while (x)
stackk[++top] = x % 10, x /= 10;
while (top)
putchar(stackk[top--] + '0');
}
int n,a[maxn],pre[maxn],suf[maxn],mx;
int main() {
n=read();
rep(i,1,n) a[i] = read(),pre[i] = suf[i] = 1;
rep(i,2,n) if(a[i]>a[i-1]) pre[i] = pre[i-1]+1,mx = max(mx,pre[i]);
dep(i,n-1,1) if(a[i]>a[i+1]) suf[i] = suf[i+1]+1,mx = max(mx,suf[i]);
int flag=1;
int cnt=0;
for(int i=1 ; i<=n ; i++) if(pre[i]==mx) cnt++;
if(cnt>=2) flag=0;
cnt=0;
for(int i=1 ; i<=n ; i++) if(suf[i]==mx) cnt++;
if(cnt>=2) flag=0;
if(flag==0) {
out(0);
return 0;
}
for(int i=1 ; i<=n ; i++) {
if(pre[i]==suf[i]&&pre[i]==mx&&pre[i]%2) {
out(1);
return 0;
}
}
out(0);
return 0;
}
/*
*/
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
cin >> n;
if (n <= 5)
cout << -1 << "\n";
else {
cout << 1 << " " << 2 << "\n";
cout << 1 << " " << 3 << "\n";
cout << 1 << " " << 4 << "\n";
for (i = 5; i <= n; i++) cout << 2 << " " << i << "\n";
}
for (i = 1; i <= n - 1; i++) cout << i << " " << i + 1 << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1000000;
int n, m;
vector<vector<pair<int, int> > > adj;
bool valid;
int ans[N];
int cnt;
int st[N * 3];
void readin() {
int u, v;
char b[10];
scanf("%d%d", &n, &m);
valid = true;
adj.clear();
adj.resize(n + 1);
for (int i = 0; i < m; ++i) {
scanf("%d%d%s", &u, &v, b);
if (v <= u) {
valid = false;
}
adj[u].push_back(make_pair(v, b[0] == 'L' ? 0 : 1));
}
}
inline int lc(int root) { return root << 1; }
inline int rc(int root) { return (root << 1) | 1; }
void init_st(int root, int l, int r) {
if (l == r) {
st[root] = l;
return;
}
int mid = (l + r) >> 1;
init_st(lc(root), l, mid);
init_st(rc(root), mid + 1, r);
st[root] = max(st[lc(root)], st[rc(root)]);
}
void update_st(int root, int l, int r, int x, int v) {
if (l == r) {
st[root] = v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid) {
update_st(lc(root), l, mid, x, v);
} else {
update_st(rc(root), mid + 1, r, x, v);
}
}
int query_st(int root, int l, int r, int x, int y) {
if (l == r) {
return st[root];
}
int mid = (l + r) >> 1;
if (y <= mid) {
return query_st(lc(root), l, mid, x, y);
} else if (x > mid) {
return query_st(rc(root), mid + 1, r, x, y);
} else {
return max(query_st(lc(root), l, mid, x, mid),
query_st(rc(root), mid + 1, r, mid + 1, y));
}
}
bool build(int root, int limit) {
if (root > limit) {
return true;
}
int l_max = 0, r_min = INT_MAX;
for (vector<pair<int, int> >::const_iterator it = adj[root].begin();
it != adj[root].end(); ++it) {
if (it->second == 0) {
l_max = max(l_max, query_st(1, 1, n, root + 1, it->first));
} else {
r_min = min(r_min, it->first);
}
}
if (l_max == 0) {
ans[cnt++] = root;
return build(root + 1, limit);
} else if (r_min == INT_MAX) {
bool ret = build(root + 1, limit);
ans[cnt++] = root;
return ret;
} else {
if (l_max >= r_min) {
return false;
}
bool ret = true;
ret = ret && build(root + 1, l_max);
ans[cnt++] = root;
ret = ret && build(l_max + 1, limit);
return ret;
}
}
void solve() {
if (!valid) {
printf("IMPOSSIBLE\n");
return;
}
init_st(1, 1, n);
for (int i = n; i >= 1; --i) {
int u = i;
for (vector<pair<int, int> >::const_iterator it = adj[i].begin();
it != adj[i].end(); ++it) {
u = max(u, it->first);
}
update_st(1, 1, n, i, query_st(1, 1, n, i, u));
}
cnt = 0;
if (build(1, n)) {
for (int i = 0; i < n; ++i) {
printf("%d%c", ans[i], i < n - 1 ? ' ' : '\n');
}
} else {
printf("IMPOSSIBLE\n");
}
}
int main() {
readin();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(const T &a) {
return a * a;
}
const int MAXN = 300;
pair<int, int> a[MAXN];
vector<pair<int, int> > ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, cnt;
scanf("%d", &n);
scanf("%d", &cnt);
int cur = 0;
for (int i = 0; i < (n - 1); i++) {
scanf("%d", &a[i].first), a[i].second = i + 1;
}
sort(a, a + n - 1);
reverse(a, a + n - 1);
int pos = 0;
for (int i = 0; i < (n - 1); i++) {
if (i > pos) {
puts("-1");
return 0;
}
while (pos != n - 1 && cnt) {
ans.push_back({cur, a[pos].second}), cnt--, pos++;
}
cnt = a[i].first;
cur = a[i].second;
}
if (pos < n - 1)
puts("-1");
else {
printf("%d\n", (int)ans.size());
for (pair<int, int> p : ans) printf("%d %d\n", p.first + 1, p.second + 1);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
struct segt {
int dat[262144];
segt() { memset(dat, -1, sizeof(dat)); }
void modify(int id, int val) {
for (id += 131072; id > 0; id >>= 1) dat[id] = max(dat[id], val);
}
int query(int l, int r) {
int ret = -1;
for (l += 131072, r += 131072; l < r; l = (l + 1) >> 1, r = (r - 1) >> 1)
ret = max(ret, max(dat[l], dat[r]));
if (l == r) ret = max(ret, dat[l]);
return ret;
}
} tre;
int n, x[100005], d[100005];
int dpl[100005], dpr[100005];
vector<int> rem[100005];
set<int> S;
int rp[100005], lp[100005];
vector<int> hv;
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n + 2); i++) scanf("%d", &x[i]);
for (int i = 1; i <= (int)(n); i++) {
scanf("%d", &d[i]);
d[i] = min(d[i] * 2, x[n + 1]);
}
d[0] = d[n + 1] = INF;
dpl[0] = 0;
S.insert(0);
for (int i = 1; i <= (int)(n + 1); i++) {
for (int j = 0; j < (int)(rem[i].size()); j++) S.erase(rem[i][j]);
dpl[i] = *S.rbegin();
if (x[i] - x[dpl[i]] >= d[i])
dpl[i] = -1;
else {
S.insert(i);
rem[upper_bound(x, x + n + 2, x[dpl[i]] + d[i]) - x].push_back(i);
}
}
if (dpl[n + 1] != 0) {
printf("0\n");
return 0;
}
S.clear();
for (int i = 0; i < (int)(n + 2); i++) rem[i].clear();
dpr[n + 1] = n + 1;
S.insert(n + 1);
for (int i = n; i >= 0; i--) {
dpr[i] = *S.begin();
if (x[dpr[i]] - x[i] >= d[i])
dpr[i] = -1;
else {
S.insert(i);
rem[lower_bound(x, x + n + 2, x[dpr[i]] - d[i]) - x].push_back(i);
}
for (int j = 0; j < (int)(rem[i].size()); j++) S.erase(rem[i][j]);
}
for (int i = 0; i < (int)(n + 2); i++) {
rp[i] = dpl[i] == -1 ? -1 : min(x[dpl[i]] + d[i], x[n + 1]);
lp[i] = dpr[i] == -1 ? INF : max(x[dpr[i]] - d[i], 0);
}
for (int i = 0; i < (int)(n + 2); i++) hv.push_back(rp[i]);
sort(hv.begin(), hv.end());
hv.resize(unique(hv.begin(), hv.end()) - hv.begin());
for (int i = 0; i < (int)(n + 2); i++) {
rp[i] = lower_bound(hv.begin(), hv.end(), rp[i]) - hv.begin();
lp[i] = lower_bound(hv.begin(), hv.end(), lp[i]) - hv.begin();
}
int ans = INF;
for (int i = 0; i < (int)(n + 2); i++) {
int cq = tre.query(lp[i], 131071);
if (cq != -1) ans = min(ans, x[i] - x[cq]);
tre.modify(rp[i], i);
}
printf("%.10lf\n", 0.5 * ans);
return 0;
}
| 4 |
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAX = 200000;
struct edge{
int from,to,num;
int cap,flow;
edge(int u= 0,int v=0,int c=0,int f=0):from(u),to(v),cap(c),flow(f){}
};
struct ISAP{
int head[MAX];
int next[MAX];
int tot;
edge edges[2 * MAX];
int que[MAX],front,tail;
int d[MAX];
bool vis[MAX];
int num[MAX];
int pre[MAX];
int cur[MAX];
int s,t,n;
edge cut[2 * MAX];
int cut_cnt;
void init(int n){
this->n = n;
memset(head,-1,sizeof(head));
tot = cut_cnt = 0;//
}
void addedge(int from,int to, int cap){
edges[tot] = edge{from,to,cap,0};//注意无向?和有向?
next[tot] = head[from], head[from] = tot++;
edges[tot] = edge{to,from,cap,0};
next[tot] = head[to],head[to] = tot++;
}
void bfs(){
memset(vis,0,sizeof(vis));
front = tail = 0;
d[t] = 0;
vis[t] = true;
que[tail++] = t;
while(front < tail){
int u = que[front++];
for(int v = head[u]; v != -1; v = next[v]){
edge & e = edges[v^1];
if(e.cap > e.flow && !vis[e.from]){
d[e.from] = d[u] + 1;
vis[e.from] = true;
que[tail++] = e.from;
}
}
}
}
int Augment(){
int x = t,a = INF;
while(x != s){
edge& e = edges[pre[x]];
a = min(a,e.cap - e.flow);
x = e.from;
}
x = t;
while(x != s){
edges[pre[x]].flow += a;
edges[pre[x]^1].flow -= a;
x = edges[pre[x]].from;
}
return a;
}
int maxflow(int s, int t){
this->s = s, this->t = t;
memset(num,0,sizeof(num));
int flow = 0;
bfs();
for(int i = 1; i <= n; ++i){
num[d[i]]++,cur[i] = head[i];
}
int x = s;
while(d[s] < n){
if(x == t){
flow += Augment();
x = s;
}
bool ok = false;
for(int &v = cur[x]; v != -1; v = next[v]){
edge& e = edges[v];
if(e.cap > e.flow && d[x] == d[e.to] + 1){
ok = true;
pre[x = e.to] = v;
break;
}
}
if(!ok){
int m = n - 1;
for(int v = head[x]; v != -1; v = next[v]){
edge & e = edges[v];
if(e.cap > e.flow) m = min(m,d[e.to]);
}
if(--num[d[x]] == 0) break;
num[d[x]=m+1]++;
cur[x] = head[x];
if(x != s) x = edges[pre[x]].from;
}
}
return flow;
}
void mincut(){
bfs();
for(int i = 0 ;i < tot; ++i){
edge & e = edges[i];
if(!vis[e.from] && vis[e.to] && e.cap > 0)
cut[cut_cnt++] = e;
}
}
void print(){
printf("Graph:\n");
for(int i = 0 ; i < tot; ++i){
edge & e = edges[i];
printf("%d->%d c:%d f:%d\n",e.from,e.to,e.cap,e.flow);
}
}
void solve(int s, int t){
printf("%d\n",maxflow(s,t));
vector<int> ans;
for(int i = 0; i < tot; i += 2){
edge & e = edges[i];
if(e.flow < 0 )
ans.push_back(i / 2 + 1);
}
printf("%d\n",ans.size());
for(int i = 0, sz = ans.size(); i < sz; ++ i)
printf("%d\n",ans[i]);
}
}solve;
int main(void)
{
//freopen("input.txt","r",stdin);
int N,M;
int u,v;
int s,t;
scanf("%d %d", &N,&M);
solve.init(N);
for(int i = 0; i < M; ++i){
scanf("%d %d", &u,&v);
solve.addedge(u,v,1);
}
scanf("%d %d", &s,&t);
solve.solve(s,t);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pos;
int a[1000005];
void up(long long &a, long long b) {
if (a == -1 || b < a) a = b;
}
int solve(int x, int n) {
int stp = 0, re = 0;
while (1) {
if (stp + x >= n) {
re++;
break;
}
auto it = upper_bound(pos.begin(), pos.end(), stp + x);
if (it == pos.begin()) return -1;
it--;
if (*it <= stp) return -1;
re++;
stp = *it;
}
return re;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int stp = 0;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
while (stp < x) pos.push_back(stp++);
stp++;
}
while (stp < n) pos.push_back(stp++);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
}
if (pos.empty() || pos[0] != 0) {
printf("-1\n");
return 0;
}
long long ans = -1;
for (int i = 1; i <= k; i++) {
int x = solve(i, n);
if (x != -1) up(ans, 1ll * x * a[i]);
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 100010;
struct node {
int len;
int c;
int l;
int r;
} T[30 * N];
int nxt, L[30 * N], R[30 * N], A[N], root[N], id[N];
node operator+(node a, node b) {
node c;
c.len = a.len + b.len;
c.c = max(a.r + b.l, max(a.c, b.c));
if (a.len == a.l)
c.l = a.len + b.l;
else
c.l = a.l;
if (b.len == b.r)
c.r = b.len + a.r;
else
c.r = b.r;
return c;
}
int update(int id, int l, int r, int k) {
int mid = (l + r) / 2;
int cur = ++nxt;
if (l == r) {
T[cur] = (node){1, 1, 1, 1};
return cur;
}
L[cur] = L[id];
R[cur] = R[id];
if (k <= mid)
L[cur] = update(L[cur], l, mid, k);
else
R[cur] = update(R[cur], mid + 1, r, k);
T[cur] = T[L[cur]] + T[R[cur]];
T[cur].len = (r - l + 1);
return cur;
}
node query(int id, int s, int e, int l, int r) {
if (id == 0) return (node){e - s + 1, 0, 0, 0};
if (s >= l && e <= r) return T[id];
int mid = (s + e) / 2;
if (r <= mid) return query(L[id], s, mid, l, r);
if (l > mid) return query(R[id], mid + 1, e, l, r);
return query(L[id], s, mid, l, r) + query(R[id], mid + 1, e, l, r);
}
int cmp(int a, int b) { return A[a] > A[b]; }
int main() {
int n;
scanf("%d", &n);
T[0].len = -1;
for (int i = 1; i < n + 1; i++) scanf("%d", &A[i]);
for (int i = 1; i < n + 1; i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i < n + 1; i++) root[i] = update(root[i - 1], 1, n, id[i]);
int Q;
scanf("%d", &Q);
while (Q--) {
int a, b, c;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
int l = 1, r = n;
while (l < r) {
int mid = (l + r) / 2;
node ret = query(root[mid], 1, n, a, b);
if (ret.c >= c)
r = mid;
else
l = mid + 1;
}
printf("%d\n", A[id[l]]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
namespace io {
char buf[1 << 15], *S = buf, *T = buf;
inline int F() {
register int aa = 0;
register bool bb = 0;
register char ch;
while (ch = (S == T && (T = (S = buf) + fread(buf, 1, 1 << 15, stdin), S == T)
? 0
: *S++),
(ch > '9' || ch < '0') && ch != '-')
;
ch == '-' ? bb = 1 : aa = ch - '0';
while (ch = (S == T && (T = (S = buf) + fread(buf, 1, 1 << 15, stdin), S == T)
? 0
: *S++),
ch <= '9' && ch >= '0')
aa = (aa << 1) + (aa << 3) + ch - '0';
return bb ? -aa : aa;
}
} // namespace io
namespace CJCJLLL {
using namespace io;
int n, a[200010];
long long s[200010];
int ansmid = 1, anslen = 0;
double ansres = -1.0;
inline void solve(register int pos) {
register int left = 0,
right = ((n - pos) < (pos - 1) ? (n - pos) : (pos - 1)), mid;
while (left + 2 < right) {
mid = (left + right + 1) >> 1;
if (2.0 * (s[pos] - s[pos - mid + 1 - 1] + s[n] - s[n - mid + 2 - 1]) /
((mid << 1) - 1) >
a[pos - mid] + a[n - mid + 1])
right = mid - 1;
else
left = mid;
}
for (register int i = left; i <= right; ++i)
if ((ansres < (1.0 * (s[pos] - s[pos - i - 1] + s[n] - s[n - i + 1 - 1]) /
(i << 1 | 1) -
a[pos])
? ansres = (1.0 * (s[pos] - s[pos - i - 1] + s[n] - s[n - i + 1 - 1]) /
(i << 1 | 1) -
a[pos]),
1 : 0))
ansmid = pos, anslen = i;
}
inline void main() {
n = F();
for (register int i = 1; i <= n; ++i) a[i] = F();
std ::sort(a + 1, a + 1 + n);
for (register int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i] * 1LL;
for (register int i = 1; i <= n; ++i) solve(i);
printf("%d\n", anslen * 2 + 1);
for (register int i = ansmid - anslen; i <= ansmid; ++i) printf("%d ", a[i]);
for (register int i = n - anslen + 1; i <= n; ++i) printf("%d ", a[i]);
puts("");
}
} // namespace CJCJLLL
int main() {
CJCJLLL ::main();
fclose(stdin), fclose(stdout);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
string s;
cin>>s;
if(s=="AAA"||s=="BBB") cout<<"No"<<endl;
else cout<<"Yes"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long X, Y;
cin >> X >> Y;
if (Y == 0)
cout << "No\n";
else if (Y == 1) {
if (X == 0)
cout << "Yes\n";
else
cout << "No\n";
} else if (X >= Y - 1 && (X - (Y - 1)) % 2 == 0)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
| 1 |
#include<stdio.h>
int main(void)
{
int n,m;
int a[10001],b[10001];
int flg[10001];
int i;
int c;
scanf("%d",&n);
scanf("%d",&m);
while(n!=0 && m!=0){
c=0;
for(i=2;i<=n;i++){
flg[i]=0;
}
flg[1]=2;
for(i=1;i<=m;i++){
scanf("%d %d",&a[i],&b[i]);
if(a[i]==1){
c++;
flg[b[i]]=1;
}
}
for(i=1;i<=m;i++){
if(flg[a[i]]==1 && flg[b[i]]==0){
c++;
flg[b[i]]=2;
}
}
for(i=1;i<=m;i++){
if(flg[a[i]]==0 && flg[b[i]]==1){
c++;
flg[a[i]]=2;
}
}
printf("%d\n",c);
scanf("%d",&n);
scanf("%d",&m);
}
return 0;
}
| 0 |
// 2013/06/22 Tazoe
#include <iostream>
using namespace std;
void setD(int D[6], int t, int f)
{
D[0] = t;
D[1] = f;
D[5] = 7-t;
D[3] = 7-f;
if((D[0]==3&&D[1]==5) || (D[1]==3&&D[5]==5) || (D[5]==3&&D[3]==5) || (D[3]==3&&D[0]==5)) D[2] = 1;
else if((D[0]==3&&D[1]==1) || (D[1]==3&&D[5]==1) || (D[5]==3&&D[3]==1) || (D[3]==3&&D[0]==1)) D[2] = 2;
else if((D[0]==5&&D[1]==1) || (D[1]==5&&D[5]==1) || (D[5]==5&&D[3]==1) || (D[3]==5&&D[0]==1)) D[2] = 3;
else if((D[0]==1&&D[1]==5) || (D[1]==1&&D[5]==5) || (D[5]==1&&D[3]==5) || (D[3]==1&&D[0]==5)) D[2] = 4;
else if((D[0]==1&&D[1]==3) || (D[1]==1&&D[5]==3) || (D[5]==1&&D[3]==3) || (D[3]==1&&D[0]==3)) D[2] = 5;
else if((D[0]==5&&D[1]==3) || (D[1]==5&&D[5]==3) || (D[5]==5&&D[3]==3) || (D[3]==5&&D[0]==3)) D[2] = 6;
D[4] = 7-D[2];
}
int searchD(int D[6], int n)
{
for(int i=0; i<6; i++){
if(D[i]==n){
return i;
}
}
return -1;
}
int main()
{
while(true){
int n;
cin >> n;
if(n==0)
break;
int F[200][200][2];
for(int y=0; y<200; y++){
for(int x=0; x<200; x++){
F[y][x][0] = 0;
F[y][x][1] = 0;
}
}
for(int i=0; i<n; i++){
int t, f;
cin >> t >> f;
int D[6];
setD(D, t, f);
/*
for(int j=0; j<6; j++){
cout << D[j] << ' ';
}
cout << endl;
*/
int Y = 100;
int X = 100;
int Z = F[100][100][1];
bool flg = true;
while(flg){
flg = false;
for(int j=6; j>=4; j--){
switch(searchD(D, j)){
case 0:
case 5:
break;
case 1:
if(F[Y+1][X][1]<Z){
Y++;
Z = F[Y][X][1];
setD(D, D[3], D[0]);
flg = true;
}
break;
case 2:
if(F[Y][X+1][1]<Z){
X++;
Z = F[Y][X][1];
setD(D, D[4], D[1]);
flg = true;
}
break;
case 3:
if(F[Y-1][X][1]<Z){
Y--;
Z = F[Y][X][1];
setD(D, D[1], D[5]);
flg = true;
}
break;
case 4:
if(F[Y][X-1][1]<Z){
X--;
Z = F[Y][X][1];
setD(D, D[2], D[1]);
flg = true;
}
break;
default:
break;
}
if(flg)
break;
}
}
F[Y][X][0] = D[0];
F[Y][X][1]++;
// cout << Y << ' ' << X << ' ' << F[Y][X][0] << ' ' << F[Y][X][1] << endl;
}
int C[7];
for(int i=0; i<7; i++){
C[i] = 0;
}
for(int y=0; y<200; y++){
for(int x=0; x<200; x++){
C[F[y][x][0]]++;
}
}
cout << C[1] << ' ' << C[2] << ' ' << C[3] << ' ' << C[4] << ' ' << C[5] << ' ' << C[6] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, all = 0, x;
scanf("%I64d%I64d", &n, &m);
while (n--) {
scanf("%I64d", &x);
cout << (all + x) / m << " ";
((all + x) >= m) ? all = (all + x) % m : all += x;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return (b == 0 ? a : gcd(b, a % b));
}
long long int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
long long int max(long long int a, long long int b, long long int c) {
return max(a, max(b, c));
}
long long int power(long long int x, long long int y) {
long long int ans = 1;
while (y > 0) {
if (y & 1) ans = (ans * x) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return ans;
}
int main() {
long long int t, n, h1, h2, a, b;
cin >> h1 >> h2 >> a >> b;
n = h2 - h1;
if (8 * a >= n)
cout << "0" << endl;
else if (12 * a <= (12 * b))
cout << "-1" << endl;
else if ((12 * b + n) <= 20 * a)
cout << "1" << endl;
else {
long long int day = 1;
n = n - 8 * a + 12 * b - 12 * a;
while (n > 0) {
n += 12 * b;
n -= 12 * a;
day++;
}
cout << day << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
int a[maxn], b[maxn];
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < 30; i++) {
int mod = 1 << (1 + i);
for (int j = 1; j <= n; j++) b[j] = a[j] % mod;
sort(b + 1, b + n + 1);
int res = 0;
for (int j = 1; j <= n; j++) {
int l, r;
l = lower_bound(b + 1, b + n + 1, (1 << i) - b[j]) - b;
r = lower_bound(b + 1, b + n + 1, (1 << (i + 1)) - b[j]) - b - 1;
res += r - l + 1;
l = lower_bound(b + 1, b + n + 1, (1 << (i + 1)) + (1 << i) - b[j]) - b;
r = lower_bound(b + 1, b + n + 1, (1 << (i + 2)) - b[j]) - b - 1;
res += r - l + 1;
if ((b[j] + b[j]) & (1 << i)) res--;
}
if ((res >> 1) & 1) ans += (1 << i);
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long int n;
cin >> t;
while (t--) {
cin >> n;
cout << n << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int A[100];
int g = 0;
int n;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int noSolution() {
printf("0\n");
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (A[i] * g); j++) {
printf("%c", i + 'a');
}
}
return 0;
}
int main(int argc, char* argv[]) {
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> A[i];
g = gcd(g, A[i]);
}
for (int i = (0); i < (n); i++) {
A[i] /= g;
}
int cnt = 0;
int pos = -1;
for (int i = (0); i < (n); i++) {
if (A[i] % 2 != 0) {
cnt++;
pos = i;
}
}
if (cnt > 1) {
if (g % 2 != 0) {
return noSolution();
}
g /= 2;
for (int i = (0); i < (n); i++) {
A[i] *= 2;
}
cnt = 0;
pos = -1;
}
if (pos != -1) {
A[pos]--;
}
string s = "";
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (A[i] / 2); j++) {
s += (char)(i + 'a');
}
}
string ss = s;
if (pos != -1) s += (char)(pos + 'a');
reverse(ss.begin(), ss.end());
s += ss;
ss = s;
for (int i = (0); i < (g - 1); i++) {
s += ss;
}
if (cnt == 0) g *= 2;
printf("%d\n", g);
printf("%s\n", s.c_str());
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5 + 5;
int n, k, a[MX];
void solve(int l, int r) {
if (r - l <= 1) return;
int m = (l + r) >> 1;
if (k > 0) {
k -= 2;
for (int i = 0; i < m - l; i++) swap(a[l + i], a[m + i]);
solve(l, m);
solve(m, r);
}
}
int main() {
cin >> n >> k;
if (k % 2 == 0) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) a[i] = i;
k--, solve(0, n);
if (k != 0)
printf("-1\n");
else
for (int i = 0; i < n; i++)
printf("%d%c", a[i] + 1, i == n - 1 ? '\n' : ' ');
return 0;
}
| 4 |
#include<iostream>
#include<cstdio>
#define MN 50
#define mod 1000000007
using namespace std;
int n,f[MN+5][MN+5][MN+5],p[MN+5],inv[MN+5],ans;
inline void R(int&x,int y){x+=y;x>=mod?x-=mod:0;}
int main()
{
scanf("%d",&n);p[0]=inv[0]=p[1]=inv[1]=1;
for(int i=2;i<=n;++i) p[i]=1LL*p[i-1]*i%mod,inv[i]=1LL*(mod-mod/i)*inv[mod%i]%mod;
for(int i=2;i<=n;++i) inv[i]=1LL*inv[i-1]*inv[i]%mod;
f[1][0][1]=p[n];
for(int i=1;i<=n;++i) for(int j=0;j<=i;++j) for(int k=0;j+k<=i;++k) if(f[i][j][k])
{
for(int l=i+2;l<=n;l+=2) R(f[l][(l-i)/2][(l-i)/2],1LL*f[i][j][k]*inv[j]%mod*inv[k]%mod);
for(int x=1;x<=j;++x)
for(int l=i+x;l<=n;l+=2)
R(f[l][x+(l-i-x)/2][(l-i-x)/2],1LL*f[i][j][k]*inv[j-x]%mod*inv[k+x]%mod);
for(int x=1;x<=k;++x)
for(int l=i+x;l<=n;l+=2)
R(f[l][(l-i-x)/2][x+(l-i-x)/2],1LL*f[i][j][k]*inv[j+x]%mod*inv[k-x]%mod);
}
for(int i=0;i<=n;++i) for(int j=0;j<=n;++j)R(ans,1LL*f[n][i][j]*inv[i]%mod*inv[j]%mod);
printf("%d",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXW = 1000100, MAXN = 1000100, INF = 0x3f3f3f3f;
vector<pair<int, int>> a[MAXW], r[MAXW];
int n, w, l;
long long ans;
struct maxqueue {
private:
stack<int, list<int>> s1, s2;
int mx = -INF;
public:
inline void insert(int x) { mx = max(mx, x), s2.push(x); }
inline int get() { return max((s1.empty() ? -INF : s1.top()), mx); }
inline void clear() {
s1 = stack<int, list<int>>(), s2 = stack<int, list<int>>(), mx = -INF;
}
inline bool empty() { return s1.empty() && s2.empty(); }
void pop() {
if (s1.empty()) {
mx = -INF;
while (!s2.empty())
s1.push(max(s2.top(), s1.empty() ? -INF : s1.top())), s2.pop();
}
s1.pop();
}
} m[MAXN];
int main() {
for (scanf("%d %d", &n, &w); n--;) {
scanf("%d", &l);
if (l < w) {
a[1].emplace_back(0, n);
r[w - l + 1].emplace_back(0, n);
a[l + 1].emplace_back(0, n);
r[w + 1].emplace_back(0, n);
}
for (int i = 1, x; i <= l; ++i) {
scanf("%d", &x);
a[i].emplace_back(x, n);
r[w - l + i + 1].emplace_back(x, n);
}
}
for (int i = 1; i <= w; ++i) {
for (const auto [x, arr] : a[i]) {
ans -= (m[arr].empty() ? 0 : m[arr].get());
m[arr].insert(x);
ans += (m[arr].empty() ? 0 : m[arr].get());
}
for (const auto [x, arr] : r[i]) {
ans -= (m[arr].empty() ? 0 : m[arr].get());
m[arr].pop();
ans += (m[arr].empty() ? 0 : m[arr].get());
}
printf("%lld ", ans);
}
}
| 5 |
#include<stdio.h>
int MAX(int a,int b){return a<b?b:a;}
int main(){
int r=0,i;
char s[100010],c[100010];
scanf("%s",s);
for(i=0;s[i];i++){
if(s[i]=='B')r=MAX(r-1,0);
else c[r++]=s[i];
}
c[r]=0;
printf("%s\n",c);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 5e5 + 10;
pair<ll, double> q[MAXN];
#define dec ruiuiehrrefrf
int n, maxv, t, v, l = 1, r = 0;
ll dec, sum = 0;
double tem = 0;
int main()
{
scanf("%d%d", &n, &maxv);
for (int i = 1; i <= n; i++)
{
scanf("%d%d", &t, &v);
while (sum + v > maxv)
{
dec = min(q[l].first, sum + v - maxv);
q[l].first -= dec;
sum -= dec;
tem -= q[l].second * dec;
if (!q[l].first) l++;
}
sum += v;
tem += 1ll * t * v;
q[++r] = make_pair(v, t);
for (; l < r && q[r].second < q[r - 1].second; --r)
{
q[r - 1].second = (q[r].second * q[r].first + q[r - 1].second * q[r - 1].first) / (q[r].first + q[r - 1].first);
q[r - 1].first += q[r].first;
}
printf("%.7f\n", tem / maxv);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int find(int m, int x) {
if (!m) return 1;
long long ans = find(m / 2, x);
ans = ans * ans % n;
if (m & 1) ans = ans * x % n;
return ans;
}
int main() {
cin >> n;
if (n == 1 || n == 4) {
cout << "YES\n";
if (n == 1)
cout << 1;
else
printf("1 3 2 4");
return 0;
}
for (int i = 2; i < n; i++)
if (n % i == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n1 ";
for (int i = 1; i < n - 1; i++)
printf("%d ", (long long)(i + 1) * find(n - 2, i) % n);
cout << n;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
if(a%b==0) cout<<'0';
else cout<<'1';
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[6];
for (int i = 0; i < 6; ++i) {
cin >> s[i];
}
bool flag = false;
for (int i = 1; i < 6; ++i) {
if (s[0][0] == s[i][0] || s[0][1] == s[i][1]) {
flag = true;
break;
}
}
if (flag)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int v[150][150];
int s[150];
int ans1 = 0, ans2 = 0;
int pi = 0;
int p[150];
bool cmp(const int &a, const int &b) { return a > b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &s[i]);
for (int j = 1; j <= s[i]; ++j) {
scanf("%d", &v[i][j]);
}
if (s[i] & 1) {
int t = s[i] / 2;
for (int j = 1; j <= t; ++j) {
ans1 += v[i][j];
}
for (int j = t + 2; j <= s[i]; ++j) {
ans2 += v[i][j];
}
p[++pi] = v[i][t + 1];
} else {
int t = s[i] / 2;
for (int j = 1; j <= t; ++j) {
ans1 += v[i][j];
}
for (int j = t + 1; j <= s[i]; ++j) {
ans2 += v[i][j];
}
}
}
sort(p + 1, p + pi + 1, cmp);
for (int i = 1; i <= pi; ++i) {
if (i & 1)
ans1 += p[i];
else
ans2 += p[i];
}
printf("%d %d", ans1, ans2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t[105], s[105], ans[105];
void ask(int x, int i) {
cout << "+ " << x << endl;
cin >> t[i] >> s[i];
}
int calc(int x) {
int i = 1;
while (1) {
if (i * (i - 1) / 2 == x) return i;
++i;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
cin >> t[0] >> s[0];
memset(ans, -1, sizeof ans);
for (int i = 1; i <= n - 1; ++i) {
ask(i, i);
}
ask(1, n);
for (int i = n; i >= 1; --i) t[i] -= t[i - 1], s[i] -= s[i - 1];
ans[1] = t[n] - t[1];
for (int i = 2; i <= n - 1; ++i) {
if (t[i]) ans[i] = calc(t[i]);
}
if (ans[3] == -1) ans[3] = (s[2] > 0);
if (ans[2] == -1) ans[2] = s[n] / (ans[3] + 1) - 1;
for (int i = 3; i <= n - 2; ++i) {
if (ans[i + 1] == -1) {
s[i] -= (ans[i - 1] + 1) * (ans[i - 2] + 1);
ans[i + 1] = (s[i] > 0);
}
}
ans[n] = (s[n - 1] - (ans[n - 2] + 1) * (ans[n - 3] + 1)) / (ans[n - 2] + 1);
cout << "! ";
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int p, c = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> p;
if (p) {
c++;
cin >> p;
} else {
cin >> p;
if (p) c++;
}
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int a[N];
int n;
int ansA, ansD;
bool ok(int x) {
for (int d = 0; d <= 20000; d++) {
int low = a[0] - x, up = a[0] + x;
bool flag = true;
for (int i = 1; i < n; i++) {
low = max(low + d, a[i] - x);
up = min(up + d, a[i] + x);
if (up < low) {
flag = false;
break;
}
}
if (flag) {
ansD = d;
ansA = low - d * (n - 1);
return true;
}
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int l = 0, r = 10000;
while (l < r) {
int m = (l + r) >> 1;
if (ok(m))
r = m;
else
l = m + 1;
}
ok(l);
printf("%d\n", l);
printf("%d %d\n", ansA, ansD);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-9;
const int INF = 1e9 + 7;
const int MAXN = int(3e5 + 7);
struct pt {
int x, y;
} p[MAXN];
long long dist(pt a, pt b) {
return 1ll * (a.x - b.x) * (a.x - b.x) + 1ll * (a.y - b.y) * (a.y - b.y);
}
long long area(pt a, pt b, pt c) {
long long d =
1ll * (b.x - a.x) * (c.y - a.y) - 1ll * (b.y - a.y) * (c.x - a.x);
return abs(d);
}
int n, ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].x >> p[i].y;
}
long long d = dist(p[1], p[2]);
int a = 1, b = 2, c;
for (int i = 2; i <= n; i++) {
if (dist(p[a], p[i]) < d) {
d = dist(p[a], p[i]);
b = i;
}
}
double ar = 6e18;
for (int i = 2; i <= n; i++) {
if (b == i) continue;
if (area(p[a], p[b], p[i]) < ar && area(p[a], p[b], p[i]) != 0) {
ar = area(p[a], p[b], p[i]);
c = i;
}
}
cout << a << " " << b << " " << c << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vis[100002];
string s;
int d[100002];
int main() {
int n, k = 1;
cin >> n;
for (int i = 0; i <= n; i++) vis[i] = false;
cin >> s;
for (int i = 1; i <= n; i++) cin >> d[i];
int i = 1;
while (i <= n) {
if (vis[i] == true)
return cout << "INFINITE", 0;
else
vis[i] = true;
if (s[i - 1] == '>')
i += d[i];
else
i -= d[i];
if (i > n || i < 1) return cout << "FINITE", 0;
}
cout << "FINITE";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long llinf = 1e18;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long mod = 2286661337;
ostream &operator<<(ostream &os, const pair<long long, long long> &a) {
return os << a.first << ' ' << a.second;
}
istream &operator>>(istream &in, pair<long long, long long> &a) {
return in >> a.first >> a.second;
}
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
string need;
for (int i = 0; i < k - 1; i++) need += "()";
need += string(n / 2 - (k - 1), '(');
need += string(n / 2 - (k - 1), ')');
vector<pair<long long, long long> > ans;
for (int i = 0; i < n; i++) {
if (s[i] != need[i]) {
for (int j = i; j < n; j++) {
if (s[j] == need[i]) {
ans.emplace_back(i + 1, j + 1);
reverse(s.begin() + i, s.begin() + j + 1);
break;
}
}
}
}
cout << ans.size() << '\n';
for (auto &i : ans) cout << i.first << ' ' << i.second << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,i,wa=0;
cin>>n;
n*=2;
int a[n];
for(i=0;i<n;i++){
cin>>a[i];
}
sort(a,a+n);
for(i=0;i<n;i+=2){
wa+=a[i];
}
cout<<wa;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
double a[55];
int n;
int main()
{ cin>>n;
for(int i=1;i<=n;++i)
cin>>a[i];
sort(a+1,a+n+1);
for(int i=2;i<=n;++i)
{
a[i]=(a[i-1]+a[i])/2;
sort(a+i,a+n+1);
}
cout<<a[n]<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int sg[2][2][300005], v[4];
long long a[300005];
int repeat;
int cal(long long x, int j, int k) {
if (x < 1000) {
return sg[j][k][x];
} else {
return sg[j][k][(x - 1000) % repeat + 1000];
}
}
void work() {
int n, x, y, z;
scanf("%d%d%d%d", &n, &x, &y, &z);
int maxx = 1000;
for (int i = 1; i <= maxx * 3; i++) {
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++) {
for (int l = 0; l <= 3; l++) {
v[l] = 0;
}
v[sg[1][1][max(0, i - x)]] = 1;
if (j) v[sg[0][1][max(0, i - y)]] = 1;
if (k) v[sg[1][0][max(0, i - z)]] = 1;
for (int l = 0; l <= 3; l++) {
if (v[l] == 0) {
sg[j][k][i] = l;
break;
}
}
}
}
}
for (repeat = 1; repeat <= maxx; repeat++) {
bool f = 1;
for (int i = 0; i <= maxx - 1; i++) {
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++) {
if (sg[j][k][i + maxx] != sg[j][k][i + maxx + repeat]) {
f = 0;
break;
}
}
if (!f) break;
}
if (!f) break;
}
if (f) {
break;
}
}
int sum = 0, ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum ^= cal(a[i], 1, 1);
}
for (int i = 1; i <= n; i++) {
int tmp = sum ^ cal(a[i], 1, 1);
if (tmp == cal(max(0ll, a[i] - x), 1, 1)) ans++;
if (tmp == cal(max(0ll, a[i] - y), 0, 1)) ans++;
if (tmp == cal(max(0ll, a[i] - z), 1, 0)) ans++;
}
printf("%d\n", ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
scanf("%d", &T);
while (T--) {
work();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int count = 0;
for (long long int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '0')
count++;
else {
if (s[i] == '1' && count > 0)
count--;
else {
if (s[i] == '1' && count == 0) s[i] = '0';
}
}
}
cout << s << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, cnt, now;
long long BASE[102], Base[102], x;
long long K[102], A[102][102];
bool Mk[102];
char S[102];
string a;
struct V {
string str;
long long h, w;
bool operator<(const V& a) const { return str < a.str; }
} AN[102];
map<string, long long> M;
void DO(long long a) {
if (Mk[a]) return;
Mk[a] = 1;
for (long long i = 1; i <= A[a][0]; ++i) {
DO(A[a][i]);
if (K[a] == 1)
AN[a].w += AN[A[a][i]].w, AN[a].h = max(AN[a].h, AN[A[a][i]].h);
else
AN[a].h += AN[A[a][i]].h, AN[a].w = max(AN[a].w, AN[A[a][i]].w);
}
if (A[a][0]) {
AN[a].h += Base[a] * 2, AN[a].w += Base[a] * 2;
if (K[a] == 1)
AN[a].w += BASE[a] * (A[a][0] - 1);
else
AN[a].h += BASE[a] * (A[a][0] - 1);
}
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%s", S + 1);
if (S[1] == 'W') {
scanf("%s", S + 1);
++cnt, now = 1;
while (S[now] != '(') AN[cnt].str += S[now], ++now;
M[AN[cnt].str] = cnt, Mk[cnt] = 1, ++now;
while (S[now] != ',') AN[cnt].w = AN[cnt].w * 10 + S[now] - '0', ++now;
++now;
while (S[now] != ')') AN[cnt].h = AN[cnt].h * 10 + S[now] - '0', ++now;
} else if (S[1] == 'H') {
++cnt, now = 1, a.clear(), K[cnt] = 1;
cin >> AN[cnt].str;
M[AN[cnt].str] = cnt;
} else if (S[1] == 'V') {
++cnt, now = 1, a.clear(), K[cnt] = 2;
cin >> AN[cnt].str;
M[AN[cnt].str] = cnt;
} else {
now = 1, a.clear();
while (S[now] != '.') a += S[now], ++now;
x = M[a], ++now;
if (S[now] == 's') {
if (S[now + 4] == 's') {
BASE[x] = 0, now += 12;
while (S[now] != ')') BASE[x] = BASE[x] * 10 + S[now] - '0', ++now;
} else {
Base[x] = 0, now += 11;
while (S[now] != ')') Base[x] = Base[x] * 10 + S[now] - '0', ++now;
}
} else if (S[now] == 'p') {
++A[x][0], now += 5, a.clear();
while (S[now] != ')') a += S[now], ++now;
A[x][A[x][0]] = M[a];
}
}
}
for (long long i = 1; i <= cnt; ++i) {
DO(i);
}
sort(AN + 1, AN + cnt + 1);
for (long long i = 1; i <= cnt; ++i) {
cout << AN[i].str << " " << AN[i].w << " " << AN[i].h << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, d;
int cnt[30001];
int dp[30001][501];
int f(int curr, int st) {
if (curr >= 30001) return 0;
if (dp[curr][st] != -1) return dp[curr][st];
int l = d + st - 250;
int mx = 0;
if (l > 1) mx = max(mx, f(curr + l - 1, st - 1));
mx = max(mx, f(curr + l, st));
mx = max(mx, f(curr + l + 1, st + 1));
return dp[curr][st] = mx + cnt[curr];
}
int main() {
scanf("%d%d", &n, &d);
for (int i = 0, x; i < n; i++) {
scanf("%d", &x);
cnt[x]++;
}
memset(dp, -1, sizeof(dp));
printf("%d\n", f(d, 250));
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
cout<<n/500*1000+n%500/5*5<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> t;
while (t--) {
string s;
string h;
cin >> s;
sort(s.begin(), s.end());
cin >> h;
int n = s.size();
if (n > h.size()) {
cout << "NO\n";
continue;
}
bool ok = false;
for (int i = 0; i <= h.size() - n; i++) {
string x = h.substr(i, n);
sort(x.begin(), x.end());
if (x == s) ok = true;
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d;
cin >> d;
vector<long long> c(26);
for(int i = 0; i < 26; i++) cin >> c.at(i);
vector<vector<long long>> s(d, vector<long long> (26));
for(int i = 0; i < d; i++){
for(int j = 0; j < 26; j++) cin >> s.at(i).at(j);
}
vector<int> ans(d), last(26);
long long score = 0;
for(int i = 0; i < d; i++){
int a;
cin >> a;
a--;
last.at(a) = i+1;
score += s.at(i).at(a);
for(int j = 0; j < 26; j++){
score -= c.at(j) * (i + 1 - last.at(j));
}
cout << score << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
template <typename T>
void read(T &x) {
bool neg = false;
unsigned char c = getchar();
for (; (c ^ 48) > 9; c = getchar())
if (c == '-') neg = true;
for (x = 0; (c ^ 48) < 10; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
if (neg) x = -x;
}
struct line {
int next, to;
} e[2 * N];
int n, m, deg[N], hd[N], cnt, f[N], q, n0, x[N], y[N], fa[N], dep[N];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
inline void adline(int u, int v) {
e[cnt].to = v;
e[cnt].next = hd[u];
hd[u] = cnt++;
}
void dfs(int u, int f) {
for (int i = hd[u]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == f) continue;
dep[v] = dep[u] + 1;
dfs(v, fa[v] = u);
}
}
int len(int u, int v) {
if (u == v) return 1;
if (dep[u] > dep[v]) return len(fa[u], v) + 1;
return len(u, fa[v]) + 1;
}
void print(int u, int v) {
if (u == v) return printf("%d ", u + 1), void();
if (dep[u] > dep[v]) return printf("%d ", u + 1), print(fa[u], v);
return print(u, fa[v]), printf("%d ", v + 1), void();
}
int main() {
read(n);
read(m);
for (int i = 0, i_end = n; i < i_end; ++i) hd[f[i] = i] = -1;
for (int i = 0, i_end = m; i < i_end; ++i) {
int u, v;
read(u);
read(v);
--u, --v;
if (find(u) == find(v)) continue;
f[find(u)] = find(v);
adline(u, v);
adline(v, u);
}
read(q);
for (int i = 0, i_end = q; i < i_end; ++i)
read(x[i]), read(y[i]), ++deg[--x[i]], ++deg[--y[i]];
for (int i = 0, i_end = n; i < i_end; ++i)
if (deg[i] & 1) ++n0;
if (n0) return printf("NO\n%d\n", n0 >> 1), 0;
dfs(0, 0);
puts("YES");
for (int i = 0, i_end = q; i < i_end; ++i) {
printf("%d\n", len(x[i], y[i]));
print(x[i], y[i]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
inline int cmp(double x, double y = 0, double tol = 1e-9) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int n, m;
int A[503][503];
std::pair<long long int, long long int> red[503], blue[503];
bool is_left(std::pair<long long int, long long int> &p0,
std::pair<long long int, long long int> &p1,
std::pair<long long int, long long int> &q) {
return (p1.first - p0.first) * (q.second - p0.second) -
(q.first - p0.first) * (p1.second - p0.second) <
0;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i)
scanf("%I64d %I64d", &red[i].first, &red[i].second);
for (int i = 0; i < m; ++i)
scanf("%I64d %I64d", &blue[i].first, &blue[i].second);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (red[i].first < red[j].first) {
for (int k = 0; k < m; ++k)
if (is_left(red[i], red[j], blue[k]))
A[i][j] +=
(red[i].first < blue[k].first && blue[k].first <= red[j].first);
A[j][i] = -A[i][j];
}
int sum = 0;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
for (int k = j + 1; k < n; ++k) sum += (A[i][j] + A[j][k] + A[k][i] == 0);
printf("%d\n", sum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long A, B;
cin >> A >> B;
long long ans;
if (A*B < 0) ans = abs(A+B)+1;
else {
if (A < B) ans = B-A;
else {
ans = A-B+2;
if (A*B == 0) ans -= 1;
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct node {
int L, R, ty, val;
} a[maxn];
int in[maxn], out[maxn], sum[maxn << 1][10];
int tmp[maxn], S[maxn << 2], n, Q, T = 1, l, r;
char s[maxn];
void del(int x) {
a[a[x].L].R = a[x].R;
a[a[x].R].L = a[x].L;
}
void update(int o, int l, int r, int x, int y, int z) {
if (l == x && y == r) {
if (!S[o]) S[o] = z;
return;
}
if (x <= ((l + r) >> 1))
update((o << 1), l, ((l + r) >> 1), x, min(y, ((l + r) >> 1)), z);
if (((l + r) >> 1) < y)
update((o << 1 | 1), ((l + r) >> 1) + 1, r, max(((l + r) >> 1) + 1, x), y,
z);
}
int A(int o, int l, int r, int x) {
int res = (!S[o] ? (int)1e9 : S[o]);
if (l == r) return res;
if (x <= ((l + r) >> 1)) return min(res, A((o << 1), l, ((l + r) >> 1), x));
return min(res, A((o << 1 | 1), ((l + r) >> 1) + 1, r, x));
}
void init() {
memset(out, 0x3f, sizeof out);
int cur = 1, dir = 1, last = 0;
a[0].R = 1;
a[n + 1].L = n;
while (cur <= n && a[0].R != n + 1) {
if (!in[cur]) {
in[cur] = T++;
for (int i = (0); i <= (9); i++) sum[T][i] = sum[T - 1][i];
}
if (a[cur].ty == -1) {
dir = -1;
if (last) del(last);
last = cur;
} else if (a[cur].ty == 1) {
dir = 1;
if (last) del(last);
last = cur;
} else {
sum[T][a[cur].val]++;
a[cur].val--;
if (a[cur].val == -1) del(cur);
last = 0;
}
if (dir == 1) {
cur = a[cur].R;
} else {
if (out[cur] > 1e9) {
update(1, 1, n, a[cur].L + 1, cur, T++);
for (int i = (0); i <= (9); i++) sum[T][i] = sum[T - 1][i];
}
cur = a[cur].L;
}
if (!cur) {
cur = a[cur].R;
dir = 1;
}
}
in[n + 1] = T;
}
int main() {
scanf("%d%d", &n, &Q);
scanf("%s", s + 1);
for (int i = (1); i <= (n); i++) {
a[i].L = i - 1;
a[i].R = i + 1;
if (s[i] == '<')
a[i].ty = -1;
else if (s[i] == '>')
a[i].ty = 1;
else
tmp[i] = ((a[i].val = s[i] - '0') == 0);
}
init();
int ans[10];
while (Q--) {
scanf("%d%d", &l, &r);
for (int i = (0); i <= (9); i++)
printf("%d ", sum[min(in[r + 1], A(1, 1, n, l))][i] - sum[in[l]][i]);
puts("");
}
return 0;
}
| 4 |
#include<stdio.h>
int main()
{
long n,i;
long k = 0;
long t = 0;
long long a;
scanf("%ld", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &a);
if (a % 2 == 1)
k++;
if (a % 4 == 0)
t++;
}
if (t >= k) {
printf("Yes");
}
else if (n % 2 == 1 && k + t == n&&k - 1 == t) {
printf("Yes");
}
else {
printf("No");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int parent[100005], a[100005], num[100005];
int finds(int x) { return parent[x] == x ? x : parent[x] = finds(parent[x]); }
struct ss {
int u, v, w;
} e[100005];
bool cmp(ss s1, ss s2) { return s1.w > s2.w; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
parent[i] = i;
num[i] = 1;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i].u, &e[i].v);
e[i].w = min(a[e[i].u], a[e[i].v]);
}
sort(e + 1, e + m + 1, cmp);
double ans = 0;
for (int i = 1; i <= m; i++) {
int fx = finds(e[i].u);
int fy = finds(e[i].v);
if (fx != fy) {
ans += 1.0 * num[fx] * num[fy] * e[i].w;
parent[fy] = fx;
num[fx] += num[fy];
}
}
printf("%.12lf\n", ans * 2 / n / (n - 1));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, p[25];
set<int> s;
void init() {
p[0] = 1;
for (int i = 1; i <= 20; i++) {
p[i] = p[i - 1] * 2;
s.insert((p[i] - 1) * (p[i - 1]));
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
while (cin >> n) {
int ans;
for (int i = 1; i <= n; i++) {
if (n % i == 0 && s.count(i)) ans = i;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vi;
int main() {
string str;
cin >> str;
int k;
cin >> k;
int ans = 0;
while (k--) {
int a = 0;
int b = 0;
string s;
cin >> s;
for (int i = 0; i < str.size(); i++) {
if (str[i] == s[0])
a++;
else if (str[i] == s[1])
b++;
else
ans += min(a, b), a = 0, b = 0;
}
ans += min(a, b);
}
cout << ans << endl;
}
| 3 |
#include<iostream>
#include<string>
using namespace std;
char s[99]="abcdefghijklmnopqrstuvwxyz.?! ############################";
int main(){
string t;
while(cin>>t){
int f = 1;
string ans;
for(int i=0;i<t.size();i+=2){
if(t[i] < '1' || '6' < t[i] || t[i+1] < '1' || '5' < t[i+1]){
f = 0; break;
}
ans.push_back(s[(t[i]-'1')*5+t[i+1]-'1']);
}
if(!f) cout << "NA" << endl;
else cout << ans << endl;
}
} | 0 |
#include<iostream>
#include<vector>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
int table[30][100];
#define INF 10000
int solve(vector<int> &cyc,vector<int>& day){
rep(i,day.size())rep(j,cyc.size())table[j][i]=INF;
table[0][0]=0;
REP(i,1,day.size()){
table[0][i]=min(table[0][i-1]+1,table[cyc.size()-1][i-1]);
REP(j,1,cyc.size()){
table[0][i]=min(table[0][i],table[j][i-1]+1);//take caffein
if (day[i]>=cyc[j]){
table[j][i]=table[j-1][i-1];
}
}
}
int ret=INF;
rep(i,cyc.size())ret=min(ret,table[i][day.size()-1]);
return ret;
}
int main(){
int n,m;
while(cin>>n && n){
vector<int> cyc,day(100,24);
rep(i,n){
int t;cin>>t;cyc.push_back(t);
}
cin>>m;
rep(i,m){
int d,time;cin>>d>>time;
day[d-1]=min(day[d-1],time);
}
cout << solve(cyc,day)<<endl;
}
return false;
} | 0 |
#include <iostream>
using namespace std;
int dp[100010];
int niz[110];
int main()
{
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> niz[i];
for (int i = 0; i <= k; i++)
for (int j = 0; j < n; j++)
if (niz[j] <= i)
if (!dp[i - niz[j]])
dp[i] = 1;
if (dp[k])
cout << "First" << endl;
else
cout << "Second" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100002];
int main() {
int n, d, h, node = 2, i, j, start = 2, c = 1;
cin >> n >> d >> h;
if (h * 2 < d) {
puts("-1");
return 0;
}
if (d == 1 && n > 2) {
puts("-1");
return 0;
}
int temp = n - 1;
for (i = 1; i <= h; i++) {
v[i].push_back(i + 1);
c++;
}
if (h < d) start = 1;
node = c + 1;
if (h < d) {
v[1].push_back(node);
c++;
}
node = c;
for (i = node, j = 1; j < d - h; j++, i++) {
v[i].push_back(i + 1);
c++;
}
node = c + 1;
if (c > n) {
puts("-1");
return 0;
}
if (c < n) {
v[start].push_back(node);
c++;
}
for (i = node; c < n; i++) {
v[start].push_back(i + 1);
c++;
}
for (int i = 1; i <= n; i++) {
if (v[i].empty()) continue;
for (j = 0; j < v[i].size(); j++) {
cout << i << ' ' << v[i][j] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned int n, m, x;
vector<int> v;
int main() {
cin >> n >> m >> x;
for (int i = 1; i <= n; i++) {
if (i != x) v.push_back(i);
}
int r = n - 1 + ((n - 2) * (n - 3)) / 2;
if (r < m || m < n - 1) {
cout << -1;
return 0;
} else {
for (int i = 0; i < n - 1; i++) cout << x << " " << v[i] << endl;
m -= n - 1;
for (int i = 1; i < n - 2; i++) {
for (int j = i + 1; j < n - 1; j++) {
if (m == 0)
break;
else {
cout << v[i] << " " << v[j] << endl;
m--;
}
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> meat(n);
vector<int> price(n);
vector<int> minimum_price(n);
int min = 10000007;
int i;
for (i = 0; i < n; i++) {
cin >> meat[i] >> price[i];
if (price[i] < min) min = price[i];
minimum_price[i] = min;
}
long long int sum = 0;
for (i = 0; i < n; i++) sum = minimum_price[i] * meat[i] + sum;
cout << sum << endl;
}
| 1 |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#define fo(i,a,b) for(int i=a;i<=b;++i)
#define fod(i,a,b) for(int i=a;i>=b;--i)
#define N 3005
#define mo 1000000007
using namespace std;
int f[N][2*N][2],n,m;
int main()
{
cin>>n>>m;
f[0][0][1]=1;
fo(i,1,n) f[0][i][0]=1;
int ans=0;
fo(i,1,m)
{
fo(j,0,n)
{
fo(p,0,1)
{
if(j) (f[i][j-1][p|(j==1)]+=f[i-1][j][p])%=mo,(f[i][j][p|(j==1)]+=f[i-1][j][p])%=mo;
if(j<n) (f[i][j+1][p]+=f[i-1][j][p])%=mo,(f[i][j][p|(j==0)]+=f[i-1][j][p])%=mo;
}
}
}
fo(i,0,n) (ans+=f[m][i][1])%=mo;
printf("%d\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, z;
cin >> n >> m >> z;
int ans = 0;
int nX = n;
int mX = m;
int nPrev = 0, mPrev = 0;
for (int i = 0; i < z && (nX <= z && mX <= z); ++i) {
if (nX == nPrev && mX == mPrev) {
} else if ((nX == mX)) {
ans++;
}
nPrev = nX;
mPrev = mX;
if ((i + 1) % n == 0) {
nX += n;
}
if ((i + 1) % m == 0) {
mX += m;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
cout << "P";
if (j != x - 1) {
if (i == 0)
cout << "RL";
else
cout << "LR";
}
}
if (i != n - 1) cout << 'R';
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long N;cin>>N;
vector<long>A(N);for(int i=0;i<N;i++)cin>>A[i];
long ans=0;
ans+=A[0]/2;A[0]%=2;
for(int i=1;i<N;i++){
ans+=(A[i]+A[i-1])/2;A[i]=min((A[i]+A[i-1])%2,A[i]);
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
#define int long long
#define ld long double
#define VI std::vector<int>
#define VVI std::vector<VI>
#define PII std::pair<int, int>
#define f(n) for (int i = 0; i < n; i++)
#define FOR(i, n) for (int i = 0; i < n; i++)
#define make(T, n) T n; std::cin >> n
#define makev(name, n) VI name(n); f(n) std::cin >> name[i]
#define mp(a, b) std::make_pair(a, b)
#define ALL(q) q.begin(), q.end()
#define RALL(q) q.rbegin(), q.rend()
#define pb(n) push_back(n)
#define M7 1000000007
#define MFFT 998244353
#define INF 2000000000000000001
#define PI 3.14159265359
using namespace std;
int gcd(int a, int b) {
if (b)
return gcd(b, a % b);
return a;
}
void solve() {
make(int, k);
make(int, l);
make(int, r);
make(int, t);
make(int, x);
make(int, y);
if (x > y) {
if ((__int128_t)k + (__int128_t)((__int128_t)y - (__int128_t)x) * (__int128_t)t >= (__int128_t)l && (__int128_t)k + (__int128_t)y <= (__int128_t)r || (__int128_t)k + (__int128_t)t * (__int128_t)((__int128_t)y - (__int128_t)x) - (__int128_t)y >= (__int128_t)l)
cout << "Yes";
else
cout << "No";
return;
}
t += (l - k) / x;
k += (int)((__int128_t)(((__int128_t)((__int128_t)l - (__int128_t)k) / (__int128_t)x) * (__int128_t)x));
int g = gcd(x, y);
if (t <= 0 || k + x + y - g <= r)
cout << "Yes";
else {
int m = k;
while (t > 0) {
k += y;
m = max(m, k);
if (m > r) {
cout << "No";
return;
}
t -= (k - l) / x;
k -= ((k - l) / x) * x;
}
if (m <= r)
cout << "Yes";
else
cout << "No";
}
}
signed main(signed argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
if (argc > 1 && (string) argv[1] == "local") {
freopen("output.txt", "w", stdout);
freopen("input.txt", "r", stdin);
}
solve();
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(228);
int a[100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
int le = a[n - 1] - 1, ri = 20000;
while (ri - le > 1) {
int mi = (le + ri) / 2;
int now = 0;
for (int i = 0; i < n; ++i) {
now += mi - a[i];
}
if (now >= m)
ri = mi;
else
le = mi;
}
cout << ri << '\n' << a[n - 1] + m << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
cout << n;
reverse(n.begin(), n.end());
cout << n;
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cek[1000];
long long arr[1000], n, arr1[50100], maks, comb[20000][510], hasil;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
for (int j = 2; j <= 40000; j++)
while (arr[i] % j == 0) {
arr[i] /= j;
arr1[j]++;
maks = max(maks, arr1[j]);
}
}
comb[0][0] = 1;
for (int i = 1; i <= n + maks - 1 + 505; i++) {
comb[i][0] = 1;
for (int j = 1; j <= n - 1; j++) {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % 1000000007;
}
}
hasil = 1;
for (int i = 2; i <= 50000; i++) {
if (arr1[i] > 0) {
hasil = (hasil * comb[n + arr1[i] - 1][n - 1]) % 1000000007;
}
}
for (int i = 1; i <= n; i++) {
if (arr[i] > 1 && !cek[i]) {
cek[i] = 1;
maks = 1;
for (int j = i + 1; j <= n; j++)
if (arr[j] == arr[i]) {
maks++;
cek[j] = 1;
}
hasil = (hasil * comb[n + maks - 1][n - 1]) % 1000000007;
}
}
cout << hasil << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long segTree[4 * 200010];
long long lazy[4 * 200010];
long long a[200010];
long long mini(long long a, long long b) {
if (a > b) {
return b;
} else
return a;
}
void build_tree(long long rangeLeft, long long rangeRight, long long index) {
lazy[index] = 0;
if (rangeLeft == rangeRight) {
segTree[index] = a[rangeLeft];
return;
}
long long mid = (rangeLeft + rangeRight) / 2;
build_tree(rangeLeft, mid, 2 * index);
build_tree(mid + 1, rangeRight, 2 * index + 1);
segTree[index] = mini(segTree[2 * index], segTree[2 * index + 1]);
}
void update_tree(long long updateLeft, long long updateRight,
long long newValue, long long rangeLeft, long long rangeRight,
long long index) {
if (lazy[index] != 0) {
segTree[index] += lazy[index];
if (rangeLeft != rangeRight) {
lazy[2 * index] += lazy[index];
lazy[2 * index + 1] += lazy[index];
}
lazy[index] = 0;
}
if (updateRight < rangeLeft || rangeRight < updateLeft) return;
if (updateLeft <= rangeLeft && rangeRight <= updateRight) {
segTree[index] += newValue;
if (rangeLeft != rangeRight) {
lazy[2 * index] += newValue;
lazy[2 * index + 1] += newValue;
}
return;
}
long long mid = (rangeLeft + rangeRight) / 2;
update_tree(updateLeft, updateRight, newValue, rangeLeft, mid, 2 * index);
update_tree(updateLeft, updateRight, newValue, mid + 1, rangeRight,
2 * index + 1);
segTree[index] = mini(segTree[2 * index], segTree[2 * index + 1]);
}
long long query_tree(long long queryLeft, long long queryRight,
long long rangeLeft, long long rangeRight,
long long index) {
if (queryRight < rangeLeft || rangeRight < queryLeft)
return 100000000000000000;
if (lazy[index] != 0) {
segTree[index] += lazy[index];
if (rangeLeft != rangeRight) {
lazy[2 * index] += lazy[index];
lazy[2 * index + 1] += lazy[index];
}
lazy[index] = 0;
}
if (queryLeft <= rangeLeft && rangeRight <= queryRight) return segTree[index];
long long mid = (rangeLeft + rangeRight) / 2;
return mini(
query_tree(queryLeft, queryRight, rangeLeft, mid, 2 * index),
query_tree(queryLeft, queryRight, mid + 1, rangeRight, 2 * index + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
build_tree(1, n, 1);
string str;
long long q;
char nl;
cin >> q;
getline(cin, str);
long long x, y, z;
for (long long i = 0; i < q; i++) {
getline(cin, str);
istringstream iss(str);
vector<long long> v;
while (!iss.eof()) {
iss >> x;
v.push_back(x);
}
if (v.size() == 2) {
x = v[0] + 1, y = v[1] + 1;
if (x <= y) {
cout << query_tree(x, y, 1, n, 1) << "\n";
} else {
cout << mini(query_tree(1, y, 1, n, 1), query_tree(x, n, 1, n, 1))
<< "\n";
}
} else {
x = v[0] + 1, y = v[1] + 1, z = v[2];
if (x <= y) {
update_tree(x, y, z, 1, n, 1);
} else {
update_tree(1, y, z, 1, n, 1);
update_tree(x, n, z, 1, n, 1);
}
}
}
}
| 3 |
#include<cstdio>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
struct edge{
int to,cost;
edge(int to,int cost):
to(to),cost(cost){}
edge(){}
};
struct visit{
int pos,total,b;
visit(int pos,int total,int b):
pos(pos),total(total),b(b){}
visit(){}
bool operator>(const visit &v)const{
return total>v.total;
}
};
int N,M,L,K,A,H;
vector<edge>G[100];
bool ice[100];
void solve(){
bool used[100][101]={{0}};
priority_queue<visit,vector<visit>,greater<visit> >Q;
Q.push(visit(A,0,M));
while(!Q.empty()){
visit v=Q.top();Q.pop();
if(used[v.pos][v.b])continue;
used[v.pos][v.b]=true;
if(v.pos==H){
printf("%d\n",v.total);
return;
}
for(int i=0;i<G[v.pos].size();i++){
edge &e=G[v.pos][i];
int tb=v.b-e.cost;
if(tb<0)continue;
if(used[e.to][tb])continue;
Q.push(visit(e.to,v.total+e.cost,tb));
}
if(!ice[v.pos])continue;
for(int i=v.b+1;i<=M;i++){
if(used[v.pos][i])continue;
Q.push(visit(v.pos,v.total+i-v.b,i));
}
}
puts("Help!");
}
int main(){
while(scanf("%d%d%d%d%d%d",&N,&M,&L,&K,&A,&H),N||M||L||K||A||H){
fill_n(G,N,vector<edge>(0));
fill_n(ice,N,false);
for(int i=0;i<L;i++){
int pos;scanf("%d",&pos);
ice[pos]=true;
}
for(int i=0;i<K;i++){
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
G[a].push_back(edge(b,c));
G[b].push_back(edge(a,c));
}
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
const double PI = acos(-1);
const long long INFF = (long long)1e18;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int MAX = (int)1e6 + 7;
int st[MAX];
int dp[MAX];
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = (1); i < (n + 1); ++i) scanf("%d", st + i);
sort(st + 1, st + n + 1);
if (k >= st[1]) {
printf("%d\n", st[1]);
return 0;
}
for (int i = (1); i < (n + 1); ++i) {
dp[st[i] - k]++;
dp[st[i] + 1]--;
}
for (int i = (1); i < (MAX); ++i) dp[i] += dp[i - 1];
int ans = k;
for (int i = (k + 1); i < (st[1] + 1); ++i) {
int cnt = 0;
for (int j = i; j < MAX; j += i) cnt += dp[j];
if (cnt == n) ans = i;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_INT = INT32_MAX;
const long long MAX_LL = INT64_MAX;
const long long mod = 1e9 + 7;
const int N = 1;
const long double pi = 3.14159265359;
bool primes[N + 1];
int npr(int n, int r) {
int res = 1;
for (auto i = n - r + 1; i <= n; i++) res *= i;
return res;
}
int ncr(int n, int r) {
int res = 1;
int rFact = 1;
for (auto i = n - r + 1; i <= n; i++) {
res *= i;
if (res % rFact == 0 && rFact <= r) res /= rFact, rFact++;
}
return res;
}
void sieve() {
memset(primes, true, sizeof(primes));
primes[0] = primes[1] = false;
for (int i = 2; i * i <= N; i++) {
if (primes[i]) {
for (int j = i * i; j <= N; j += i) primes[j] = false;
}
}
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n == 2) return true;
for (auto i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
set<long long> getDivisors(long long val) {
set<long long> st;
for (auto i = 1; i <= sqrt(val); i++)
if (val % i == 0) st.insert(i), st.insert(val / i);
return st;
}
long long fastPow(long long base, long long power) {
long long res = 1;
while (power > 0) {
if (power % 2 != 0) res = (res * base) % mod;
base = (base * base) % mod;
power /= 2;
}
return res;
}
bool palindrome(const string& s) {
string reversedS = s;
reverse(reversedS.begin(), reversedS.end());
if (s == reversedS)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string p, s;
cin >> p;
long long d;
cin >> d;
for (auto i = 1; i < p.size(); i++) {
if (p[i] != '9') {
break;
} else if (i == p.size() - 1 && p[i] == '9') {
cout << p;
return 0;
}
}
if (p.size() == 1) {
cout << p;
return 0;
}
for (auto i = 0; i < p.size(); i++) {
string cur = s;
if (p[i] == '0') {
s += p[i];
continue;
} else if (i == p.size() - 1)
continue;
else if (p[i] == '1' && !i) {
for (auto j = 0; j < p.size() - 1; j++) cur += '9';
if (stoll(p) - stoll(cur) <= d) {
cout << cur;
return 0;
}
} else {
cur += p[i] - 1;
for (auto j = i + 1; j < p.size(); j++) cur += '9';
if (stoll(p) - stoll(cur) <= d) {
cout << cur;
return 0;
}
}
s += p[i];
}
cout << p << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
template <class T>
inline void gmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void gmin(T &a, T b) {
if (b < a) a = b;
}
using namespace std;
const int N = 1e6 + 10, M = 2e6 + 10, Z = 1e9 + 7, maxint = 2147483647,
ms1 = 16843009, ms31 = 522133279, ms63 = 1061109567,
ms127 = 2139062143;
const double PI = acos(-1.0), eps = 1e-8;
void fre() {
freopen("/Users/luras/Desktop/in.txt", "r", stdin);
freopen("/Users/luras/Desktop/out.txt", "w", stdout);
}
const int INF = 1e9;
int casenum, casei;
struct A {
int x, y;
} a[N], ans[N];
map<int, int> mop;
map<int, int>::iterator it;
int mop2[N * 2];
int n, k, t, num;
int e[N * 4];
int flag;
int cmp(A a, A b) { return a.x < b.x; }
int main() {
while (~scanf("%d%d", &n, &k)) {
mop.clear();
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
mop[a[i].x];
mop[a[i].y];
}
t = 0;
for (it = mop.begin(); it != mop.end(); it++) {
t += 2;
mop[it->first] = t;
mop2[t >> 1] = it->first;
}
memset(e, 0, sizeof(e));
for (int i = 1; i <= n; i++) {
e[mop[a[i].x]]++;
e[mop[a[i].y] + 1]--;
}
for (int i = 1; i <= t; i++) {
e[i] += e[i - 1];
}
flag = 0;
num = 0;
for (int i = 1; i <= t; i++) {
if (e[i] >= k) {
if (flag == 0) {
flag = 1;
ans[++num].x = mop2[i >> 1];
ans[num].y = mop2[i >> 1];
} else {
ans[num].y = mop2[i >> 1];
}
} else {
flag = 0;
}
}
printf("%d\n", num);
sort(ans + 1, ans + num + 1, cmp);
for (int i = 1; i <= num; i++) {
printf("%d %d\n", ans[i].x, ans[i].y);
}
}
return 0;
}
| 4 |
#include <stdio.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int cnt[4];
int main() {
char t[8];
int x;
while (scanf("%d,%s", &x, t) != EOF) {
if (t[1] == 'B') cnt[2]++;
else if (t[0] == 'A') cnt[0]++;
else if (t[0] == 'B') cnt[1]++;
else if (t[0] == 'O') cnt[3]++;
}
rep (i, 4) printf("%d\n", cnt[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
char str[N][10];
int type[N];
vector<int> wtf;
vector<int> fix;
vector<int> rekt[2];
int val[N];
set<int> there;
int e;
vector<pair<string, string> > v;
int main() {
scanf("%d", &n);
e = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", str[i]);
scanf("%d", type + i);
e += type[i];
}
for (int i = 1; i <= n; ++i) {
int num = 0;
for (int j = 0; str[i][j]; ++j) {
if (isdigit(str[i][j])) {
num *= 10;
num += str[i][j] - '0';
} else {
num = -1;
break;
}
}
if (num < 1 || num > n) {
num = -1;
}
if (str[i][0] == '0') {
num = -1;
}
val[i] = num;
if (num == -1) {
wtf.emplace_back(i);
} else {
there.insert(num);
if (type[i] == 1 && num <= e) {
fix.emplace_back(i);
} else if (type[i] == 0 && num > e) {
fix.emplace_back(i);
} else {
rekt[type[i]].emplace_back(i);
}
}
}
if (rekt[0].empty() && rekt[1].empty()) {
} else {
if (there.size() == n) {
int x;
if (!rekt[0].empty()) {
x = rekt[0].back();
rekt[0].pop_back();
} else {
x = rekt[1].back();
rekt[1].pop_back();
}
there.erase(val[x]);
v.push_back({str[x], "random"});
str[x][0] = 'r';
str[x][1] = 'a';
str[x][2] = 'n';
str[x][3] = 'd';
str[x][4] = 'o';
str[x][5] = 'm';
val[x] = -1;
wtf.emplace_back(x);
}
}
set<int> canuse;
canuse.clear();
for (int i = 1; i <= n; ++i) {
canuse.insert(i);
}
for (int x : there) {
canuse.erase(x);
}
while (!(rekt[0].empty() && rekt[1].empty())) {
if (!rekt[1].empty() && *canuse.begin() <= e) {
v.push_back({str[rekt[1].back()], to_string(*canuse.begin())});
canuse.erase(canuse.begin());
canuse.insert(val[rekt[1].back()]);
rekt[1].pop_back();
} else if (!rekt[0].empty() && *prev(canuse.end()) > e) {
v.push_back({str[rekt[0].back()], to_string(*prev(canuse.end()))});
canuse.erase(prev(canuse.end()));
canuse.insert(val[rekt[0].back()]);
rekt[0].pop_back();
}
}
for (int x : wtf) {
if (type[x] == 1) {
v.push_back({str[x], to_string(*canuse.begin())});
canuse.erase(canuse.begin());
} else {
v.push_back({str[x], to_string(*prev(canuse.end()))});
canuse.erase(prev(canuse.end()));
}
}
printf("%d\n", int(v.size()));
for (auto it : v) {
cout << "move " << it.first << " " << it.second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll MOD = 1e9+7;
pair<int,int> p[200010];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll ans = 1;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].first;
p[i].second = 1;
}
for (int i = 0; i < n; i++) {
cin >> p[i + n].first;
}
sort(p,p+2*n);
ll ct1 = 0, ct0 = 0;
for (int i = 0; i < 2 * n; i++) {
if (p[i].second == 0) {
if (ct1 == 0) {
ct0++;
} else {
ans *= ct1--;
ans %= MOD;
}
} else {
if (ct0 == 0) {
ct1++;
} else {
ans *= ct0--;
ans %= MOD;
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5+10;
ll n, a[maxn], countN[maxn], ans;
int main(){
cin >> n;
for(int i=0; i<n; i++){
cin >> a[i];
countN[a[i]]++;
}
for(int i=1; i<=n; i++){
ans += (countN[i]*(countN[i]-1))/2;
}
for(int i=0; i<n; i++){
cout << ans-(countN[a[i]]-1) << endl;
}
} | 0 |
// Don't be dead serious about your life -- it's just like a program
// Never open a ranklist untill and unless you are done with solving problems, wastes 3/4 minutes
// Do not treat CP as a placement thing, love it and enjoy it, you will succeed for sure.
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef unsigned long long int ull;
//fundamentals
#define pb push_back
#define pf push_front
#define lb(v,val) (lower_bound(v.begin(),v.end(),val)-v.begin())
#define ub(v,val) (upper_bound(v.begin(),v.end(),val)-v.begin())
#define line cout<<"\n";
#define sortv(v) sort(v.begin(),v.end())
#define sortvd(v) sort(v.begin(),v.end(),greater<ll>())
#define lcm(a,b) (a*b/gcd(a,b))
#define all(v) ((v).begin(),(v).end())
#define v_at_in(n) *p.find_by_order(ll n)
#define mp make_pair
//loops
#define f(i,a,b) for(ll i=(ll)a;i<(ll)b;i++)
#define rf(i,a,b) for(ll i=(ll)a;i>=(ll)b;i--)
#define f0 for(ll i=0;i<n;i++)
#define f1 for(ll i=1;i<=n;i++)
#define fr for(ll i=n-1;i>=0;i--)
//input of array
#define inarray ll a[n];for(ll i=0;i<n;i++)cin>>a[i];
// starter pack
#define test ll T;cin>>T;while(T--)
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
//maximum and minimum
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define max4(a,b,c,d) max(a,max3(b,c,d))
#define min4(a,b,c,d) min(a,min3(b,c,d))
#define endl "\n"
//some values
#define PI 3.14159265
const ll MOD=1000000000+7;
const ll MOD1 = 998244353;
const ll Val9=1000000000;
const ll Val6=1000000;
ll pwr(ll x, ll y){
ll r=1;
while(y>0){
if(y&1)
r=r*x;
x*=x;
y>>=1;
}
return r;
}
ll pwrm(ll x, ll y, ll m){
x%=m;
ll r=1;
while(y>0){
if(y&1)
r=r*x%m;
x=x*x%m;
y>>=1;
}
return r;
}
int main()
{
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
fast;
// Shuru karte hai bina kisi backchodi ke_____
test{
ll n;cin>>n;inarray
map<ll,ll>m;
f(i,0,n)
m[a[i]]++;
ll c[n+1];
f(i,0,n+1)c[i]=0;
map<ll, ll>::iterator itr;
for(itr=m.begin();itr!=m.end();itr++)
{
c[itr->second]++;
}
ll m1=0,sum=0;
rf(i,n,0)
{
sum=sum+c[i];
if(c[i]>0)
{
m1=max(m1,i*sum);
}
}
cout<<n-m1<<endl;
}
// End of program Logic
cerr<<"Time : "<<1000*((double)clock())/(double)CLOCKS_PER_SEC<<"ms\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p, q;
cin >> n >> m >> p >> q;
int x = 0, y = 0, a = 0, b = 0;
x = (n * 3 / 10);
y = (n - ((n / 250) * p));
a = (m * 3 / 10);
b = (m - ((m / 250) * q));
if (max(x, y) == max(a, b)) {
cout << "Tie" << endl;
} else if (max(x, y) > max(a, b)) {
cout << "Misha" << endl;
} else {
cout << "Vasya" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, d;
cin >> r >> d;
int n;
cin >> n;
int i, j, r1[n], x[n], y[n];
int ans = 0;
for (i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> r1[i];
float b = sqrt(x[i] * x[i] + y[i] * y[i]);
if ((b - r1[i] >= r - d) && (b + r1[i] <= r)) ans++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 10;
const double eps = 1e-10;
int n, m, k, a[maxn], d[maxn][20], w[maxn][20];
double ans[maxn], k0[maxn], k1[maxn];
int query(int l, int r) {
int k = 0;
while ((1 << (k + 1)) <= r - l + 1) k++;
if (d[l][k] < d[r - (1 << k) + 1][k]) return w[l][k];
return w[r - (1 << k) + 1][k];
}
void RMQ() {
for (int i = 0; i < n; i++) d[i][0] = a[i], w[i][0] = i;
for (int j = 1; (1 << j) <= n; j++)
for (int i = 0; i + (1 << (j - 1)) < n; i++) {
if (d[i][j - 1] > d[i + (1 << (j - 1))][j - 1])
d[i][j] = d[i + (1 << (j - 1))][j - 1],
w[i][j] = w[i + (1 << (j - 1))][j - 1];
else
d[i][j] = d[i][j - 1], w[i][j] = w[i][j - 1];
}
}
void add(int l, int r, double *k, double x) {
if (l > r) return;
k[l] += x, k[r + 1] -= x;
}
void solve(int l, int r) {
if (l > r) return;
int m = query(l, r);
int a = m - l, b = r - m;
double mv = ::a[m];
if (a > b) swap(a, b);
add(1, a, k1, 1 * mv);
add(a + 1, b + 1, k0, (a + 1) * mv);
add(b + 2, a + b + 1, k1, -1 * mv);
add(b + 2, a + b + 1, k0, (a + b + 2) * mv);
solve(l, m - 1), solve(m + 1, r);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
RMQ();
solve(0, n - 1);
for (int i = 0; i <= n; i++)
if (i) k0[i] += k0[i - 1], k1[i] += k1[i - 1];
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &k);
printf("%.10lf\n", (k0[k] + k1[k] * k) / (n + 1 - k));
}
return 0;
}
| 4 |
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define inf 111111111
using namespace std;
int n,p[55],t[55],dp[55][5];
int main()
{
int n;
while(scanf("%d",&n)==1)
{
if(n==0) break;
for(int i=0;i<n;++i) scanf("%d%d",&p[i],&t[i]);
for(int i=0;i<=n;i++)
for(int j=0;j<=3;j++) dp[i][j]=inf;
if(p[0]<=t[0]) dp[0][1]=p[0];
else {printf("NG 1\n");continue;}
int ng=-1;
for(int i=1;i<n;i++)
{
for(int j=1;j<=3;j++)
{
if(p[i-1]*(j+1)+p[i]<=t[i]-t[i-1]&&dp[i-1][j]<inf)
{
dp[i][1]=min(dp[i][1],dp[i-1][j]+p[i-1]+p[i]);
}
}
for(int j=1;j<=2;j++)
{
int tp=abs(p[i-1]-p[i]);
if(tp*(j+1)<=t[i]-t[i-1]&&dp[i-1][j]<inf) dp[i][j+1]=min(dp[i][j+1],dp[i-1][j]+tp);
}
if(dp[i][1]==inf&&dp[i][2]==inf&&dp[i][3]==inf)
{
ng=i;
break;
}
}
if(ng==-1)
{
int ans=inf;
for(int i=1;i<=3;i++) ans=min(ans,dp[n-1][i]+p[n-1]);
printf("OK %d\n",ans);
}
else printf("NG %d\n",ng+1);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 5, K = 200 + 5, Q = 5000 + 5;
int k, ans[N][N];
namespace BIPATITE {
const int N = ::N * ::N + 5;
int lk[2][N][K];
int get_mex(bool d, int x) {
int i = 1;
while (lk[d][x][i]) ++i;
return i;
}
void add_e(int x, int y, int c) {
lk[0][x][c] = y;
lk[1][y][c] = x;
ans[x / ::N][y / ::N] = c;
}
void modify(bool d, int x, int c0, int c1) {
if (!lk[d][x][c0]) return;
int y = lk[d][x][c0];
lk[d][x][c0] = 0;
lk[d ^ 1][y][c0] = 0;
modify(d ^ 1, y, c1, c0);
if (!d)
add_e(x, y, c1);
else
add_e(y, x, c1);
}
void add_e(int x, int y) {
int lx = get_mex(0, x), ly = get_mex(1, y);
if (!lk[1][y][lx]) {
add_e(x, y, lx);
return;
}
if (!lk[0][x][ly]) {
add_e(x, y, ly);
return;
}
modify(1, y, lx, ly);
add_e(x, y, lx);
}
}; // namespace BIPATITE
int du[2][N];
int inc(bool d, int x) { return x * N + (du[d][x]++) / k; }
int main() {
int n, m, q;
cin >> n >> m >> q >> k;
static pair<int, int> e[Q];
for (int i = 1; i <= q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
int x1 = inc(0, x), y1 = inc(1, y);
BIPATITE::add_e(x1, y1);
e[i] = {x, y};
}
int ans1 = 0;
for (int x = 1; x <= n; ++x) ans1 += du[0][x] % k > 0;
for (int x = 1; x <= m; ++x) ans1 += du[1][x] % k > 0;
printf("%d\n", ans1);
for (int i = 1; i <= q; ++i) printf("%d ", ans[e[i].first][e[i].second]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int MAX = 80;
int dp[80][80][80][2];
vector<int> K, V, X;
void mini(int &a, int b) { a = min(a, b); }
int count_rem(const vector<int> &list, int from, int limit_val) {
int cnt = 0;
for (int i = from; i < (int)list.size() && list[i] < limit_val; ++i) {
++cnt;
}
return cnt;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; ++i)
if (s[i] == 'V')
V.push_back(i);
else if (s[i] == 'K')
K.push_back(i);
else
X.push_back(i);
for (int i = 0; i < 80; ++i)
for (int j = 0; j < 80; ++j)
for (int k = 0; k < 80; ++k) dp[i][j][k][0] = inf, dp[i][j][k][1] = inf;
dp[0][0][0][0] = 0;
for (int v = 0; v <= (int)V.size(); ++v) {
for (int k = 0; k <= (int)K.size(); ++k) {
for (int x = 0; x <= (int)X.size(); ++x) {
for (int type = 0; type < 2; ++type) {
auto moving_cost = [&](int where) {
return count_rem(V, v, where) + count_rem(K, k, where) +
count_rem(X, x, where);
};
int already = dp[v][k][x][type];
if (v < (int)V.size())
mini(dp[v + 1][k][x][1], already + moving_cost(V[v]));
if (k < (int)K.size() && type == 0)
mini(dp[v][k + 1][x][0], already + moving_cost(K[k]));
if (x < (int)X.size())
mini(dp[v][k][x + 1][0], already + moving_cost(X[x]));
}
}
}
}
int ans = inf;
for (int i = 0; i < 2; ++i) mini(ans, dp[V.size()][K.size()][X.size()][i]);
cout << ans << endl;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <cassert>
#include <string>
#include <memory.h>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <cctype>
#include <fstream>
#include <cmath>
using namespace std;
#define REP2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for(ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n) & 1)
typedef long long ll;
typedef pair<ll, ll> P;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-10;
bool is_number(const string &s){
REP(i, s.size()) if(!isdigit(s[i])) return false;
return true;
}
int main(){
int m, n;
string name;
map<string, int> L, R;
cin >> m;
REP(i, m){
cin >> name ;
cin >> L[name] >> R[name];
}
cin >> n;
stack<vector<int> > st;
REP(i, n){
string exp;
vector<int> vec(256, 0);
cin >> exp;
if(is_number(exp)){
vec[atoi(exp.c_str())] = 1;
}else if(L.find(exp) != L.end()){
for(int i = L[exp]; i <= R[exp]; i++) vec[i] = 1;
}else{
vector<int> b = st.top(); st.pop();
vector<int> a = st.top(); st.pop();
REP(i, 256)REP(j, 256)if(a[i] && b[j]){
if(exp == "+") vec[(i+j)%256] = 1;
if(exp == "-") vec[(i-j+256)%256] = 1;
if(exp == "*") vec[(i*j)%256] = 1;
if(exp == "/"){
if(j == 0) {
cout << "error" << endl;
return 0;
}
vec[(i/j)%256] = 1;
}
}
}
st.push(vec);
}
cout << "correct" << endl;
return 0;
} | 0 |
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
using namespace std;
constexpr int number_of_hands = 9;
typedef pair<int, char> card;
inline bool same_colors(vector<card>::const_iterator first, vector<card>::const_iterator last) {
const char color = first->second;
while(++first != last) {
if(color != first->second) return false;
}
return true;
}
inline bool continues(vector<card>::const_iterator first, vector<card>::const_iterator last) {
int next = first->first;
while(++first != last) {
if(++next != first->first) return false;
}
return true;
}
inline bool same_numbers(vector<card>::const_iterator first, vector<card>::const_iterator last) {
const int number = first->first;
while(++first != last) {
if(number != first->first) return false;
}
return true;
}
inline bool is_set(vector<card>::const_iterator first, vector<card>::const_iterator last) {
return same_colors(first, last) && (continues(first, last) || same_numbers(first, last));
}
bool win(const vector<card>& cards) {
for(int i = 0; i < number_of_hands; i += 3) {
if(!is_set(cards.begin() + i, cards.begin() + i + 3)) return false;
}
return true;
}
int judge(vector<card>& cards) {
sort(cards.begin(), cards.end());
do {
if(win(cards)) return 1;
} while(next_permutation(cards.begin(), cards.end()));
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
while(T--) {
vector<card> cards(number_of_hands);
for(int i = 0; i < number_of_hands; ++i) {
cin >> cards[i].first;
}
for(int i = 0; i < number_of_hands; ++i) {
cin >> cards[i].second;
}
cout << judge(cards) << endl;
}
return EXIT_SUCCESS;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
unordered_map<ll, ll>M;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int tot = 0;
int n;
scanf("%d", &n);
ll ans = 0;
for (ll i = 1; i <= n; i++) {
ll a;
scanf("%lld", &a);
ll e;
if (M.count(a) == 0)
e = 0;
else
e = M[a];
ans += e * (n - i + 1);
M[a] = e + i;
//cout << e << ' ' << M[a] << ' ' << i << ' ' << ans << endl;
}
printf("%lld\n", ans);
M.clear();
}
} | 3 |
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int N = (int)2e5 + 123, inf = 1e9, mod = 1e9 + 7;
const ll INF = 1e18;
int n, ans;
vector< pii > v;
multiset< int > al, ar, bl, br;
int main()
{
scanf("%d", &n);
for(int i = 0; i < n; i++){
int l, r;
scanf("%d%d", &l, &r);
v.pb({r, l});
}
sort(v.begin(), v.end());
for(auto it : v){
int l = it.s, r = it.f;
bl.insert(l);
br.insert(r);
}
for(auto it : v){
int l = it.s, r = it.f;
bl.erase(bl.find(l));
br.erase(br.find(r));
ans = max(ans, r - l + 1 + max(0, *br.begin() - *bl.rbegin() + 1));
bl.insert(l);
br.insert(r);
}
for(auto it : v){
int l = it.s, r = it.f;
al.insert(l);
ar.insert(r);
bl.erase(bl.find(l));
br.erase(br.find(r));
if(bl.empty())
break;
ans = max(ans, max(0, *ar.begin() - *al.rbegin() + 1) + max(0, *br.begin() - *bl.rbegin() + 1));
}
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, k, ini[N], tipo[N];
vector<pair<int, int> > que[N][3];
bool cmp(pair<long long, pair<long long, int> > a,
pair<long long, pair<long long, int> > b) {
return (a.first * b.second.first > a.second.first * b.first);
}
bool cmp1(int a, int b) { return tipo[a] < tipo[b]; }
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", &ini[i]);
for (int i = 0; i < m; i++) {
int type, j, val;
scanf("%d %d %d", &type, &j, &val);
type--;
j--;
que[j][type].push_back(make_pair(val, i));
tipo[i] = type;
}
for (int i = 0; i < n; i++)
sort((que[i][0]).begin(), (que[i][0]).end()),
reverse((que[i][0]).begin(), (que[i][0]).end());
for (int i = 0; i < n; i++) {
if (((int)(que[i][0]).size()) > 0 && que[i][0][0].first > ini[i])
que[i][1].push_back(
make_pair(que[i][0][0].first - ini[i], que[i][0][0].second));
sort((que[i][1]).begin(), (que[i][1]).end());
reverse((que[i][1]).begin(), (que[i][1]).end());
}
vector<pair<long long, pair<long long, int> > > ord;
for (int i = 0; i < n; i++) {
long long atual = ini[i];
for (int j = 0; j < ((int)(que[i][1]).size()); j++) {
ord.push_back(
make_pair(que[i][1][j].first, make_pair(atual, que[i][1][j].second)));
atual += que[i][1][j].first;
}
for (int j = 0; j < ((int)(que[i][2]).size()); j++) {
ord.push_back(
make_pair(que[i][2][j].first - 1, make_pair(1, que[i][2][j].second)));
}
}
sort(ord.begin(), ord.end(), cmp);
vector<int> ans;
for (int i = 0; i < min(k, ((int)(ord).size())); i++) {
ans.push_back(ord[i].second.second);
}
sort(ans.begin(), ans.end(), cmp1);
printf("%d\n", ((int)(ans).size()));
for (int i = 0; i < ((int)(ans).size()); i++) {
if (i) printf(" ");
printf("%d", ans[i] + 1);
}
puts("");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct ab {
int w, c;
double div;
};
bool operator<(ab a, ab b) { return a.div < b.div; }
long long int dp[300005];
ab a[100005];
int main() {
int n, m;
cin >> n >> m;
int w, c;
double div[n];
for (int i = 0; i < n; i++) {
cin >> w >> c;
a[i].w = w;
a[i].c = c;
a[i].div = (double)c / (double)w;
}
sort(a, a + n);
int p = 0;
long long int k = 0;
dp[0] = 0;
for (int i = n - 1; i >= 0; i--) {
p = p + a[i].w;
if (p > m) {
p = m;
}
int l = max(a[i].w, p - 3);
for (int j = p; j >= l; j--) {
dp[j] = max(dp[j], dp[j - a[i].w] + a[i].c);
k = max(k, dp[j]);
}
}
cout << k << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, s, max_sum;
pair<pair<int, int>, int> city[2000];
bool gor_mil(double r) {
int sum = s;
for (int i = 0; i < n; i++) {
double x = city[i].first.first, y = city[i].first.second;
if (x * x + y * y <= r * r) sum += city[i].second;
}
return sum >= 1000000;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> s;
max_sum = s;
for (int i = 0; i < n; i++) {
cin >> city[i].first.first >> city[i].first.second >> city[i].second;
max_sum += city[i].second;
}
if (max_sum < 1000000) {
cout << -1;
return 0;
}
double l = 0, r = 100000;
for (int i = 0; i < 10000; i++) {
double now = (l + r) / 2;
if (gor_mil(now))
r = now;
else
l = now;
}
cout << fixed << setprecision(10) << r;
return 0;
}
| 2 |
#include<bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
//using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
//typedef tree<pair<ll,ll>,null_type,less<pair<ll,ll>>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define rep(i,a,b) for(i=a;i<b;i++)
#define repr(i,a,b) for(i=a;i>=b;i--)
#define F first
#define S second
#define pb push_back
#define m_p make_pair
#define all(a) (a).begin(),(a).end()
void boost()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main()
{
boost();
int T;
cin>>T;
while(T--)
{
int n,i,j;
cin>>n;
if(n == 1)
cout<<"0\n";
else if(n == 2)
cout<<"1\n";
else if(n == 3)
cout<<"2\n";
else if(n%2 == 0)
cout<<"2\n";
else
cout<<"3\n";
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
if (a < b) {
printf("-1\n");
return 0;
}
double n = (double)a / b;
int ni = (int)n;
int l = ni;
if (l % 2 == 0) l -= 1;
int diff = a - l * b;
double res = b + (double)diff / (ni + (ni % 2));
printf("%.9f\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, sz, a[1000005], s[1000005];
bool ch(long long p1, long long q1, long long p2, long long q2) {
return p1 * q2 > q1 * p2;
}
int main() {
long long i, j, t, x;
cin >> n;
cin >> t;
a[0] = t;
s[0] = 1;
sz = 0;
for (i = 1; i < n; i++) {
scanf("%I64d", &x);
a[sz + 1] = x;
s[sz + 1] = 1;
for (j = sz; j >= 0; j--) {
if (!ch(a[j], s[j], a[j] + a[j + 1], s[j] + s[j + 1])) break;
a[j] += a[j + 1];
s[j] += s[j + 1];
a[j + 1] = s[j + 1] = 0;
}
sz = j + 1;
}
for (i = 0; i <= sz; i++) {
double ans;
ans = (double)(a[i]) / s[i];
for (j = 0; j < s[i]; j++) {
printf("%.15f\n", ans);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
int N, D;
void solve() {
vector<vector<int> > C(N, vector<int>(10000));
for (int i = 0; i < N; i++) {
int m; cin >> m;
C[i].resize(m);
for (int j = 0; j < m; j++) {
cin >> C[i][j];
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 9999; j++) {
C[i][j + 1] += C[i][j];
}
}
queue<P> que;
multiset<int> s;
for (int i = 0; i < N; i++) que.push(P(0, i)), s.insert(0);
vector<int> iter(N, 0);
int count = 0;
while (que.size()) {
P p = que.front(); que.pop();
int num = p.first;
int idx = p.second;
if (iter[idx] >= C[idx].size()) continue;
auto ite = s.find(num);
s.erase(ite);
int max_ = max(*s.rbegin(), C[idx][iter[idx]]);
int min_ = min(*s.begin(), C[idx][iter[idx]]);
if (max_ - min_ <= D) {
que.push(P(C[idx][iter[idx]], idx));
s.insert(C[idx][iter[idx]]);
iter[idx]++;
count = 0;
} else {
s.insert(num);
que.push(p);
count++;
}
if (count > N) {
break;
}
}
cout << (count > N ? "No" : "Yes") << endl;
}
int main() {
while (cin >> N >> D, N || D) solve();
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.