solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MX = 2e5 + 1;
int pos[MX], n, log_n;
struct fen_tree {
ll ft[MX];
void upd(int a, ll val) {
for (; a <= n; a += a & -a) {
ft[a] += val;
}
}
ll qry(int a) {
ll res = 0;
for (; a; a -= a & -a) {
res += ft[a];
}
return res;
}
int kth(ll a) {
ll sum = 0;
int res = 0;
for (int i = log_n - 1; i >= 0; --i) {
int len = 1 << i;
if (res + len <= n && sum + ft[res + len] < a) {
res += len;
sum += ft[res];
}
}
return res + 1;
}
} ft_cnt, ft_pos;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
log_n = 32 - __builtin_clz(n);
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
pos[a] = i;
}
ll inv = 0;
ll offset = 0;
for (int i = 1; i <= n; ++i) {
ft_cnt.upd(pos[i], 1);
ft_pos.upd(pos[i], pos[i]);
inv += i - ft_cnt.qry(pos[i]);
int m = (i + 1) / 2;
int ndx = ft_cnt.kth(m);
ll move_cnt = ll(2 * m - i) * ndx + ft_pos.qry(n) - 2 * ft_pos.qry(ndx);
cout << inv + move_cnt - offset << ' ';
offset += (i + 1) / 2;
}
cout << '\n';
}
| 9 | CPP |
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
int N;
while(cin>>N,N){
int data,old[10]={0};
while(N--){
cin>>data;
data/=10;
if(data>5)data=6;
old[data]++;
}
for(int i=0;i<7;i++){
cout<<old[i]<<endl;
}
}
return 0;
} | 0 | CPP |
n=int(input())
a=input().split()
x=0
while x<len(a):
a[x]=int(a[x])
x=x+1
q=0
b=[]
while q<len(a) and 2<=n<=100:
b.append(a[q])
q=q+1
a.sort(reverse=True)
f=0
y=0
while f<len(b) and 2<=n<=100:
if int(a[0])==int(b[f]):
b=b[:f]+b[f+1:]
break
else:
f=f+1
y=y+1
g=-1
z=0
while g>=-len(b) and 2<=n<=100:
if int(a[-1])==int(b[g]):
break
else:
g=g-1
z=z+1
print(y+z)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int readInt() {
static int n, ch;
n = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) n = n * 10 + ch - '0', ch = getchar();
return n;
}
const int MAX_N = 500000;
int n, a[MAX_N];
inline int judge(int x) { return (x % 2 + 2) % 2; }
int main() {
n = readInt();
puts("YES");
for (int i = 0; i < n; ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", ((judge(a) << 1) + judge(b)) + 1);
}
return 0;
}
| 8 | CPP |
def main():
lista = []
line, lenght = input().split()
line = int(line)
lenght = int(lenght)
dicio: dict = {}
for i in range(line):
text = input()
dicio[text] = i+1
lista.append(text)
for i in range (lenght - 1, -1 , -1):
if (i + 1) % 2 != 0:
lista.sort(key=lambda x: x[i])
else:
lista.sort(key=lambda x: x[i], reverse=True)
for word in lista:
print(dicio[word], end=' ')
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int n;
int main() {
srand(time(0));
std::ios::sync_with_stdio(0);
cin >> n;
int l = 0, r = 1e9, cnt = 0, x;
while (l < r) {
int mid = (l + r) / 2;
cout << "> " << mid << endl;
cnt++;
cin >> x;
if (x)
l = mid + 1;
else
r = mid;
}
int d = 0;
cnt = 60 - cnt;
for (int i = 1; i <= cnt; i++) {
cout << "? " << (rand() % 100 * 10000 + rand() % 10000) % n + 1 << endl;
cin >> x;
d = gcd(d, l - x);
}
cout << "! " << l - d * (n - 1) << " " << d;
}
| 11 | CPP |
from collections import *
n = int(input())
a = list(input())
b = list(input())
ans = []
cb = dict()
cb['?'] = []
for i in range(n):
if(b[i] not in cb):
cb[b[i]] = [i]
else:
cb[b[i]].append(i)
for i in range(n):
if(a[i] == '?'):
continue
if(a[i] in cb and len(cb[a[i]]) != 0):
ans.append((i,cb[a[i]][-1]))
cb[a[i]].pop()
visa = [0 for i in range(n)]
visb = [0 for i in range(n)]
for i in ans:
visa[i[0]] = 1
visb[i[1]] = 1
ch = []
for i in range(n):
if(visa[i] == 0):
ch.append([a[i],i])
ch.sort()
for i in cb['?']:
ans.append((ch[-1][1],i))
visb[i] = 1
ch.pop()
chb = []
for i in range(n):
if(visb[i] == 0):
chb.append(i)
for i in ch:
if(i[0] != '?'):
break
ans.append((i[1],chb[-1]))
chb.pop()
print(len(ans))
for i in ans:
print(i[0]+1,i[1]+1)
| 10 | PYTHON3 |
from collections import Counter
guest_name = input()
host_name = input()
puzzled_names = input()
count_guest = Counter(guest_name)
count_host = Counter(host_name)
puzzled_names = Counter(puzzled_names)
combined = count_guest + count_host
if combined == puzzled_names:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e3 + 7;
const int Q = 1e9 + 7;
inline int pls(int x, int y) { return (x + y) % Q; }
inline int mns(int x, int y) { return pls(x, Q - y); }
inline int mul(int x, int y) { return 1LL * x * y % Q; }
int n, m;
char s[2][M], t[M];
int l[M][2][M], r[M][2][M];
bool bl[M][2][M], br[M][2][M];
struct Hsh {
static const int W = 131;
unsigned long long lf[M], rt[M], pw[M];
unsigned long long lfhsh(int x, int len) {
int y = x + len - 1;
return lf[y] - lf[x - 1] * pw[len];
}
unsigned long long rthsh(int len, int y) {
int x = y - len + 1;
return rt[x] - rt[y + 1] * pw[len];
}
void init(char *s, int n) {
int i;
for (pw[0] = 1, i = 1; i <= n; ++i) pw[i] = pw[i - 1] * W;
for (lf[0] = 0, i = 1; i <= n; ++i) lf[i] = lf[i - 1] * W + s[i] - 'a';
for (rt[n + 1] = 0, i = n; i > 0; --i) rt[i] = rt[i + 1] * W + s[i] - 'a';
}
} hs[2], ht;
void solve() {
int i, j, k;
for (i = n; i > 0; --i)
for (j = 0; j < 2; ++j)
for (k = 2; k <= m; k += 2)
br[i][j][k] = (i + k / 2 - 1 <= n &&
hs[j].lfhsh(i, k / 2) == ht.lfhsh(m - k + 1, k / 2) &&
hs[j ^ 1].rthsh(k / 2, i + k / 2 - 1) ==
ht.lfhsh(m - k / 2 + 1, k / 2));
for (i = 1; i <= n; ++i)
for (j = 0; j < 2; ++j)
for (k = 2; k <= m; k += 2)
bl[i][j][k] = (i - k / 2 + 1 >= 1 &&
hs[j].rthsh(k / 2, i) == ht.lfhsh(m - k + 1, k / 2) &&
hs[j ^ 1].lfhsh(i - k / 2 + 1, k / 2) ==
ht.lfhsh(m - k / 2 + 1, k / 2));
r[n + 1][0][0] = r[n + 1][1][0] = 1;
for (i = n; i > 0; --i)
for (j = 0; j < 2; ++j)
for (r[i][j][0] = 1, k = 1; k <= m; ++k) {
if (s[j][i] == t[m - k + 1])
r[i][j][k] = pls(r[i][j][k], r[i + 1][j][k - 1]);
if (k > 2 && s[j][i] == t[m - k + 1] && s[j ^ 1][i] == t[m - k + 2])
r[i][j][k] = pls(r[i][j][k], r[i + 1][j ^ 1][k - 2]);
if (br[i][j][k]) r[i][j][k] = pls(r[i][j][k], 1);
}
l[0][0][0] = l[0][1][0] = 1;
for (i = 1; i <= n; ++i)
for (j = 0; j < 2; ++j)
for (l[i][j][0] = 1, k = 1; k <= m; ++k) {
if (s[j][i] == t[m - k + 1])
l[i][j][k] = pls(l[i][j][k], l[i - 1][j][k - 1]);
if (k > 2 && s[j][i] == t[m - k + 1] && s[j ^ 1][i] == t[m - k + 2])
l[i][j][k] = pls(l[i][j][k], l[i - 1][j ^ 1][k - 2]);
if (bl[i][j][k]) l[i][j][k] = pls(l[i][j][k], 1);
}
for (i = n; i > 0; --i)
for (j = 0; j < 2; ++j)
for (k = 2; k <= m; k += 2)
br[i][j][k] = (i + k / 2 - 1 <= n &&
hs[j].lfhsh(i, k / 2) == ht.lfhsh(1, k / 2) &&
hs[j ^ 1].rthsh(k / 2, i + k / 2 - 1) ==
ht.lfhsh(k / 2 + 1, k / 2));
for (i = 1; i <= n; ++i)
for (j = 0; j < 2; ++j)
for (k = 2; k <= m; k += 2)
bl[i][j][k] = (i - k / 2 + 1 >= 1 &&
hs[j].rthsh(k / 2, i) == ht.lfhsh(1, k / 2) &&
hs[j ^ 1].lfhsh(i - k / 2 + 1, k / 2) ==
ht.lfhsh(k / 2 + 1, k / 2));
int ans = 0;
for (i = 1; i <= n; ++i)
for (j = 0; j < 2; ++j) {
if (s[j][i] == t[1]) {
ans = pls(ans, pls(l[i - 1][j][m - 1], r[i + 1][j][m - 1]));
if (m == 1) ans = mns(ans, 1);
}
for (k = 2; k <= m; k += 2) {
if (bl[i][j][k]) ans = pls(ans, r[i + 1][j ^ 1][m - k]);
if (br[i][j][k]) ans = pls(ans, l[i - 1][j ^ 1][m - k]);
}
if (m == 2 && bl[i][j][2]) ans = mns(ans, 1);
}
printf("%d\n", ans);
}
int main() {
int i;
scanf("%s", s[0] + 1);
scanf("%s", s[1] + 1);
scanf("%s", t + 1);
n = strlen(s[0] + 1);
m = strlen(t + 1);
hs[0].init(s[0], n);
hs[1].init(s[1], n);
ht.init(t, m);
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph;
int vis[3000];
int par[3000];
int k, b;
int level[3000];
void dfs1(int);
void bfs2(int);
vector<int> cyc;
int main() {
int n;
cin >> n;
graph.clear();
graph.resize(n);
memset(par, 0, sizeof par);
int x, y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
x--;
y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
memset(level, 0, sizeof level);
memset(vis, 0, sizeof vis);
dfs1(0);
swap(b, k);
cyc.push_back(k);
while (b != k) {
cyc.push_back(par[k]);
k = par[k];
}
memset(vis, 0, sizeof vis);
for (int i = 0; i < cyc.size(); i++) vis[cyc[i]] = 1;
for (int i = 0; i < cyc.size(); i++) bfs2(cyc[i]);
for (int i = 0; i < n; i++) cout << level[i] << " ";
}
void dfs1(int s) {
vis[s] = 1;
for (int i = 0; i < graph[s].size(); i++) {
int v = graph[s][i];
if (!vis[v]) {
par[v] = s;
dfs1(v);
} else if (par[s] != v) {
k = s;
b = v;
}
}
}
void bfs2(int sommet) {
queue<int> q;
q.push(sommet);
vis[sommet] = 1;
level[sommet] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (!vis[v]) {
q.push(v);
level[v] = 1 + level[u];
vis[v] = 1;
}
}
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-9;
const double pi = 4 * atan(1.0);
const int N = 1010;
const int M = 25;
const int MOD = int(1e9) + 7;
int sz;
char s[N];
int pv[N * M], pc[N * M], _link[N * M], q[N * M], len[N * M];
int _next[N * M][10], go[N * M][10];
int dp[N * M][M + 1][2], ndp[N * M][M + 1][2];
inline void build() {
scanf("%s", s);
int n = strlen(s);
sz = 1;
for (int i = 0; i < 10; ++i) {
_next[0][i] = -1;
}
for (int i = 0; i < n; ++i) {
int cur = 0;
for (int j = 0; j < M && i + j < n; ++j) {
if (_next[cur][s[i + j] - '0'] == -1) {
for (int z = 0; z < 10; ++z) {
_next[sz][z] = -1;
}
pv[sz] = cur;
pc[sz] = s[i + j] - '0';
len[sz] = len[cur] + 1;
_next[cur][s[i + j] - '0'] = sz++;
}
cur = _next[cur][s[i + j] - '0'];
}
}
int l = 0, r = 1;
q[0] = 0;
while (l < r) {
int v = q[l++];
if (v == 0 || pv[v] == 0) {
_link[v] = 0;
} else {
_link[v] = go[_link[pv[v]]][pc[v]];
}
for (int i = 0; i < 10; ++i) {
if (_next[v][i] != -1) {
go[v][i] = _next[v][i];
} else {
go[v][i] = go[_link[v]][i];
}
}
for (int i = 0; i < 10; ++i) {
if (_next[v][i] != -1) {
q[r++] = _next[v][i];
}
}
}
}
inline int calc() {
scanf("%s", s);
int n = strlen(s);
assert(n / 2 <= M);
for (int i = 0; i < sz; ++i) {
for (int j = 0; j <= n / 2; ++j) {
for (int z = 0; z < 2; ++z) {
dp[i][j][z] = 0;
}
}
}
dp[0][0][1] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < sz; ++j) {
for (int z = 0; z <= n / 2; ++z) {
for (int h = 0; h < 2; ++h) {
ndp[j][z][h] = 0;
}
}
}
for (int j = 0; j < sz; ++j) {
for (int z = 0; z <= n / 2; ++z) {
for (int h = 0; h < 2; ++h) {
if (dp[j][z][h] == 0) {
continue;
}
for (int c = (i == 0 ? 1 : 0); c <= (h ? s[i] - '0' : 9); ++c) {
int nj = go[j][c];
int nz = max(z, len[nj]);
if (nz > n / 2) {
nz = n / 2;
}
int nh = h;
if (h && c < s[i] - '0') {
nh = 0;
}
ndp[nj][nz][nh] += dp[j][z][h];
if (ndp[nj][nz][nh] >= MOD) {
ndp[nj][nz][nh] -= MOD;
}
}
}
}
}
for (int j = 0; j < sz; ++j) {
for (int z = 0; z <= n / 2; ++z) {
for (int h = 0; h < 2; ++h) {
dp[j][z][h] = ndp[j][z][h];
}
}
}
}
int ans = 0;
for (int i = 0; i < sz; ++i) {
ans = (ans + dp[i][n / 2][0]) % MOD;
ans = (ans + dp[i][n / 2][1]) % MOD;
}
return ans;
}
inline bool check() {
int n = strlen(s), cur = 0, max_len = 0;
for (int i = 0; i < n; ++i) {
cur = go[cur][s[i] - '0'];
max_len = max(max_len, len[cur]);
}
if (max_len >= n / 2) {
return true;
} else {
return false;
}
}
int main() {
if (0) cerr << (sizeof(dp) + sizeof(ndp)) / 1024 / 1024 << endl;
build();
int ans = (MOD - calc()) % MOD;
if (check()) {
ans = (ans + 1) % MOD;
}
ans = (ans + calc()) % MOD;
cout << ans << endl;
return 0;
}
| 12 | CPP |
n, k = map(int, input().split())
a = list(map(int, input().split()))
if k >= n - 1:
print(n)
else:
j = 0
cnt = 0
for i in range(1, n):
if a[i] < a[j]:
cnt += 1
if cnt == k:
print(a[j])
break
else:
j = i
cnt = 1
else:
print(n)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
int n;
int a[100007],par[100007],cur[100007],cnt[100007];
int u,v;
vector <int> edge[100007];
void dfs(int u){
int sum=0,ct=0,mx=0;
for(int i=0;i<(int)edge[u].size();i++){
int v=edge[u][i];
if(v==par[u]) continue;
par[v]=u;
dfs(v);
sum+=a[v];
mx=max(mx,a[v]);
ct++;
}
if(ct==1 && a[u]!=sum){
cout<<"NO";
exit(0);
}
else if(ct==1 && a[u]==sum){
a[u]=sum;
return;
}
else if(ct==0){
return;
}
else if(ct>1 && (sum<a[u] || a[u]*2LL<sum || (mx*2LL>sum && sum-mx<sum-a[u]))){
cout<<"NO";
exit(0);
}
else if(ct>1){
a[u]=sum-((sum-a[u])*2LL);
}
}
signed main(){
ios_base::sync_with_stdio(0);
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
for(int i=1;i<n;i++){
cin>>u>>v;
edge[u].pb(v);
edge[v].pb(u);
cnt[u]++;
cnt[v]++;
}
if(n==2){
if(a[1]==a[2]) cout<<"YES";
else cout<<"NO";
return 0;
}
for(int i=1;i<=n;i++){
if(cnt[i]==1){
par[i]=0;
dfs(i);
break;
}
}
cout<<"YES";
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, K;
string S;
int main() {
cin >> N >> K >> S;
vector<int> v;
v.push_back( 0 );
char c = '1';
for( int i = 0; i < S.size(); i++ ) {
if( S[i] != c ) {
v.push_back( i );
c = S[i];
}
}
v.push_back( S.size() );
int ans = 0;
for( int i = 0; i < v.size() - 1; i += 2 ) {
int l = i;
int r = min( i + 2 * K + 1, (int)v.size() - 1 );
int cnt = v[r] - v[l];
ans = max( ans, cnt );
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, x;
vector<int> v[1005], a[1005];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> x;
a[x].push_back(i);
v[i].resize(n + 1, 0);
}
int st = -1;
for (int i = n; i >= 1; --i) {
for (int k : a[i]) {
st++;
int cur = st;
for (int j = 1; j <= i; ++j) {
v[k][cur] = 1;
cur++;
cur %= (n + 1);
}
}
}
cout << n + 1 << "\n";
for (int i = 0; i < n + 1; ++i) {
for (int j = 1; j <= n; ++j) cout << v[j][i];
cout << "\n";
}
return 0;
}
| 13 | CPP |
import math
t=int(input())
for a in range(t):
x,y,n=map(int,input().split())
maximum=n//x * x
k=y+maximum
if k<=n or k==n:
print(k)
elif k>=n:
print(k-x)
| 7 | PYTHON3 |
n=int(input().strip())
l=list(map(int,input().strip().split()))
result=0
two=l.count(2)
one=l.count(1)
if(two>=one):
result+=one
else:
result+=two
one=one-two
result+=(one//3)
print(result)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char alphabets[27] = "abcdefghijklmnopqrstuvwxyz";
int main() {
std::set<string> unique;
string s;
cin >> s;
for (int i = 0; i < 26; ++i) {
string newstr = s + alphabets[i];
unique.insert(newstr);
for (int j = newstr.length() - 1; j > 0; --j) {
std::swap(newstr[j], newstr[j - 1]);
unique.insert(newstr);
}
}
cout << unique.size() << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1000000000;
int n, k, idx;
struct segment_tree {
int l, r, val;
} seg[5000005];
int rt[100005];
struct robot {
int x, r, q;
} arr[100005];
vector<int> v;
void add(int &id, int l, int r, int p) {
if (!id) id = ++idx;
seg[id].val++;
if (l == r) return;
int m = (l + r) >> 1;
if (p <= m)
add(seg[id].l, l, m, p);
else
add(seg[id].r, m + 1, r, p);
}
long long query(int id, int l, int r, int ql, int qr) {
if (!id) return 0;
if (ql <= l && qr >= r) return seg[id].val;
long long m = (l + r) >> 1, ans = 0;
if (ql <= m) ans += query(seg[id].l, l, m, ql, qr);
if (qr > m) ans += query(seg[id].r, m + 1, r, ql, qr);
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> arr[i].x >> arr[i].r >> arr[i].q;
v.push_back(arr[i].q);
}
sort((v).begin(), (v).end());
v.resize(unique((v).begin(), (v).end()) - v.begin());
sort(arr + 1, arr + 1 + n, [](robot &a, robot &b) { return a.r > b.r; });
long long ans = 0;
for (int i = 1; i <= n; i++) {
int idx = lower_bound((v).begin(), (v).end(), arr[i].q - k) - v.begin();
for (; idx < v.size() && v[idx] <= arr[i].q + k; idx++) {
ans += query(rt[idx], 0, mx, max(arr[i].x - arr[i].r, 0),
min(arr[i].x + arr[i].r, mx));
}
idx = lower_bound((v).begin(), (v).end(), arr[i].q) - v.begin();
add(rt[idx], 0, mx, arr[i].x);
}
cout << ans << '\n';
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char buf[100002];
string a;
string b;
vector<int> v[100002];
long long int dp1[100002];
long long int dp2[100002];
int main() {
scanf("%s", buf);
a = buf;
scanf("%s", buf);
b = buf;
for (int i = 0; i < a.size(); i++) {
v[a[i] - 'a'].push_back(i);
}
int cur = 0;
for (int i = 0; i < b.size(); i++) {
vector<int> &vv = v[b[i] - 'a'];
int id = lower_bound(vv.begin(), vv.end(), cur) - vv.begin();
if (id == vv.size()) {
for (int j = i; j < b.size(); j++) {
dp1[j] = INT_MAX;
}
break;
}
cur = vv[id];
dp1[i] = cur;
cur++;
}
cur = a.size() - 1;
for (int i = b.size() - 1; i >= 0; i--) {
vector<int> &vv = v[b[i] - 'a'];
int id = upper_bound(vv.begin(), vv.end(), cur) - vv.begin();
id--;
if (id >= 0) {
cur = vv[id];
dp2[i] = cur;
cur--;
} else {
for (int j = 0; j <= i; j++) {
dp2[j] = -1;
}
break;
}
}
int maxi = INT_MAX;
int lef;
int rig;
for (int i = 0; i < b.size(); i++) {
int id = dp1[i];
if (id == INT_MAX) {
continue;
}
int j = upper_bound(dp2, dp2 + b.size(), id) - dp2;
j = max(j, i + 1);
int er = j - i - 1;
if (maxi > er) {
maxi = er;
lef = i;
rig = j;
}
}
for (int i = 0; i < b.size(); i++) {
if (dp1[i] != INT_MAX) {
int len = i + 1;
if (maxi > b.size() - len) {
maxi = b.size() - len;
lef = i;
rig = b.size();
}
}
if (dp2[i] != -1) {
int len = b.size() - i;
if (maxi > b.size() - len) {
maxi = b.size() - len;
lef = -1;
rig = i;
}
}
}
if (maxi == INT_MAX) {
puts("-");
return 0;
}
printf("%s%s", b.substr(0, lef + 1).c_str(),
b.substr(rig, b.size() - rig).c_str());
puts("");
return 0;
}
| 9 | CPP |
import sys
s = input()
if s == s.upper():
print(s.lower())
sys.exit()
elif s[1:] == s[1:].upper():
print(s[0].upper() + s[1:].lower())
sys.exit()
print(s)
| 7 | PYTHON3 |
k, n, s, p = map(int, input().split())
one = (n + s - 1) // s
print((one * k + p - 1) // p)
| 7 | PYTHON3 |
n,m=(map(int,input().strip().split(' ')))
arr=list((map(int,input().strip().split(' '))))
dp=[arr[0]]
for i in range(1,n):
dp.append(dp[i-1]+arr[i])
brr=list((map(int,input().strip().split(' '))))
start = 0
for i in range(m):
x=brr[i]
for j in range(start,n):
if(dp[j]>=brr[i]):
if(j!=0):
print(j+1,x-dp[j-1])
else:
print(j+1,x)
start = j
break
| 9 | PYTHON3 |
from collections import Counter
for _ in range(int(input())):
n = int(input())
l = ""
for i in range(n):
l = l+input()
# initializing string
res = Counter(l)
f = 1
for i in res:
#print(i)
if res[i]%n != 0:
f = 0
break
if f == 0: print("NO")
else: print("YES")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, k;
scanf("%d%d", &n, &k);
printf("%d\n", k * (6 * (n - 1) + 5));
for (int i = 0; i < n; i++)
printf("%d %d %d %d\n", k * (6 * i + 1), k * (6 * i + 3), k * (6 * i + 4),
k * (6 * i + 5));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[110];
int ans[110];
bool use[110];
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) cin >> a[i];
int cur = 0;
for (int i = 0; i < k; i++) {
int lea = a[i] % (n - i);
for (int j = 0; j < lea; j++) {
if (++cur >= n) cur = 0;
while (use[cur]) {
if (++cur >= n) cur = 0;
}
}
ans[i] = cur + 1;
use[cur] = true;
if (i + 1 < n) {
while (use[cur]) {
if (++cur >= n) cur = 0;
}
}
cout << ans[i] << " ";
}
return 0;
}
| 8 | CPP |
#include <iostream>
#include <algorithm>
#define REP(i, a, n) for(int i = ((int) a); i < ((int) n); i++)
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pii;
int N;
pii A[1000];
int main(void) {
while(cin >> N, N) {
REP(i, 0, N) cin >> A[i].fi >> A[i].se;
sort(A, A + N);
int s1 = 0, s2 = 0;
REP(i, 0, N - 1) s1 += A[i].fi;
REP(i, 0, N) s2 += A[i].se;
if(s1 >= A[N - 1].fi) {
cout << A[N - 1].fi + s1 + s2 << endl;
} else {
int d = A[N - 1].fi - s1;
bool dp[N][d + 1];
REP(i, 0, N) REP(j, 0, d + 1) dp[i][j] = false;
dp[0][0] = true;
int m = 0;
REP(i, 0, N - 1) REP(j, 0, d + 1) if(dp[i][j]) {
dp[i + 1][j] = true;
if(j + A[i].se <= d) {
dp[i + 1][j + A[i].se] = true;
m = max(m, j + A[i].se);
}
}
cout << A[N - 1].fi * 2 + (s2 - m) << endl;
}
}
return 0;
} | 0 | CPP |
#include<iostream>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
using namespace std;
#define REP(i,a,n) for(int i = a ; i < n ; i++)
#define rep(i,n) REP(i,0,n)
typedef long long ll;
int n;
double dp[20][3][3];
int dx[] = {-1,1,0,0};
int dy[] = {0,0,1,-1};
int main(){
while(cin>>n,n){
char a,b,c;
cin>>a>>b>>c;
int sx = (a - 'A') % 3;
int sy = (a - 'A') / 3;
int gx = (b - 'A') % 3;
int gy = (b - 'A') / 3;
int tx = (c - 'A') % 3;
int ty = (c - 'A') / 3;
memset(dp,0,sizeof(dp));
dp[0][sx][sy] = 1;
rep(i,n){
rep(j,3){
rep(k,3){
if(dp[i][j][k] == 0) continue;
rep(d,4){
int nx = j + dx[d];
int ny = k + dy[d];
if(3>nx && nx>=0 && 3>ny && ny>=0 && (nx!=tx || ny!=ty)){
dp[i+1][nx][ny] += dp[i][j][k] / 4;
}
else{
dp[i+1][j][k] += dp[i][j][k] / 4;
}
}
}
}
}
printf("%.8f\n",dp[n][gx][gy]);
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, p, x, y, c1 = 0, c2 = 0, s1 = 0, s2 = 0;
int main() {
cin >> n;
while (n--) {
cin >> p >> x >> y;
if (p == 1) {
c1++;
s1 = s1 + x;
} else if (p == 2) {
c2++;
s2 = s2 + x;
}
}
if (s1 >= (c1 * 10) / 2)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (s2 >= (c2 * 10) / 2)
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
return 0;
}
| 7 | CPP |
#besme taala
#ya_hossein
from collections import Counter
for i in range(int(input())):
s = input()
states = Counter()
for j in range(len(s)):
states[s[j]] += 1
if states['R'] >= states['S'] and states['R'] >= states['P']:
print('P'*int(len(s)))
elif states['S'] >= states['P'] and states['S'] >= states['R']:
print('R'*int(len(s)))
else:
print('S' * int(len(s))) | 8 | PYTHON3 |
import sys
import math
input=sys.stdin.readline
t=int(input())
#t=1
for _ in range(t):
n=int(input())
#n,k=map(int,input().split())
dc={}
girl={}
for __ in range(n):
a=list(map(int,input().split()))
#print(a)
n1=len(a)
for i in range(1,n1):
if dc.get(a[i],0)==0:
girl[__]=1
dc[a[i]]=1
#print(123,a[i],dc,girl)
break
ind=-1
#print(girl,dc)
for k in range(n):
if girl.get(k,0)==0:
ind=k
break
#print(123,ind)
if ind!=-1:
for i in range(1,n+1):
if dc.get(i,0)==0:
print("IMPROVE")
print(ind+1,i)
break
else:
print("OPTIMAL") | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 100 * 10 + 10;
int x[maxN], y[maxN], z[maxN];
int main() {
string s;
cin >> s;
int n = (((int)s.size()));
for (int i = 1; i <= n; i++) {
x[i] = x[i - 1];
y[i] = y[i - 1];
z[i] = z[i - 1];
if (s[i - 1] == 'x')
x[i]++;
else if (s[i - 1] == 'y')
y[i]++;
else
z[i]++;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
int xx = x[r] - x[l - 1], yy = y[r] - y[l - 1], zz = z[r] - z[l - 1];
int minVal = min(xx, min(yy, zz));
int val1 = xx - minVal, val2 = yy - minVal, val3 = zz - minVal;
if (r - l + 1 >= 3 && (val1 > 1 || val2 > 1 || val3 > 1))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 10;
int n;
int g[N][N];
int ans;
void (*f)(int, int, int);
void read(int i, int j, int k) { scanf("%d", &g[i][j]); }
void floyd(int k, int i, int j) { g[i][j] = min(g[i][j], g[i][k] + g[k][j]); }
void maxs(int i, int j, int k) { i == j ? 0 : ans = max(ans, g[i][j]); }
void loop1(int i, int n, int j, int m, int k, int l);
int loop0(int i, int n, int j, int m, int k, int l) {
f(i, j, k);
loop1(i, n, j, m, k + 1, l);
return 0;
}
void loop1(int i, int n, int j, int m, int k, int l) {
k == l ? ++j, k = 0 : 0;
j == m ? ++i, j = 0 : 0;
i == n ? 0 : loop0(i, n, j, m, k, l);
}
int main() {
scanf("%d", &n);
f = &read;
loop1(0, n, 0, n, 0, 1);
f = &floyd;
loop1(0, n, 0, n, 0, n);
f = &maxs;
loop1(0, n, 0, n, 0, 1);
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 1e5 + 5;
int p[N], deg[N], ch[N][2];
bool con(int u, int v) { return ch[u][0] == v || ch[u][1] == v; }
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
ch[u][deg[u]++] = v;
ch[v][deg[v]++] = u;
}
iota(p + 1, p + n + 1, 1);
for (int t = 0; t < 10000; t++) {
shuffle(p + 1, p + n + 1, rng);
p[n + 1] = p[1];
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += !con(p[i], p[i + 1]);
if (cnt < m) continue;
cnt = 0;
for (int i = 1; i <= n && cnt < m; i++)
if (!con(p[i], p[i + 1])) {
cout << p[i] << ' ' << p[i + 1] << '\n';
cnt++;
}
return 0;
}
cout << "-1\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M, i, j, data[5005], dp[5005], final;
double x;
int main() {
scanf("%d %d", &N, &M);
for (i = 1; i <= N; ++i) {
scanf("%d %lf", &data[i], &x);
}
final = 1;
for (i = 1; i <= N; ++i) {
dp[i] = 1;
for (j = 1; j < i; ++j) {
if (data[j] <= data[i]) {
dp[i] = max(dp[i], dp[j] + 1);
}
final = max(final, dp[i]);
}
}
printf("%d\n", N - final);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i,n) for(int i=0;i<(int)n;++i)
//debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class S, class T> ostream& operator << (ostream& os, const pair<S, T> v){
os << "(" << v.first << ", " << v.second << ")"; return os;
}
template<class T> ostream& operator << (ostream& os, const vector<T> v){
for(int i = 0; i < v.size(); i++){if(i > 0){os << " ";} os << v[i];} return os;
}
template<class T> ostream& operator << (ostream& os, const vector<vector<T>> v){
for(int i = 0; i < v.size(); i++){if(i > 0){os << endl;} os << v[i];} return os;
}
const ll INFLL = (1ll << 60);
vector<ll> solve(const vector<ll> &X){
ll N = X.size();
vector<ll> A(N);
REP(i, N) A[i] = X[i];
stack<pll> st;
st.push({N-1, INFLL});
vector<ll> res(N+1, 0);
for(int i=N-2;i>=0;i--){
ll cnt = res[i+1];
if(A[i] <= A[i+1]){
ll tmp = A[i];
ll yoyu = 0;
while(1){
if(tmp*4 > A[i+1]) break;
tmp *= 4;
yoyu++;
}
if(yoyu > 0)st.push({i, yoyu});
}else{
ll tmp = A[i+1];
ll tarinai = 0;
while(1){
if(tmp >= A[i]) break;
tmp *= 4;
tarinai++;
}
while(tarinai > 0){
cnt += (st.top().first - i);
st.top().second--;
if(st.top().second == 0) st.pop();
tarinai--;
}
}
res[i] = cnt;
}
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> A(N), B(N);
REP(i, N) cin >> A[i];
REP(i, N) B[i] = A[N-i-1];
auto jun = solve(A);
auto gyaku = solve(B);
ll res = INFLL;
//cout << jun << endl;
//cout << gyaku << endl;
REP(i, N+1){
ll tmp = 2*jun[i] + 2*gyaku[N-i] + i;
res = min(res, tmp);
}
cout << res << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long t[444444];
int main() {
const int p = 998244353;
int n;
string x;
cin >> n >> x;
int y = 0;
for (int i = 1; i <= n + n; i++) {
if (i % 2 == 0)
y = (y * 2 + x[i / 2 - 1] - '0') % p;
if (n * 2 % i || n % i == 0)
continue;
int b = 1;
for (int j = 0; j < n; j++) {
int z = x[j % (i / 2)] ^ j / (i / 2) & 1;
if (x[j] != z) {
b = x[j] > z;
break;
}
}
t[i] = (y + b) % p;
}
for (int i = 1; i <= n + n; i++) {
if (n * 2 % i || n % i == 0)
continue;
for (int j = i * 3; j <= n + n; j += i + i)
if (n * 2 % j == 0)
(t[j] += p - t[i]) %= p;
}
long r = 0;
for (int i = 1; i <= n + n; i++) {
if (n * 2 % i || n % i == 0)
continue;
(r += t[i] * i) %= p;
}
cout << r << endl;
return 0;
}
| 0 | CPP |
n = int(input())
a = sorted(list(map(int, input().split())))
out = 0
for i in range(1, n - 1):
if a[0] < a[i] < a[-1]:
out += 1
print(out)
| 7 | PYTHON3 |
def R(): return map(int, input().split())
ans = []
n, q = R()
d = (n*n+1)//2
for _ in range(q):
x, y = R()
i = ((x-1)*n+y-1)//2+1
if (x+y) % 2 == 1:
i += d
ans.append(str(i))
print("\n". join(ans))
| 8 | PYTHON3 |
a,b=map(int,input().split());print([a+b,'error'][(a+b)//10]) | 0 | PYTHON3 |
for _ in range(int(input())):
n,m=map(int, input().split())
l=['B'*m for i in range(n)]
l[0]='W'+l[0][1:]
for i in range(n):
print(l[i]) | 7 | PYTHON3 |
I =lambda:int(input())
M =lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))
n,k=M()
s=input()
s=list(s)
l=len(s);b=0
if l==1 and k>=1:
print(0)
exit()
while b<n and k>0:
if b==0 and s[b]!="1":
k-=1;s[b]="1"
elif int(s[b])>0 and b!=0:
s[b]="0"
k-=1
b+=1
for i in s:
print(i,end="") | 8 | PYTHON3 |
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <numeric>
#include <iterator>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int,int> PII;
typedef vector<PII> VPII;
typedef stringstream SS;
template < typename T > inline T fromString( const string &s ){ T res; istringstream iss( s ); iss >> res; return res; };
template < typename T > inline string toString( const T &a ){ ostringstream oss; oss << a; return oss.str(); };
#define REP( i, m, n ) for ( int i = (int)( m ); i < (int)( n ); ++i )
#define FOR( v, c ) for ( auto &v : c )
#define EACH( it, c ) for ( auto it = c.begin(); it != c.end(); ++it )
#define ALL( c ) (c).begin(), (c).end()
#define DRANGE( c, p ) (c).begin(), (c).begin() + p, (c).end()
#define PB( n ) push_back( n )
#define MP( a, b ) make_pair( ( a ), ( b ) )
#define EXIST( c, e ) ( (c).find( e ) != (c).end() )
#define fst first
#define snd second
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
map<char,char> dir = {
{ 'T', 'a' },
{ 'L', 'i' },
{ 'U', 'u' },
{ 'R', 'e' },
{ 'D', 'o' }
};
constexpr char cons[] = "w\0kstnhmyr";
int main()
{
cin.tie( 0 );
for ( char n, d; cin >> n >> d; )
{
if ( n == '0' && d == 'U' )
{
cout << "nn";
}
else
{
if ( n != '1' )
{
cout << cons[ n - '0' ];
}
cout << dir[d];
}
}
cout << endl;
return 0;
} | 0 | CPP |
#gritty_learner code https://codeforces.com/contest/1237/submission/62713539
import math
def distance(a,b):
d=0.0
for i in range(3):
d+=(a[i]-b[i])**2
d = math.sqrt(d)
return d
t = int(input())
points=[]
visited = [0]*t
for z in range(t):
delta = [float(x) for x in input().split()]
points.append(delta)
# print(points)
for i in range(t):
if visited[i]==1:
continue
d = float('inf')
pair = -1
for j in range(i+1,t):
if visited[j]==1:
continue
delta = distance(points[i],points[j])
# print(delta)
if delta < d:
pair = j
d = delta
visited[i]=1
visited[pair]=1
print(i+1,pair+1)
# a=[3,1,0]
# b=[2,2,0]
# print(distance(a,b)) | 9 | PYTHON3 |
#!/usr/bin/python3
import sys
import itertools
def dfs(maze, startx, starty):
visited = set()
traversal = []
stack = [(startx, starty)]
while stack:
x, y = stack.pop()
visited.add((x,y))
traversal.append((x,y))
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
xx = x + dx
yy = y + dy
if (
0 <= xx < len(maze[0])
and 0 <= yy < len(maze)
and maze[yy][xx] == "."
and (xx, yy) not in visited
):
visited.add((xx, yy))
stack.append((xx, yy))
return traversal
lines = [l.strip() for l in sys.stdin.readlines()]
height, width, k = lines[0].split()
k = int(k)
maze = lines[1:]
#####
#maze = ["." * 500 for _ in range(500)]
#k = 249999
#####
avail = set()
for y in range(len(maze)):
for x in range(len(maze[y])):
if maze[y][x] == ".":
avail.add((x, y))
startx, starty = next(iter(avail))
traversal = dfs(maze, startx, starty)
for x, y in itertools.islice(reversed(traversal), k):
s = list(maze[y])
s[x] = 'X'
maze[y] = ''.join(s)
print("\n".join(maze)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t, n, k, i, ans, mx, avg, ans2;
cin >> t;
while (t--) {
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n - k; i++) {
avg = (a[i] + a[i + k]) / 2;
mx = max(avg - a[i], a[i + k] - avg);
if (i == 0) {
ans = mx;
ans2 = avg;
} else {
ans = min(ans, mx);
if (ans == mx) ans2 = avg;
}
}
cout << ans2 << endl;
}
}
| 9 | CPP |
n=int(input())
a=list(map(int,input().split()))
a.sort()
tempa=a[-1]-a[1]
tempb=a[-2]-a[0]
print(min(tempa,tempb))
| 8 | PYTHON3 |
n = int (input())
s = input()
se = set ()
for i in s:
se.add(i)
if len(se) == n & n != 1 :
print ("No")
else:
print ("Yes")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T>
class flow_graph {
public:
static constexpr T eps = (T)1e-9;
struct edge {
int from;
int to;
T c;
T f;
};
vector<vector<int>> g;
vector<edge> edges;
int n;
int st;
int fin;
T flow;
flow_graph(int _n, int _st, int _fin) : n(_n), st(_st), fin(_fin) {
assert(0 <= st && st < n && 0 <= fin && fin < n && st != fin);
g.resize(n);
flow = 0;
}
void clear_flow() {
for (const edge &e : edges) {
e.f = 0;
}
flow = 0;
}
int add(int from, int to, T forward_cap, T backward_cap) {
assert(0 <= from && from < n && 0 <= to && to < n);
int id = (int)edges.size();
g[from].push_back(id);
edges.push_back({from, to, forward_cap, 0});
g[to].push_back(id + 1);
edges.push_back({to, from, backward_cap, 0});
return id;
}
};
template <typename T>
class dinic {
public:
flow_graph<T> &g;
vector<int> ptr;
vector<int> d;
vector<int> q;
dinic(flow_graph<T> &_g) : g(_g) {
ptr.resize(g.n);
d.resize(g.n);
q.resize(g.n);
}
bool expath() {
fill(d.begin(), d.end(), -1);
q[0] = g.fin;
d[g.fin] = 0;
int beg = 0, end = 1;
while (beg < end) {
int i = q[beg++];
for (int id : g.g[i]) {
const auto &e = g.edges[id];
const auto &back = g.edges[id ^ 1];
if (back.c - back.f > g.eps && d[e.to] == -1) {
d[e.to] = d[i] + 1;
if (e.to == g.st) {
return true;
}
q[end++] = e.to;
}
}
}
return false;
}
T dfs(int v, T w) {
if (v == g.fin) {
return w;
}
int &j = ptr[v];
while (j >= 0) {
int id = g.g[v][j];
const auto &e = g.edges[id];
if (e.c - e.f > g.eps && d[e.to] == d[v] - 1) {
T t = dfs(e.to, min(e.c - e.f, w));
if (t > g.eps) {
g.edges[id].f += t;
g.edges[id ^ 1].f -= t;
return t;
}
}
j--;
}
return 0;
}
T max_flow() {
while (expath()) {
for (int i = 0; i < g.n; i++) {
ptr[i] = (int)g.g[i].size() - 1;
}
T big_add = 0;
while (true) {
T add = dfs(g.st, numeric_limits<T>::max());
if (add <= g.eps) {
break;
}
big_add += add;
}
if (big_add <= g.eps) {
break;
}
g.flow += big_add;
}
return g.flow;
}
vector<bool> min_cut() {
max_flow();
vector<bool> ret(g.n);
for (int i = 0; i < g.n; i++) {
ret[i] = (d[i] != -1);
}
return ret;
}
};
const int MAXC = 25;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k, q;
cin >> n >> m >> k >> q;
flow_graph<int> g(n, 0, n - 1);
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
--x;
--y;
g.add(x, y, z, 0);
}
dinic<int> d(g);
vector<vector<int>> backup(1 << k, vector<int>(2 * m));
vector<int> backup_flow(1 << k);
vector<int> without(1 << k, 0);
without.back() = d.max_flow();
for (int i = 0; i < 2 * m; i++) {
backup.back()[i] = g.edges[i].f;
}
backup_flow.back() = g.flow;
for (int t = (1 << k) - 2; t >= 0; t--) {
for (int id = 0; id < k; id++) {
if (!(t & (1 << id))) {
for (int i = 0; i < 2 * m; i++) {
g.edges[i].f = backup[t | (1 << id)][i];
}
for (int i = 0; i < k; i++) {
g.edges[2 * i].c = ((t & (1 << i)) ? 0 : MAXC);
}
g.flow = backup_flow[t | (1 << id)];
without[t] = d.max_flow();
for (int i = 0; i < 2 * m; i++) {
backup[t][i] = g.edges[i].f;
}
backup_flow[t] = g.flow;
break;
}
}
}
vector<int> cap(k);
vector<int> sum(1 << k);
while (q--) {
for (int i = 0; i < k; i++) {
cin >> cap[i];
}
sum[0] = 0;
for (int t = 1; t < (1 << k); t++) {
int bit = __builtin_ctz(t);
sum[t] = sum[t ^ (1 << bit)] + cap[bit];
}
int ans = 787788789;
for (int t = 0; t < (1 << k); t++) {
ans = min(ans, sum[t] + without[t]);
}
cout << ans << '\n';
}
return 0;
}
| 12 | CPP |
for _ in range(int(input())):
m, n = [int(i) for i in input().split()]
nums = [[int(i) for i in input().split()] for i in range(m)]
ans = 0
for i in range(m//2):
for j in range(n//2):
pairs = sorted([nums[i][j], nums[-(i+1)][j], nums[i][-(j+1)], nums[-(i+1)][-(j+1)]])
ans += pairs[-1] + pairs[-2] - pairs[0] - pairs[1]
if m%2 == 1:
for i in range(n//2):
ans += abs(nums[m//2][i] - nums[m//2][-(i+1)])
if n%2 == 1:
for i in range(m//2):
ans += abs(nums[i][n//2] - nums[-(i+1)][n//2])
print(ans)
| 8 | PYTHON3 |
for i in range(int(input())):
x,y,n = list(map(int, input().split()))
if((n - (n%x))+y <=n):
print((n - (n%x))+y)
else:
print((n - (n%x))-(x-y)) | 7 | PYTHON3 |
n = input()[::-1]
c0 = n.count('0')
c2 = n.count('2')
c5 = n.count('5')
c7 = n.count('7')
s = 1e9
if c0 > 1:
i = n.find('0')
j = n.find('0', i + 1)
s = min(s, i + j - 1)
if c2 and c5:
i = n.find('2')
j = n.find('5')
r = j + i - 1 + (j > i)
i, j = sorted([i, j])
m = n[:i] + n[i + 1: j] + n[j + 1:]
if not m:
s = min(s, r)
elif int(m) == 0:
pass
else:
d = -1
while m[d] == '0':
d -= 1
s = min(s, r - d - 1)
if c5 and c0:
i = n.find('5')
j = n.find('0')
s = min(s, j + i - 1 + (j > i))
if c7 and c5:
i = n.find('7')
j = n.find('5')
r = j + i - 1 + (j > i)
i, j = sorted([i, j])
m = n[:i] + n[i + 1: j] + n[j + 1:]
if not m:
s = min(s, r)
elif int(m) == 0:
pass
else:
d = -1
while m[d] == '0':
d -= 1
s = min(s, r - d - 1)
print(-1 if s == 1e9 else s)
| 11 | PYTHON3 |
#pragma optimization_level 3
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0); \
cout << fixed; \
cout << setprecision(10);
#define randomINIT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define ll long long
#define all(x) (x).begin(), (x).end()
#define rep for (ll i = 0; i < n; i++)
#define fori(a, b, c) for (ll i = a; i <= b; i = i + c)
#define pr(val) cout << val << endl
int main()
{
ll t;
cin >> t;
while (t--)
{
ll n;
cin >> n;
string a[n];
ll info[10][2], minfo[10][2]; //[digit][r] , [digit][c]
for (int i = 0; i < 10; i++)
for (int j = 0; j < 2; j++)
{
info[i][j] = -1;
minfo[i][j] = 3000;
}
rep cin >> a[i];
for (ll i = 0; i < n; i++)
{
for (ll j = 0; j < n; j++)
{
ll d = a[i][j] - '0';
info[d][0] = max(info[d][0], i);
info[d][1] = max(info[d][1], j);
minfo[d][0] = min(minfo[d][0], i);
minfo[d][1] = min(minfo[d][1], j);
}
}
ll cur_area = 0;
for (ll d = 0; d < 10; d++)
{
cur_area = 0;
for (ll i = 0; i < n; i++)
{
for (ll j = 0; j < n; j++)
{
if (a[i][j] == char(d + '0'))
{
ll tmp1 = max(j, n - j - 1) * max(i - minfo[d][0], info[d][0] - i);
ll tmp2 = max(i, n - i - 1) * max(j - minfo[d][1], info[d][1] - j);
cur_area = max({cur_area, tmp1, tmp2});
}
}
}
cout << cur_area << " ";
}
cout << '\n';
}
} | 9 | CPP |
for _ in range(int(input())):
x,y=map(int,input().split())
a,b=map(int,input().split())
ans=0
if 2*a<b:
ans=(x+y) * a
print(ans)
else:
ans = min(x, y)
p = max(x, y) - min(x, y)
ans *= b
ans += a * p
print(ans)
| 7 | PYTHON3 |
x = int(input())
if x%2 == 0:
print(str(x-4) + " " + str(4))
else:
print(str(x-9) + " " + str(9)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int v[200002], fv[200002], p, sol, minpoz[400005], n, d[200002], poz[200002], k;
vector<int> a[200002];
inline void rez1(int x) {
int i, s = 0;
for (i = 1; i <= n; i++) {
if (v[i] == p) s++;
if (v[i] == x) s--;
if (s == 0) sol = max(sol, i);
if (minpoz[s + n] != 0)
sol = max(sol, i - minpoz[s + n]);
else
minpoz[s + n] = i;
}
s = 0;
for (i = 1; i <= n; i++) {
if (v[i] == p) s++;
if (v[i] == x) s--;
minpoz[s + n] = 0;
}
}
inline void rez2(int x) {
int i, l, m = fv[x], t, tt, left, right, st, dr, j;
for (l = m; l >= 1; l--) {
for (i = 1; i <= m - l + 1; i++)
if (a[x][i + l] - a[x][i - 1] - 1 > sol) {
t = d[a[x][i + l - 1]] - d[a[x][i]];
tt = d[a[x][i + l]] - d[a[x][i - 1]];
left = a[x][i - 1] + 1;
right = a[x][i + l] - 1;
st = d[a[x][i]] + 1;
dr = d[a[x][i + l - 1]];
if (l >= t && l <= tt) {
t = l - t;
for (j = 0; j <= t; j++)
if (st - j >= 1 && dr + t - j <= k && poz[st - j] >= left &&
poz[dr + t - j] <= right)
sol = max(sol, min(right, poz[dr + t - j + 1] - 1) -
max(left, poz[st - j - 1] + 1) + 1);
}
}
}
}
int main() {
int i, maxim = 0, r;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> v[i];
fv[v[i]]++;
if (a[v[i]].empty()) a[v[i]].push_back(0);
a[v[i]].push_back(i);
if (fv[v[i]] > maxim)
maxim = fv[v[i]], p = v[i];
else if (fv[v[i]] == maxim)
p = 0;
}
for (i = 1; i <= n; i++)
if (a[v[i]][a[v[i]].size() - 1] != n + 1) a[v[i]].push_back(n + 1);
if (p == 0)
cout << n;
else {
for (i = 1; i <= n; i++) {
d[i] = d[i - 1];
if (v[i] == p) {
d[i]++;
poz[++k] = i;
}
}
d[n + 1] = d[n];
poz[k + 1] = n + 1;
r = sqrtl(n);
for (i = 1; i <= n; i++)
if (fv[i] > 0 && i != p) {
if (fv[i] >= r)
rez1(i);
else
rez2(i);
}
cout << sol;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int a[maxn], ans[maxn], res, n, cur;
char s[maxn][maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
cur = 0;
for (int j = 1; j <= n; j++)
if (a[j] == 0) {
cur = j;
break;
}
if (!cur) break;
ans[++res] = cur;
for (int j = 1; j <= n; j++)
if (s[cur][j] == '1') a[j]--;
}
printf("%d\n", res);
for (int i = 1; i <= res; i++) printf("%d ", ans[i]);
return 0;
}
| 8 | CPP |
a = list(map(int,input().split()))
print('Yay!' if all(x <= 8 for x in a) else ':(') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int bufSize = 1e6;
inline char nc() {
static char buf[bufSize], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, bufSize, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T>
inline T read(T &r) {
static char c;
static int flag;
flag = 1, r = 0;
for (c = nc(); !isdigit(c); c = nc())
if (c == '-') flag = -1;
for (; isdigit(c); c = nc()) r = r * 10 + c - 48;
return r *= flag;
}
const int maxn = 2e5 + 100;
int n, a[maxn], hb[maxn];
set<pair<int, int> > S;
int main() {
read(n);
for (int i = 1; i <= n; ++i) read(a[i]);
for (int i = 1; i <= n; ++i)
for (int j = 29; j >= 0; --j)
if (a[i] & (1 << j)) {
hb[i] = j;
break;
}
for (int l = 1; l <= n; ++l) {
int maxx = 1 << (hb[l] + 1);
long long now = a[l + 1];
for (int r = l + 2; r <= n; ++r) {
if (now >= maxx) break;
if ((a[l] ^ a[r]) == now) S.insert(make_pair(l, r));
now += a[r];
}
}
for (int r = n; r > 0; --r) {
int maxx = 1 << (hb[r] + 1);
long long now = a[r - 1];
for (int l = r - 2; l > 0; --l) {
if (now >= maxx) break;
if ((a[l] ^ a[r]) == now) S.insert(make_pair(l, r));
now += a[l];
}
}
printf("%d\n", S.size());
return 0;
}
| 11 | CPP |
def solve():
M = int(input())
if M < 4:
print(-1)
return
ans = list(range(M, 4, -2)) + [3,1,4,2] + list(range(M - 1, 4, -2))[::-1]
print(*ans)
for _ in range(int(input())):
solve()
| 13 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int NS = 100010;
struct Edge {
int to, next;
} edge[NS << 1];
int n, top, flag;
long long ans;
long long dp[NS];
int head[NS];
void add_edge(int u, int v) {
edge[top].to = v;
edge[top].next = head[u];
head[u] = top++;
edge[top].to = u;
edge[top].next = head[v];
head[v] = top++;
}
long long gcd(long long ta, long long tb) {
return tb == 0 ? ta : gcd(tb, ta % tb);
}
long long lcm(long long ta, long long tb) { return ta / gcd(ta, tb) * tb; }
long long dfs(int rt, int fa) {
if (flag) return 1;
long long g = 1;
long long cson = 0, sum = (1LL << 60);
for (int i = head[rt]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (to != fa) {
long long t = dfs(to, rt);
if (flag) return 1;
dp[rt] += dp[to];
sum = min(sum, dp[to]);
cson++;
g = lcm(g, t);
}
}
if (cson == 0) return 1;
sum *= cson;
g *= cson;
sum -= sum % g;
long long t = dp[rt] - sum;
ans += t, dp[rt] -= t;
if (dp[rt] <= 0) flag = 1;
return g;
}
int main() {
while (~scanf("%d", &n)) {
long long res = 0;
ans = top = flag = 0;
memset(head, -1, sizeof(head));
for (int i = 1; i <= n; i++) scanf("%I64d", &dp[i]), res += dp[i];
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
add_edge(u, v);
}
dfs(1, -1);
if (flag) {
ans = res;
}
printf("%I64d\n", ans);
}
return 0;
}
| 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
int n,p,t;
deque<int> q;
int main()
{
scanf("%d",&n);
p = 1;
if(n&1) p ^= 1;
for(int i=1;i<=n;i++)
{
scanf("%d",&t);
if(p&1) q.push_back(t);
else q.push_front(t);
p ^= 1;
}
while(!q.empty())
{
printf("%d ",q.front());
q.pop_front();
}
return 0;
}
| 0 | CPP |
def luk(n):
n = str(n)
return (n.count('4')+n.count('7')) == len(n)
n = int(input())
for i in range(1,n+1):
if n%i == 0:
if luk(i): print('YES'); exit()
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
map<string, int> mp;
vector<string> ans(n);
for (int i = 0; i < ans.size(); i++) ans[i] = "999999999999";
for (int i = 0; i < n; i++) {
for (int l = 0; l < v[i].size(); l++) {
string vr = "";
for (int r = l; r < v[i].size(); r++) {
vr.push_back(v[i][r]);
if (mp.find(vr) != mp.end() && mp[vr] != i)
mp[vr] = -1;
else
mp[vr] = i;
}
}
}
for (auto now : mp) {
if (now.second != -1) {
if (ans[now.second].size() > now.first.size())
ans[now.second] = now.first;
}
}
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> p[1000001];
long long pC = 0;
long long n, m;
char arr[1001][1001];
long long dp[1001][1001];
long long func(long long a, long long b, long long c, long long d) {
return dp[c][d] - dp[c][b - 1] - dp[a - 1][d] + dp[a - 1][b - 1];
}
void func() {
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= m; j++) {
dp[i][j] = 0LL;
if (i != 0 && j != 0) {
if (arr[i][j] == 'B') {
dp[i][j] = 1LL;
p[pC].first = i;
p[pC++].second = j;
}
}
dp[i][j] = dp[i][j] + dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - 1];
}
}
}
bool singleLine(long long a, long long b, long long c, long long d) {
if (a == c) {
if (b > d) {
swap(b, d);
}
if (func(a, b, c, d) != d - b + 1) {
return false;
}
return true;
} else if (b == d) {
if (a > c) {
swap(c, a);
}
if (func(a, b, c, d) != c - a + 1) {
return false;
}
return true;
}
return false;
}
bool checkOut(long long a, long long b, long long c, long long d, long long e,
long long f) {
if (singleLine(a, b, e, f) && singleLine(c, d, e, f)) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> arr[i][j];
}
}
func();
for (long long i = 0; i < pC; i++) {
for (long long j = i + 1; j < pC; j++) {
long long a = p[i].first, b = p[i].second;
long long c = p[j].first, d = p[j].second;
if (a == c || b == d) {
if (!singleLine(a, b, c, d)) {
cout << "NO\n";
return 0;
}
} else {
long long e = a, f = d, g = c, h = b;
if (checkOut(a, b, c, d, e, f) == false &&
checkOut(a, b, c, d, g, h) == false) {
cout << "NO\n";
return 0;
}
}
}
}
cout << "YES\n";
}
| 8 | CPP |
def main():
q1 = a = q2 = 0
for s in input():
if s == 'Q':
q1 += 1
q2 += a
elif s == 'A':
a += q1
return q2
print(main())
# from testing import do_tests
# do_tests(3, main)
| 7 | PYTHON3 |
for _ in range(int(input())):
n, k = map(int, input().split())
if k % (n-1):
print(k//(n-1)*n+k % (n-1))
else:
print(k//(n-1)*n-1)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<int> st;
int main() {
cin >> n;
int p, x;
for (int i = 1; i <= 2; ++i) {
cin >> p;
for (int j = 1; j <= p; ++j) cin >> x, st.insert(x);
}
cout << ((st.size() == n) ? "I become the guy." : "Oh, my keyboard!");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e9;
const double eps = 1e-5;
using pdi = pair<double, pair<int, int>>;
using tp4 = tuple<double, int, int, int>;
int N, M;
struct edge
{
int to;
double cost;
int lim;
edge(int t, double d, int l) : to(t), cost(d), lim(l) {}
};
// dist,v,pv,velocity
void dijkstra(int s, vector<vector<vector<double>>> &dist, vector<vector<edge>> &G)
{
priority_queue<tp4, vector<tp4>, greater<tp4>> que;
for (auto e : G[s])
{
int ns = e.to;
que.push(make_tuple(e.cost, ns, s, 1));
dist[ns][s][1] = e.cost;
}
while (!que.empty())
{
auto p = que.top();
que.pop();
double d = get<0>(p);
int v = get<1>(p);
int par = get<2>(p);
int velo = get<3>(p);
if (dist[v][par][velo] - d < -eps)
continue;
for (edge e : G[v])
{
if (e.to == par)
continue;
for (int nvelo = max(velo - 1, 1); nvelo <= min(velo + 1, e.lim); nvelo++)
{
if (dist[e.to][v][nvelo] - dist[v][par][velo] - e.cost / (double)nvelo > eps)
{
dist[e.to][v][nvelo] = dist[v][par][velo] + e.cost / (double)nvelo;
que.push(make_tuple(dist[e.to][v][nvelo], e.to, v, nvelo));
}
}
}
}
}
int main()
{
while (cin >> N >> M, N | M)
{
int s, g;
cin >> s >> g;
s--, g--;
vector<vector<edge>> G(N);
for (int i = 0; i < M; i++)
{
int a, b, c, d;
cin >> a >> b >> c >> d;
a--, b--;
G[a].push_back(edge(b, c, d));
G[b].push_back(edge(a, c, d));
}
double res = INF;
vector<vector<vector<double>>> dist(N, vector<vector<double>>(N, vector<double>(31, INF)));
dijkstra(s, dist, G);
for (int v = 0; v < N; v++)
{
res = min(res, dist[g][v][1]);
}
if (abs(res - INF) < eps)
{
cout << "unreachable" << endl;
}
else
{
cout << fixed << setprecision(10) << res << endl;
}
// s+N -> g+N
}
}
| 0 | CPP |
t = int(input())
for i in range(t):
[n,k] = [int(x) for x in input().split()]
x = n-(k-1)
y = n-2*(k-1)
if x%2 != 0 and x > 0:
print('YES')
print('1 '*(k-1)+str(x))
elif y%2 == 0 and y > 0:
print('YES')
print('2 '*(k-1)+str(y))
else: print('NO')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, K, x, y, s[N], f[N];
vector<int> v[N];
int main() {
scanf("%d%d", &n, &K);
for (int i = 0; i < (K); ++i)
scanf("%d%d", &x, &y), v[y + n - x].push_back(n - x + 1);
int L = 0;
while (L <= n && L * (L + 1) / 2 + 2 <= 3 * K) ++L;
for (int i = 1; i < (n + 1); ++i) {
for (int j = 0; j < (L + 1); ++j) s[j] = 0;
for (auto e : v[i]) s[min(L, e)]++;
for (int j = (L)-1; j >= (0); --j) s[j] += s[j + 1];
int Min = f[0] + s[0] * 3;
for (int j = (min(L, i + 1)) - 1; j >= (1); --j) {
f[j] = min(Min, f[j - 1] + s[j + 1] * 3);
Min = min(Min, f[j - 1] + s[j + 1] * 3 + j * (j + 1) / 2 + 2);
}
f[0] = Min;
}
printf("%d\n", f[0]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int p = 1, X, Y, z = 1 << 30, q, r;
char s[25], t[25], b[25];
map<int, int> wte;
map<string, int> m;
struct odp {
int p, g, l, c;
string s;
bool operator<(const odp &T) const {
return p != T.p ? p > T.p
: (g - l != T.g - T.l ? g - l > T.g - T.l
: (g != T.g ? g > T.g : s < T.s));
}
} c[5], d[5];
int main() {
for (int i = (0); i < (5); i++) {
int a, b;
scanf("%s %s %d:%d", s, t, &a, &b);
string S(s), T(t);
if (!m[S]) {
c[p].s = S;
m[S] = p++;
}
if (!m[T]) {
c[p].s = T;
m[T] = p++;
}
c[m[S]].c++;
c[m[T]].c++;
c[m[S]].g += a;
c[m[T]].l += a;
c[m[T]].g += b;
c[m[S]].l += b;
if (a > b) {
c[m[S]].p += 3;
} else if (a == b) {
c[m[S]].p++;
c[m[T]].p++;
} else {
c[m[T]].p += 3;
}
}
string x = "BERLAND";
q = m[x];
for (int i = (1); i < (5); i++)
if (c[i].s != x && c[i].c == 2) r = i;
for (int i = (0); i < (81); i++)
for (int j = (0); j < (i); j++) {
for (int k = (1); k < (5); k++) d[k] = c[k];
d[q].p += 3;
d[q].g += i;
d[q].l += j;
d[r].g += j;
d[r].l += i;
sort(d + 1, d + 5);
bool fg = 0;
for (int i = (1); i < (3); i++)
if (d[i].s == x) fg = 1;
if (fg) {
if (i - j < z || i - j == z && j < Y) X = i, Y = j, z = X - Y;
}
}
if (z < 1 << 30)
printf("%d:%d\n", X, Y);
else
puts("IMPOSSIBLE");
scanf("\n");
}
| 9 | CPP |
def long_numbers(s, t):
m = max(len(s), len(t))
for i in range(m):
sn = '0'
if len(s) - m + i >= 0:
sn = s[len(s) - m + i]
tn = '0'
if len(t) - m + i >= 0:
tn = t[len(t) - m + i]
if sn < tn:
return '<'
if sn > tn:
return ">"
return "="
s1 = input()
s2 = input()
print(long_numbers(s1, s2))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
unsigned int a[2001][64], t;
int n, d[2001], T, m, x, y;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 64; j++) a[i][j] = 0;
d[i] = 0;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
a[x][y >> 5] ^= (1ll << (y & 31));
a[y][x >> 5] ^= (1ll << (x & 31));
d[x]++;
d[y]++;
}
bool bo = 1;
for (int i = 1; i <= n; i++)
if (d[i] & 1) {
bo = 0;
break;
}
if (bo) {
puts("1");
for (int i = 1; i <= n; i++) printf("1 ");
puts("");
continue;
}
for (int i = 1; i <= n; i++)
if (d[i] & 1) a[i][i >> 5] ^= (1ll << (i & 31)), a[i][0] ^= 1;
for (int i = 1; i <= n; i++) {
if (!((a[i][i >> 5] >> (i & 31)) & 1)) {
for (int j = i + 1; j <= n; j++)
if ((a[j][i >> 5] >> (i & 31)) & 1) {
for (int k = 0; k < 64; k++)
t = a[i][k], a[i][k] = a[j][k], a[j][k] = t;
break;
}
}
for (int j = 1; j <= n; j++)
if (i != j && ((a[j][i >> 5] >> (i & 31)) & 1))
for (int k = 0; k < 64; k++) a[j][k] ^= a[i][k];
}
puts("2");
for (int i = 1; i <= n; i++) printf("%d ", (a[i][0] & 1) + 1);
puts("");
}
return 0;
}
| 19 | CPP |
k, n, w = map(int, input().split())
sum = 0
for i in range(1, w + 1):
sum += i * k
print(sum - n if n < sum else 0)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int v, v1, v2, v3, ans1, ans2, ans3;
int main() {
scanf("%d%d%d%d", &v1, &v2, &v3, &v);
ans1 = 2 * v1;
ans2 = 2 * v2;
if (v3 >= v) {
if (v3 <= 2 * v) {
ans3 = v3;
if (v * 2 >= ans2)
printf("-1");
else
printf("%d\n%d\n%d\n", ans1, ans2, ans3);
} else
printf("-1");
} else {
if (v <= 2 * v3) {
ans3 = v;
if (v * 2 >= ans2)
printf("-1");
else
printf("%d\n%d\n%d\n", ans1, ans2, ans3);
} else
printf("-1");
}
}
| 7 | CPP |
r, c = map(int, input().split())
for i in range(r):
if i % 2 == 0:
print(c * "#")
elif i % 4 == 3:
print( "#" + (c - 1) * "." )
else:
print((c - 1) * "." + "#") | 7 | PYTHON3 |
def solve():
n = int(input())
a = sorted([int(i) for i in input().split()])
mx = max(a)
smx = 0
for i in a:
if i == mx - 1:
smx += 1
out = 1
sub = 1
mod = 998244353
for i in range(1, n + 1):
out = (out * i) % mod
if (smx + 1) != i:
sub = (sub * i) % mod
if a.count(max(a)) > 1:
return out
else:
return (out - sub + mod) % mod
for _ in range(int(input())):
print(solve()) | 9 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
steps=-a[0]
a[0]=0
for i in range(1,n):
if i%2==1:
a[i]=(a[i]-steps)%n
if i%2==0:
a[i]=a[i]+steps
if a[i]<0:
a[i]=n+a[i]
if a==list(range(n)):
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
vector<int> adj[MAX];
int a[MAX], b[MAX];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = int(0); i < int(m); i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", a + i);
}
queue<int> q;
for (int i = int(1); i < int(n + 1); i++) {
if (a[i] == b[i]) {
q.push(i);
}
}
vector<int> ans;
while (!q.empty()) {
int cur = q.front();
q.pop();
ans.push_back(cur);
b[cur]++;
for (auto &each : adj[cur]) {
b[each]++;
if (b[each] == a[each]) {
q.push(each);
}
}
}
printf("%d\n", (int)ans.size());
for (auto &each : ans) {
printf("%d ", each);
}
printf("\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int INF = 0x7fffffff;
const int maxn = 100000010;
const long long mod = 2147493647;
const double eps = 1e-4;
const double PI = 3.1415926535898;
using namespace std;
int a[1010];
bool cmp(int a, int b) { return a > b; }
int main(void) {
int n;
while (~scanf("%d", &n)) {
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n, cmp);
int flag = 0;
double sum = 0;
for (int i = 0; i < n; i += 2) {
sum += PI * a[i] * a[i] - PI * a[i + 1] * a[i + 1];
}
printf("%.10lf\n", sum);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
long long tre(long long x) { return x * (x + 1) >> 1; }
long long count(int a, int ab, int ac, int b, int c, int t) {
int x = ab - b + 1, y = ac - c + 1;
if (x <= 0 || y <= 0) return 0;
if (a + b + c > t) return 0;
long long ans = (long long)x * y;
if (a + ab + ac > t) {
int s = a + ab + ac - t;
ans -= tre(s);
if (x < s) ans += tre(s - x);
if (y < s) ans += tre(s - y);
}
if (b + c <= a) ans -= tre(a - b - c + 1);
return ans;
}
int main() {
int a, b, c, d, t, s;
long long ans = 0;
scanf("%d%d%d%d", &a, &b, &c, &t);
t += a + b + c;
for (int i = a; i * 2 < t; ++i) {
ans += count(i, i, i, b, c, t);
}
for (int i = b; i * 2 < t; ++i) {
ans += count(i, i - 1, i, a, c, t);
}
for (int i = c; i * 2 < t; ++i) {
ans += count(i, i - 1, i - 1, a, b, t);
}
printf("%I64d\n", ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
bool can(long long x) {
long long both = x / 6;
long long two = x / 2;
long long three = x / 3;
two -= both;
three -= both;
long long need_2 = max(a - two, 0LL);
long long need_3 = max(b - three, 0LL);
if (both >= need_2 + need_3) return true;
return false;
}
int main() {
cin >> a >> b;
long long low = 0;
long long high = 1e18;
while (high - low > 1) {
long long mid = (low + high) / 2;
if (can(mid))
high = mid;
else
low = mid;
}
cout << high;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
char array[n][m];
int a = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a == 0) {
array[i][j] = 'B';
} else {
array[i][j] = 'W';
}
a = 1 - a;
}
}
if ((n * m) % 2 == 0) {
array[0][1] = 'B';
array[1][0] = 'B';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << array[i][j];
}
cout << "\n";
}
}
return 0;
}
| 7 | CPP |
t = int(input())
for test in range(t):
n = int(input())
a = [int(x)for x in input().split()]
b = [int(x)for x in input().split()]
pos = -2
neg = -2
if a[0]>0:
pos=1
elif a[0]<0:
neg=1
av = []
for i in range(1,n):
av.append((pos,neg))
if a[i]>0:
pos=1
elif a[i]<0:
neg=1
if a[0]!=b[0]:
print("NO")
continue
f=0
for i in range(1,n):
x = av[i-1]
pos,neg=x[0],x[1]
if b[i]==a[i]:
continue
elif b[i]>a[i]:
if pos==1:
continue
else:
f=1
break
elif b[i]<a[i]:
if neg==1:
continue
else:
f=1
break
if f==1:
print("NO")
else:
print("YES")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, i, j, k, x, y, s, ct;
cin >> n;
vector<pair<int, int>> a(n);
for (i = 0; i < n; i++) {
cin >> x >> y;
a[i] = {y, x};
}
sort(a.rbegin(), a.rend());
ct = 1;
s = 0;
for (i = 0; (i < n) && (ct > 0); i++) {
ct--;
ct += a[i].first;
s += a[i].second;
}
cout << s << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 109;
const int maxm = 10009;
int n, m, head[maxn], tot;
struct pp {
int nxt, to;
} g[maxm];
void add(int u, int v) { g[++tot].nxt = head[u], g[tot].to = v, head[u] = tot; }
queue<int> q;
long long f[maxn], h[maxn];
int dis1[maxn], vis[maxn], dis2[maxn];
void bfs1(int x) {
while (!q.empty()) q.pop();
memset(dis1, -1, sizeof(dis1));
memset(f, 0, sizeof(f));
memset(vis, 0, sizeof(vis));
q.push(x);
vis[x] = 1, dis1[x] = 0, f[x] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = g[i].nxt) {
int v = g[i].to;
if (dis1[v] == -1 || dis1[v] == dis1[u] + 1) {
dis1[v] = dis1[u] + 1, f[v] += f[u];
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
}
void bfs2(int x) {
while (!q.empty()) q.pop();
memset(dis2, -1, sizeof(dis2));
memset(h, 0, sizeof(h));
memset(vis, 0, sizeof(vis));
q.push(x);
vis[x] = 1, dis2[x] = 0, h[x] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = g[i].nxt) {
int v = g[i].to;
if (dis2[v] == -1 || dis2[v] == dis2[u] + 1) {
dis2[v] = dis2[u] + 1, h[v] += h[u];
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
}
int main() {
memset(f, 0, sizeof(f));
memset(head, -1, sizeof(head));
tot = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
bfs1(1);
bfs2(n);
long long sum = f[n];
long long ans = 0;
for (int i = 1; i <= n; i++)
if (dis1[i] + dis2[i] == dis1[n])
if (i == 1 || i == n)
ans = max(ans, f[i] * h[i]);
else
ans = max(ans, f[i] * h[i] * 2);
double las = double(ans) / double(sum);
printf("%.13lf", las);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0);
const long long N = 1e9 + 5;
long long i, j, x, y, z, t;
int main() {
char c[4];
cin >> c[1] >> x;
cin >> c[2] >> y;
z = c[1] + 1 - 'a';
t = c[2] + 1 - 'a';
long long ar[9][9] = {0};
for (i = 1; i < 9; i++) {
ar[z][i] = 1;
}
for (i = 1; i < 9; i++) {
ar[i][x] = 1;
}
ar[t][y] = 1;
for (int i = 1; i <= 8; i++) {
for (int j = 1; j <= 8; j++) {
if ((abs(i - t) == 2 && abs(j - y) == 1) ||
(abs(i - t) == 1 && abs(j - y) == 2)) {
ar[i][j] = 1;
}
if ((abs(i - z) == 2 && abs(j - x) == 1) ||
(abs(i - z) == 1 && abs(j - x) == 2)) {
ar[i][j] = 1;
}
}
}
long long ans = 0;
for (int i = 1; i <= 8; i++) {
for (int j = 1; j <= 8; j++)
if (ar[i][j] == 0) {
ans++;
}
}
cout << ans;
}
| 8 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 1 21:05:31 2019
@author: Quaint Sun
"""
import copy
n=int(input())
a=list(map(int,input().split()))
b=copy.deepcopy(a)
b.sort()
if a==b:
print('yes')
print(1,1)
else:
x=0
y=0
for i in range(1,n):
if a[i-1]>a[i]:
x=i
break
for j in range(x,n):
if a[j-1]<a[j]:
y=j
break
if y==0:
y=n
new=a[x-1:y]
new.sort()
a[x-1:y]=new
if a==b:
print('yes')
print(x,y)
else:
print('no') | 8 | PYTHON3 |
#include<set>
#include<cstdio>
#include<cctype>
#include<string>
inline int Read(){
char a;
int b;
while(!isdigit(a=getchar()));
b=a^'0';
while(isdigit(a=getchar()))b=(((b<<2)+b)<<1)+(a^'0');
return b;
}
int main()
{
std::multiset<std::string> set;
for(int i=Read();i;i--)set.insert("a");
for(int i=Read();i;i--)set.insert("b");
for(int i=Read();i;i--)set.insert("c");
while(set.size()>1){
std::string s=*set.begin(),t=*set.rbegin();
set.erase(set.lower_bound(s));
set.erase(set.lower_bound(t));
set.insert(s+t);
}
printf("%s\n",(*set.begin()).c_str());
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1LL << 60;
map<pair<pair<long long, long long>, long long>, long long> dyn;
long long bestway[45][45];
long long n, m;
vector<long long> pricea, priceb;
map<int, vector<vector<long long> > > mem;
void init(int key) {
if (mem.count(key)) return;
mem[key] = vector<vector<long long> >(45);
for (int i = 0; i < 45; i++) mem[key][i].resize(45, -1);
}
long long best(long long count, long long res, long long mn) {
if (res > n) return MAX;
assert(res >= mn);
if (count == 0 && res != 0) return 0;
if (count == 1) {
return bestway[res + 20][mn + 20];
}
init(count);
if (mem[count][res + 20][mn + 20] >= 0) return mem[count][res + 20][mn + 20];
long long left = count / 2;
long long right = count - left;
long long choice = MAX;
for (long long i = mn; i <= n; i++) {
long long j = res - i;
if (j < -n) continue;
long long cand = best(left, i, mn);
int mn2 = mn - i;
if (mn2 < -n) mn2 = -n;
cand += best(right, j, mn2);
choice = min(choice, cand);
}
return mem[count][res + 20][mn + 20] = choice;
}
long long cost = 0, score = 0;
void rec(long long id, long long lowest) {
if (id == n) {
bestway[score + 20][lowest + 20] =
min(bestway[score + 20][lowest + 20], cost);
} else {
cost += pricea[id];
score += 1;
rec(id + 1, lowest);
cost -= pricea[id];
score -= 1;
if (score > lowest) {
cost += priceb[id];
score -= 1;
rec(id + 1, lowest);
score += 1;
cost -= priceb[id];
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < 45; i++)
for (int j = 0; j < 45; j++) bestway[i][j] = MAX;
pricea.resize(n);
priceb.resize(n);
for (long long i = 0; i < n; i++) cin >> pricea[i];
for (long long i = 0; i < n; i++) cin >> priceb[i];
for (int i = -n; i <= 0; i++) rec(0, i);
cout << best(m, 0, 0) << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
int n, size, sol, A[101], obidjen[101];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]);
std::sort(A + 1, A + n + 1);
for (int i = 1; i <= n; ++i)
if (!obidjen[i]) {
size = 1;
++sol;
obidjen[i] = 1;
for (int j = i + 1; j <= n; ++j)
if ((A[j] >= size) && (!obidjen[j])) {
obidjen[j] = 1;
++size;
}
}
printf("%d", sol);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long inv[100005];
long long invFact[100005];
long long fact[100005];
long long numPart(int n, int f) {
n = n - f;
if (n < 0) return 0;
long long ret = fact[n + f - 1] * invFact[n] % 1000000007;
ret = ret * invFact[f - 1] % 1000000007;
return ret;
}
int main() {
int t;
cin >> t;
inv[1] = 1;
for (int i = 2; i < 100005; i++) {
inv[i] =
(1000000007 - (1000000007 / i) * inv[1000000007 % i] % 1000000007) %
1000000007;
}
fact[0] = 1;
invFact[0] = 1;
for (int i = 1; i < 100005; i++) {
fact[i] = fact[i - 1] * (i) % 1000000007;
invFact[i] = invFact[i - 1] * inv[i] % 1000000007;
}
while (t--) {
int n, f;
cin >> n >> f;
long long x = n;
vector<int> primes;
for (int i = 2; i * i <= x; i++) {
if (n % i == 0) {
while (n % i == 0) n = n / i;
if (i < x) primes.push_back(i);
}
}
if (n != 1) primes.push_back(n);
int numPrimes = primes.size();
long long ans = 0;
for (int i = 1; i < (1 << numPrimes); i++) {
int numBits = __builtin_popcount(i);
long long g = 1;
for (int j = 0; j < numPrimes; j++) {
if (i & (1 << j)) g = g * primes[j];
}
if (numBits % 2 == 1) {
ans = ans + numPart(x / g, f);
} else {
ans = ans + 1000000007 - numPart(x / g, f);
}
ans = ans % 1000000007;
}
ans = (numPart(x, f) - ans + 1000000007) % 1000000007;
cout << ans << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e4 + 100;
const int MAXC = 16;
int N, M, K;
bool mem[MAXN][MAXC];
int tot[MAXC];
int sent[MAXN][MAXC];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15);
cin >> N >> M >> K;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> mem[i][j];
}
}
for (int i = 0; i < K; i++) {
int p, c;
cin >> p >> c;
tot[c - 1]++;
sent[p - 1][c - 1]++;
}
for (int i = 0; i < N; i++) {
int ans = 0;
for (int c = 0; c < M; c++) {
if (!mem[i][c]) continue;
ans += tot[c] - sent[i][c];
}
cout << ans << " ";
}
cout << endl;
}
| 8 | CPP |
from math import log,floor
S = input()
index = 0
for i in range(len(S)):
if(S[i]=="1"):
index = len(S)-i-1
break
if(index==0):
print(0)
exit()
if(S.count("1")==1 and not index&1):
print(int(index//2))
else:
print(int(index//2)+1)
| 7 | PYTHON3 |
N, M = map(int, input().split())
if N * 2 <= M:
print(N + (M - N * 2) // 4)
else:
print(M // 2)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> out;
map<string, int> M;
int m, n;
bool e[16][16];
string name[100];
int main() {
cin >> n >> m;
memset(e, false, sizeof(e));
for (int i = 0; i < n; i++) {
cin >> name[i];
M[name[i]] = i;
}
for (int i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
e[M[s1]][M[s2]] = true;
e[M[s2]][M[s1]] = true;
}
int upperlim = 1 << n;
int anscnt = -1, ansbit = 0;
for (int s = 0; s < upperlim; s++) {
bool suc = true;
int cnt = 0;
for (int i = 0; suc && (i < n); i++)
if (s & (1 << i)) {
cnt++;
for (int j = i + 1; j < n; j++)
if ((s & (1 << j)) && (e[i][j])) {
suc = false;
break;
}
}
if (!suc) continue;
if (cnt > anscnt) {
anscnt = cnt;
ansbit = s;
}
}
cout << anscnt << endl;
for (int i = 0; i < n; i++)
if (ansbit & (1 << i)) out.push_back(name[i]);
sort(out.begin(), out.end());
for (int i = 0; i < anscnt; i++) cout << out[i] << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
pair<int, int> a[200005];
int s[200005];
int nxt[200005];
int main() {
int n, cur, dist;
cin >> dist >> cur >> n;
int max = cur;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + n);
stack<int> stk;
for (int i = n - 1; i >= 0; i--) {
while (stk.size() && a[stk.top()].second >= a[i].second) {
stk.pop();
}
if (stk.size())
nxt[i] = stk.top();
else
nxt[i] = -1;
stk.push(i);
}
cur -= a[0].first;
long long ret = 0;
for (int i = 0; i < n; i++) {
if (cur < 0) {
puts("-1");
return 0;
}
int needy = min(max, (nxt[i] == -1 ? dist : a[nxt[i]].first) - a[i].first);
if (needy > cur) {
ret += 1ll * (needy - cur) * a[i].second;
cur = needy;
}
cur -= (i == n - 1 ? dist : a[i + 1].first) - a[i].first;
}
if (cur < 0) {
puts("-1");
return 0;
}
printf("%lld", ret);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (m == 3) {
if (n == 3) {
printf("0 0\n3 0\n0 3\n");
return 0;
}
if (n == 4) {
printf("0 0\n3 0\n0 3\n1 1\n");
return 0;
}
if (n >= 5) {
printf("-1\n");
return 0;
}
}
for (int i = 0; i < m; i++) printf("%d %d\n", i, 1000000 + i * i);
for (int i = m; i < n; i++) printf("%d %d\n", -i, -1000000 - i * i);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x, y;
int main() {
scanf("%d%d", &x, &y);
char ans;
if (y * log2(x) < x * log2(y)) ans = '<';
if (y * log2(x) > x * log2(y)) ans = '>';
if (y * log2(x) == x * log2(y) || x == y) ans = '=';
printf("%c\n", ans);
return 0;
}
| 8 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.