solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100500];
int p[100500], f[100500], tn;
void pfs(int u, int fa) {
f[u] = fa;
for (int i = 0; i < g[u].size(); i++)
if (g[u][i] != fa) pfs(g[u][i], u);
p[++tn] = u;
}
int n, mx[100500];
int calc(int lim) {
int cnt = 0;
for (int t = 1; t <= n; t++) {
int u = p[t], l0 = 0, l1 = 0;
for (int i = 0; i < g[u].size(); i++)
if (f[u] != g[u][i]) {
int sav = mx[g[u][i]];
if (sav > l0) {
l1 = l0;
l0 = sav;
} else
l1 = max(l1, sav);
}
if (l0 + l1 + 1 >= lim) {
cnt++;
mx[u] = 0;
} else
mx[u] = l0 + 1;
}
return cnt;
}
int nxt(int l, int c) {
int r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (calc(mid) == c)
l = mid;
else
r = mid - 1;
}
return l;
}
int BS;
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
pfs(1, 0);
BS = min((int)sqrt(n * log(n)), n);
for (int i = 1; i <= BS; i++) printf("%d ", calc(i));
for (int i = BS + 1; i <= n;) {
int sav = calc(i), p = nxt(i, sav);
for (int j = i; j <= p; j++) printf("%d ", sav);
i = p + 1;
}
return 0;
}
| 10 | CPP |
n, w = map(int, input().split())
a = sorted(map(int, input().split()))
print(min(w, 3 * n * min(a[0], a[n] / 2))) | 8 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
if n < 31:
print("NO")
else:
a, b, c = 6, 10, 14
arr = [a, b, c]
n -= sum(arr)
print("YES")
if n in arr:
print(a, b, c + 1, n - 1)
else:
print(a, b, c, n)
| 7 | PYTHON3 |
b1, q, l, m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
if abs(b1)>l:
print(0)
elif b1==0:
if 0 in a:
print(0)
else:
print('inf')
elif q==0:
if not 0 in a:
print('inf')
elif b1 in a:
print(0)
else:
print(1)
elif q==1:
if b1 in a:
print(0)
else:
print ('inf')
elif q== (-1):
if(not b1 in a) or (not -b1 in a):
print('inf')
else:
print(0)
else:
cnt = 0
b = b1
while abs(b)<=l:
if not b in a:
cnt+=1
b*=q
print(cnt) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p = 0, s = 0;
cin >> n;
vector<int> T(n, 0);
for (int i = 0; i < n; i++) {
cin >> T[i];
s += T[i];
}
for (int i = 0; i < n; i++)
if ((s - T[i]) % 2 == 0) p++;
cout << p;
return 0;
}
| 7 | CPP |
(n,k) = map(int,input().split())
dic = dict()
for _ in range(k):
(u,v,d) = map(int,input().split())
if u not in dic:
dic[u]=-d
else:
dic[u]-=d
if v not in dic:
dic[v] = d
else:
dic[v]+=d
dic_neg = dict()
dic_pos = dict()
for key,value in dic.items():
if value>0:
dic_pos[key] = value
elif value<0:
dic_neg[key] = value
li_pos = sorted(dic_pos.items(), key = lambda kv:[kv[1], kv[0]],reverse = True)
li_neg = sorted(dic_neg.items(), key = lambda kv:[kv[1], kv[0]])
li_pos = [[key,val] for (key,val) in li_pos]
li_neg = [[key,val] for (key,val) in li_neg]
# print(li_pos,li_neg)
pos_ind,neg_ind = 0,0
li = []
while(pos_ind!=len(li_pos)):
if li_pos[pos_ind][1]>=abs(li_neg[neg_ind][1]):
li.append([li_neg[neg_ind][0],li_pos[pos_ind][0],abs(li_neg[neg_ind][1])])
li_pos[pos_ind][1] +=li_neg[neg_ind][1]
li_neg[neg_ind][1] = 0
else:
li.append([li_neg[neg_ind][0],li_pos[pos_ind][0],li_pos[pos_ind][1]])
li_neg[neg_ind][1] +=li_pos[pos_ind][1]
li_pos[pos_ind][1] = 0
if li_neg[neg_ind][1]==0:
neg_ind+=1
if li_pos[pos_ind][1]==0:
pos_ind+=1
# print(li_pos,li_neg)
# print(li)
print(len(li))
for i in li:
print(*i)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
inline int power(int a, int b) {
if (b < 0) {
a = power(a, mod - 2);
b = -b;
}
int out = 1;
while (b) {
if (b & 1) out = mult(out, a);
a = mult(a, a);
b >>= 1;
}
return out;
}
int n, k;
vector<int> prime;
bool flag[200010];
void init() {
for (int i = 2; i <= 200000; i++) {
if (!flag[i]) prime.push_back(i);
for (int j = 0; j < prime.size() && i * prime[j] <= 200000; j++) {
flag[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
vector<int> v[200010][2], prm[200010];
int main() {
init();
scanf("%d%d", &n, &k);
int ans = 0, ans2 = 0;
for (int i = 1; i <= 2 * n; i++) {
int tmp = i;
for (int j = 0; prime[j] * prime[j] <= i; j++) {
if (tmp % prime[j] == 0) {
prm[i].push_back(prime[j]);
while (tmp % prime[j] == 0) tmp /= prime[j];
}
}
if (tmp != 1) prm[i].push_back(tmp);
int cnt = prm[i].size();
for (int j = 0; j < (1 << cnt); j++) {
tmp = 1;
for (int k = 0; k < cnt; k++)
if ((j >> k) & 1) tmp *= prm[i][k];
if (__builtin_popcount(j) & 1)
v[i][0].push_back(tmp);
else
v[i][1].push_back(tmp);
}
}
for (int i = 1; i <= 2 * n; i++) {
for (int j = 1; j * j <= i; j++) {
if (i % j == 0) {
int gcd = j, s2 = i / gcd, mx = (n - 1) / gcd;
if (gcd >= n) continue;
int l = max(1, s2 - mx), r = min(s2 - 1, mx), cnt = 0;
for (int x : v[s2][1]) cnt += (r / x) - ((l - 1) / x);
for (int x : v[s2][0]) cnt -= (r / x) - ((l - 1) / x);
ans2 = add(ans2, mult(cnt, power(k, max(i - n, gcd) - n)));
if (j * j != i) {
gcd = i / j;
if (gcd >= n) continue;
s2 = i / gcd;
mx = (n - 1) / gcd;
l = max(1, s2 - mx), r = min(s2 - 1, mx);
cnt = 0;
for (int x : v[s2][1]) cnt += (r / x) - ((l - 1) / x);
for (int x : v[s2][0]) cnt -= (r / x) - ((l - 1) / x);
ans2 = add(ans2, mult(cnt, power(k, max(i - n, gcd) - n)));
}
}
}
}
printf("%d\n", ans2);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct s {
int l, r;
} ab[55], cd[55];
int c[2111];
int getnum(int x) {
if (x <= 0) return 0;
int rnt = 0;
for (int i = x; i <= 2111; i += (i & (-i))) {
rnt += c[i];
}
return rnt;
}
void add(int i, int a) {
while (i >= 1) {
c[i] += a;
i -= (i & (-i));
}
}
int main() {
int p, q, l, r;
scanf("%d%d%d%d", &p, &q, &l, &r);
for (int i = 0; i < p; i++) scanf("%d%d", &ab[i].l, &ab[i].r);
for (int i = 0; i < q; i++) scanf("%d%d", &cd[i].l, &cd[i].r);
int ans = 0;
for (int i = l; i <= r; i++) {
memset(c, 0, sizeof(c));
for (int j = 0; j < p; j++) {
add(ab[j].r, 1);
add(ab[j].l - 1, -1);
}
for (int j = 0; j < q; j++) {
add(cd[j].r + i, 1);
add(cd[j].l - 1 + i, -1);
}
for (int j = 1; j < 2111; j++) {
if (getnum(j) > 1) {
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int k, n, m;
long long a[N];
int op[N];
struct assign {
long long num;
int id;
bool operator<(const assign& tmp) const { return num < tmp.num; }
} as[N];
struct add {
long long num;
int id;
};
vector<add> ad[N];
struct mul {
long double num;
int id;
};
vector<mul> mu;
int x;
long long y;
assign max(assign a, assign b) {
if (a < b)
return b;
else
return a;
}
bool cmp(add a, add b) { return a.num > b.num; }
bool cmp1(mul a, mul b) { return a.num > b.num; }
bool cmp2(mul a, mul b) { return op[a.id] < op[b.id]; }
int ans[N], cntt;
int main() {
cin >> k >> n >> m;
for (int i = 1; i <= k; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d %d %lld", &op[i], &x, &y);
if (op[i] == 1) {
as[x] = max(as[x], (assign){y, i});
}
if (op[i] == 2) {
ad[x].push_back((add){y, i});
}
if (op[i] == 3) {
mu.push_back((mul){1.0 * y, i});
}
}
for (int i = 1; i <= k; i++) {
if (as[i].num > a[i]) {
ad[i].push_back((add){as[i].num - a[i], as[i].id});
}
}
for (int i = 1; i <= k; i++) {
sort(ad[i].begin(), ad[i].end(), cmp);
long long tmp = a[i];
for (unsigned int j = 0; j < ad[i].size(); j++) {
mu.push_back((mul){1.0 * (tmp + ad[i][j].num) / tmp, ad[i][j].id});
tmp += ad[i][j].num;
}
}
sort(mu.begin(), mu.end(), cmp1);
int tmp = mu.size();
m = min(m, tmp);
cout << m << endl;
for (int i = 0; i < m; i++) {
if (op[mu[i].id] == 1) printf("%d ", mu[i].id);
}
for (int i = 0; i < m; i++) {
if (op[mu[i].id] == 2) printf("%d ", mu[i].id);
}
for (int i = 0; i < m; i++) {
if (op[mu[i].id] == 3) ans[++cntt] = mu[i].id;
}
sort(ans + 1, ans + cntt + 1);
for (int i = 1; i <= cntt; i++) cout << ans[i] << " ";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238;
int main() {
double w, h, a;
cin >> w >> h >> a;
if (h > w) swap(h, w);
cout << fixed << setprecision(15);
if (a > 90) a = 180 - a;
a = a / 360 * 2 * PI;
double t = atan2(h, w);
if (a > 2 * t) {
double r = h / 2.0 / sin(a / 2), x = tan(a / 2) * r;
cout << 2 * r * x;
} else {
double h1 = w / 2 * tan(a / 2), s1 = h / 2 - h1, a1 = s1 * s1 * tan(a);
double w1 = h / 2 * tan(a / 2), s2 = w / 2 - w1, a2 = s2 * s2 * tan(a);
cout << w * h - a1 - a2;
}
}
| 7 | CPP |
#include <iostream>
#include <cstdlib>
using namespace std;
struct Node {
int key;
Node *right,*left,*parent;
};
Node *root,*NIL;
Node *treeMinimum(Node *x) {
while (x->left!=NIL) {
x=x->left;
}
return x;
}
Node *find(Node *u,int k) {
while (u!=NIL and k!=u->key) {
if (k<u->key) {
u=u->left;
}
else {
u=u->right;
}
}
return u;
}
Node *treeSuccessor(Node *x) {
if (x->right!=NIL) {
return treeMinimum(x->right);
}
Node *y=x->parent;
while (y!=NIL and x==y->right) {
x=y;
y=y->parent;
}
return y;
}
void treeDelete(Node *z) {
Node *y;
Node *x;
if (z->left==NIL or z->right==NIL) {
y=z;
}
else {
y=treeSuccessor(z);
}
if (y->left!=NIL) {
x=y->left;
}
else {
x=y->right;
}
if (x!=NIL) {
x->parent=y->parent;
}
if (y->parent==NIL) {
root=x;
}
else {
if (y==y->parent->left) {
y->parent->left=x;
}
else {
y->parent->right=x;
}
}
if (y!=z) {
z->key=y->key;
}
free(y);
}
void insert(int k) {
Node *y=NIL;
Node *x=root;
Node *z;
z=(Node *)malloc(sizeof(Node));
z->key=k;
z->left=NIL;
z->right=NIL;
while (x!=NIL) {
y=x;
if (z->key<x->key) {
x=x->left;
}
else {
x=x->right;
}
}
z->parent=y;
if (y==NIL) {
root=z;
}
else {
if (z->key<y->key) {
y->left=z;
}
else {
y->right=z;
}
}
}
void inorder(Node *u) {
if (u==NIL) {
return ;
}
inorder(u->left);
cout<<" "<<u->key<<flush;
inorder(u->right);
}
void preorder(Node *u) {
if (u==NIL) {
return ;
}
cout<<" "<<u->key<<flush;
preorder(u->left);
preorder(u->right);
}
int main() {
int n;
cin>>n;
for (int i=0; i<n; i++) {
string com;
cin>>com;
if (com=="insert") {
int x;
cin>>x;
insert(x);
}
else if (com=="print") {
inorder(root);
cout<<endl;
preorder(root);
cout<<endl;
}
else if (com=="find") {
int x;
cin>>x;
Node *t=find(root,x);
if (t!=NIL) {
cout<<"yes"<<endl;
}
else {
cout<<"no"<<endl;
}
}
else {
int x;
cin>>x;
treeDelete(find(root,x));
}
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int tree[800005];
int lazy[800005];
int arr[200005];
int final[200005];
void updateRangeUtil(int si, int ss, int se, int us, int ue, int diff) {
if (lazy[si] != 0) {
tree[si] += (se - ss + 1) * lazy[si];
if (ss != se) {
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
}
lazy[si] = 0;
}
if (ss > se || ss > ue || se < us) return;
if (ss >= us && se <= ue) {
tree[si] += (se - ss + 1) * diff;
if (ss != se) {
lazy[si * 2 + 1] += diff;
lazy[si * 2 + 2] += diff;
}
return;
}
int mid = (ss + se) / 2;
updateRangeUtil(si * 2 + 1, ss, mid, us, ue, diff);
updateRangeUtil(si * 2 + 2, mid + 1, se, us, ue, diff);
tree[si] = tree[si * 2 + 1] + tree[si * 2 + 2];
}
void updateRange(int n, int us, int ue, int diff) {
updateRangeUtil(0, 0, n - 1, us, ue, diff);
}
int getSumUtil(int ss, int se, int qs, int qe, int si) {
if (lazy[si] != 0) {
tree[si] += (se - ss + 1) * lazy[si];
if (ss != se) {
lazy[si * 2 + 1] += lazy[si];
lazy[si * 2 + 2] += lazy[si];
}
lazy[si] = 0;
}
if (ss > se || ss > qe || se < qs) return 0;
if (ss >= qs && se <= qe) return tree[si];
int mid = (ss + se) / 2;
return getSumUtil(ss, mid, qs, qe, 2 * si + 1) +
getSumUtil(mid + 1, se, qs, qe, 2 * si + 2);
}
int getSum(int n, int qs, int qe) {
if (qs < 0 || qe > n - 1 || qs > qe) {
return -1;
}
return getSumUtil(0, n - 1, qs, qe, 0);
}
void constructSTUtil(int arr[], int ss, int se, int si) {
if (ss > se) return;
if (ss == se) {
tree[si] = arr[ss];
return;
}
int mid = (ss + se) / 2;
constructSTUtil(arr, ss, mid, si * 2 + 1);
constructSTUtil(arr, mid + 1, se, si * 2 + 2);
tree[si] = tree[si * 2 + 1] + tree[si * 2 + 2];
}
void constructST(int arr[], int n) { constructSTUtil(arr, 0, n - 1, 0); }
int main() {
long long l, r, n, k, q, i, a, b, haha;
haha = 0;
cin >> n >> k >> q;
for (i = 0; i < 200005; i++) arr[i] = 0;
constructST(arr, 200005);
for (i = 0; i < n; i++) {
cin >> l >> r;
updateRange(200005, l, r, 1);
}
for (i = 0; i < 200005; i++) {
if (getSum(200005, i, i) >= k) {
haha += 1;
}
final[i] = haha;
}
while (q--) {
cin >> a >> b;
cout << final[b] - final[a - 1] << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long N = 1e5 + 3;
void topo(long long id, vector<long long> °, vector<long long> *graph,
long long *dp) {
for (long long child : graph[id]) {
--deg[child];
dp[child] = max(dp[child], 1 + dp[id]);
if (deg[child] == 0) topo(child, deg, graph, dp);
}
}
bool check(long long mx, vector<pair<long long, long long>> &edges,
long long n) {
vector<long long> v[n + 1], deg(n + 1, 0);
for (long long i = 0; i < mx; ++i)
v[edges[i].first].push_back(edges[i].second), deg[edges[i].second]++;
long long dp[n + 1];
long long id = -1;
long long cnt = 0;
for (long long i = 1; i <= n; ++i) {
cnt += (deg[i] == 0);
if (deg[i] == 0) id = i;
}
if (cnt != 1) return false;
memset(dp, 0, sizeof dp);
dp[id] = 1;
topo(id, deg, v, dp);
for (long long i = 1; i <= n; ++i) {
if (dp[i] == n) return true;
}
return false;
}
void solve() {
vector<pair<long long, long long>> edges;
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long x, y;
cin >> x >> y;
edges.push_back({x, y});
}
long long l = 1, r = m;
long long ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid, edges, n))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) solve();
}
| 10 | CPP |
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
using namespace std;
#define REP(i,n) for (int i=0;i<(n);++i)
#define rep(i,a,b) for(int i=a;i<(b);++i)
template<class T> inline bool chmin(T &a, T b){ if(a > b) { a = b; return true;} return false;}
template<class T> inline bool chmax(T &a, T b){ if(a < b) { a = b; return true;} return false;}
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
int N,K;
int main() {
cin.tie(0); ios_base::sync_with_stdio(false);
cin >> N >> K;
vector<int> a(N),b(N);
REP(i,N) cin >> a[i];
deque<int> dq;
for(int i = 0; i < N; ++i){
// 後ろが今見てるのより小さくなるまで
while(!dq.empty() && a[dq.back()] >= a[i]) dq.pop_back();
dq.push_back(i);
if(i - K + 1 >= 0){
b[i - K + 1] = a[dq.front()];
if(dq.front() == i - K + 1) dq.pop_front();
}
}
for(int i = 0; i <= N-K; ++i) cout << b[i] << (i==N-K ? '\n' : ' ');
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int factorial(int n);
int factorial(int n) {
if (n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int i = 0;
int n1 = n;
while (i < n) {
if (s[i] != s[i + 1]) {
} else {
s.erase(s.begin() + i);
n--;
i = i - 2;
}
i = i + 2;
}
if (n % 2 == 0) {
} else {
n--;
}
cout << n1 - n << endl;
for (int i = 0; i < n; i++) {
cout << s[i];
}
cout << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
string s[N];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = n - 2; i >= 0; i--) {
int len1 = s[i + 1].length();
int len2 = s[i].length();
int len = max(len1, len2);
string str = "#";
for (int j = 1; j < len; j++) {
if (j < len2)
str.push_back(s[i][j]);
else
break;
if (str > s[i + 1]) {
str.pop_back();
break;
}
}
s[i] = str;
}
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
l = list(map(int,input().split()))
p = [0]
s = 0
for i in l:
s+=i
p.append(s)
mx = 0
for i in range(1,n+1):
if(p[i]>100*i):
mx = max(mx,i)
else:
for j in range(i):
if(p[i]-p[j]>100*(i-j)):
mx = max(mx,i-j)
break
print(mx)
| 8 | PYTHON3 |
a=input()
print(['No','Yes'][len(set(a[:3]))*len(set(a[-3:]))<=2]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m1, m2;
const long long int N = 3 * 1e5;
vector<long long int>::iterator itr, itr1;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > Edges(m);
vector<int> Ans(m);
vector<int> degree(n);
vector<vector<pair<int, int> > > adj(n);
set<pair<int, int> > Good_set;
vector<int> in_good_set(n, true);
for (int i = 0; i < m; i++) {
cin >> Edges[i].first >> Edges[i].second;
Edges[i].first--;
Edges[i].second--;
adj[Edges[i].first].push_back({Edges[i].second, i});
adj[Edges[i].second].push_back({Edges[i].first, i});
degree[Edges[i].first]++;
degree[Edges[i].second]++;
}
for (int i = 0; i < n; i++) {
Good_set.insert({degree[i], i});
}
while (!Good_set.empty() && Good_set.begin()->first < k) {
int node = Good_set.begin()->second;
for (auto &y : adj[node]) {
int x = y.first;
if (in_good_set[x]) {
Good_set.erase({degree[x], x});
--degree[x];
Good_set.insert({degree[x], x});
}
}
Good_set.erase({degree[node], node});
in_good_set[node] = false;
}
for (int i = m - 1; i >= 0; i--) {
Ans[i] = Good_set.size();
int u = Edges[i].first, v = Edges[i].second;
if (in_good_set[u] && in_good_set[v]) {
Good_set.erase({degree[u], u});
--degree[u];
Good_set.insert({degree[u], u});
Good_set.erase({degree[v], v});
--degree[v];
Good_set.insert({degree[v], v});
while (!Good_set.empty() && Good_set.begin()->first < k) {
int node = Good_set.begin()->second;
for (auto &y : adj[node]) {
int x = y.first;
if (y.second >= i) continue;
if (in_good_set[x]) {
Good_set.erase({degree[x], x});
--degree[x];
Good_set.insert({degree[x], x});
}
}
Good_set.erase({degree[node], node});
in_good_set[node] = false;
}
}
}
for (int i = 0; i < m; i++) {
cout << Ans[i] << "\n";
}
return 0;
}
| 11 | CPP |
from math import ceil
n = int(input())
a = sorted(map(int, input().split()), reverse=True)
c = a.count(4)
t1 = a.count(1)
t2 = a.count(2)
t3 = a.count(3)
c += t3
if t1 > t3:
t1 = t1-t3
else:
t1 = 0
c += (t2//2)
if t2 & 1 == 1:
t2 = 1
c += 1
if t1 >= 2:
t1 -= 2
else:
t1 = 0
c += ceil(t1/4)
print(c)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
struct query {
int index;
long double s, r;
query(int _index, int _s, int _r) {
index = _index;
s = _s;
r = _r;
}
query() {
index = 0;
s = 0;
r = 0;
}
};
const long double EPS = 1e-10;
bool operator>(query a, query b) {
if (abs(a.s - b.s) > EPS) return a.s > b.s;
if (abs(a.r - b.r) > EPS) return a.r > b.r;
return a.index > b.index;
}
bool operator<(query a, query b) {
if (abs(a.s - b.s) > EPS) return a.s < b.s;
if (abs(a.r - b.r) > EPS) return a.r < b.r;
return a.index < b.index;
}
int N;
bool win(query a, query b, long double R) {
long double ascore = 1 / a.s + R / a.r;
long double bscore = 1 / b.s + R / b.r;
return ascore - bscore <= EPS;
}
long double getR(query a, query b, long double minimum) {
long double ok = 1e18;
long double ng = minimum;
for (int timer = 0; timer <= 500; timer++) {
long double mid = (ok + ng) / 2.0;
if (win(a, b, mid))
ok = mid;
else
ng = mid;
}
return ok;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
vector<query> input(N);
for (int i = 1; i <= N; i++) {
int r, s;
cin >> s >> r;
input[i - 1].index = i;
input[i - 1].s = s;
input[i - 1].r = r;
}
sort(input.begin(), input.end(), greater<query>());
vector<query> candidate;
long double rmax = 0.0;
long double rmaxbefore = 0.0;
for (int i = 0; i < input.size(); i++) {
if (i >= 1 && input[i - 1].s - input[i].s > EPS) rmaxbefore = rmax;
if (rmax - input[i].r >= EPS) continue;
chmax(rmax, input[i].r);
if (!(input[i].r - rmaxbefore >= EPS)) continue;
candidate.push_back(input[i]);
}
for (int i = 0; i < candidate.size(); i++) cerr << candidate[i].index << endl;
vector<pair<query, long double> > v;
v.push_back({candidate[0], 0.0});
for (int i = 1; i < candidate.size(); i++) {
while (!v.empty()) {
if (!win(v.back().first, candidate[i], v.back().second)) {
v.pop_back();
} else {
break;
}
}
long double minimum = getR(candidate[i], v.back().first, v.back().second);
cerr << candidate[i].index << " wins against " << v.back().first.index
<< " with R=" << minimum << endl;
v.push_back({candidate[i], minimum});
}
vector<int> ans;
for (int i = 0; i < v.size(); i++) {
ans.push_back(v[i].first.index);
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 9 | CPP |
import math
k = int(input())
s = ['c', 'o', 'd', 'e', 'f', 'o', 'r', 'c', 'e', 's']
baseVal = int(10**(math.log10(k)/10))
freq = [baseVal for _ in range(10)]
state, flag = baseVal**10, True
while state < k :
for i in range(10):
freq[i] += 1
state = (state//baseVal)*(baseVal+1)
if state >= k :
flag = False
break
if flag is True:
baseVal += 1
ans = []
for i in range(10):
for _ in range(freq[i]):
ans.append(s[i])
print("".join(ans)) | 8 | PYTHON3 |
s=input()
x=s.count("0")
y=s.count("1")
print(min(x,y)*2) | 0 | PYTHON3 |
N, A, B, C = map(int,input().split())
L = [int(input()) for _ in range(N)]
def dfs(idx, a, b, c):
if idx == N:
if a == 0 or b == 0 or c == 0:
return 1e9
return abs(A-a) + abs(B-b) + abs(C-c)
x = dfs(idx+1,a,b,c)
y = dfs(idx+1,a+L[idx],b,c) + 10*(a!=0)
z = dfs(idx+1,a,b+L[idx],c) + 10*(b!=0)
w = dfs(idx+1,a,b,c+L[idx]) + 10*(c!=0)
return min(x,y,z,w)
ans = dfs(0,0,0,0)
print(ans) | 0 | PYTHON3 |
ip=[]
ip=input().split('+')
ip.sort()
for i in range(len(ip)):
print(ip[i],end='')
if i!= len(ip)-1:
print('+',end='')
| 7 | PYTHON3 |
def main():
a, b = map(int, input().split())
s, t = input(), -100
x = sum({"L": -1, "R": 1}.get(c, 0) for c in s)
y = sum({"D": -1, "U": 1}.get(c, 0) for c in s)
if x and y:
t += min(a // x, b // y)
elif x:
t += a // x
elif y:
t += b // y
if t > 0:
a -= t * x
b -= t * y
for c in s * 101:
if a == 0 == b:
print("Yes")
return
a -= {"L": -1, "R": 1}.get(c, 0)
b -= {"D": -1, "U": 1}.get(c, 0)
print("No")
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct dat {
int L, R, V;
} a[100005];
int N, M;
bool cmp(dat a, dat b) {
if (a.L != b.L) return a.L < b.L;
if (a.R != b.R) return a.R < b.R;
return a.V < b.V;
}
int ans[100005], s[100005];
void build(int k) {
int last = 0;
for (int i = (1), _b = (M); i <= _b; i++)
if (a[i].V >> k & 1) {
for (int j = (max(last + 1, a[i].L)), _b = (a[i].R); j <= _b; j++)
ans[j] |= (1 << k);
last = max(last, a[i].R);
}
memset(s, 0, sizeof s);
for (int i = (1), _b = (N); i <= _b; i++)
s[i] = s[i - 1] + (!(ans[i] >> k & 1));
for (int i = (1), _b = (M); i <= _b; i++)
if (!(a[i].V >> k & 1))
if (s[a[i].R] == s[a[i].L - 1]) {
cout << "NO\n";
exit(0);
}
}
int main(void) {
cin >> N >> M;
for (int i = (1), _b = (M); i <= _b; i++) cin >> a[i].L >> a[i].R >> a[i].V;
sort(a + 1, a + M + 1, cmp);
for (int i = (0), _b = (29); i <= _b; i++) build(i);
cout << "YES\n";
for (int i = (1), _b = (N); i <= _b; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 8 | CPP |
import sys
import collections
rlines = sys.stdin.readlines()
lines = (l.strip() for l in rlines)
def eucycle(n,m,adj):
diredges = []
us = list(adj.keys())
for u in us:
while adj[u]:
v0 = u
v1 = adj[v0].pop()
adj[v1].remove(v0)
diredges.append((v0,v1))
while v1 != u:
v0 = v1
v1 = adj[v0].pop()
adj[v1].remove(v0)
diredges.append((v0,v1))
return diredges
def solve(n,m,edges):
adj = collections.defaultdict(set)
diredges = []
for u,v in edges:
adj[u].add(v)
adj[v].add(u)
odds = set(u for u in adj if len(adj[u])%2 == 1)
ans = n - len(odds)
assert(len(odds)%2 == 0)
for o in odds:
adj[n+1].add(o)
adj[o].add(n+1)
diredges = eucycle(n+1,m,adj)
return str(ans) + '\n' + '\n'.join(str(u) + ' ' + str(v) for (u,v) in diredges\
if u != n+1 and v != n+1)
t = int(next(lines))
for ti in range(t):
n,m = [int(s) for s in next(lines).split()]
edges = []
for ei in range(m):
u,v = [int(s) for s in next(lines).split()]
edges.append((u,v))
#print(edges)
print(solve(n,m,edges))
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int mod = (int)1e9 + 7;
const int MXN = (int)3e5 + 7;
bitset<MXN> ck;
vector<int> edge[MXN];
int prt[MXN], dep[MXN];
int len, cntp;
vector<int> ans1;
vector<int> ans2[MXN];
void dfs(int u, int pa, int dpt) {
prt[u] = pa;
dep[u] = dpt;
ck[u] = 1;
int num = 0;
int v1 = -1, v2 = -1;
for (int v : edge[u]) {
if (v == pa) continue;
if (!ck[v]) {
num++;
dfs(v, u, dpt + 1);
} else {
if (v1 == -1)
v1 = v;
else
v2 = v;
}
}
if (!num) {
if (dpt >= len) {
if (!ans1.empty()) return;
int v = u;
for (int i = dpt; i >= 1; i--) {
ans1.push_back(v);
v = prt[v];
}
} else {
cntp++;
assert(v1 != -1);
assert(v2 != -1);
if ((dpt - dep[v1] + 1) % 3) {
int v = u;
while (v != v1) {
ans2[cntp].push_back(v);
v = prt[v];
}
ans2[cntp].push_back(v1);
} else if ((dpt - dep[v2] + 1) % 3) {
int v = u;
while (v != v2) {
ans2[cntp].push_back(v);
v = prt[v];
}
ans2[cntp].push_back(v2);
} else {
if (dep[v1] > dep[v2]) swap(v1, v2);
ans2[cntp].push_back(u);
int v = v2;
while (v != v1) {
ans2[cntp].push_back(v);
v = prt[v];
}
ans2[cntp].push_back(v1);
}
}
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
len = (n + k - 1) / k;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!ck[i]) dfs(i, 0, 1);
}
if (!ans1.empty()) {
puts("PATH");
printf("%d\n", (int)(ans1).size());
for (int i = 0; i < (int)(ans1).size(); i++)
printf("%d%c", ans1[i], " \n"[i == (int)(ans1).size() - 1]);
} else if (cntp >= k) {
puts("CYCLES");
for (int j = 1; j <= k; j++) {
printf("%d\n", (int)(ans2[j]).size());
for (int i = 0; i < (int)(ans2[j]).size(); i++)
printf("%d%c", ans2[j][i], " \n"[i == (int)(ans2[j]).size() - 1]);
}
} else {
assert(0);
}
return 0;
}
| 11 | CPP |
def f(noofque):
prev = [0] * (2 * noofque + 1)
prev[noofque] = 1
curr = [0] * len(prev)
for i in range(noofque):
for j in range(len(prev)):
if(j == 0):
curr[j] = prev[1]
elif(j == len(prev) - 1):
curr[j] = prev[j - 1]
else:
curr[j] = prev[j - 1] + prev[j + 1]
prev = curr + []
return prev
sent = input()
received = input()
final = sent.count('+') - sent.count('-')
currfinal = received.count('+') - received.count('-')
noofque = received.count('?')
if(noofque):
if(final >= currfinal - noofque and final <= currfinal + noofque):
arr = f(noofque)
# print(arr)
print(arr[final - currfinal + noofque] / (2 ** noofque))
else:
print('0.000000000000')
else:
if(final == currfinal):
print('1.000000000000')
else:
print('0.000000000000') | 8 | PYTHON3 |
from math import log
a, b = map(int, input().split())
# Gracias a las leyes de los logaritmos, mas efectivo para cuando n siendo el exponente de 2 y 3 es un numero grande
print(int(log(b / a, 10) / log(3 / 2, 10))+1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 1;
const int B = 8191;
int n, a[MAXN];
vector<pair<int, int> > q[MAXN];
int eachq[B + 1];
queue<int> app[5005];
int dp[5005][B + 1];
bool vis[B + 1];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), app[a[i]].push(i);
for (int i = 0; i <= 5000; ++i) app[i].push(INF);
for (int i = 0; i <= 5000; ++i)
for (int j = 0; j <= B; ++j) eachq[i ^ j] = i;
memset(dp, 63, sizeof(dp));
int cnt = 0;
for (int i = 0; i <= 5000; ++i) {
dp[i][i] = app[i].front();
if (dp[i][i] != INF) {
q[dp[i][i]].push_back(make_pair(i, i));
cnt += 1;
vis[i] = 1;
}
}
for (int t = 1; t <= n; ++t) {
for (auto it : q[t]) {
while (eachq[it.second] != -1 && eachq[it.second] > it.first) {
int Tmp_ = eachq[it.second]--;
auto Tmp = make_pair(Tmp_, it.second ^ Tmp_);
while (app[Tmp.first].front() <= t) app[Tmp.first].pop();
if (app[Tmp.first].front() != INF) {
cnt += vis[Tmp.second] == 0;
vis[Tmp.second] = 1;
if (cnt == B + 1) break;
dp[Tmp.first][Tmp.second] = app[Tmp.first].front();
q[dp[Tmp.first][Tmp.second]].push_back(Tmp);
}
}
}
}
vector<int> ans;
ans.push_back(0);
for (int i = 1; i <= B; ++i) {
if (vis[i]) ans.push_back(i);
}
printf("%d\n", int(ans.size()));
for (auto it : ans) printf("%d ", it);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr int INF = INT32_MAX;
constexpr int MAXN = 1e3 + 10;
constexpr double eps = 1e-8;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
using Vec = vector<int>;
template <class T>
void Min(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void Max(T &a, T b) {
if (b > a) a = b;
}
ll N, M, K, T;
Vec A;
vector<Pii> dirs = {{1, 2}, {1, -2}, {-1, 2}, {-1, -2},
{2, 1}, {2, -1}, {-2, 1}, {-2, -1}};
vector<Pii> moves_from[MAXN][MAXN];
vector<Pii> pos;
bool vis_white[MAXN][MAXN];
bool vis_black[MAXN][MAXN];
int dist_white_goal[MAXN][MAXN];
int dist_black_goal[MAXN][MAXN];
int act;
int white_x, white_y, black_x, black_y;
void LegalMoves(int x, int y) {
for (auto d : dirs) {
int nx = x + d.first, ny = y + d.second;
if (1 <= nx && nx <= N && 1 <= ny && ny <= M)
moves_from[x][y].emplace_back(nx, ny);
}
}
void BfsWhite(int x, int y) {
if (1 <= x && x <= N && 1 <= y && y <= M) {
for (auto to : moves_from[x][y]) {
if (!vis_white[to.first][to.second]) {
dist_white_goal[to.first][to.second] = 1 + dist_white_goal[x][y];
vis_white[to.first][to.second] = true;
pos.emplace_back(to.first, to.second);
}
}
}
if (act + 1 < pos.size()) {
act++;
BfsWhite(pos[act].first, pos[act].second);
}
}
void BfsBlack(int x, int y) {
if (1 <= x && x <= N && 1 <= y && y <= M) {
for (auto to : moves_from[x][y]) {
if (!vis_black[to.first][to.second]) {
dist_black_goal[to.first][to.second] = 1 + dist_black_goal[x][y];
vis_black[to.first][to.second] = true;
pos.emplace_back(to.first, to.second);
}
}
}
if (act + 1 < pos.size()) {
act++;
BfsBlack(pos[act].first, pos[act].second);
}
}
void Solution() {
for (int i = (int)(1); i < (int)(N + 1); ++i) {
for (int j = (int)(1); j < (int)(M + 1); ++j) LegalMoves(i, j);
}
vis_white[N / 2][M / 2] = true;
act = -1;
BfsWhite(N / 2, M / 2);
act = -1;
pos.clear();
vis_black[N / 2 + 1][M / 2] = true;
BfsBlack(N / 2 + 1, M / 2);
if (dist_white_goal[white_x][white_y] + 1 <=
dist_white_goal[black_x][black_y] &&
dist_white_goal[white_x][white_y] <= dist_black_goal[black_x][black_y]) {
cout << "WHITE" << endl;
while (white_x != N / 2 || white_y != M / 2) {
for (auto to : moves_from[white_x][white_y]) {
if (dist_white_goal[to.first][to.second] <
dist_white_goal[white_x][white_y]) {
cout << to.first << ' ' << to.second << endl;
white_x = to.first, white_y = to.second;
if (white_x == black_x && white_y == black_y) return;
if (white_x != N / 2 || white_y != M / 2) cin >> black_x >> black_y;
break;
}
}
}
return;
}
if (dist_black_goal[black_x][black_y] + 2 <=
dist_black_goal[white_x][white_y] &&
dist_black_goal[black_x][black_y] + 1 <=
dist_white_goal[white_x][white_y]) {
cout << "BLACK" << endl;
cin >> white_x >> white_y;
while (black_x != N / 2 + 1 || black_y != M / 2) {
for (auto to : moves_from[black_x][black_y]) {
if (dist_black_goal[to.first][to.second] <
dist_black_goal[black_x][black_y]) {
cout << to.first << ' ' << to.second << endl;
black_x = to.first, black_y = to.second;
if (white_x == black_x && white_y == black_y) return;
if (black_x != N / 2 + 1 || black_y != M / 2)
cin >> white_x >> white_y;
break;
}
}
}
return;
}
if ((white_x + white_y) % 2 != (black_x + black_y) % 2) {
cout << "WHITE" << endl;
if (dist_white_goal[white_x][white_y] <=
dist_black_goal[black_x][black_y]) {
while (white_x != N / 2 || white_y != M / 2) {
for (auto to : moves_from[white_x][white_y]) {
if (dist_white_goal[to.first][to.second] <
dist_white_goal[white_x][white_y]) {
cout << to.first << ' ' << to.second << endl;
white_x = to.first, white_y = to.second;
if (white_x == black_x && white_y == black_y) return;
cin >> black_x >> black_y;
break;
}
}
}
} else {
while (white_x != N / 2 + 1 || white_y != M / 2) {
for (auto to : moves_from[white_x][white_y]) {
if (dist_black_goal[to.first][to.second] <
dist_black_goal[white_x][white_y]) {
cout << to.first << ' ' << to.second << endl;
if (black_x == to.first && black_y == to.second) return;
white_x = to.first, white_y = to.second;
cin >> black_x >> black_y;
break;
}
}
}
for (auto to : moves_from[white_x][white_y]) {
if (black_x == to.first && black_y == to.second) {
cout << to.first << ' ' << to.second << endl;
return;
}
}
while (white_x != N / 2 || white_y != M / 2) {
for (auto to : moves_from[white_x][white_y]) {
if (dist_white_goal[to.first][to.second] <
dist_white_goal[white_x][white_y]) {
cout << to.first << ' ' << to.second << endl;
if (black_x == to.first && black_y == to.second) return;
white_x = to.first, white_y = to.second;
if (white_x != N / 2 || white_y != M / 2) cin >> black_x >> black_y;
break;
}
}
}
}
return;
} else {
cout << "BLACK" << endl;
cin >> white_x >> white_y;
if (dist_white_goal[white_x][white_y] >=
dist_black_goal[black_x][black_y]) {
while (black_x != N / 2 + 1 || black_y != M / 2) {
for (auto to : moves_from[black_x][black_y]) {
if (dist_black_goal[to.first][to.second] <
dist_black_goal[black_x][black_y]) {
cout << to.first << ' ' << to.second << endl;
black_x = to.first, black_y = to.second;
if (white_x == black_x && white_y == black_y) return;
cin >> white_x >> white_y;
break;
}
}
}
} else {
while (black_x != N / 2 || black_y != M / 2) {
for (auto to : moves_from[black_x][black_y]) {
if (dist_white_goal[to.first][to.second] <
dist_white_goal[black_x][black_y]) {
cout << to.first << ' ' << to.second << endl;
black_x = to.first, black_y = to.second;
if (white_x == black_x && white_y == black_y) return;
cin >> white_x >> white_y;
break;
}
}
}
for (auto to : moves_from[black_x][black_y]) {
if (white_x == to.first && white_y == to.second) {
cout << to.first << ' ' << to.second << endl;
return;
}
}
while (black_x != N / 2 + 1 || black_y != M / 2) {
for (auto to : moves_from[black_x][black_y]) {
if (dist_black_goal[to.first][to.second] <
dist_black_goal[black_x][black_y]) {
cout << to.first << ' ' << to.second << endl;
black_x = to.first, black_y = to.second;
if (white_x == black_x && white_y == black_y) return;
if (black_x != N / 2 + 1 || black_y != M / 2)
cin >> white_x >> white_y;
break;
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> N >> M;
cin >> white_x >> white_y >> black_x >> black_y;
Solution();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
while (a % 2 == 0) a /= 2, ans++;
}
cout << ans << "\n";
} | 0 | CPP |
import sys
import io, os
import math
import bisect
def main():
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
t=int(input())
for i in range(t):
n=int(input())
a=[int(i) for i in input().split()]
ans=0
for i in range(1,n):
if a[i]<a[i-1]:
diff=abs(a[i]-a[i-1])
bina=bin(diff)
count=len(bina)-2
#print(bina,count)
a[i]=a[i-1]
if count>ans:
ans+=(count-ans)
sys.stdout.write(str(ans)+'\n')
if __name__ == "__main__":
main()
| 9 | PYTHON3 |
_, *inp = map(str.rstrip, open(0).readlines())
ans = []
for s in inp:
a = 0
for c in s:
a += 1 if c == 'A' or a == 0 else -1
ans.append(a)
print(*ans, sep='\n')
| 9 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
for x in range(2,10**5):
if n%x==0:
print(str(n//x)+" "+str(n-(n//x)))
break
else:
print("1 "+str(n-1))
| 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
int cnt[30]={};
for(int i=0;i<s.size();i++){
cnt[s[i]-'A']=1;
}
if(cnt['N'-'A']^cnt['S'-'A']||cnt['W'-'A']^cnt['E'-'A'])cout<<"No"<<endl;
else cout<<"Yes"<<endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mINF = 1000 * 1000 * 1000 + 9;
const double ebs = 0.000001;
int main() {
int kol_vo;
cin >> kol_vo;
vector<int> v(kol_vo);
for (int c = 0; c < kol_vo; c++) cin >> v[c];
vector<int> dop;
dop.push_back(31);
dop.push_back(28);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(28);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(29);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(28);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(28);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
dop.push_back(30);
dop.push_back(31);
for (int c = 0; c < dop.size() - kol_vo; c++) {
bool b = true;
for (int i = 0; i < kol_vo; i++) {
if (v[i] != dop[c + i]) b = false;
}
if (b == true) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define DUMP(x) cerr << #x << "=" << x << endl
#define DUMP2(x, y) cerr<<"("<<#x<<", "<<#y<<") = ("<<x<<", "<<y<<")"<< endl
#define BINARY(x) static_cast<bitset<16> >(x)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define in_range(x, y, w, h) (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define ALL(a) (a).begin(),(a).end()
typedef long long ll;
const int INF = 1e9;
const ll INFLL = 1e18;
typedef pair<int, int> PII;
int dx[4]={0, -1, 1, 0}, dy[4]={-1, 0, 0, 1};
int main()
{
ios::sync_with_stdio(false);
int M, GRE, GEO, DP, GRA, O;
while (cin >> M >> GRE >> GEO >> DP >> GRA >> O) {
if (!M && !GRE && !GEO && !DP && !GRA && !O) break;
int G1 = M + DP;
int G2 = GRE + GRA;
int G3 = GEO + O;
int ans = 0;
int mn = min({G1, G2, G3});
/*
{
int tmp = mn;
tmp += (G1 - mn) / 3;
tmp += (G2 - mn) / 3;
tmp += (G3 - mn) / 3;
tmp += min({(G1 - mn)%3, (G2 - mn)%3, (G3 - mn)%3});
ans = max(ans, tmp);
}
{
int tmp = 0;
tmp += G1/3; G1%=3;
tmp += G2/3; G2%=3;
tmp += G3/3; G3%=3;
tmp += min({G1, G2, G3});
ans = max(ans, tmp);
}
*/
// cerr << "------------" << endl;
for (int m=max(0, mn-100); m<=mn; m++) {
int tmp = m;
tmp += (G1 - m) / 3;
tmp += (G2 - m) / 3;
tmp += (G3 - m) / 3;
ans = max(ans, tmp);
// DUMP(tmp);
}
cout << ans << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int A[4], D[4];
double F[4], R[4];
bool eq(double a, double b) { return a - b < 1e-8 && b - a < 1e-8; }
void done(int x) {
printf("%d\n", x);
exit(0);
}
int main() {
for (int i = 0; i < 4; ++i) scanf("%d", &A[i]);
for (int i = 1; i < 4; ++i) D[i] = A[i] - A[i - 1];
if (D[1] == D[2] && D[2] == D[3]) done(A[3] + D[3]);
for (int i = 0; i < 4; ++i)
if (A[i] == 0) done(42);
for (int i = 0; i < 4; ++i) {
F[i] = A[i];
if (i) R[i] = F[i] / F[i - 1];
}
if (!eq(R[1], R[2]) || !eq(R[2], R[3]) || !eq(R[1], R[3])) done(42);
if (A[3] * A[3] / A[2] == (double)A[3] * A[3] / A[2])
done(A[3] * A[3] / A[2]);
else
done(42);
}
| 7 | CPP |
x=list(input().split("+"))
x.sort()
k=len(x)
print(x[0],end="")
for i in range(1,k):
print(("+"+x[i]),end="") | 7 | PYTHON3 |
n, m, k = map(int, input().split())
if m < n or k < n:
print('NO')
else:
print('YES') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long c[1005], ch, v, m, n, ans, ce;
vector<long long> a[1005];
vector<pair<pair<long long, long long>, long long> > p;
bool visit[1005];
void dfs(long long s, long long cp) {
visit[s] = true;
ch += a[s].size();
v++;
n--;
for (long long i = 0; i < a[s].size(); i++) {
if (!visit[a[s][i]]) dfs(a[s][i], cp);
}
if (s == cp) {
ce += (v) * (v - 1) / 2 - ch / 2;
p.push_back(make_pair(make_pair(v, ch / 2), (v) * (v - 1) / 2 - ch / 2));
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long k, x, y;
cin >> n >> m >> k;
for (long long i = 0; i < k; ++i) cin >> c[i];
for (long long i = 0; i < m; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (long long i = 0; i < k; i++) {
v = 0;
ch = 0;
dfs(c[i], c[i]);
m -= ch / 2;
}
for (long long i = 0; i < p.size(); i++)
ans = max(ans, (n + p[i].first.first) * (n + p[i].first.first - 1) / 2 - m -
p[i].first.second + ce - p[i].second);
cout << ans;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
bool ask(int x, int y) {
if (x == 0) return false;
if (y == n + 1) return true;
cout << "1 " << x << " " << y << endl;
fflush(stdout);
string res;
cin >> res;
return res == "TAK";
}
void answer(int a, int b) {
cout << "2 " << a << " " << b << endl;
fflush(stdout);
}
int getDish(int left, int right) {
if (right < left) return -1;
while (right - left > 1) {
int mid = left + right >> 1;
if (ask(mid, mid + 1)) {
right = mid;
} else {
left = mid + 1;
}
}
return ask(left, right) ? left : right;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int k;
cin >> n >> k;
int a = getDish(0, n + 1);
int b = getDish(0, a - 1);
if (!ask(b, a)) {
b = getDish(a + 1, n + 1);
}
answer(b, a);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long pow(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
T gcd(T x, T y) {
for (T t; x; t = x, x = y % x, y = t)
;
return y;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
Graph() { adj.clear(); }
void resize(int n) { adj.resize(n + 5); }
void add(int s, edge e) { adj[s].push_back(e); }
void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
vector<edge> &operator[](int t) { return adj[t]; }
};
const int maxn = 1100000;
int x[maxn * 2];
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
x[i] = i;
}
int *p = x;
for (int i = 2; i <= n; ++i) {
for (int j = (n - 1) / i * i; j >= 0; j -= i) {
p[min(n, j + i)] = p[j];
}
++p;
}
for (int i = 0; i < n; ++i) {
cout << p[i] + 1 << " ";
}
cout << endl;
return 0;
}
| 10 | CPP |
## necessary imports
import sys
input = sys.stdin.readline
from math import log2, log, ceil
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp
## gcd function
def gcd(a,b):
if a == 0:
return b
return gcd(b%a, a)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return res
## upper bound function code -- such that e in a[:i] e < x;
def upper_bound(a, x, lo=0):
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if a[mid] < x:
lo = mid+1
else:
hi = mid
return lo
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b
# find function
def find(x, link):
while(x != link[x]):
x = link[x]
return x
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, size, link):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e6 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve()
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()))
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
string = input().strip();
string = string.replace('144', ' ');
string = string.replace('14', ' ');
string = string.replace('1', ' ');
string = string.replace(' ', '');
if len(string) == 0:
print('YES')
else:
print('NO'); | 7 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
x=n//2
a=list()
b=2
if x%2==1:
print("NO")
continue
print("YES")
for i in range(1,n//2+1):
a.append(b*i)
for i in range(x//2):
a.append(a[i]-1)
for i in range(x//2,n//2):
a.append(a[i]+1)
print(*a)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long INF = 1e18;
long long n, a, b, c;
int main() {
scanf("%lld%lld%lld%lld", &n, &a, &b, &c);
if (n % 4 == 0)
cout << 0;
else if (n % 4 == 3)
cout << min(c + b, min(a, c + c + c));
else if (n % 4 == 2)
cout << min(b, min(a + a, c + c));
else if (n % 4 == 1)
cout << min(c, min(b + a, a + a + a));
return 0;
}
| 7 | CPP |
k,r=map(int,input().split())
for i in range(k):
if (((10*i)%k==0 or (10*i+r)%k==0)and i!=0) or r%k==0:
break
if ((10*i)+r)%k==0:
print(int((10*i+r)/k))
else:
print(int((10*i)/k))
| 7 | PYTHON3 |
n, m = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
res = 0
cont = 0
for i in l:
if i < 0 and cont < m:
res += abs(i)
cont += 1
print(res) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long N = 1000005;
long long dp[N], a[N], n;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long x, y;
vector<long long> cur;
for (long long i = 0; i < n; i++) cin >> x >> y, cur.push_back(x), a[x] = y;
long long ans = 0, prev = 0;
for (long long i = 0; i < N; i++) {
if (a[i]) {
long long le = i - a[i] - 1;
if (le < 0)
dp[i] = 1;
else
dp[i] = dp[le] + 1;
} else {
dp[i] = prev;
}
prev = dp[i];
}
for (long long i = 0; i < n; i++) {
ans = max(dp[cur[i]], ans);
}
cout << n - ans << "\n";
return 0;
}
| 9 | CPP |
_,a=input(),list(map(int,input().split()));
l=a[0]
b=[0]*1001
s=l
for i in range(1,len(a)):
b[a[i]]+=1
for i in range(len(b)-1,-1,-1):
if l>i:
print(0)
break
elif b[i]>0:
if s+b[i]>i:
print(i-l+1)
break
s+=b[i]
b[i-1]+=b[i] | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long cum[100004];
int main() {
int val[26];
for (int i = 0; i < 26; i++) {
scanf("%d", &val[i]);
}
string s;
cin >> s;
int n = s.size();
vector<int> pos[27];
s = "#" + s;
for (int i = 1; i <= n; i++) {
cum[i] = cum[i - 1] + val[s[i] - 'a'];
pos[s[i] - 'a'].push_back(i);
}
long long ans = 0;
for (int c = 0; c < 26; c++) {
map<long long, int> cnt;
for (auto x : pos[c]) {
ans += cnt[cum[x - 1]];
cnt[cum[x]]++;
}
}
printf("%I64d\n", ans);
}
| 10 | CPP |
from math import *
from collections import *
from operator import itemgetter
import bisect
i = lambda: input()
ii = lambda: int(input())
iia = lambda: list(map(int,input().split()))
isa = lambda: list(input().split())
I = lambda:list(map(int,input().split()))
chrIdx = lambda x: ord(x)-96
idxChr = lambda x: chr(96+x)
t = ii()
for _ in range(t):
n = ii()
a = iia()
a.sort()
m = 1000000
for i in range(n-1):
if(a[i+1]-a[i]<m):
m = a[i+1]-a[i]
print(m)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int q, x_1, y_1, x_2, y_2, k, len, a[35], b[35], c[35];
pair<int, int> dp[35][2][2][2];
int Add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int Minus(int a, int b) { return a < b ? a - b + mod : a - b; }
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return make_pair(Add(a.first, b.first), Add(a.second, b.second));
}
pair<int, int> dfs(int now, int f1, int f2, int f3) {
if (now == -1) return make_pair(1, 0);
if (~dp[now][f1][f2][f3].first) return dp[now][f1][f2][f3];
pair<int, int> ret = make_pair(0, 0);
for (int i = 0; i <= (f1 ? a[now] : 1); i++)
for (int j = 0; j <= (f2 ? b[now] : 1); j++)
if ((i ^ j) <= (f3 ? c[now] : 1)) {
pair<int, int> tmp = dfs(now - 1, f1 && i == a[now], f2 && j == b[now],
f3 && (i ^ j) == c[now]);
ret = ret + tmp;
if (i ^ j) ret.second = (ret.second + (1ll << now) * tmp.first) % mod;
}
dp[now][f1][f2][f3] = ret;
return ret;
}
int calc(int x, int y, int k) {
if (x < 0 || y < 0 || k < 0) return 0;
memset(dp, -1, sizeof(dp));
len = 0;
while (x || y || k) {
a[len] = (x & 1);
b[len] = (y & 1);
c[len++] = (k & 1);
x >>= 1;
y >>= 1;
k >>= 1;
}
pair<int, int> ret = dfs(len - 1, 1, 1, 1);
return Add(ret.first, ret.second);
}
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x_1, &y_1, &x_2, &y_2, &k);
printf(
"%d\n",
Minus(
Add(calc(x_2 - 1, y_2 - 1, k - 1), calc(x_1 - 2, y_1 - 2, k - 1)),
Add(calc(x_1 - 2, y_2 - 1, k - 1), calc(x_2 - 1, y_1 - 2, k - 1))));
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, c[2001];
int main() {
scanf("%d", &n);
if (n > 11) {
printf("%lld\n", 292 + (n - 11) * (long long)49);
return 0;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++)
for (int r = 0; r <= n; r++)
if (i + j + k + r == n) c[i * 1 + j * 5 + k * 10 + r * 50]++;
int cnt = 0;
for (int i = 1; i <= 2000; i++) {
if (c[i]) cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[110];
int vis[110];
int dfs(int i, int x) {
vis[i]++;
if (vis[i] > 2) return -0x3f3f3f3f;
if (a[i] == i && x != i) return -0x3f3f3f3f;
if (a[i] == x) {
vis[x]++;
return 1;
}
return dfs(a[i], x) + 1;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
bool flag = 0;
int ans = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) vis[j] = 0;
int t = dfs(i, i);
if (t < 0) {
flag = 1;
break;
}
if (t % 2 == 0) t /= 2;
if (ans == 0)
ans = t;
else if (ans != t && t != 0)
ans = ans / gcd(ans, t) * t;
}
if (flag)
printf("-1\n");
else
printf("%d\n", ans);
}
return 0;
}
| 9 | CPP |
from itertools import*
input()
a=[len([*g])for k,g in groupby(input().split())]
t=max(map(min,zip(a,a[1:])))
print(2*t)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, x1, x2, y11, y2;
string s1, s2;
int main() {
cin >> s1 >> s2;
x1 = (s1[0] - 48) * 10 + (s1[1] - 48);
x2 = (s1[3] - 48) * 10 + (s1[4] - 48);
y11 = (s2[0] - 48) * 10 + s2[1] - 48;
y2 = (s2[3] - 48) * 10 + s2[4] - 48;
a = x1 - y11;
if (a < 0) {
a = 24 + a;
}
b = x2 - y2;
if (b < 0) {
b = 60 + b;
if (a == 0) {
a = 23;
} else {
a--;
}
}
if (a == 0) {
cout << "00";
} else if (a >= 10) {
cout << a;
} else {
cout << "0" << a;
}
cout << ":";
if (b == 0) {
cout << "00";
} else if (b >= 10) {
cout << b;
} else {
cout << "0" << b;
}
}
| 7 | CPP |
A,B,C,K = map(int, input().split())
a = min(A, K)
b = min(B, K-a)
c = K - a - b
print(a - c) | 0 | PYTHON3 |
n=input().lower()
for i in n:
if i not in 'aoyiue':
print('.',i,sep='',end='') | 7 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Wed Jan 22 20:06:05 2020
@author: HP
"""
for i in range(int(input())):
l=[int(i) for i in input().split()]
a=l[0]
b=l[1]
c=l[2]
n=l[-1]
A=(n-2*a+b+c)/3
B=(n+a-2*b+c)/3
C=(n+a-2*c+b)/3
if sum(l)%3==0:
if A>=0 and B>=0 and C>=0 and A+B+C==n and a+A==b+B==c+C:
print("YES")
else:
print("NO")
else:
print("NO") | 7 | PYTHON3 |
n=int(input())
nodes_x=[]
nodes_y=[]
for i in range(n):
x,y=(map(int,input().split()))
nodes_x.append([x])
nodes_y.append([y])
ans=1
for i in range(n-1):
for j in range(i+1,n):
if set(nodes_x[i])&set(nodes_x[j]) or set(nodes_y[i])&set(nodes_y[j]):
nodes_x[j]+=nodes_x[i]
nodes_y[j]+=nodes_y[i]
ans+=1
break
print(n-ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
vector<vector<int> > adjList(100009, vector<int>());
bool vis[100009];
vector<int> ans;
bool check_valid_edges(vector<vector<int> > &a, int n) {
for (size_t i = 1; i <= n; i++)
if (a[i].size() != 4) return false;
return true;
}
int comp(int node1, int node2) {
int c = 0;
for (int i = 0; i < adjList[node1].size(); i++) {
for (int j = 0; j < adjList[node2].size(); j++) {
if (adjList[node1][i] == adjList[node2][j]) c++;
}
}
return c;
}
void dfs(int node) {
vis[node] = true;
bool f = true;
for (int i = 0; i < adjList[node].size() && f; i++) {
if (comp(node, adjList[node][i]) == 2 && !vis[adjList[node][i]])
ans.push_back(adjList[node][i]), dfs(adjList[node][i]), f = false;
}
}
int main() {
cin >> n;
for (int i = 1; i <= (2 * n); i++) {
cin >> x >> y;
adjList[x].push_back(y);
adjList[y].push_back(x);
}
if (!check_valid_edges(adjList, n)) return cout << -1 << endl, 0;
if (n == 5)
return cout << "1 2 3 4 5\n" << endl, 0;
else if (n == 6) {
int s_node = 21;
for (int i = 0; i < adjList[1].size(); i++) s_node -= adjList[1][i];
s_node--;
cout << "1 " << adjList[1][0] << " " << adjList[1][1] << " " << s_node
<< " " << adjList[1][2] << " " << adjList[1][3] << endl;
;
} else {
dfs(1);
ans.push_back(1);
if (ans.size() == n)
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
else
cout << -1 << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 7;
vector<int> adj[N];
double dfs(int u, int p, double len) {
double ret = 0;
int cnt = 0;
for (int v : adj[u]) {
if (v == p) continue;
++cnt;
ret = ret + dfs(v, u, len + 1.0);
}
if (!cnt) return len;
return (ret) / (double)cnt;
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << fixed << setprecision(10) << dfs(1, 0, 0) << endl;
}
| 9 | CPP |
# @oj: codeforces
# @id: hitwanyang
# @email: [email protected]
# @date: 2020-08-24 17:58
# @url:https://codeforc.es/problemset/problem/1196/D1
import sys,os
from io import BytesIO, IOBase
import collections,itertools,bisect,heapq,math,string
from decimal import *
# region fastio
BUFSIZE = 8192
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def main():
t=int(input())
for i in range(t):
n,k=map(int,input().split())
s=str(input())
rgb="RGB"*(k//3+2)
sub=["R"+rgb[1:k],"G"+rgb[2:k+1],"B"+rgb[3:k+2]]
x=0
ans=n+1
while x<=n-k:
temp=s[x:x+k]
for j in sub:
mn=0
for y in range(len(temp)):
if temp[y]!=j[y]:
mn+=1
ans=min(mn,ans)
x+=1
print (ans)
if __name__ == "__main__":
main() | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int cs = 1;
void file();
int dx[] = {+0, +0, -1, +1};
int dy[] = {+1, -1, +0, +0};
int X[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int Y[] = {-1, +1, +0, +0, +1, +1, -1, -1};
int kx[] = {-2, -2, -1, -1, 1, 1, 2, 2};
int ky[] = {-1, 1, -2, 2, -2, 2, -1, 1};
template <class mpX>
mpX GCD(mpX a, mpX b) {
return b == 0 ? a : GCD(b, a % b);
}
template <class mpX>
mpX LCM(mpX a, mpX b) {
return a * (b / GCD(a, b));
}
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
const int lim = 1e5 + 123;
void solve() {
long long n, cal;
cin >> n >> cal;
vector<pair<long long, long long>> v;
for (int i = 0; i < n; i++) {
long long tem;
cin >> tem;
v.push_back({tem, 0});
}
long long a;
cin >> a;
for (int i = 0; i < n; i++) {
long long tem;
cin >> tem;
v[i].second = tem;
}
priority_queue<long long, vector<long long>, greater<long long>> pq;
bool ckr = true;
long long cost = 0;
for (int i = 0; i < n; i++) {
pq.push(v[i].second);
if (cal < v[i].first) {
while (!pq.empty()) {
cal += a;
cost += pq.top();
pq.pop();
if (cal >= v[i].first) break;
}
}
if (cal < v[i].first) {
ckr = false;
break;
}
}
if (ckr)
cout << cost << endl;
else
cout << "-1" << endl;
}
int main() {
int t;
solve();
return 0;
}
void file() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
| 10 | CPP |
def sumRectangle(x,y):
s = 0
a = (y+1)*(y)//2
b = (y+1)*(x+1)*x//2
return a*(x+1)+b
m,b = [int(x) for x in input().split(' ')]
mx = -1
for y in range(b+1):
sumR = sumRectangle((b-y)*m,y)
if sumR > mx:
mx=sumR
print(mx)
| 8 | PYTHON3 |
def fact(x):
if x==0:
return 1
else:
return x*fact(x-1)
a,b=map(int,input().split())
print(fact(min(a,b))) | 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main(){
int n,x;
cin >> n >>x;
while(n!=0||x!=0){
int i,j,k;
int l=0;
for(i=1;i<=n;i++){
for(j=i+1;j<=n;j++){
for(k=j+1;k<=n;k++){
if(i+j+k==x) l++;
}
}
}
cout << l << endl;
cin >> n >> x;
}
}
| 0 | CPP |
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<set>
using namespace std;
typedef long long ll;
typedef double db;
#define fo(i,j,k) for(i=j;i<=k;i++)
#define fd(i,j,k) for(i=j;i>=k;i--)
#define cmax(a,b) (a=(a>b)?a:b)
#define cmin(a,b) (a=(a<b)?a:b)
const int N=1e6+5,mo=1e9+7;
int n,m,K,i,j,k,q1,q2;
ll f[2][2005][2],sum[2005];
int ans;
int main()
{
scanf("%d %d %d",&n,&m,&K);
m--;K--;
q1=0;
q2=1;
f[0][0][0]=1;
fo(i,1,max(n,m)*2)
{
fo(j,0,n) sum[j+1]=(sum[j-1+1]+f[q1][j][0]+f[q1][j][1])%mo;
fo(j,0,n)
{
f[q2][j][0]=(sum[j+1]-sum[j-1+1])%mo;
k=max(0,j-K);
f[q2][j][1]=(sum[j-1+1]-sum[k-1+1])%mo;
}
fo(j,0,n)
if (j%K==n%K&&(i*K-j)%K==m%K&&i*K-j<=m)
ans=(ans+f[q2][j][1])%mo;
q1^=1;q2^=1;
}
ans=(ans+mo)%mo;
printf("%d",ans);
} | 0 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double PI = acos(-1.0);
int m, n, cnt[1011][1011];
char a[1011][1011];
bool mark[300];
const int di[4] = {-1, 1, 0, 0};
const int dj[4] = {0, 0, -1, 1};
int now;
pair<int, int> x[100];
bool inside(int i, int j) {
if (i < 0 || j < 0) return false;
if (i > m || j > n) return false;
return true;
}
char getColor() {
for (int cur = ('0'), _b = ('9'); cur <= _b; cur++) mark[cur] = false;
for (int p = (1), _b = (now); p <= _b; p++) {
for (int dir = 0, _a = (4); dir < _a; dir++) {
int i = x[p].first + di[dir];
int j = x[p].second + dj[dir];
if (a[i][j] >= '0' && a[i][j] <= '9') mark[a[i][j]] = true;
}
}
char c = '0';
while (mark[c]) c++;
return c;
}
bool check(char c) {
c = getColor();
for (int p = (1), _b = (now); p <= _b; p++)
if (a[x[p].first][x[p].second] != '.') return false;
bool ok = true;
for (int p = (1), _b = (now); p <= _b; p++) a[x[p].first][x[p].second] = c;
for (int p = (1), _b = (now); p <= _b; p++) {
int i = x[p].first, j = x[p].second;
for (int dir = 0, _a = (4); dir < _a; dir++) {
int ii = i + di[dir], jj = j + dj[dir];
if (a[ii][jj] == '.') {
cnt[ii][jj]--;
if (!cnt[ii][jj]) ok = false;
}
}
}
if (!ok) {
for (int p = (1), _b = (now); p <= _b; p++) {
int i = x[p].first, j = x[p].second;
for (int dir = 0, _a = (4); dir < _a; dir++) {
int ii = i + di[dir], jj = j + dj[dir];
if (a[ii][jj] == '.') {
cnt[ii][jj]++;
if (!cnt[ii][jj]) ok = false;
}
}
}
for (int p = (1), _b = (now); p <= _b; p++)
a[x[p].first][x[p].second] = '.';
}
return ok;
}
int main() {
cin >> m >> n;
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++) cin >> a[i][j];
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++)
if (a[i][j] == '.') {
cnt[i][j] = 0;
for (int dir = 0, _a = (4); dir < _a; dir++) {
int ii = i + di[dir], jj = j + dj[dir];
if (inside(ii, jj) && a[ii][jj] == '.') cnt[i][j]++;
}
if (!cnt[i][j]) {
puts("-1");
return 0;
}
} else
cnt[i][j] = -1;
for (int i = (1), _b = (m); i <= _b; i++)
for (int j = (1), _b = (n); j <= _b; j++)
if (a[i][j] == '.') {
char c;
now = 2;
x[1] = make_pair(i, j);
x[2] = make_pair(i, j + 1);
if (check(c)) continue;
now = 2;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j);
if (check(c)) continue;
now = 3;
x[1] = make_pair(i, j);
x[2] = make_pair(i, j + 1);
x[3] = make_pair(i, j + 2);
if (check(c)) continue;
now = 3;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j);
x[3] = make_pair(i + 2, j);
if (check(c)) continue;
now = 3;
x[1] = make_pair(i, j);
x[2] = make_pair(i, j + 1);
x[3] = make_pair(i + 1, j);
if (check(c)) continue;
now = 3;
x[1] = make_pair(i, j);
x[2] = make_pair(i, j + 1);
x[3] = make_pair(i + 1, j + 1);
if (check(c)) continue;
now = 3;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j);
x[3] = make_pair(i + 1, j + 1);
if (check(c)) continue;
now = 3;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j - 1);
x[3] = make_pair(i + 1, j);
if (check(c)) continue;
now = 4;
x[1] = make_pair(i, j);
x[2] = make_pair(i, j + 1);
x[3] = make_pair(i, j + 2);
x[4] = make_pair(i + 1, j + 1);
if (check(c)) continue;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j - 1);
x[3] = make_pair(i + 1, j);
x[4] = make_pair(i + 2, j);
if (check(c)) continue;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j);
x[3] = make_pair(i + 1, j + 1);
x[4] = make_pair(i + 2, j);
if (check(c)) continue;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j - 1);
x[3] = make_pair(i + 1, j);
x[4] = make_pair(i + 1, j + 1);
if (check(c)) continue;
now = 5;
x[1] = make_pair(i, j);
x[2] = make_pair(i + 1, j - 1);
x[3] = make_pair(i + 1, j);
x[4] = make_pair(i + 1, j + 1);
x[5] = make_pair(i + 2, j);
if (check(c)) continue;
puts("-1");
return 0;
}
for (int i = (1), _b = (m); i <= _b; i++) {
for (int j = (1), _b = (n); j <= _b; j++) cout << a[i][j];
puts("");
}
return 0;
}
| 8 | CPP |
for i in range(int(input())):
n = int(input())
s = [int(i) for i in input().split()]
d = [[0,0] for i in range(n+1)]
e = set()
f = False
for i in range(n):
if s[i] not in e:
d[s[i]][0]=i
e.add(s[i])
else:
d[s[i]][1]=i
for i in range(n+1):
if d[i][1]-d[i][0]>1:
f = True
break
if f:
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10;
const int mo = 998244353;
int a[N], b[N], s[N], lz[N];
void f(int x, int L, int R, int y, int l, int r) {
if (L <= l && R >= r) {
s[x] += y;
lz[x] += y;
return;
}
int m = (l + r) >> 1;
if (L <= m) f(x << 1, L, R, y, l, m);
if (R > m) f(x << 1 | 1, L, R, y, m + 1, r);
s[x] = max(s[x << 1], s[x << 1 | 1]) + lz[x];
}
int q(int x, int l, int r, int nw) {
if (l == r) return l;
int m = (l + r) >> 1;
nw += lz[x];
return s[x << 1 | 1] + nw > 0 ? q(x << 1 | 1, m + 1, r, nw)
: q(x << 1, l, m, nw);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (auto i = (1); i <= (n); ++i) {
scanf("%d", &a[i]);
f(1, 1, a[i], 1, 1, 1e6);
}
for (auto i = (1); i <= (m); ++i) {
scanf("%d", &b[i]);
f(1, 1, b[i], -1, 1, 1e6);
}
int k;
scanf("%d", &k);
for (auto o = (1); o <= (k); ++o) {
int op, i, x;
scanf("%d%d%d", &op, &i, &x);
if (op == 1) {
f(1, 1, a[i], -1, 1, 1e6);
a[i] = x;
f(1, 1, a[i], 1, 1, 1e6);
} else {
f(1, 1, b[i], 1, 1, 1e6);
b[i] = x;
f(1, 1, b[i], -1, 1, 1e6);
}
printf("%d\n", s[1] > 0 ? q(1, 1, 1e6, 0) : -1);
}
}
| 9 | CPP |
inf = 10 ** 15
n = int(input())
w = list(map(int, input().split()))
s = [input() for i in range(n)]
sr = [x[::-1] for x in s]
cost = [[0, w[i]] for i in range(n)]
for i in range(1, n):
tmp = inf
if s[i] >= s[i - 1]:
tmp = min(tmp, cost[i - 1][0])
if s[i] >= sr[i - 1]:
tmp = min(tmp, cost[i - 1][1])
cost[i][0] = tmp
tmp = inf
if sr[i] >= s[i - 1]:
tmp = min(tmp, cost[i - 1][0])
if sr[i] >= sr[i - 1]:
tmp = min(tmp, cost[i - 1][1])
cost[i][1] = tmp + w[i]
ans = min(cost[-1][0], cost[-1][1])
if ans >= inf:
print(-1)
else:
print(ans)
| 9 | PYTHON3 |
n = int(input())
l1 = list( map(int, input().split()))
ans = n
left = n-1
right = n-1
for i in range(n-1, -1, -1):
right = min(left, i)
left = min( left, max(0, i-l1[i]))
ans = ans - (right - left)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x1, y1;
cin >> n >> x1 >> y1;
unordered_set<long double> slope;
for (long long int i = 0; i < n; i++) {
long long int x2, y2;
long double s;
cin >> x2 >> y2;
if (x1 == x2)
s = DBL_MAX;
else
s = (long double)(y2 - y1) / (x2 - x1);
if (slope.find(s) == slope.end()) {
slope.insert(s);
}
}
cout << slope.size();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int a[105], b[105];
int main() {
int n, x, num = 0;
a[0] = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x != 0) {
b[num] = i;
num++;
a[num] = b[num] = i + 1;
} else {
b[num - 1]++, a[num]++;
}
}
a[0] = 1;
if (num < 1) {
puts("NO");
} else {
puts("YES");
printf("%d\n", num);
for (int i = 0; i < num; i++) {
printf("%d %d\n", a[i], b[i]);
}
}
}
| 7 | CPP |
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
#define mp make_pair
#define pb push_back
const int N=705;
vector<int> E[N];
set<pair<int,int> > has;
vector<pair<int,int> > sz;
int cnt[2];
int was[N];
bool bad;
void DFS(int u)
{
cnt[was[u]]++;
for(int i=0;i<E[u].size();i++)
{
int v=E[u][i];
if(was[v]==-1) was[v]=was[u]^1,DFS(v);
else
{
if(was[u]==was[v]) bad=1;//,printf("(%i %i)\n",u,v);
}
}
}
bool dp[N][N];
int main()
{
int u,v,n,m,i,j;
scanf("%i %i",&n,&m);
while(m--) scanf("%i %i",&u,&v),has.insert(mp(u,v)),has.insert(mp(v,u));
for(i=1;i<=n;i++)
{
for(j=i+1;j<=n;j++)
{
if(!has.count(mp(i,j)))
{
E[i].pb(j);
E[j].pb(i);
//printf("->%i %i\n",i,j);
}
}
}
sz.pb(mp(-1,-1));
for(i=1;i<=n;i++) was[i]=-1;
for(i=1;i<=n;i++) if(was[i]==-1)
{
cnt[0]=cnt[1]=0;
was[i]=1;DFS(i);
sz.pb(mp(cnt[0],cnt[1]));
}
if(bad) return printf("-1\n"),0;
int goal=n/2;
dp[0][0]=1;
for(i=1;i<sz.size();i++)
{
for(j=0;j<=goal;j++)
{
dp[i][j]=(j>=sz[i].first?dp[i-1][j-sz[i].first]:0)|(j>=sz[i].second?dp[i-1][j-sz[i].second]:0);
}
}
int ans=0;
for(i=0;i<=goal;i++) if(dp[sz.size()-1][i]) ans=i;
int ret=n-ans;
int out=ans*(ans-1)/2+ret*(ret-1)/2;
printf("%i\n",out);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200005;
int orders[MAX];
int n, k, a, b, q, x, y, tam;
struct node {
int from, to;
int prev, aft;
node() {}
node(int _from, int _to, int _prev, int _aft) {
from = _from;
to = _to;
prev = _prev;
aft = _aft;
}
};
vector<node> seg[40];
void makeSeg() {
node aux = node(n, n, 0, 0);
tam = 0;
for (int i = 0; i < n; i++) seg[0].push_back(node(i, i, 0, 0));
if (n & 1) seg[0].push_back(aux);
tam++;
while (seg[tam - 1].size() > 1) {
for (int i = 0; i < seg[tam - 1].size(); i += 2) {
int lf = seg[tam - 1][i].from;
int rg = seg[tam - 1][i + 1].to;
seg[tam].push_back(node(lf, rg, 0, 0));
}
if (seg[tam].size() & 1 && seg[tam].size() > 1) seg[tam].push_back(aux);
tam++;
}
}
void updatePrev(int line, int pos, int ini, int fin, int val) {
if (seg[line][pos].from == ini && seg[line][pos].to == fin) {
seg[line][pos].prev = val;
return;
}
node& cur = seg[line][pos];
node& lf = seg[line - 1][pos * 2];
node& rg = seg[line - 1][pos * 2 + 1];
if (lf.to >= fin) {
updatePrev(line - 1, pos * 2, ini, fin, val);
} else {
if (rg.from <= ini) {
updatePrev(line - 1, pos * 2 + 1, ini, fin, val);
} else {
updatePrev(line - 1, pos * 2, ini, lf.to, val);
updatePrev(line - 1, pos * 2 + 1, rg.from, fin, val);
}
}
cur.prev = lf.prev + rg.prev;
return;
}
void updateAft(int line, int pos, int ini, int fin, int val) {
if (seg[line][pos].from == ini && seg[line][pos].to == fin) {
seg[line][pos].aft = val;
return;
}
node& cur = seg[line][pos];
node& lf = seg[line - 1][pos * 2];
node& rg = seg[line - 1][pos * 2 + 1];
if (lf.to >= fin) {
updateAft(line - 1, pos * 2, ini, fin, val);
} else {
if (rg.from <= ini) {
updateAft(line - 1, pos * 2 + 1, ini, fin, val);
} else {
updateAft(line - 1, pos * 2, ini, lf.to, val);
updateAft(line - 1, pos * 2 + 1, rg.from, fin, val);
}
}
cur.aft = lf.aft + rg.aft;
return;
}
int getPrev(int line, int pos, int ini, int fin) {
if (seg[line][pos].from == ini && seg[line][pos].to == fin) {
return seg[line][pos].prev;
}
node& cur = seg[line][pos];
node& lf = seg[line - 1][pos * 2];
node& rg = seg[line - 1][pos * 2 + 1];
if (lf.to >= fin) {
return getPrev(line - 1, pos * 2, ini, fin);
} else {
if (rg.from <= ini) {
return getPrev(line - 1, pos * 2 + 1, ini, fin);
} else {
int ans = 0;
ans = getPrev(line - 1, pos * 2, ini, lf.to);
ans += getPrev(line - 1, pos * 2 + 1, rg.from, fin);
return ans;
}
}
return 0;
}
int getAft(int line, int pos, int ini, int fin) {
if (seg[line][pos].from == ini && seg[line][pos].to == fin) {
return seg[line][pos].aft;
}
node& cur = seg[line][pos];
node& lf = seg[line - 1][pos * 2];
node& rg = seg[line - 1][pos * 2 + 1];
if (lf.to >= fin) {
return getAft(line - 1, pos * 2, ini, fin);
} else {
if (rg.from <= ini) {
return getAft(line - 1, pos * 2 + 1, ini, fin);
} else {
int ans = 0;
ans = getAft(line - 1, pos * 2, ini, lf.to);
ans += getAft(line - 1, pos * 2 + 1, rg.from, fin);
return ans;
}
}
return 0;
}
void print() {
for (int i = 0; i < tam; i++) {
for (int j = 0; j < seg[i].size(); j++) {
cout << "{" << seg[i][j].from << " " << seg[i][j].to << " "
<< seg[i][j].prev << "-" << seg[i][j].aft << "}\t";
}
cout << endl;
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tipo;
cin >> n >> k >> a >> b >> q;
makeSeg();
for (int i = 0; i < q; i++) {
cin >> tipo >> x;
if (tipo == 1) {
x--;
cin >> y;
orders[x] += y;
if (orders[x] > b) {
updatePrev(tam - 1, 0, x, x, b);
} else {
updatePrev(tam - 1, 0, x, x, orders[x]);
}
if (orders[x] > a) {
updateAft(tam - 1, 0, x, x, a);
} else {
updateAft(tam - 1, 0, x, x, orders[x]);
}
} else {
x--;
int lf = x;
int rg = x + k;
int ans = 0;
if (lf > 0) ans = getPrev(tam - 1, 0, 0, lf - 1);
if (rg < n) ans += getAft(tam - 1, 0, rg, n - 1);
cout << ans << '\n';
}
}
return 0;
}
| 10 | CPP |
#!/usr/bin/env python
import sys
def eligible(score, position, thresh):
if score < thresh:
return False
i = (score // 50) % 475
for __ in range(25):
i = (i * 96 + 42) % 475
if position == 26 + i:
return True
return False
def main():
p, x, y= map(int, sys.stdin.readline().split())
diff = 0
for __ in range(475):
if eligible(x + diff, p, y):
print("0")
return
diff -= 50
diff = 0
for __ in range(475):
if eligible(x + diff, p, y):
succ = diff // 100
unsucc = (diff // 50) %2 ## if 1, we need additional success
print(str(succ + unsucc))
return
diff += 50
main()
| 8 | PYTHON3 |
#include <iostream>
using namespace std;
int main(){
int m, d;
cin >> m >> d;
if (m>d) cout << m-1;
else cout << m;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toStr(T s) {
ostringstream os;
os << s;
return os.str();
}
template <class T>
char* toCharArr(T n) {
char* s;
sprintf(s, "%ld", n);
return s;
}
int Int(char c) { return int(c - 48); }
template <class T>
int toInt(T s) {
int re = 0;
istringstream is(s);
is >> re;
return re;
}
inline bool cmp(pair<int, int> p, pair<int, int> q) {
return p.second < q.second;
}
unsigned long long in() {
int x = 0, c;
for (; (unsigned long long)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned long long)((c = getchar()) - '0') < 10);
return x;
}
void QuickSort(int a[], int id[], int l, int r) {
int i = l, j = r;
while (i <= j) {
int m = a[id[(l + r) / 2]];
while (a[id[i]] < m) i++;
while (a[id[j]] > m) j--;
if (i <= j) {
int tmp = id[i];
id[i] = id[j];
id[j] = tmp;
i++;
j--;
}
if (l < j) QuickSort(a, id, l, j);
if (i < r) QuickSort(a, id, i, r);
}
}
string Cong(string a, string b) {
string re = "";
for (int i = 0; i <= a.length() + 1; i++) re += '0';
for (int i = a.length() - 1; i >= 0; i--) {
int tmp = Int(a[i]) + Int(b[i]);
if ((tmp + int(re[i] - 48)) < 10)
re[i] = char(tmp + int(re[i] - 48));
else {
string s = toStr(tmp + int(re[i] - 48));
re[i] = s[1];
re[i - 1] = s[0];
}
}
return re;
}
int main() {
int n, x;
long t = 0;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> x;
if ((i + j) == (n - 1)) {
t += x;
continue;
}
if (i == (n - 1) / 2) {
t += x;
continue;
}
if (j == (n - 1) / 2) {
t += x;
continue;
}
if (i == j) {
t += x;
}
}
}
cout << t;
}
| 7 | CPP |
#In the name of Allah
from sys import stdin, stdout
input = stdin.readline
def isnum():
if s[0] == "R":
for i in range(len(s)):
if s[i].isdigit():
for j in range(i + 1, len(s)):
if s[j] == "C":
return True
return False
def toint():
res = 0
n = len(a)
rng = range(n - 1, -1, -1)
for i, j in zip(range(n), rng):
res += (ord(a[i]) - 64) * 26 ** j
return str(res)
def toal(n):
if n == 0:
return ""
if n <= 26:
return chr(64 + n)
if n % 26 == 0:
return toal(n // 26 - 1) + chr(90)
return toal(n // 26) + chr(64 + n % 26)
def ints():
a = ""
for i in range(1,10 ** 6):
if s[i].isdigit():
a += s[i]
else:
break
b = 0
for j in range(i,10 ** 6):
try:
if s[j].isdigit():
b = b * 10 + int(s[j])
except IndexError:
break
return a, b
def _ints():
a = ""
b = ""
for i in s:
if i.isalpha():
a += i
else:
b += i
return a, b
for _ in range(int(input())):
s = input()[:-1]
if isnum():
a, b = ints()
stdout.write(toal(b) + a + "\n")
else:
a, b = _ints()
stdout.write("R" + b + "C" + toint())
stdout.write("\n")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)(1e6 + 7);
const long long INF = (long long)(1e18 + 7);
const long long MOD = (long long)(1e9 + 7);
const long long LG = 20;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m;
cin >> n >> m;
long long x[n];
for (long long i = 0; i < n; i++) {
cin >> x[i];
}
long long p[m];
for (long long i = 0; i < m; i++) {
cin >> p[i];
}
long long g = x[1] - x[0];
for (long long i = 2; i < n; i++) {
g = gcd(g, x[i] - x[i - 1]);
}
long long y = x[0];
for (long long i = 0; i < m; i++) {
if (g % p[i] == 0) {
cout << "YES\n";
cout << y << " " << i + 1;
exit(0);
}
}
cout << "NO";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
std::vector<long long> a(n);
std::map<long long, long long> cnt;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
sort((a).begin(), (a).end());
if (cnt[a[0]] > (n / 2))
cout << "Bob\n";
else
cout << "Alice\n";
}
| 9 | CPP |
#include<stdio.h>
#include<iostream>
#include<fstream>
#include<stack>
#include<math.h>
using namespace std;
int main(){
int n;
cin >> n;
for (int i = 0; i < n; i++){
int bn;
int b[101];
int max = 0, min = 0;
cin >> bn;
for (int j = 0; j < bn; j++)cin >> b[j];
for (int j = 0; j < bn; j++){
if (j == 0)continue;
if (b[j] - b[j - 1]>0){
if (b[j] - b[j - 1]>max) max = b[j] - b[j - 1];
}
if (b[j] - b[j - 1]<0){
if (b[j - 1] - b[j]>min) min = b[j - 1] - b[j];
}
}
cout << max << ' ' << min << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> banx, bany;
int x[10], y[10], n;
void ck(int p, int s, int id) {
if (s & 1) {
if (s & 2)
x[id] = 1;
else
x[id] = n;
if (s & 4)
y[id] = p;
else
y[id] = n + 1 - p;
} else {
if (s & 2)
x[id] = p;
else
x[id] = n + 1 - p;
if (s & 4)
y[id] = 1;
else
y[id] = n;
}
}
bool ok(int p, int i, int j) {
ck(p, i, 0);
ck(p, j, 1);
for (int ii = 0; ii < 2; ii++) {
if (x[ii] == 1 || x[ii] == n) {
if (bany.find(y[ii]) != bany.end()) return false;
} else {
if (banx.find(x[ii]) != banx.end()) return false;
}
}
if (i == j) return true;
if (x[0] == x[1]) {
if (x[0] > 1 && x[0] < n) return false;
}
if (y[0] == y[1]) {
if (y[0] > 1 && y[0] < n) return false;
}
if (x[0] == y[1] && y[0] == x[1]) return false;
if (x[0] == n + 1 - y[1] && y[0] == n + 1 - x[1]) return false;
return true;
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int xx, yy;
scanf("%d%d", &xx, &yy);
banx.insert(xx);
bany.insert(yy);
}
int tot = 0;
for (int ii = 2; ii <= n + 1 - ii; ii++) {
int anss = 0;
for (int i = 0; i < 8; i++)
for (int j = i + 1; j < 8; j++)
for (int k = j + 1; k < 8; k++)
for (int l = k + 1; l < 8; l++) {
if (ok(ii, i, i)) anss = max(anss, 1);
if (ok(ii, i, j)) anss = max(anss, 2);
if (ok(ii, i, j) && ok(ii, i, k) && ok(ii, j, k))
anss = max(anss, 3);
if (ok(ii, i, j) && ok(ii, i, k) && ok(ii, i, l) && ok(ii, j, k) &&
ok(ii, j, l) && ok(ii, k, l))
anss = max(anss, 4);
}
tot += anss;
}
printf("%d\n", tot);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int pow_mod(long long int a, long long int b) {
long long int res = 1;
while (b != 0) {
if (b & 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
void solve() {
long long int n;
cin >> n;
long long int ans = -1;
long long int l = 1;
long long int r = (long long int)1e7;
while (l <= r) {
long long int mid = (l + r) / 2;
long long int val = mid * (mid + 1);
val /= 2;
if (val <= n) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
long long int v[ans + 2][ans + 1];
long long int val = 1;
for (long long int i = 1; i <= ans; i++) {
for (long long int j = i; j <= ans; j++) {
v[i][j] = val++;
}
}
val = 1;
for (long long int j = 1; j <= ans; j++) {
for (long long int i = j + 1; i <= ans + 1; i++) {
v[i][j] = val++;
}
}
cout << ans + 1 << endl;
for (long long int i = 1; i <= ans + 1; i++) {
for (long long int j = 1; j <= ans; j++) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) solve();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long m, n, k;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
cin >> m >> n >> k;
if (k < max(n, m))
cout << -1 << endl;
else {
long long tmp = abs(n - m);
long long dig = min(n, m);
if (tmp % 2) {
cout << k - 1 << endl;
} else {
if ((k - tmp) % 2 == dig % 2) {
cout << k << endl;
} else {
cout << k - 2 << endl;
}
}
}
}
return 0;
}
| 8 | CPP |
N = int(input())
A = list(map(int,input().split()))
t = 0
for e in A:
t += e%2
print("YES" if t%2 == 0 else "NO")
| 0 | PYTHON3 |
w=input()
x=w.split()
for i in range(4):
x[i]=int(x[i])
a=4
a+=2*x[1]
a+=2*x[3]
a+=2*max(x[0],x[2])
print(a) | 7 | PYTHON3 |
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
#sys.setrecursionlimit(100000000)
inp = lambda: int(input())
strng = lambda: input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda: list(input().strip())
mul = lambda: map(int, input().strip().split())
mulf = lambda: map(float, input().strip().split())
seq = lambda: list(map(int, input().strip().split()))
ceil = lambda x: int(x) if (x == int(x)) else int(x) + 1
ceildiv = lambda x, d: x // d if (x % d == 0) else x // d + 1
flush = lambda: stdout.flush()
stdstr = lambda: stdin.readline()
stdint = lambda: int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
stdarr = lambda: map(int, stdstr().split())
mod = 1000000007
for _ in range(stdint()):
n, k = stdarr()
s = input()
s = list(s)
pos = True
if(n == k):
one = n//2 - s.count("1")
zer = n//2 - s.count("0")
if(one >= 0 and zer >= 0 and one+zer == s.count("?")):
print("YES")
else:
print("NO")
else:
for i in range(n):
if(s[i] != "?" and s[i%k] != "?" and s[i] != s[i%k]):
pos = False
break
else:
if(s[i] == "?" and s[i%k] == "?"):
continue
elif(s[i] != "?" and s[i%k] == "?"):
s[i%k] = s[i]
else:
s[i] = s[i%k]
if(not pos):
print("NO")
continue
c = Counter(s[:k])
if(c["1"] > k//2 or c["0"] > k//2):
print("NO")
else:
print("YES")
| 7 | PYTHON3 |
import math
s = input().split()
n, b = int(s[0]), int(s[1])
sqrtn = math.ceil(math.sqrt(b)) + 1
p = []
e = []
ntmp = b
for i in range(2, sqrtn + 1):
if ntmp == 1: break
if ntmp % i == 0:
cnt = 0
while ntmp % i == 0:
cnt += 1
ntmp //= i
p.append(i)
e.append(cnt)
if ntmp != 1:
p.append(int(ntmp))
e.append(1)
m = [0] * len(p)
for i in range(len(p)):
ntmp = n
while ntmp:
ntmp //= p[i]
m[i] += ntmp
u = min( [ m[i] // e[i] for i in range(len(p)) ] )
print(u)
| 9 | PYTHON3 |
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <math.h>
#include <iomanip>
#include <limits>
#include <list>
#include <queue>
#include <tuple>
#include <map>
using namespace std;
#define MOD (long long int)(1e9+7)
#define ll long long int
#define rep(i,n) for(int i=0; i<(int)(n); i++)
#define reps(i,n) for(int i=1; i<=(int)(n); i++)
#define REP(i,n) for(int i=n-1; i>=0; i--)
#define REPS(i,n) for(int i=n; i>0; i--)
#define INF (int)(1123456789)
#define LINF (long long int)(112345678901234567)
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
vector<ll> noB,noW,sumB,sumW;
//n^k
ll po(ll n, ll k){
if(k == 1){
return n;
}else if(k==0){
return 1;
}else if(k%2 == 0){
ll memo = po(n,k/2)%MOD;
return memo*memo%MOD;
}else{
return n * po(n,k-1)%MOD;
}
}
int main(void){
ll b,w;
cin>>b>>w;
noB.push_back(0);
noW.push_back(0);
sumB.push_back(0);
sumW.push_back(0);
reps(i,b+w){
if(i < b){
noB.push_back(0);
sumB.push_back(0);
}else if(i == b){
noB.push_back(1);
sumB.push_back(1);
}else{
noB.push_back(noB[i-1] * (i-1)%MOD * po(i-1-b+1,MOD-2)%MOD);
sumB.push_back((sumB[i-1]*2 + noB[i])%MOD);
}
if(i<w){
noW.push_back(0);
sumW.push_back(0);
}else if(i==w){
noW.push_back(1);
sumW.push_back(1);
}else{
noW.push_back(noW[i-1] * (i-1)%MOD * po(i-1-w+1,MOD-2)%MOD);
sumW.push_back((sumW[i-1]*2 + noW[i])%MOD);
}
}
vector<ll> ansB;
ansB.push_back(0);
reps(i,b+w){
ansB.push_back((-sumB[i-1]+sumW[i-1]+po(2,i-1)+MOD)%MOD);
ansB[i] = (ansB[i] * po(po(2,i)%MOD,MOD-2))%MOD;
cout<<ansB[i]<</*" "<<sumB[i]<<" "<<sumW[i]<<" "<<" "<<" "<<" "<<*/endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
multiset<int> s[maxn];
int n, w;
vector<pair<int, int> > ql[maxn], qr[maxn];
long long ans[maxn];
int main() {
cin >> n >> w;
for (int i = 1; i <= n; i++) {
s[i].insert(-0x3f3f3f3f);
int l;
scanf("%d", &l);
for (int j = 1; j <= l; j++) {
int t;
scanf("%d", &t);
ql[j].push_back(make_pair(i, t));
qr[w - l + j + 1].push_back(make_pair(i, t));
}
if (l < w) {
ql[l + 1].push_back(make_pair(i, 0));
ql[1].push_back(make_pair(i, 0));
qr[w - l + 1].push_back(make_pair(i, 0));
}
}
multiset<int>::iterator it, it1;
long long sum = 0;
for (int i = 1; i <= w; i++) {
for (auto j : qr[i]) {
it = s[j.first].lower_bound(j.second);
it1 = it;
it1++;
if (it1 == s[j.first].end()) {
it1--;
it1--;
if (it1 == s[j.first].begin())
sum -= j.second;
else
sum += *it1 - j.second;
}
s[j.first].erase(it);
}
for (auto j : ql[i]) {
s[j.first].insert(j.second);
it = s[j.first].lower_bound(j.second);
it1 = it;
it1++;
if (it1 == s[j.first].end()) {
it1 = it;
it1--;
if (it1 == s[j.first].begin())
sum += j.second;
else
sum += j.second - *it1;
}
}
ans[i] = sum;
}
for (int i = 1; i <= w; i++) printf("%lld ", ans[i]);
return 0;
}
| 11 | CPP |
#872#sily
for _ in range(int(input())):
n=int(input())
ss=[0]*26
flag=0
for i in range(n):
a=input()
for j in a:
ss[ord(j)-97]+=1
for i in ss:
if(i%n):
flag=1
break
if(flag):
print("NO")
else:
print("YES")
| 7 | PYTHON3 |
n, size, tasks = map(int, input().split())
friends = list(map(int, input().split()))
online = list()
for i in range(tasks):
type, id = map(int, input().split())
id -= 1
if type == 1:
adds = friends[id]
online = sorted(online + [adds], reverse=True)
if len(online) > size:
del online[-1]
else:
flag_oh_my_god_why = False
search = friends[id]
for bear in online:
if bear == search:
flag_oh_my_god_why = True
break
if flag_oh_my_god_why == False: print('NO')
else: print('YES') | 8 | PYTHON3 |
j=[int(i) for i in input().split(' ')]
leng=j[0]
summ=j[1]
if leng==1 and summ==0 :
print('0 0')
elif leng*9<summ or summ<=0:
print('-1 -1')
else :
mi=[]
ma=[]
for i in range(leng) :
mi.append(0)
ma.append(0)
i=0
while summ>9 :
mi[leng-1-i]=9
ma[i]=9
summ=summ-9
i+=1
# i+=1
# print(i)
if summ<=9 :
ma[i]=summ
if ma.count(0)>0 :
mi[leng-1-i]=summ-1
mi[0]=1
else :
mi[leng-1-i]=summ
#ma,mi=str(ma),str(mi)
#print(mi,ma)
mi="".join(str(x) for x in mi)
#print(mi)
ma="".join(str(x) for x in ma)
print(mi,ma) | 9 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.