solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
double a, b, m;
double vx, vy, vz;
int main() {
cin >> a >> b >> m;
cin >> vx >> vy >> vz;
double t = m / abs(vy);
double lenz = t * abs(vz);
double lenx = t * abs(vx);
int z = lenz / b;
double ansx, ansz;
if (vz != 0) {
if (z % 2 == 0) {
ansz = lenz - z * b;
} else {
ansz = b - (lenz - z * b);
}
} else {
ansz = 0;
}
if (vx != 0) {
double xunhuant = (2 * a) / abs(vx);
double tx = t - ((int)(t / xunhuant)) * xunhuant;
if (vx < 0) {
if (tx <= xunhuant / 4) {
ansx = vx * tx + a / 2;
} else if (tx <= xunhuant * 3 / 4) {
ansx = -vx * tx - a / 2;
} else {
ansx = vx * tx + a * 5 / 2;
}
} else {
if (tx <= xunhuant / 4) {
ansx = vx * tx + a / 2;
} else if (tx <= xunhuant * 3 / 4) {
ansx = -vx * tx + a * 3 / 2;
} else {
ansx = vx * tx - a * 3 / 2;
}
}
} else {
ansx = a / 2;
}
printf("%.10lf %.10lf", ansx, ansz);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[10500];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
n = pow(2, n + 1);
for (int i = 2; i < n; i++) cin >> a[i];
int sum = 0;
for (int i = n - 1; i >= 2; i -= 2) {
if (a[i] > a[i - 1]) {
sum += (a[i] - a[i - 1]);
a[i / 2] += a[i];
} else {
sum += (a[i - 1] - a[i]);
a[i / 2] += a[i - 1];
}
}
cout << sum << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
int n, m, a[maxn];
int dp[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
double x;
cin >> x;
dp[i] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (a[j] <= a[i]) {
dp[i] = max(dp[i], 1 + dp[j]);
}
}
}
int hi = 0;
for (int i = 0; i < n; i++) {
hi = max(dp[i], hi);
}
int ans = n - hi;
cout << ans << endl;
return 0;
}
| 10 | CPP |
def f(s):
total = 0
current = 0
smallestsofar = 0
for char in s:
total += smallestsofar
if char == '+':
current += 1
else:
current -= 1
smallestsofar = min(smallestsofar,current)
total += (1-smallestsofar)*len(s)
return total
numberoftests = int(input())
for _ in range(numberoftests):
print(f(input())) | 9 | PYTHON3 |
#include<iostream>
#include<cstdio>
#include<bitset>
#include<algorithm>
using namespace std;
#define MAX_N 100100
class union_find{
private:
int parents[MAX_N];
int rank[MAX_N];
int weight[MAX_N];
public:
union_find(int n){
for(int i=0;i<n;i++){
parents[i]=i;
rank[i]=0;
weight[i]=0;
}
}
int find(int x){
if(parents[x]==x){
return x;
}else{
int tmp=find(parents[x]);
weight[x]=weight[x]+weight[parents[x]];
return parents[x]=tmp;
}
}
void unite(int x,int y,int w){
int tmpx=find(x);
int tmpy=find(y);
if(tmpx==tmpy)return;
if(rank[tmpx]<rank[tmpy]){
weight[tmpx]=w-weight[x]+weight[y];
parents[tmpx]=tmpy;
}else{
weight[tmpy]=-w-weight[y]+weight[x];
parents[tmpy]=tmpx;
if(rank[tmpx]==rank[tmpy])rank[tmpx]++;
}
}
int get_weight(int x,int y){
if(find(x)==find(y)){
return weight[x]-weight[y];
}else{
return -2000000;
}
}
};
int main(){
char c;
int a,b,w;
int n,m;
while(cin>>n>>m,n!=0||m!=0){
union_find uf(n+1);
for(int i=0;i<m;i++){
cin>>c;
if(c=='!'){
cin>>a>>b>>w;
uf.unite(a,b,w);
}else if(c=='?'){
cin>>a>>b;
int tmp=uf.get_weight(a,b);
if(tmp!=-2000000){
cout<<tmp<<endl;
}else{
cout<<"UNKNOWN"<<endl;
}
}
}
}
} | 0 | CPP |
print("1" if eval(input().replace(" ","%")) else "0") | 0 | PYTHON3 |
n,m=map(int,input().split())
if n&1:
for i in range(m):
print(i+1,n-i)
else:
a=0
for i in range(m):
if n&2:
if i+1==(n//2+1)//2:a=1
elif i+1==n//2//2+1:a=1
print(i+1+a,n-i) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long n, k;
long a[500010], stk[500010], in_stk[500010];
long top, swap_id;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
a[n + 1] = 0;
n = n + 1;
top = 1;
stk[1] = 1;
for (int i = 2; i <= n; i++)
if (a[i] < a[stk[top]]) {
top += 1;
stk[top] = i;
in_stk[i] = top;
}
swap_id = 0;
for (int i = 2; i <= top; i++) {
if (stk[i] - stk[i - 1] > 2 * k) {
cout << "NO";
return 0;
}
if (stk[i] - stk[i - 1] > k) {
if (swap_id != 0) {
cout << "NO";
return 0;
} else
swap_id = i;
}
}
if (swap_id == 0 ||
(swap_id < top && stk[swap_id + 1] - stk[swap_id - 1] <= 2 * k)) {
cout << "YES";
return 0;
}
for (int i = stk[swap_id] + 1; i <= n; i++) {
if (in_stk[i] == 0 || (stk[in_stk[i] + 1] - stk[in_stk[i] - 1] <= k)) {
if (a[i] < a[stk[swap_id - 1]] && a[i] > a[stk[swap_id]]) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<pair<string, string> > v1, v2;
for (long long i = 0; i < n; i++) {
string s1, s2;
cin >> s1 >> s2;
pair<string, string> p = make_pair(s1, s2);
v1.push_back(p);
}
for (long long i = 0; i < m; i++) {
string s1, s2;
cin >> s1 >> s2;
pair<string, string> p = make_pair(s1, s2);
v2.push_back(p);
}
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < n; j++) {
string a = v1[j].second;
string b = v2[i].second;
b.erase(b.end() - 1);
if (a == b)
cout << v2[i].first << " " << v2[i].second << " #" << v1[j].first
<< endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m,d;
cin>>n>>m>>d;
if(d)printf("%.12lf",1.0*(m-1)*2*(n-d)/n/n);
else printf("%.12lf",1.0*(m-1)*(n-d)/n/n);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 100;
const long long maxlog = 18;
int h[maxn], par[maxn][maxlog], dp[maxn];
vector<int> g[maxn];
void dfs(int v, int p) {
h[v] = h[p] + 1;
par[v][0] = p;
dp[v] = 1;
for (int i = 1; i < maxlog; i++) par[v][i] = par[par[v][i - 1]][i - 1];
for (int i = 0; i < g[v].size(); i++)
if (g[v][i] != p) dfs(g[v][i], v), dp[v] += dp[g[v][i]];
}
int LCA(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = maxlog - 1; i >= 0; i--)
if (h[par[u][i]] >= h[v]) u = par[u][i];
if (u == v) return u;
for (int i = maxlog - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
int get_distance(int u, int v, int lca) { return h[u] + h[v] - 2 * h[lca]; }
int parent_h(int u, int h) {
for (int i = maxlog - 1; i >= 0; i--)
if ((h >> i) & 1) u = par[u][i];
return u;
}
int main() {
int n;
scanf("%d ", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d ", &u, &v);
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
h[0] = -1;
dfs(0, 0);
int q;
scanf("%d ", &q);
while (q--) {
int a, b;
scanf("%d%d ", &a, &b);
a--;
b--;
int lca = LCA(a, b);
int dist = get_distance(a, b, lca);
if (a == b)
printf("%d\n", n);
else if (dist & 1)
printf("%d\n", 0);
else {
if (h[a] == h[b]) {
int res = n;
res -= dp[parent_h(a, h[a] - h[lca] - 1)];
res -= dp[parent_h(b, h[b] - h[lca] - 1)];
printf("%d\n", res);
} else {
if (h[a] < h[b]) swap(a, b);
int p = parent_h(a, dist / 2);
int res = dp[p];
res -= dp[parent_h(a, h[a] - h[p] - 1)];
printf("%d\n", res);
}
}
}
return 0;
}
| 11 | CPP |
l1=input().lower()
l2=input().lower()
alp='abcdefghijklmnopqrstuvwxyz'
for i in range(len(l1)):
if alp.index(l1[i])>alp.index(l2[i]):
print(1)
break;
elif alp.index(l1[i])<alp.index(l2[i]):
print(-1)
break;
elif i == len(l1)-1:
print(0) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#define mset(a, b) memset(a, b, sizeof(a))
#define mcpy(a, b) memcpy(a, b, sizeof(a))
#define rg register
using namespace std;
typedef long long LL;
const int N = 105;
template <typename T> inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
namespace ModCalculator {
int MOD;
inline void Inc(int &x, int y) {
x += y; if (x >= MOD) x -= MOD;
}
inline void Dec(int &x, int y) {
x -= y; if (x < 0) x += MOD;
}
inline int Mul(int x, int y) {
return 1LL * x * y % MOD;
}
inline int Mul(int x, int y, int z) {
return 1LL * x * y % MOD * z % MOD;
}
}
using namespace ModCalculator;
inline int ksm(int x, int k) {
int ret = 1;
while (k) {
if (k & 1) ret = Mul(ret, x);
x = Mul(x, x);
k >>= 1;
}
return ret;
}
int n, m, K;
int fac[N], finv[N], pw[N][N * N];
int dp[2][N][N], g[N][N];
void init() {
read(n); read(m); read(K); read(MOD);
if (n < m) swap(n, m);
fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = Mul(fac[i - 1], i);
}
finv[n] = ksm(fac[n], MOD - 2);
for (int i = n - 1; i >= 0; --i) {
finv[i] = Mul(finv[i + 1], i + 1);
}
for (int i = 0, r = n * m; i <= K; ++i) {
pw[i][0] = 1;
for (int j = 1; j <= r; ++j) {
pw[i][j] = Mul(pw[i][j - 1], i);
}
}
}
void solve() {
int cur = 0, pre = 1;
dp[0][0][0] = 1;
for (int i = 1; i <= K; ++i) {
swap(pre, cur);
mset(dp[cur], 0);
for (int t = 0; t <= n; ++t) {
for (int k = 0; k <= m; ++k) {
g[t][k] = Mul(finv[t], pw[i][t * (m - k)], pw[K - i + 1][t * k]);
}
}
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= m; ++k) {
for (int t = 0; t <= j; ++t) {
Inc(dp[cur][j][k], Mul(dp[pre][j - t][k], g[t][k]));
}
}
}
swap(pre, cur);
mset(dp[cur], 0);
for (int j = 0; j <= n; ++j) {
for (int t = 0; t <= m; ++t) {
g[j][t] = Mul(finv[t], pw[i][t * (n - j)], pw[K - i + 1][t * j]);
}
}
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= m; ++k) {
for (int t = 0; t <= k; ++t) {
Inc(dp[cur][j][k], Mul(dp[pre][j][k - t], g[j][t]));
}
}
}
swap(pre, cur);
mset(dp[cur], 0);
for (int t = 0; t <= n; ++t) {
for (int k = 0; k <= m; ++k) {
g[t][k] = Mul(finv[t], pw[i][t * (m - k)], pw[K - i][t * k]);
if (t & 1) g[t][k] = MOD - g[t][k];
}
}
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= m; ++k) {
for (int t = 0; t <= j; ++t) {
Inc(dp[cur][j][k], Mul(dp[pre][j - t][k], g[t][k]));
}
}
}
swap(pre, cur);
mset(dp[cur], 0);
for (int j = 0; j <= n; ++j) {
for (int t = 0; t <= m; ++t) {
g[j][t] = Mul(finv[t], pw[i][t * (n - j)], pw[K - i][t * j]);
if (t & 1) g[j][t] = MOD - g[j][t];
}
}
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= m; ++k) {
for (int t = 0; t <= k; ++t) {
Inc(dp[cur][j][k], Mul(dp[pre][j][k - t], g[j][t]));
}
}
}
}
printf("%d\n", Mul(dp[pre][n][m], fac[n], fac[m]));
}
int main() {
init();
solve();
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define eb emplace_back
#define lb lower_bound
#define fi first
#define se second
#define rep(i, a, b) for (auto i = (a); i < (b); ++i) // [a, b)
#define trav(e, x) for (auto &e : x)
#define getchar getchar_unlocked
#define putchar putchar_unlocked
inline int in() {
int n, c, flag = 1;
while ((c = getchar()) < '0') if (c == EOF) return -1; else flag = -1;
n = c - '0';
while ((c = getchar()) >= '0') n = n * 10 + c - '0';
return n * flag;
}
inline void out(int n) {
int res[10], i = 0;
do { res[i++] = n % 10, n /= 10; } while (n);
while (i) putchar(res[--i] + '0');
putchar('\n');
}
signed main() {
int n = in();
vector<pii> p(n); trav(q, p) q.fi = in(), q.se = in();
vector<int> x(n); rep(i, 0, n) x[i] = p[i].fi;
sort(all(x)); x.erase(unique(all(x)), end(x));
vector<vector<pii>> y(sz(x));
rep(i, 0, n) {
int j = lb(all(x), p[i].fi) - begin(x);
y[j].eb(p[i].se, i);
}
trav(v, y) sort(all(v));
int t = in();
while (t--) {
vi ans;
int sx = in(), tx = in(), sy = in(), ty = in();
int l = lb(all(x), sx) - begin(x);
rep(i, l, sz(x)) {
if (x[i] > tx) break;
int a = lb(all(y[i]), pii(sy, 0)) - begin(y[i]);
rep(j, a, sz(y[i])) {
if (y[i][j].fi > ty) break;
ans.eb(y[i][j].se);
}
}
sort(all(ans)); trav(x, ans) out(x); putchar('\n');
}
}
| 0 | CPP |
print(":("if max(map(int,input().split()))>8 else "Yay!") | 0 | PYTHON3 |
m, n = map(int, input().split())
print("Yes") if m==n else print("No") | 0 | PYTHON3 |
t = int(input())
while t != 0:
n, m, x, y = list(map(int, input().split()))
a = []
for i in range(n):
a.append(input())
i, j = 0, 0
cost = 0
flag = True if y < 2*x else False
while i < n:
j = 0
while j < m:
if a[i][j] == "*":
j += 1
elif j+1 < m and a[i][j] == "." and a[i][j+1] == "." and flag:
cost += y
j += 2
else:
cost += x
j += 1
i += 1
print(cost)
t -= 1
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int> > Mat(5, vector<long long int>(5, -1));
vector<long long int> moves;
void read(long long int howMuch, long long int row) {
for (int i = 0; i < howMuch; i++) {
char aux;
cin >> aux;
if (aux == '.')
Mat[row][i] = 0;
else
Mat[row][i] = 1;
}
}
void printMat() {
for (auto x : Mat) {
for (auto v : x) cout << v << " ";
cout << "\n";
}
}
void prep() {
read(3, 0);
read(4, 1);
read(5, 2);
read(4, 3);
read(3, 4);
}
void getPosibles() {
set<long long int> uniques;
vector<vector<long long int> > diagonalIzq = {{0, 3, 7},
{1, 4, 8, 12},
{2, 5, 9, 13, 16},
{6, 10, 14, 17},
{11, 15, 18}};
for (int i = 0; i < 5; i++) {
vector<long long int> currDiag = diagonalIzq[i];
for (int j = 0; j < currDiag.size(); j++) {
long long int mask = 0;
for (int k = j; k >= 0; k--) {
long long int num = currDiag[k];
mask = mask | (1 << (num));
moves.push_back(mask);
}
}
}
vector<vector<long long int> > horizontal = {{0, 1, 2},
{3, 4, 5, 6},
{7, 8, 9, 10, 11},
{12, 13, 14, 15},
{16, 17, 18}};
for (int i = 0; i < 5; i++) {
vector<long long int> currHori = horizontal[i];
for (int j = 0; j < currHori.size(); j++) {
long long int mask = 0;
for (int k = j; k >= 0; k--) {
long long int num = currHori[k];
mask = mask | (1 << (num));
if (k == j) continue;
moves.push_back(mask);
}
}
}
vector<vector<long long int> > diagonalDer = {{7, 12, 16},
{3, 8, 13, 17},
{0, 4, 9, 14, 18},
{1, 5, 10, 15},
{2, 6, 11}};
for (int i = 0; i < 5; i++) {
vector<long long int> currDer = diagonalDer[i];
for (int j = 0; j < currDer.size(); j++) {
long long int mask = 0;
for (int k = j; k >= 0; k--) {
long long int num = currDer[k];
mask = mask | (1 << (num));
if (k == j) continue;
moves.push_back(mask);
}
}
}
}
long long int getMask() {
vector<long long int> aux;
for (int i = 0; i < 3; i++) aux.push_back(Mat[0][i]);
for (int i = 0; i < 4; i++) aux.push_back(Mat[1][i]);
for (int i = 0; i < 5; i++) aux.push_back(Mat[2][i]);
for (int i = 0; i < 4; i++) aux.push_back(Mat[3][i]);
for (int i = 0; i < 3; i++) aux.push_back(Mat[4][i]);
long long int mask = 0;
for (int i = 0; i < 19; i++) {
if (aux[i]) {
mask = mask | (1 << i);
}
}
return mask;
}
int main() {
;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
prep();
long long int maskPrincipal = getMask();
getPosibles();
vector<long long int> dp((1 << 19));
dp[0] = 0;
for (long long int mask = 1; mask < (1 << 19); mask++) {
unordered_set<int> toGrundy;
vector<bool> Grundy(50);
for (auto move : moves) {
if ((mask & move) == move) {
Grundy[dp[mask & (~move)]] = true;
}
}
for (int i = 0; i < 50; i++) {
if (!Grundy[i]) {
dp[mask] = i;
break;
}
}
}
if (dp[maskPrincipal]) {
cout << "Karlsson"
<< "\n";
} else {
cout << "Lillebror"
<< "\n";
}
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define N (1<<19)
const LL mod=998244353;
LL n,sum,isum,a[N],ans;
void upd(LL &x,LL y){x=(x+y)%mod;}
LL inv(LL x){
return x==1?1:(mod-mod/x)*inv(mod%x)%mod;
}
void fwt(LL f[],LL n){
for (LL i=0;i<n;++i){
LL t=1<<i;
for (LL j=0;j<1<<n;j+=t<<1){
LL *f1=f+j,*f2=f+j+t;
for (LL k=0;k<t;++k){
LL x=(f1[k]+f2[k])%mod,y=(f1[k]-f2[k]+mod)%mod;
f1[k]=x; f2[k]=y;
}
}
}
}
int main(){
scanf("%lld",&n);
for (LL i=0;i<1<<n;++i){
scanf("%lld",a+i);
upd(sum,a[i]);
}
isum=inv(sum);
for (LL i=0;i<1<<n;++i) a[i]=a[i]*isum%mod;
fwt(a,n);
a[0]=0; for (LL i=1;i<1<<n;++i) a[i]=inv((1-a[i]+mod)%mod);
fwt(a,n);
for (LL i=0;i<1<<n;++i){
ans=(a[0]-a[i]+mod)%mod;
printf("%lld\n",ans);
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 101000;
long long a[MAX_N], b[MAX_N];
struct skt {
int x, y;
long long z;
} edge[2 * MAX_N];
int pre[2 * MAX_N];
bool cmp(skt a, skt b) { return a.z > b.z; }
int find(int x) {
if (pre[x] != x) pre[x] = find(pre[x]);
return pre[x];
}
int main(void) {
int n, m, i, j, k;
scanf("%d%d", &m, &n);
for (i = 1; i <= m; i++) scanf("%lld", &a[i]);
for (i = 1; i <= n; i++) scanf("%lld", &b[i]);
for (i = 1; i <= n + m; i++) pre[i] = i;
int cnt = 0;
long long res = 0;
for (i = 1; i <= m; i++) {
int x;
scanf("%d", &k);
for (j = 1; j <= k; j++) {
scanf("%d", &x);
edge[++cnt].x = n + i, edge[cnt].y = x, edge[cnt].z = a[i] + b[x];
res += edge[cnt].z;
}
}
sort(edge + 1, edge + cnt + 1, cmp);
for (i = 1; i <= cnt; i++) {
int x = edge[i].x, y = edge[i].y;
long long z = edge[i].z;
int fx = find(x), fy = find(y);
if (fx != fy) {
pre[fx] = fy;
res -= z;
}
}
printf("%lld\n", res);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int a[1010][1010];
int p1[1010][1010];
int p2[1010][1010];
int p3[1010][1010];
int p4[1010][1010];
bool vis[1010][1010];
int d;
int n, m;
int cntv, cnte;
int odd_num = 0;
void dfs(int x, int y) {
int cnt = 0;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++)
if (abs(i) + abs(j) == 1) {
if (x + i * d <= n && x + i * d >= 1 && y + j * d <= m &&
y + j * d >= 1) {
bool z = true;
if (i != 0 && abs(p3[x + i * d][y] - p3[x][y]) != d) z = false;
if (j != 0 && abs(p4[x][y + j * d] - p4[x][y]) != d) z = false;
if (z) {
cnt++;
cnte++;
if (!vis[x + i * d][y + j * d]) {
cntv++;
vis[x + i * d][y + j * d] = true;
dfs(x + i * d, y + j * d);
}
}
}
}
if (cnt % 2 == 1) odd_num++;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(12);
cin >> n >> m;
int cnt1 = 0;
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) {
a[i][j] = 0;
p1[i][j] = 0;
p2[i][j] = 0;
p3[i][j] = 0;
p4[i][j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
set<int> q;
int x = 0, y = 0;
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++) {
cnt1 += a[i][j];
if (a[i][j] && x == 0) {
x = i;
y = j;
}
p3[i][j] = p3[i - 1][j] + a[i][j];
p4[i][j] = p4[i][j - 1] + a[i][j];
if (a[i][j])
p1[i][j] = p1[i - 1][j] + 1;
else {
if (p1[i - 1][j] - 1 > 0) q.insert(p1[i - 1][j] - 1);
p1[i][j] = 0;
}
if (a[i][j])
p2[i][j] = p2[i][j - 1] + 1;
else {
if (p2[i][j - 1] - 1 > 0) q.insert(p2[i][j - 1] - 1);
p2[i][j] = 0;
}
}
if (q.size() == 0) {
cout << "-1";
return 0;
}
bool z = false;
int GCD;
while (!q.empty()) {
if (!z)
GCD = *q.begin();
else
GCD = gcd(*q.begin(), GCD);
q.erase(q.begin());
z = true;
}
vector<int> v;
for (int i = 1; i * i <= GCD; i++) {
if (GCD % i == 0) v.push_back(i);
if (i * i != GCD) v.push_back(GCD / i);
}
z = false;
vector<int> ans;
for (int i = 0; i < v.size(); i++)
if (v[i] > 1) {
for (int j = 1; j <= n; j++)
for (int k = 1; k <= m; k++) vis[j][k] = false;
d = v[i];
cntv = 1;
cnte = 0;
odd_num = 0;
vis[x][y] = true;
dfs(x, y);
if (cntv + (cnte / 2) * (d - 1) == cnt1 && odd_num <= 2) {
ans.push_back(v[i]);
z = true;
}
}
if (!z) {
cout << "-1";
return 0;
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 11 | CPP |
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 19
MOD = 10 ** 9 + 7
def compress(S):
zipped, unzipped = {}, {}
for i, a in enumerate(sorted(S)):
zipped[a] = i
unzipped[i] = a
return zipped, unzipped
for _ in range(INT()):
N = INT()
A = LIST()
zipped, _ = compress(A)
for i in range(N):
A[i] = zipped[A[i]]
B = [0] * N
for i, a in enumerate(A):
B[a] = i
mx = cnt = 1
for i in range(N-1):
if B[i] < B[i+1]:
cnt += 1
else:
cnt = 1
mx = max(mx, cnt)
print(N - mx)
| 12 | PYTHON3 |
import sys
w = sys.stdin.readline()
print(str(w[0].upper() + w[1:]))
| 7 | PYTHON3 |
n,t=map(int,input().split())
a=list(map(int,input().split()))
s=[0]*n
d=dict()
for i,k in enumerate(a):
s[i]=i+a[i]+1
d[i+1]=s[i]
st=1
q=0
for i in range(1,n):
if st==n:
break
k=d[st]
if k==t:
q=1
break
st=k
print(('NO','YES')[q])
| 7 | PYTHON3 |
#!use/bin/env python3
if __name__=="__main__":
a = list(map(int, input().split()))
k = a[0]
n = a[1]
w = a[2]
ans = 0
for i in range(1, w+1):
ans += i
if n > k*ans:
print(0)
else:
print(k*ans - n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
const int M = 1e9 + 7;
const int N = 2e5 + 5;
using namespace std;
long long int n;
long long int a[N];
void fn(long long int T, long long int &cnt, long long int &g) {
for (long long int i = 0; i < n; ++i) {
if (T >= a[i]) {
T -= a[i];
++cnt;
g += a[i];
}
}
}
int main() {
long long int T;
cin >> n >> T;
for (long long int i = 0; i < n; ++i) cin >> a[i];
long long int mn = *min_element(a, a + n);
long long int ans = 0;
while (T >= mn) {
long long int cnt = 0, g = 0;
fn(T, cnt, g);
ans += cnt * (T / g);
T %= g;
}
cout << ans << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
int parent[3003][3003];
bool vis[3003][3003];
vector<vector<int>> v(3003, vector<int>());
set<pair<int, pair<int, int>>> s;
struct node {
int pp, p, x, c;
};
void fun() {
node cur, nw;
queue<node> q;
cur.pp = 1, cur.x = 1, cur.p = 1, cur.c = 0;
q.push(cur);
int ans = 1e+9;
while (q.size()) {
cur = q.front();
q.pop();
if (vis[cur.p][cur.x]) continue;
vis[cur.p][cur.x] = 1;
parent[cur.p][cur.x] = cur.pp;
if (cur.x == n) {
ans = cur.c;
x = cur.p;
break;
}
for (int i = 0; i < v[cur.x].size(); i++) {
if (s.find(make_pair(cur.p, make_pair(cur.x, v[cur.x][i]))) != s.end())
continue;
nw.pp = cur.p, nw.p = cur.x, nw.x = v[cur.x][i], nw.c = cur.c + 1;
q.push(nw);
}
}
if (ans == 1e+9) {
cout << -1 << endl;
return;
}
cout << ans << endl;
vector<int> a;
int tmp;
y = n;
a.push_back(y);
while (1) {
a.push_back(x);
if (x == 1) break;
tmp = x;
x = parent[x][y];
y = tmp;
}
for (int i = a.size() - 1; i >= 0; i--) cout << a[i] << " ";
cout << endl;
}
int main() {
int m, k;
cin >> n >> m >> k;
while (m--) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
int z;
while (k--) {
cin >> x >> y >> z;
s.insert(make_pair(x, make_pair(y, z)));
}
fun();
}
| 11 | CPP |
inp = str(input())
arr = inp.split()
a = int(arr[0])
b =int(arr[1])
count = 0
while a<=b:
count+=1
a=3*a
b=2*b
print(count) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int work(int n, int k) {
int ans = 0, p = 0;
while (n) {
ans += (n % k) * pow(10, p);
n /= k;
p++;
}
return ans;
}
int k;
int main() {
cin >> k;
for (int i = 1; i < k; i++) {
for (int j = 1; j < k; j++) {
cout << work(i * j, k) << " ";
}
cout << endl;
}
return 0;
}
| 14 | CPP |
val=int(input())
if (val % 2==0 and val!=2):
print ('YES')
else:
print ('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 200005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int r() { return (rand() << 15) | rand(); }
long long R() { return ((long long)r() << 30) | r(); }
long long calc(long long x) { return x * (x + 1) * (x + 2) / 6; }
int n, m, x, y, p = 0;
long long a[N], b[N], s = 0, t = 0, ans = 0;
vector<int> A[N], B[N];
map<long long, long long> C, L;
int main() {
scanf("%d%d", &n, &m);
srand(time(NULL));
for (int i = (1); i <= (n); ++i) a[i] = R();
for (int i = (1); i <= (n); ++i) {
scanf("%d%d", &x, &y);
A[x].push_back(i);
B[y].push_back(i);
b[x] ^= a[i];
b[y + 1] ^= a[i];
}
for (int i = (1); i <= (m); ++i) b[i] ^= b[i - 1];
b[m + 1] = -1;
for (int i = (1); i <= (m + 1); ++i) {
if (!b[i]) continue;
ans -= calc(i - p - 1);
p = i;
}
for (int i = (1); i <= (m); ++i) b[i] ^= b[i - 1];
C[0]++;
for (int i = (1); i <= (m); ++i) {
for (__typeof((A[i]).begin()) it = (A[i]).begin(); it != (A[i]).end(); it++)
s ^= a[*it];
for (__typeof((B[i]).begin()) it = (B[i]).begin(); it != (B[i]).end(); it++)
t ^= a[*it];
ans += C[b[i] ^ s] * i - L[b[i] ^ s];
C[b[i] ^ t]++, L[b[i] ^ t] += i;
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#define ld double
#define ull unsigned long long
#define ll long long
#define pii pair <int, int>
#define iiii pair <int, pii >
#define mp make_pair
#define INF 1000000000
#define MOD 1000000007
#define rep(i, x) for(int (i) = 0; (i) < (x); (i)++)
inline int getint() {
int x = 0, p = 1; char c = getchar();
while (c <= 32) c = getchar();
if (c == 45) p = -p, c = getchar();
while (c > 32) x = x * 10 + c - 48, c = getchar();
return x * p;
}
using namespace std;
//ruogu_alter
const int N = 2e5 + 10;
const int s = N - 1;
const int t = N - 2;
int n, pre[N], pree[N], flow[N];
ll dis[N];
bool vis[N];
struct edge {
int to, val, cost, rev;
};
const ll inf = 2e18;
vector<edge> g[N];
//
inline void addedge(int x, int y, int z, int w) {
g[x].emplace_back((edge){y, z, w, (int)g[y].size()});
g[y].emplace_back((edge){x, 0, -w, (int)g[x].size() - 1});
}
bool spfa() {
memset(vis, 0, sizeof(vis)); pre[t] = -1;
rep(i, N) dis[i] = -inf, flow[i] = INF; dis[s] = 0;
queue<int> qu; qu.emplace(s);
while (qu.size()) {
int u = qu.front(); qu.pop(); vis[u] = false;
rep(i, g[u].size()) {
edge &e = g[u][i];
if (e.val && dis[e.to] < 1ll * e.cost + dis[u]) {
dis[e.to] = 1ll * e.cost + dis[u];
pre[e.to] = u;
pree[e.to] = i;
flow[e.to] = min(flow[u], e.val);
if (!vis[e.to]) {
vis[e.to] = true;
qu.emplace(e.to);
}
}
}
}
return pre[t] >= 0;
}
ll ek() {
ll res = 0;
while (spfa()) {
int now = t;
res += 1ll * flow[t] * dis[t];
while (now != s) {
int u = pre[now], x = pree[now];
g[u][x].val -= flow[t];
g[now][g[u][x].rev].val += flow[t];
now = u;
}
}
return res;
}
int main() {
n = getint();
rep(i, n) {
int x = getint(), y = getint(), c = getint();
addedge(s, i, c, 0);
addedge(i, 2 * n, INF, x + y);
addedge(i, 2 * n + 1, INF, x - y);
addedge(i, 2 * n + 2, INF, y - x);
addedge(i, 2 * n + 3, INF, -x - y);
}
for (int i = n; i < 2 * n; i++) {
int x = getint(), y = getint(), c = getint();
addedge(i, t, c, 0);
addedge(2 * n, i, INF, -x - y);
addedge(2 * n + 1, i, INF, y - x);
addedge(2 * n + 2, i, INF, x - y);
addedge(2 * n + 3, i, INF, x + y);
}
cout << ek() << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n;
bool compatible[24][24];
int dp[2][1<<21];
int main() {
cin>>n;
int x, y;
for(int i = 0 ; i<n;i++)
for(int j = 0 ;j<n;j++)
cin>>compatible[i][j];
memset(dp,0,sizeof(dp));
dp[1][0] = 1;
for(int i = 0;i<n;i++){
for(int j = 0;j<n;j++){
for(int k = 0;k<(1<<n);k++){
if(!dp[(i+1)%2][k] || (k&(1<<j))) continue;
if(compatible[i][j])
dp[i%2][k|(1<<j)] = (dp[i%2][k|(1<<j)]+dp[(i+1)%2][k])%mod;
}
}
}
cout<<dp[(n-1)%2][(1<<n)-1];
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e9 + 7;
long long int arr[200005];
long long int n, m, k, t, t1, t2, t3, t4, t5, t6;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> t1 >> t2;
n /= 2;
cin >> m >> k;
long long int ans = 0;
if (m > k) {
if (n > t1) {
ans = t1 * m;
n -= t1;
ans += min(t2, n) * k;
} else {
ans = n * m;
}
} else {
if (n > t2) {
ans = t2 * k;
n -= t2;
ans += min(t1, n) * m;
} else {
ans = n * k;
}
}
cout << ans << "\n";
}
return 0;
}
| 7 | CPP |
nbebidas = int(input())
conc = []
suco = input().split()
conc = 0
for bebida in suco:
conc = conc + int(bebida)
print (conc/nbebidas)
| 8 | PYTHON3 |
N,K=map(int,input().split())
A=list(map(int,input().split()))
print(-((1-N)//(K-1))) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x;
char c;
while ((c = getchar()) < '0' || c > '9')
;
for (x = c - '0'; (c = getchar()) >= '0' && c <= '9';) x = x * 10 + c - '0';
return x;
}
int a[100000 + 5], t[131072 * 2 + 5], f[100000 + 5];
int query(int l, int r) {
int res = 0;
for (l += 131072, r += 131072 + 2; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) res = max(res, t[l + 1]);
if (r & 1) res = max(res, t[r - 1]);
}
return res;
}
void rw(int k, int x) {
for (k += 131072 + 1; k; k >>= 1) t[k] = max(t[k], x);
}
int main() {
int n, m, i, x, ans = 0;
n = read();
m = read();
while (n--) ++a[read()], --a[read() + 1];
for (i = 1; i <= m; ++i)
a[i] += a[i - 1], rw(a[i], f[i] = query(0, a[i]) + 1);
memset(t, 0, sizeof(t));
for (i = m; i; --i)
ans = max(ans, f[i] + (x = query(0, a[i]))), rw(a[i], x + 1);
printf("%d", ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("test.in");
long long dp[10][305][305];
int x[305], y[305];
pair<double, pair<int, int> > t[90005];
int main() {
int n, i, j, p, k = 0;
long long sol = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
for (j = 1; j < i; j++) {
t[++k] = make_pair(atan2(y[i] - y[j], x[i] - x[j]), make_pair(i, j));
t[++k] = make_pair(atan2(y[j] - y[i], x[j] - x[i]), make_pair(j, i));
}
}
sort(t + 1, t + k + 1);
for (i = 1; i <= n; i++) dp[0][i][i] = 1;
for (i = 1; i <= k; i++) {
for (j = 1; j <= 5; j++) {
for (p = 1; p <= n; p++) {
dp[j][p][t[i].second.second] += dp[j - 1][p][t[i].second.first];
}
}
}
for (i = 1; i <= n; i++) sol = sol + dp[5][i][i];
cout << sol;
}
| 14 | CPP |
#include <bits/stdc++.h>
struct node {
int data;
struct node *link;
};
struct node *head, *newnode;
int main() {
int n, k;
long long a, b;
struct node *temp;
head = NULL;
scanf("%d %d", &n, &k);
int i = 1;
while (i <= n) {
newnode = (struct node *)malloc(sizeof(struct node));
newnode->link = NULL;
newnode->data = i;
if (head == NULL) {
head = temp = newnode;
} else {
temp->link = newnode;
temp = newnode;
}
i++;
}
temp->link = head;
temp = head;
while (k--) {
scanf("%lld", &a);
b = a % n;
if (b == 0) {
temp = head;
while (temp->link != head) {
temp = temp->link;
}
} else {
while (b > 0) {
temp = head;
head = head->link;
b--;
}
}
temp->link = head->link;
printf("%d ", head->data);
temp = head;
head = head->link;
free(temp);
n--;
}
return 0;
}
| 8 | CPP |
#include<iostream>
#include<cassert>
using namespace std;
#define N 8
#define F -1
#define NF 1
int r[N], c[N], dp[2 * N - 1], dn[2 * N - 1];
bool x[N][N];
void print() {
int i, j;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
if (x[i][j]) {
if (r[i] != j) {
return;
}
}
}
}
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
cout << ((r[i] == j) ? "Q" : ".");
}
cout << endl;
}
}
void init() {
int i;
for (i = 0; i < N; i++) { r[i] = F, c[i] = F; }
for (i = 0; i < 2 * N - 1; i++) { dp[i] = F; dn[i] = F; }
}
void recur(int i) {
int j;
if (i == N) {
print();
return;
}
for (j = 0; j < N; j++) {
if (NF == c[j] || NF == dp[i + j] || NF == dn[i - j + N - 1]) {
continue;
}
r[i] = j;
c[j] = dp[i + j] = dn[i - j + N - 1] = NF;
recur(i + 1);
r[i] = c[j] = dp[i + j] = dn[i - j + N - 1] = F;
}
}
int main(void) {
int i,j, k,r,c;
init();
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
x[i][j] = false;
}
}
cin >> k;
for (i = 0; i < k; i++) {
cin >> r >> c;
x[r][c] = true;
}
recur(0);
return 0;
}
| 0 | CPP |
for loop in range(int(input())):
data = input()
[a, b, c, d] = list(map(int, data.split()))
print(b, c, c)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f, mod = 1e9 + 7;
const int N = (int)3 * 1e5 + 5, M = 1e8 + 5;
using namespace std;
int t, n;
int a[N], s[N];
int main() {
cin >> t;
int k, q;
while (t--) {
cin >> n >> q;
memset(a, 0, sizeof a);
getchar();
for (int i = (1); i < (n + 1); i++) {
char c;
scanf("%c", &c);
if (c == '+')
a[i] = 1;
else
a[i] = -1;
if (i & 1)
s[i] = s[i - 1] + a[i];
else
s[i] = s[i - 1] - a[i];
}
int l, r;
while (q--) {
cin >> l >> r;
int x = abs(s[r] - s[l - 1]);
if (x % 2 == 1)
cout << 1 << endl;
else if (x == 0)
cout << 0 << endl;
else
cout << 2 << endl;
}
}
return 0;
}
| 10 | CPP |
n, h = tuple([int(element) for element in input().split(" ")])
friends = [int(element)-h for element in input().split(" ")]
friends = [1 if element <= 0 else 2 for element in friends]
print(sum(friends)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[15];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int tmp = a[2];
sort(a, a + n);
printf("%d", 2 + (tmp ^ a[0]));
}
| 10 | CPP |
n=list(map(str,input().split('+')))
n.sort()
a='+'
a=a.join(n)
print(a) | 7 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
printf("25");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[4];
cin >> n >> a[1] >> a[2] >> a[3];
a[0] = 0;
sort(a, a + 4);
int cuts[4][n + 1];
memset(cuts, 0, sizeof(cuts));
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (j < a[i])
cuts[i][j] = cuts[i - 1][j];
else {
if (j == a[i])
cuts[i][j] = max(cuts[i - 1][j], 1);
else {
int k = j - a[i];
if (cuts[i][k] != 0)
cuts[i][j] = max(1 + cuts[i][k], cuts[i - 1][j]);
else
cuts[i][j] = cuts[i - 1][j];
}
}
}
}
cout << cuts[3][n];
}
| 7 | CPP |
from time import time
from random import randint
class Deleted(Exception): pass
def solve(arr):
start = 0
arr.sort()
while sum(arr)%2 != 0:
try:
for i in range(start, len(arr)-1):
if (arr[i+1] - arr[i] == 1):
del arr[i+1]
del arr[i]
start = i
raise(Deleted)
print("NO")
return
except Deleted:
pass
print("YES")
return
def submit():
for case in range(int(input())):
input()
numbers = list(map(int, input().split()))
solve(numbers)
def tryOut():
start_time = time()
# -------------------------------------------------------------------------------------------------------------------
numbers = [11, 14, 16, 12]
solve(numbers)
# -------------------------------------------------------------------------------------------------------------------
print(f"Execution time: {time() - start_time}s")
submit()
#tryOut()
| 9 | PYTHON3 |
n,m = (int(i) for i in input().split())
maxd = 10**10
l = -1
r = -1
for i in range(m):
a,b = (int(i) for i in input().split())
if b-a< maxd:
l = a-1
r = b-1
maxd = r-l
ans_l = [0]*n
for i in range(l,r+1):
ans_l[i] = i-l
k = maxd
t = -1
for i in range(l-1,-1,-1):
if t < 0:
t = k
ans_l[i] = t
t-=1
t = 0
for i in range(r+1,n):
if t > maxd:
t = 0
ans_l[i]=t
t+=1
print(maxd+1)
print(' '.join(list(map(str,ans_l)))) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 1e9;
int n, m, h;
vector<int> g[maxn];
int degree[maxn], killed[maxn];
void print_ans(vector<int> &ans, int i, int j) {
printf("%d\n", j - i + 1);
for (int k = (i); k <= (j); k++) printf("%d%c", ans[k], k == j ? '\n' : ' ');
}
int idx[maxn];
void find_cycle() {
int u = 1;
while (killed[u]) u++;
vector<int> ans;
ans.push_back(u);
for (int i = (1); i <= (n); i++) idx[i] = -1;
idx[u] = 0;
while (1) {
for (int v : g[u])
if (!killed[v]) {
if (idx[v] == -1) {
idx[v] = ans.size();
ans.push_back(u = v);
break;
} else if (idx[u] - idx[v] + 1 >= h) {
puts("2");
print_ans(ans, idx[v], idx[u]);
return;
}
}
}
}
const int maxnode = 4 * maxn;
struct Node {
int l, r, mdeg, mpos;
} tr[maxnode];
void maintain(int o) {
if (tr[tr[o].l].mdeg < tr[tr[o].r].mdeg) {
tr[o].mdeg = tr[tr[o].l].mdeg;
tr[o].mpos = tr[tr[o].l].mpos;
} else {
tr[o].mdeg = tr[tr[o].r].mdeg;
tr[o].mpos = tr[tr[o].r].mpos;
}
}
int tc;
int build(int L, int R) {
int o = ++tc;
if (L == R) {
tr[o].mdeg = degree[L];
tr[o].mpos = L;
} else {
int M = (L + R) / 2;
tr[o].l = build(L, M);
tr[o].r = build(M + 1, R);
maintain(o);
}
return o;
}
int query(int o) { return tr[o].mpos; }
void update(int o, int L, int R, int p, int d = 0) {
if (L == R) {
if (d == 0) {
killed[L] = 1;
degree[L] = inf;
} else {
degree[L] += d;
}
tr[o].mdeg = degree[L];
} else {
int M = (L + R) / 2;
if (p <= M)
update(tr[o].l, L, M, p, d);
else
update(tr[o].r, M + 1, R, p, d);
maintain(o);
}
}
void print_tree(int o, int L, int R, int indent = 0) {
int M = (L + R) / 2;
for (int i = (1); i <= (indent); i++) printf(" ");
if (L != R)
printf("[%d,%d]:deg=%d,pos=%d\n", L, R, tr[o].mdeg, tr[o].mpos);
else {
printf("[%d]:deg=%d,pos=%d\n", L, tr[o].mdeg, tr[o].mpos);
return;
}
print_tree(tr[o].l, L, M, indent + 1);
print_tree(tr[o].r, M + 1, R, indent + 1);
}
int root;
void kill(int u) { update(root, 1, n, u); }
void upd(int u) { update(root, 1, n, u, -1); }
int main() {
scanf("%d", &n);
scanf("%d", &m);
while (h * h < n) h++;
for (int i = (1); i <= (m); i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
g[u].push_back(v);
g[v].push_back(u);
degree[u]++;
degree[v]++;
}
root = build(1, n);
vector<int> ans;
for (int k = (1); k <= (h); k++) {
int u = query(root);
if (degree[u] < h - 1) {
kill(u);
for (int v : g[u])
if (!killed[v]) {
kill(v);
for (int first : g[v])
if (!killed[first]) upd(first);
}
ans.push_back(u);
} else {
find_cycle();
return 0;
}
}
puts("1");
int last = ans.size() - 1;
for (int i = (0); i <= (last); i++)
printf("%d%c", ans[i], i == last ? '\n' : ' ');
return 0;
}
| 12 | CPP |
n = int(input())
flag = True
old_spect = 3
new_spect = 3
for x in range(n):
val = int(input())
if not(flag):
continue
if val==new_spect:
flag = False
continue
list1 = [1,2,3]
list1.remove(old_spect)
list1.remove(val)
new_spect = list1[0]
old_spect = new_spect
if flag:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
mod = 1000000007
s = input()
n = len(s)
su,ans,c,x = 0,[],0,0
for i in s: su += int(i)
for i in range(1,n):
su -= int(s[-i])
ss = su*i + int(s[-i])*((n-i)*(n-i+1))//2 + c
if i==n-1:x = ss
else:ans.append(ss%10)
c = ss//10
ans.reverse()
pp = str(x) + ''.join(map(str,ans))
print(int(pp)%mod) | 9 | PYTHON3 |
N, ans = int(input()), ''
while N > 0:
N = N - 1
ans += chr(N % 26 + ord('a'))
N //= 26
print(ans[::-1])
| 0 | PYTHON3 |
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cmath>
#include<cstring>
#include<cctype>
#include<complex>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<functional>
#include<vector>
#include<string>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<numeric>
using namespace std;
const int dx[]={1,0,-1,0};
const int dy[]={0,1,0,-1};
#define INF 1e+8
#define EPS 1e-7
#define PB push_back
#define fi first
#define se second
#define ll long long
#define reps(i,j,k) for(int i = (j); i < (k); i++)
#define rep(i,j) reps(i,0,j)
typedef pair<int,int> Pii;
typedef vector<int> vi;
class data{
public:
short field[10][10];
short cnt;
data(){}
data(short _field[10][10],short _cnt){
rep(i,10){
rep(j,10){
field[i][j] = _field[i][j];
}
}
cnt = _cnt;
}
};
bool memo[10][10];
short chenge(char c){
if(c == 'R')return 0;
if(c == 'G')return 1;
return 2;
}
bool check(short f[10][10],short W,short H){
short comp = f[0][0];
rep(i,H){
rep(j,W){
if(comp != f[i][j])return false;
}
}
return true;
}
void dfs(short b,short col,short y,short x,short stage[10][10],short W,short H){
rep(i,4){
short ny = y+dy[i];
short nx = x+dx[i];
if(ny < 0 || ny > H-1 || nx < 0 || nx > W-1 || stage[ny][nx]!=b)continue;
if(memo[ny][nx]++)continue;
stage[ny][nx] = col;
dfs(b,col,ny,nx,stage,W,H);
}
return ;
}
void copy(short stage[10][10],short bef[10][10],short W,short H){
rep(i,H){
rep(j,W){
stage[i][j] = bef[i][j];
}
}
return ;
}
int main(){
int W,H;
while(scanf("%d%d",&W,&H),W){
short stage[10][10];
rep(i,H){
rep(j,W){
char c;
scanf(" %c",&c);
stage[i][j] = chenge(c);
}
}
queue < data > Q;
Q.push(data(stage,0));
short ans = -1;
while(!Q.empty()){
data d = Q.front();Q.pop();
/*
puts("-----------------------------");
rep(i,H){
rep(j,W){
printf("%d ",d.field[i][j]);
}
puts("");
}
puts("-----------------------------");*/
if(check(d.field,W,H)){
ans = d.cnt;
break;
}
short col1 = (d.field[0][0]+1)%3;
short col2 = (d.field[0][0]+2)%3;
short sub[10][10];
copy(sub,d.field,W,H);
memset(memo,0,sizeof(memo));
sub[0][0] = col1;
dfs(d.field[0][0],col1,0,0,sub,W,H);
Q.push(data(sub,d.cnt+1));
copy(sub,d.field,W,H);
memset(memo,0,sizeof(memo));
sub[0][0] = col2;
dfs(d.field[0][0],col2,0,0,sub,W,H);
Q.push(data(sub,d.cnt+1));
}
printf("%d\n",ans);
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a = 2520;
cin >> n;
cout << (n / a);
return 0;
}
| 16 | CPP |
#include <iostream>
using namespace std;
int main() {
int m;
cin >> m;
long long r = 0, s = 0;
for (int i = 0; i < m; i++) {
long long d, c;
cin >> d >> c;
r += c;
s += d * c;
}
cout << r - 1 + (s - 1) / 9 << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int Ls[N * 20], Rs[N * 20], L[N * 20], R[N * 20], M[N * 20];
int root[N], tot;
struct node {
int id, key;
bool operator<(const node& t) const { return key < t.key; }
} a[N];
int sorted[N];
int n;
inline void pushup(int k, int l, int r) {
M[k] = max(R[Ls[k]] + L[Rs[k]], max(M[Ls[k]], M[Rs[k]]));
int mid = (l + r) >> 1;
if (L[Ls[k]] >= mid - l + 1)
L[k] = mid - l + 1 + L[Rs[k]];
else
L[k] = L[Ls[k]];
if (R[Rs[k]] >= r - mid)
R[k] = r - mid + R[Ls[k]];
else
R[k] = R[Rs[k]];
}
inline int bulidtree(int l, int r) {
int k = tot++;
if (l == r) {
L[k] = R[k] = M[k] = 1;
return k;
}
int mid = (l + r) >> 1;
Ls[k] = bulidtree(l, mid);
Rs[k] = bulidtree(mid + 1, r);
pushup(k, l, r);
return k;
}
inline void COPY(int x, int y) {
Ls[x] = Ls[y];
Rs[x] = Rs[y];
}
inline int update(int o, int p, int l, int r) {
int k = tot++;
COPY(k, o);
if (l == r) {
L[k] = R[k] = M[k] = 0;
return k;
}
int mid = (l + r) >> 1;
if (p <= mid)
Ls[k] = update(Ls[k], p, l, mid);
else
Rs[k] = update(Rs[k], p, mid + 1, r);
pushup(k, l, r);
return k;
}
inline int query(int o, int x, int y, int l, int r) {
if (l == x && r == y) return M[o];
int mid = (l + r) >> 1;
if (y <= mid)
return query(Ls[o], x, y, l, mid);
else if (x > mid)
return query(Rs[o], x, y, mid + 1, r);
else {
int ret = min(mid - x + 1, R[Ls[o]]) + min(y - mid, L[Rs[o]]);
return max(ret, max(query(Ls[o], x, mid, l, mid),
query(Rs[o], mid + 1, y, mid + 1, r)));
}
}
inline bool ok(int x, int l, int r, int w) {
return query(root[x], l, r, 1, n) >= w;
}
inline int search(int x, int y, int w) {
int l = 1, r = n;
int mid;
while (l <= r) {
mid = (l + r) >> 1;
if (ok(mid, x, y, w))
l = mid + 1;
else
r = mid - 1;
}
return sorted[r];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].key);
sorted[i] = a[i].key;
a[i].id = i;
}
sort(sorted + 1, sorted + n + 1);
sort(a + 1, a + n + 1);
root[1] = bulidtree(1, n);
int j = 1;
for (int i = 2; i <= n; i++) {
root[i] = root[i - 1];
while (j <= n && a[j].key < sorted[i]) {
root[i] = update(root[i], a[j].id, 1, n);
j++;
}
}
int q;
scanf("%d", &q);
int l, r, w;
while (q--) {
scanf("%d %d %d", &l, &r, &w);
printf("%d\n", search(l, r, w));
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t;
int r, c;
int a[100][100];
char s[100];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &r, &c);
for (int i = 1; i <= r; i++) {
scanf("%s", s);
for (int j = 1; j <= c; j++) {
if (s[j - 1] == 'A')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
bool flag = 0;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
if (a[i][j]) {
flag = 1;
break;
}
}
}
if (!flag) {
printf("MORTAL\n");
continue;
}
flag = 0;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
if (!a[i][j]) {
flag = 1;
break;
}
}
}
if (!flag) {
printf("0\n");
continue;
}
bool flag1 = 1, flag2 = 1, flag3 = 1, flag4 = 1;
for (int i = 1; i <= r; i++) {
if (!a[i][1]) flag1 = 0;
if (!a[i][c]) flag2 = 0;
}
for (int i = 1; i <= c; i++) {
if (!a[1][i]) flag3 = 0;
if (!a[r][i]) flag4 = 0;
}
if (flag1 || flag2 || flag3 || flag4) {
printf("1\n");
continue;
}
flag = 0;
for (int i = 1; i <= r; i++) {
bool fl = 1;
for (int j = 1; j <= c; j++) {
if (!a[i][j]) {
fl = 0;
break;
}
}
if (fl) flag = 1;
}
for (int j = 1; j <= c; j++) {
bool fl = 1;
for (int i = 1; i <= r; i++) {
if (!a[i][j]) {
fl = 0;
break;
}
}
if (fl) flag = 1;
}
if (flag) {
printf("2\n");
continue;
}
if (a[1][1] || a[1][c] || a[r][1] || a[r][c]) {
printf("2\n");
continue;
}
flag = 0;
for (int i = 1; i <= r; i++) {
if (a[i][1]) flag = 1;
if (a[i][c]) flag = 1;
}
for (int i = 1; i <= c; i++) {
if (a[1][i]) flag = 1;
if (a[r][i]) flag = 1;
}
if (flag) {
printf("3\n");
continue;
}
printf("4\n");
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long count = 0;
while (n) {
if (n % k == 0) {
n = n / k;
count++;
} else {
count += n % k;
n = n - n % k;
}
}
cout << count << endl;
}
}
| 7 | CPP |
t= int(input())
x=0
y=0
for i in range(t):
y=0
a,b,c=map(int,input().split())
if a==1:
y+=1
if b==1:
y+=1
if c==1 and y!=2:
y+=1
if y>1:
x+=1
print(x)
| 7 | PYTHON3 |
import heapq
def dijkstra(graph, source):
distances = [(float('inf'), None) for i in range(len(graph))]
distances[0] = (0, None)
h = []
heapq.heappush(h, (0, source))
while len(h) > 0:
w, node = heapq.heappop(h)
for i, edge in graph[node]:
if (edge == -1): continue
tmp = w + edge
if (distances[i][0] > tmp):
distances[i] = (tmp, node)
heapq.heappush(h, (tmp, i))
return distances
def reconstruct(distances):
path = []
nxt = (distances[-1], len(distances)-1)
while True:
path.append(str(nxt[1] + 1))
if (nxt[0][1] is None): break
nxt = (distances[nxt[0][1]], nxt[0][1])
return path
v, e = map(int, input().split())
graph = [[] for i in range(v)]
for i in range(e):
o, d, w = map(int, input().split())
o -= 1
d -= 1
graph[o].append((d, w))
graph[d].append((o, w))
path = reconstruct(dijkstra(graph, 0))
if (path[-1] != "1"):
print("-1")
else:
path.reverse()
print(" ".join(path))
| 9 | PYTHON3 |
from sys import stdin,stdout,setrecursionlimit
from collections import defaultdict
from threading import stack_size,Thread
setrecursionlimit(10**6)
stack_size(2**25)
adj=defaultdict(list)
visited=[False]*(100001)
intime=[0]*(100001)
outtime=[0]*(100001)
res=[]
bridge=False
timer=0
def dfs(node,par):
global adj, visited, intime, outtime, res, bridge,timer
visited[node]=True
intime[node]=timer
outtime[node]=timer
timer+=1
for j in adj[node]:
if j==par:
continue
if visited[j]:
outtime[node]=min(outtime[node],intime[j])
if intime[node]>intime[j]:
res.append((node,j))
else:
dfs(j,node)
if outtime[j]>intime[node]:
bridge=True
return
res.append((node,j))
outtime[node] = min(outtime[node], outtime[j])
def solve():
n,m=map(int,stdin.readline().split())
global adj,visited,intime,outtime,res,bridge,timer
timer=0
bridge=False
for i in range(m):
u,v=map(int,stdin.readline().split())
adj[u].append(v)
adj[v].append(u)
dfs(1,-1)
if bridge:
print(0)
else:
for i in range(len(res)):
print(*res[i])
if __name__=='__main__':
#solve()
Thread(target=solve).start()
| 11 | PYTHON3 |
a=list(map(int,input().split()))
b=list(map(int,input().split()))
n=int(input())
c=0
if(sum(a)%5==0):
c+=sum(a)//5
else:
c+=sum(a)//5+1
if(sum(b)%10==0):
c+=sum(b)//10
else:
c+=sum(b)//10+1
if(c<=n):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
def main():
num = int(input())
arr = []
while num > 0:
arr.append(input())
num -= 1
for word in arr:
if len(word) > 10:
abbr = word[0] + str(len(word[1:len(word)-1])) + word[-1]
print(abbr)
else:
print(word)
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
from collections import defaultdict
n = int(input())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
#c = [(a[i] - b[i]) for i in range(0, n)]
c = [0] * n
d = defaultdict()
for i in range(0, n):
c[i] = a[i] - b[i]
if not (c[i] in d):
d[c[i]] = 0
if c[i] > 0:
d[c[i]] += 1
if c[i] < 0:
c[i] = -c[i]
c.sort()
tot = 0
for i in range(0, n):
if not(c[i] in d):
continue
if d[c[i]] > 0:
tot += i
d[c[i]] -= 1
print(tot)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int main() {
int n, m, ff[100100] = {0}, pf[100100] = {0}, a[100100], b[100100], f[100100];
scanf("%d", &n);
scanf("%d", &m);
n++;
m++;
for (int(i) = (1); (i) < (n); ++(i)) {
scanf("%d", &f[i]);
ff[f[i]]++;
pf[f[i]] = i;
}
for (int(i) = (1); (i) < (m); ++(i)) {
scanf("%d", &b[i]);
}
int g = 1;
for (int(i) = (1); (i) < (m); ++(i)) {
if (ff[b[i]] == 0) {
printf("Impossible\n");
return (0);
} else if (ff[b[i]] > 1) {
g = 0;
} else {
a[i] = pf[b[i]];
}
}
if (g) {
printf("Possible\n");
for (int(i) = (1); (i) < (m); ++(i)) {
printf("%d ", a[i]);
}
} else {
printf("Ambiguity\n");
}
return (0);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 512;
struct LR {
int l, r;
LR(int l = 0, int r = 0) : l(l), r(r) {}
};
int n, t1[N];
char m[N][N];
int row[N], col[N], mark[N];
int q[N], cq;
void gg() {
printf("NO\n");
exit(0);
}
void reverseC(int c1, int c2) {
while (c1 < c2) swap(col[c1++], col[--c2]);
}
LR getLR(int row, int c1, int c2) {
int lf = n, rf = 0;
for (int c = c1; c < c2; c++)
if (m[row][col[c]] == '1') {
lf = min(mark[col[c]], lf);
rf = max(mark[col[c]], rf);
}
return LR(lf, rf);
}
int markRight(int c, int cright) {
int cz = c;
while (cz < cright && mark[col[cz]] == mark[col[c]]) ++cz;
return cz;
}
int sortRow(int row, int c1, int c2) {
cq = 0;
for (int i = c1; i < c2; i++)
if (m[row][col[i]] == '1') q[cq++] = col[i];
int ret = cq;
for (int i = c1; i < c2; i++)
if (m[row][col[i]] == '0') q[cq++] = col[i];
for (int i = c1; i < c2; i++) col[i] = q[i - c1];
return c1 + ret;
}
void reMarks(int row, int c1, int c2) {
int cur = c1;
q[col[c1]] = cur;
for (int c = c1 + 1; c < c2; c++) {
if (mark[col[c]] == mark[col[c - 1]] &&
m[row][col[c]] == m[row][col[c - 1]])
q[col[c]] = cur;
else
q[col[c]] = cur = c;
}
for (int c = c1; c < c2; c++) mark[col[c]] = q[col[c]];
}
void solve(int r1, int r2, int c1, int c2) {
int sel = -1, selt = -1;
for (int r = r1; r < r2; r++)
if (t1[row[r]] > selt) selt = t1[row[sel = r]];
swap(row[r1], row[sel]);
int mid = sortRow(row[r1], c1, c2);
reMarks(row[r1], c1, c2);
for (int cr = r1 + 1; cr < r2; cr++) {
int selRow = -1, minL = n + 1, maxR = -1;
for (int r = cr; r < r2; r++) {
LR lr = getLR(row[r], c1, c2);
if (lr.l < minL || lr.l == minL && lr.r > maxR)
selRow = r, minL = lr.l, maxR = lr.r;
}
if (minL == maxR) {
int pp = cr;
for (int r = cr; r < r2; r++) {
LR lr = getLR(row[r], c1, c2);
if (lr.l == minL && lr.r == maxR) swap(row[r], row[pp++]);
}
solve(cr, pp, minL, markRight(minL, c2));
cr = pp - 1;
} else {
swap(row[cr], row[selRow]);
int Row = row[cr];
int cx = minL;
while (cx < c2) {
int cy = markRight(cx, c2);
sortRow(Row, cx, cy);
cx = cy;
}
bool already = false;
cx = c1;
while (cx < mid) {
int cy = markRight(cx, c2);
if (cy >= mid) break;
if (m[Row][col[cx]] == '1' && m[Row][col[cy - 1]] == '0' &&
m[Row][col[cy]] == '1') {
if (already) gg();
reverseC(cx, cy);
already = 1;
}
cx = cy;
}
reMarks(Row, c1, c2);
if (m[Row][col[mid]] == '1') {
int nmid = markRight(mid, c2);
if (m[Row][col[mid - 1]] == '0' && already == 0 &&
(m[Row][col[cx - 1]] == '0')) {
reverseC(cx, mid);
}
if (m[Row][col[mid - 1]] == '0') {
cq = 0;
for (int i = mid; i < nmid; i++) q[cq++] = col[i];
for (int i = c1; i < mid; i++) q[cq++] = col[i];
for (int i = c1; i < nmid; i++) col[i] = q[i - c1];
}
mid = nmid;
reMarks(Row, c1, c2);
}
int cnt = (m[Row][col[c1]] - '0');
for (int c = c1 + 1; c < c2; c++)
if (m[Row][col[c - 1]] == '0' && m[Row][col[c]] == '1') cnt++;
if (cnt > 1) gg();
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", m[i]);
for (int j = 0; j < n; j++) t1[i] += m[i][j] - '0';
row[i] = col[i] = i;
}
solve(0, n, 0, n);
printf("YES\n");
for (int i = 0; i < n; i++, printf("\n"))
for (int j = 0; j < n; j++) printf("%c", m[i][col[j]]);
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
#define val first
#define id second
using namespace std;
const int N=1e6+10;
int a[N],n,ans[N],r;
pair<int,int> x[N];
struct SegTree{
int mx[N],mn[N],tag[N];
#define ls (rt<<1)
#define rs ((rt<<1)|1)
#define middef int mid=(l+r)>>1
void _add(int rt,int v){tag[rt]+=v,mx[rt]+=v,mn[rt]+=v;}
void push_down(int rt){if(tag[rt])_add(ls,tag[rt]),_add(rs,tag[rt]),tag[rt]=0;}
void push_up(int rt){
mx[rt]=max(mx[ls],mx[rs]);
mn[rt]=min(mn[ls],mn[rs]);
}
void add(int L,int R,int v,int l=0,int r=n,int rt=1){
if(r<L||R<l)return;
if(L<=l&&r<=R)return _add(rt,v);
middef;push_down(rt);
add(L,R,v,l,mid,ls);
add(L,R,v,mid+1,r,rs);
push_up(rt);
}
void build(int l=0,int r=n,int rt=1){
if(l==r)return _add(rt,a[l]);
middef;
build(l,mid,ls),build(mid+1,r,rs);
push_up(rt);
}
int get_max(int L,int R,int l=0,int r=n,int rt=1){
if(r<L||R<l)return -1e9;
if(L<=l&&r<=R)return mx[rt];
middef;push_down(rt);
return max(get_max(L,R,l,mid,ls),get_max(L,R,mid+1,r,rs));
}
int get_min(int L,int R,int l=0,int r=n,int rt=1){
if(r<L||R<l)return 1e9;
if(L<=l&&r<=R)return mn[rt];
middef;push_down(rt);
return min(get_min(L,R,l,mid,ls),get_min(L,R,mid+1,r,rs));
}
}s,t;
int main(){
cin>>n;
for(int i=1;i<=n;++i)cin>>x[i].val,x[i].id=i,a[i]=a[i-1]+1;
s.build();
for(int i=1;i<=n;++i)a[i]=a[i-1]-1;
t.build();
sort(x+1,x+n+1);
for(int i=1;i<=n;i=r+1){
r=i;
while(r<=n&&x[r].val==x[i].val)r++;
r--;
for(int j=i;j<=r;++j)
t.add(x[j].id,n,2);
for(int j=i;j<=r;++j){
int res=t.get_max(x[j].id,n)-t.get_min(0,x[j].id-1)-1;
res/=2;
ans[x[j].id]=max(ans[x[j].id],res);
res=s.get_max(x[j].id,n)-s.get_min(0,x[j].id-1);
res/=2;
ans[x[j].id]=max(ans[x[j].id],res);
}
for(int j=i;j<=r;++j)
s.add(x[j].id,n,-2);
}
for(int i=1;i<=n;++i)cout<<ans[i]<<" ";
}
| 12 | CPP |
from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *
####################################---fast-input-output----#########################################
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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:
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")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
def input(): return stdin.readline().strip()
def fast(): return stdin.readline().strip()
def zzz(): return [int(i) for i in fast().split()]
z, zz = fast, lambda: (map(int, z().split()))
szz, graph, mod, szzz = lambda: sorted(
zz()), {}, 10**9 + 7, lambda: sorted(zzz())
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def output(answer, end='\n'): stdout.write(str(answer) + end)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try
"""
##################################################---START-CODING---###############################################
n = int(z())
lst = []
me = sum(zzz())
for i in range(n-1):
lst.append(sum(zzz()))
lst =sorted(lst)
print(n-bisect(lst,me)) | 7 | PYTHON3 |
n = int(input())
a = sorted(list(map(int, input().split())))
ans = 0
neg = 0
zer = 0
for i in a:
if i > 0:
if i != 1:
ans += i - 1
elif i < 0:
if i != -1:
ans += abs(i + 1)
neg += 1
else:
ans += 1
zer += 1
if neg % 2 == 1 and zer == 0:
print(ans + 2)
else:
print(ans) | 8 | PYTHON3 |
t =int(input())
def isdia(tu):
ro,col = tu
a1,a2 = ro
b1,b2 = col
if b1 == a2:
return True
return False
def findT(tu):
ro,col = tu
a1,a2 = ro
b1,b2 = col
return ((a1,b1),(a2,b2))
while t:
t -= 1
n,m = list(map(int,input().split(" ")))
a = n
mat = []
d = dict()
while a:
a -= 1
a1,a2 = list(map(int,input().split(" ")))
b1,b2 = list(map(int,input().split(" ")))
tu = ((a1,a2),(b1,b2))
d[tu] = 1
if m % 2 == 1:
print("NO")
else:
flag1 = 0
flag2 = 0
for i in d:
if isdia(i):
flag1 = 1
break
for tu in d:
ab = findT(tu)
if d.get(tu) != None:
flag2 = 1
break
if flag1 and flag2:
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
a,b = input().split()
a = int(a)
b = int(b)
c = 0
while a <= b :
c+=1
a = a * 3
b = b * 2
print(c)
| 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
arr = [int(i) for i in input().split()]
c_arr = [0,0,0]
for i in arr:
c_arr[i%3] += 1
ans = c_arr[0]
temp = min(c_arr[1:])
ans += temp
ans += ((c_arr[1] if c_arr[1]>c_arr[2] else c_arr[2])-temp)//3
print(ans) | 8 | PYTHON3 |
s = input()
l = [i for i in s]
st = set(l)
k = int(input())
if len(st)>=k:
print(0)
elif k>len(l):
print("impossible")
else:
print(k-len(st)) | 7 | PYTHON3 |
import sys
n = input()
n = int(n)
m = 0
while(n):
n = n - 1
x = 0
string = input()
stringset = string.split()
for sr in stringset:
num = int(sr)
if(num==1):
x = x + 1
if(x>1):
m = m + 1
print (m) | 7 | PYTHON3 |
while True:
f = input()
_, op, _ = f.split()
if op == '?':
break
print(int(eval(f))) | 0 | PYTHON3 |
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
T = int(input())
i = 0
while (i < T):
i += 1
n, a, b = [int(k) for k in input().split()]
temp = ''
result = ''
for j in range(b):
temp += chr(ord('a') + j)
if (len(temp) == n % b):
temp2 = temp
while (len(result) <= n - b):
result += temp
if (n % b != 0):
result += temp2
print(result)
| 8 | PYTHON3 |
def solve(h, m):
return (23 - h)*60 + 60 - m
def main():
for _ in range(int(input())):
h, m = list(map(int, input().split()))
print(solve(h, m))
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t = 1;
while (t--) {
long long n, k = 1;
cin >> n;
long long arr[n][n];
for (int i = 0; i < n; ++i) {
if (i % 2 == 0) {
for (int j = 0; j < n; ++j) {
arr[j][i] = k;
k++;
}
} else {
for (int j = n - 1; j >= 0; --j) {
arr[j][i] = k;
k++;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cout << arr[i][j] << " ";
}
cout << endl;
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long double x, y;
basic_string<int> id;
bool operator<(pt b) const {
if (x != b.x) return x < b.x;
return y < b.y;
}
};
bool ispod(pt a, pt b) { return a.x <= b.x && a.y <= b.y; }
long double det(pt a, pt b, pt c) {
return a.x * b.y + b.x * c.y + c.x * a.y - a.y * b.x - b.y * c.x - c.y * a.x;
}
int n, nn, m, h;
pt a[200005], b[200005], c[200005];
map<pair<int, int>, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
if (mp.count({x, y}))
a[mp[{x, y}]].id += i;
else {
a[nn].x = (long double)1 / x;
a[nn].y = (long double)1 / y;
a[nn].id = {i};
mp[{x, y}] = nn;
nn++;
}
}
sort(a, a + nn);
for (int i = 0; i < nn; i++) {
while (h >= 2 && det(c[h - 2], c[h - 1], a[i]) < -1e-16) h--;
c[h++] = a[i];
}
{
basic_string<int> sol;
for (int i = 0; i < h; i++) sol += c[i].id;
sort(sol.begin(), sol.end());
for (int x : sol) cerr << x << ' ';
cerr << '\n';
}
while (h >= 2 && ispod(c[h - 2], c[h - 1])) h--;
basic_string<int> sol;
for (int i = 0; i < h; i++) sol += c[i].id;
sort(sol.begin(), sol.end());
for (int x : sol) cout << x << ' ';
cout << '\n';
}
| 11 | CPP |
n = int(input())
home = list()
guest = list()
for i in range(n):
a, b = map(int, input().split())
home.append(a)
guest.append(b)
c = 0
for i in range(n):
color = home[i]
for j in range(n):
if i != j and color == guest[j]:
c += 1
print(c) | 7 | PYTHON3 |
n = int(input())
l = [int(e) for e in input().split()]
count = 1
m = -1
for i in range(len(l) - 1):
if l[i] > l[i + 1]:
m = max(m, count)
count = 1
else:
count += 1
print(max(m, count))
| 7 | PYTHON3 |
from sys import stdin
#####################################################################
def iinput(): return int(stdin.readline())
def sinput(): return input()
def minput(): return map(int, stdin.readline().split())
def linput(): return list(map(int, stdin.readline().split()))
#####################################################################
t = iinput()
while t:
t-=1
n, m= minput()
print((n*m+1)//2) | 7 | PYTHON3 |
a=int(input())
if a%4==0:
print("1","A")
elif a%4==2:
print("1","B")
elif a%4==3:
print("2","A")
elif a%4==1:
print("0","A") | 7 | PYTHON3 |
n,m,a,b = list(map(int,input().split()))
k=n*a
c=(n//m)*b + b
p=(n//m)*b + (n%m)*a
i=min(k,c,p)
print(i) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > q;
int n, x[110];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i];
sort(x, x + n);
for (int i = 0; i < n; i++) {
if (!q.empty() && q.top() <= x[i]) {
x[i] = q.top() + 1;
q.pop();
q.push(x[i]);
} else
q.push(1);
}
cout << q.size() << endl;
}
| 7 | CPP |
import sys
from bisect import bisect
input = sys.stdin.readline
def solve():
n = int(input())
*a, = map(int, input().split())
z = a.copy()
z.sort()
p = [0]*n
F = [0]*n
C = [0]*n
for i in range(n):
x = bisect(z, a[i]) - 1
p[i] = x
C[x] += 1
while x < n:
F[x] += 1
x = x | (x + 1)
#b = [False]*n
r = 0
for i in range(n-1,-1,-1):
#c1 = 0
#c2 = 0
#for j in range(i):
# c1 += a[i] < a[j]
# c2 += a[i] > a[j]
c = 0
x = p[i]
while x >= 0:
c += F[x]
x = (x & (x + 1)) - 1
#if c - C[p[i]] != c2:
# print(C)
# print('wut', i, p[i], c2, c - C[p[i]], c, C[p[i]])
x = p[i]
#b[i] = c2 < c1
r += min(c - C[x], i + 1 - c)
C[x] -= 1
while x < n:
F[x] -= 1
x = x | (x + 1)
print(r)
for i in range(int(input())):
solve()
| 11 | PYTHON3 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
int n;
while(cin>>n,n){
vvi dp(3,vi(3));
char a,b,c;
cin>>a>>b>>c;
a-='A';b-='A';c-='A';
dp[a/3][a%3]=1;
// dp[c/3][c%3]=-1;
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
rep(q,n){
vvi nd(3,vi(3));
rep(i,3)rep(j,3)rep(k,4){
int x=i+dx[k];
int y=j+dy[k];
if(x<0||y<0||x>=3||y>=3||c/3==x&&c%3==y)
x-=dx[k],y-=dy[k];
nd[x][y]+=dp[i][j];
}
dp=nd;
}
double out=dp[b/3][b%3];
printf("%.9f\n",out/pow(4,n));
}
} | 0 | CPP |
t = int(input())
for i in range(t):
n, x = map(int, input().split())
deg_of_x = 0
for j in range(n-1):
u, v= map(int, input().split())
if u == x or v == x:
deg_of_x += 1
if deg_of_x <= 1:
print("Ayush")
elif (n %2) == 0:
print("Ayush")
else:
print("Ashish")
| 9 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 5 10:04:35 2019
@author: plosi
"""
def main():
n=int(input())
s=input()
ct=0
for i in range(n):
if s[i]=="1":
ct=ct+1;
if (n-ct)!=ct:
print(1)
print(s)
else:
print(2)
print(s[0:n-1]+" "+s[n-1]);
main() | 7 | PYTHON3 |
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
int main(){
string s,a;
int n = 0;
while(getline(cin,s)){
for(int i = 0;i < s.length();++i){
if('0' <= s[i] && s[i] <= '9' && i < s.length()){
a = s[i];
++i;
while('0' <= s[i] && s[i] <= '9' && i < s.length()){
a += s[i];
++i;
}
n += atoi(a.c_str());
}
}
}
cout << n << endl;
return 0;
} | 0 | CPP |
#!/usr/bin/env python3
from math import *
from itertools import *
from collections import *
from bisect import *
if __name__ == '__main__':
n = input()
if n == '0':
print(0)
else:
if len(n) % 2 == 0:
print(len(n)//2)
else:
if n.count('1') == 1:
print(len(n)//2)
else:
print(len(n)//2+1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pos;
vector<vector<int>> a;
vector<int> b;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, R, r;
cin >> n >> R >> r;
if (n == 1) {
cout << (r < R + 1e-8 ? "YES\n" : "NO\n");
return 0;
}
if (n == 2) {
cout << (2 * r < R + 1e-8 ? "YES\n" : "NO\n");
return 0;
}
double a = (R - r) * sin(acos(-1) / n);
if (a + 1e-8 > r) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pi;
void solve()
{
int n;
cin >> n;
int a[n];
for(int i=0;i<n;i++)
cin >> a[i];
vector<int> s;
for(int i=0;i<n;i++)
{
if(a[i]==1)
{
s.push_back(a[i]);
}
else
{
while(s.size()>0&&s[s.size()-1]!=a[i]-1)
{
s.pop_back();
}
if(s.size()>0)
s.pop_back();
s.push_back(a[i]);
}
for(int j=0;j<s.size();j++)
{
if(j!=s.size()-1)
cout << s[j] << ".";
else
cout << s[j] << endl;
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while(t--)
{
solve();
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define x first
#define y second
typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x,T y){x<y?x=y:T();}
template <typename T> void chkmin(T &x,T y){y<x?x=y:T();}
template <typename T> void readint(T &x)
{
x=0;int f=1;char c;
for(c=getchar();!isdigit(c);c=getchar())if(c=='-')f=-1;
for(;isdigit(c);c=getchar())x=x*10+(c-'0');
x*=f;
}
/*const int MOD=;
inline int dmy(int x){return x>=MOD?x-MOD:x;}
inline void inc(int &x,int y){x=dmy(x+y);}
int qmi(int x,int y)
{
int ans=1;
for(;y;y>>=1,x=1ll*x*x%MOD)
if(y&1)ans=1ll*ans*x%MOD;
return ans;
}*/
const int MAXN=300005;
int n,a[MAXN],b[MAXN],as[MAXN];
vector<int> G[MAXN];
int pa[MAXN],vis[MAXN],p[MAXN],dep[MAXN],deg[MAXN];
void dfs1(int u)
{
for(auto v:G[u])
{
pa[v]=u;
dep[v]=dep[u]+1;
dfs1(v);
}
}
void dfs2(int u,int &dfn_cnt)
{
if(!vis[u])vis[u]=++dfn_cnt;
for(auto v:G[u])dfs2(v,dfn_cnt);
}
void check(const int *tp,ll d)
{
ll td=d;
memcpy(p,tp,sizeof(p));
memcpy(a,as,sizeof(a));
for(int i=1;i<=n;++i)
sort(G[i].begin(),G[i].end(),[&](int x,int y){return p[x]<p[y];});
int dfn_cnt=0;
memset(vis,0,sizeof(vis));
dfs2(1,dfn_cnt);
for(int i=1;i<=n;++i)
if(p[i]!=vis[i])exit(0*printf("NO\n"));
priority_queue<pii,vector<pii>,greater<pii> > pq;
for(int i=1;i<=n;++i)deg[i]=G[i].size();
for(int i=1;i<=n;++i)if(!deg[i])pq.push(mp(p[i],i));
memset(vis,0,sizeof(vis));
dfn_cnt=0;
for(int i=1;i<=n;++i)
{
++dfn_cnt;
int u=pq.top().y;pq.pop();
if(d>=dep[u])
{
d-=dep[u],vis[u]=i;
--deg[pa[u]];
if(!deg[pa[u]])pq.push(mp(p[pa[u]],pa[u]));
}
else
{
while(d<dep[u])u=pa[u];
vis[u]=i;
break;
}
}
dfs2(1,dfn_cnt);
for(int i=1;i<=n;++i)
if(vis[i]!=a[i])exit(0*printf("NO\n"));
printf("YES\n");
printf("%lld\n",td);
for(int i=1;i<=n;++i)printf("%d ",p[i]);
putchar('\n');
exit(0);
}
int main()
{
#ifdef LOCAL
freopen("code.in","r",stdin);
// freopen("code.out","w",stdout);
#endif
ll d=0;
readint(n);
for(int i=1;i<=n;++i)readint(a[i]),as[i]=a[i];
for(int i=1;i<=n;++i)b[a[i]]=i;
for(int i=1,u,v;i<n;++i)readint(u),readint(v),G[u].pb(v);
dfs1(1);
int r=a[1];
if(r==1)check(as,0);
for(int i=b[r-1];i!=1;i=pa[i])a[i]=a[pa[i]],++d;
a[1]=r-1;
for(int i=1;i<=n;++i)b[a[i]]=i;
int dfn=0;
vis[1]=++dfn;
for(int i=1;i<r-1;++i)
{
vector<int> al;
for(int u=b[i];!vis[u];u=pa[u])al.pb(u);
reverse(al.begin(),al.end());
for(auto u:al)vis[u]=++dfn;
d+=dep[b[i]];
}
for(int i=1;i<=n;++i)
if(!vis[i])vis[i]=a[i];
check(vis,d);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[26], last[26];
int main() {
string s;
cin >> s;
int n = s.size();
memset(a, 0x3f, sizeof(a));
for (int i = 0; i < n; ++i) {
if (a[s[i] - 'a'] == 0x3f3f3f3f) {
a[s[i] - 'a'] = i + 1;
} else {
a[s[i] - 'a'] = max(a[s[i] - 'a'], i - last[s[i] - 'a']);
}
last[s[i] - 'a'] = i;
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < 26; ++i) {
a[i] = max(n - last[i], a[i]);
ans = min(ans, a[i]);
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
n,m = map(int,input().split())
list_of_count_name = list(map(int,input().split()))
sum_name = 0
page_turned = 0
ans = ''
for i in range(n):
sum_name += list_of_count_name[i]
turning = (sum_name //m) - page_turned
page_turned += turning
if i == n-1:
ans+=str(turning)
else:
ans+=str(turning)
ans+=' '
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 2;
long long a[N];
long long s[N];
long long rmq[N][20];
long long get(long long l, long long r) {
long long k = log2(r - l + 1);
return min(rmq[l][k], rmq[r - (1 << k) + 1][k]);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, C;
cin >> n >> C;
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long x;
cin >> a[i] >> x;
s[i] = s[i - 1] + C - x;
ans = max(ans, C - x);
rmq[i][0] = s[i];
}
for (long long i = 1; i < n; ++i) a[i] = a[i + 1] - a[i];
for (long long i = 0; i < 18; ++i)
for (long long j = 0; j + (2 << i) - 1 <= n; ++j)
rmq[j][i + 1] = min(rmq[j][i], rmq[j + (1 << i)][i]);
stack<long long> st;
multiset<long long> ms;
ms.insert(1e18);
for (long long i = 1; i < n; ++i) {
long long R = i - 1;
while (st.size() && a[st.top()] <= a[i]) {
long long L = st.top();
if (L < R) ms.erase(ms.find(get(L, R - 1) + a[R] * a[R]));
R = L;
st.pop();
}
long long L = st.size() ? st.top() : 0;
if (L < R) ms.erase(ms.find(get(L, R - 1) + a[R] * a[R]));
ms.insert(get(L, i - 1) + a[i] * a[i]);
ans = max(ans, s[i + 1] - *ms.begin());
st.push(i);
}
cout << ans << endl;
}
| 13 | CPP |
import sys
from collections import Counter as C
# sys.stdin = open('in.txt', 'r')
# sys.stdout = open('out.txt', 'w')
if(len(set(input()))&1):
print('IGNORE HIM!')
else:
print('CHAT WITH HER!') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a = 0, b = 0;
void move1(int i) {
if (i > 0) i -= n;
a = (a - i) % n;
b = (b - i) % n;
if ((i + n) % 2 == 1) swap(a, b);
}
void move2() {
a--;
b++;
if (a < 0) a += n;
if (b >= n) b -= n;
swap(a, b);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < q; i++) {
int temp;
scanf("%d", &temp);
if (temp == 1) {
scanf("%d", &temp);
move1(temp);
} else
move2();
}
for (int i = 1; i <= n; i++) {
if (i % 2 == 1) {
printf("%d ", (a + i - 1) % n + 1);
} else
printf("%d ", (b + i - 1) % n + 1);
}
cout << endl;
return 0;
}
| 10 | CPP |
Subsets and Splits