solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
n, c, b = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
cost = 0
m = min(c, b)
if n % 2 != 0:
if a[(n//2)] == 2:
cost += m
for i in range(n//2):
if a[i] == a[n-i-1] == 2:
cost += 2 * m
elif a[i] != a[n-i-1] and a[i] != 2 and a[n-i-1] != 2:
print(-1)
break
elif (a[i] == 2 and a[n-i-1] == 0) or (a[i] == 0 and a[n-i-1] == 2):
cost += c
elif (a[i] == 2 and a[n-i-1] == 1) or (a[i] == 1 and a[n-i-1] == 2):
cost += b
else:
print(cost)
| 7 | PYTHON3 |
n=int(input())
b=list(map(int,input().split()))
mx=0;a=[]
for item in b:
s=item+mx
mx=max(mx,s)
a.append(str(s))
print(" ".join(a)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
const long long int MAXN = 3e5 + 15, md = 998244353, inf = 1e15;
unordered_map<long long int, long long int, custom_hash> t;
long long int tav(long long int n, long long int k) {
long long int res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
res %= md;
}
n *= n;
n %= md;
k /= 2;
}
return res;
}
long long int dv(long long int a, long long int b) {
a %= md;
b %= md;
if (!t.count(b)) {
t[b] = tav(b, md - 2);
}
long long int res = 1ll * a * t[b] % md;
return res;
}
vector<long long int> adj[MAXN];
long long int dp[MAXN][3];
void DFS(long long int r, long long int par) {
for (auto i : adj[r]) {
if (i == par) continue;
DFS(i, r);
}
dp[r][0] = 1;
for (auto i : adj[r]) {
if (i == par) continue;
dp[r][0] *= dp[i][0] + dp[i][1];
dp[r][0] %= md;
}
dp[r][2] = 1;
for (auto i : adj[r]) {
if (i == par) continue;
dp[r][2] *= dp[i][0] + 2 * dp[i][1];
dp[r][2] %= md;
}
dp[r][1] = 0;
for (auto i : adj[r]) {
if (i == par) continue;
long long int h = dv(dp[r][2], dp[i][0] + 2 * dp[i][1]) * dp[i][2] % md;
dp[r][1] += h;
}
dp[r][1] %= md;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
for (long long int i = 1; i < n; i++) {
long long int v, u;
cin >> v >> u;
v--;
u--;
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(0, -1);
cout << (dp[0][0] + dp[0][1]) % md << '\n';
return 0;
}
| 9 | CPP |
for i in[*open(0)][1:]:l=[i.count("S"),i.count("P"),i.count("R")];print(["R","S","P"][l.index(max(l))]*(len(i)-1)) | 8 | PYTHON3 |
n=int(input())
mishka=0
chris=0
for _ in range(n):
m,c=map(int,input().split())
if m>c:
mishka+=1
if c>m:
chris+=1
if mishka>chris:
print('Mishka')
elif mishka<chris:
print('Chris')
else:
print('Friendship is magic!^^') | 7 | PYTHON3 |
count=0
arr=input()
for i in range (0, len(arr), 1):
if arr[i]=='4' or arr[i]=='7':
count+=1
if count==4 or count==7:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
n = int(input())
x = list(map(int, input().split()))
a = 2 * [0]
for i in range(n):
if x[i] == 25:
a[0] += 1
elif x[i] == 50:
if a[0] < 1:
print('NO')
break
else:
a[0] -= 1
a[1] += 1
elif x[i] == 100:
if (a[0] < 3 and a[1] == 0) or a[0] == 0:
print('NO')
break
else:
if a[1] != 0:
a[1] -= 1
a[0] -= 1
else:
a[0] -= 3
if i == n - 1:
print('YES')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(10, 0), b(10, 0);
string n;
string num;
cin >> n >> num;
for (auto w : num) {
a[w - '0']++;
}
int minimum = INT_MAX;
for (auto w : n) b[w - '0']++;
for (int i = 0; i < 10; i++) {
if (i != 2 && i != 6 && i != 5 && i != 9 && b[i] > 0)
minimum = min(minimum, a[i] / b[i]);
}
if (b[2] + b[5] > 0) minimum = min(minimum, (a[2] + a[5]) / (b[2] + b[5]));
if (b[6] + b[9] > 0) minimum = min(minimum, (a[6] + a[9]) / (b[6] + b[9]));
cout << minimum;
return 0;
}
| 8 | CPP |
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <memory>
#include <string>
#include <algorithm>
#include <complex>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <bitset>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
#define strtok_r strtok_s
#endif
#define ITER(c) __typeof__((c).begin())
#define FOREACH(it, c) for (ITER(c) it=(c).begin(); it != (c).end(); ++it)
#define RITER(c) __typeof__((c).rbegin())
#define RFOREACH(it, c) for (RITER(c) it=(c).rbegin(); it != (c).rend(); ++it)
#define REP(i, n) REPEAT(i, 0, n)
#define RREP(i, n) RREPEAT(i, 0, n);
#define REPEAT(i, k, n) for(int i = (k); i < (k+n); ++i)
#define RREPEAT(i, k, n) for(int i = (k)+(n)-1; i >= (k); ++i)
#define ALL(c) (c).begin(), (c).end()
#define LLPOW(p1,p2) ((ll)pow((double)(p1), (int)p2))
#define ESIZEOF(A) (sizeof(A)/sizeof((A)[0]))
#define MIN(p1,p2) (((p1)<(p2))?(p1):(p2))
#define MAX(p1,p2) (((p1)>(p2))?(p1):(p2))
#define CIN_NO_SYNC do { cin.tie(0); ios_base::sync_with_stdio(false); } while(0)
#define GETSTR(p) fgets((p), sizeof(p), stdin)
#define CHOMP(p) do{ char *_q = (p) + strlen(p)-1; if(*_q == '\n' || *_q == '\r') *_q = 0; } while(0)
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef unsigned long long ull;
#define X real()
#define Y imag()
typedef double D;
typedef complex<D> P;
#define EPS (1e-9)
#ifdef _DEBUG
#define pf printf
#define pr(n) do { cout << #n " = " << (n) << endl; } while(0)
#else
#define pf(...) /* */
#define pr(...) /* */
#endif
struct t {
char code;
const char *bs1;
const char *bs2;
} table[] = {
{ ' ', "101", "11010" },
{ '\'', "000000", "11110" },
{ ',', "000011", "11100" },
{ '-', "10010001", "11101" },
{ '.', "010001", "11011" },
{ '?', "000001", "11111" },
{ 'A', "100101", "00000" },
{ 'B', "10011010", "00001" },
{ 'C', "0101", "00010" },
{ 'D', "0001", "00011" },
{ 'E', "110", "00100" },
{ 'F', "01001", "00101" },
{ 'G', "10011011", "00110" },
{ 'H', "010000", "00111" },
{ 'I', "0111", "01000" },
{ 'J', "10011000", "01001" },
{ 'K', "0110", "01010" },
{ 'L', "00100", "01011" },
{ 'M', "10011001", "01100" },
{ 'N', "10011110", "01101" },
{ 'O', "00101", "01110" },
{ 'P', "111", "01111" },
{ 'Q', "10011111", "10000" },
{ 'R', "1000", "10001" },
{ 'S', "00110", "10010" },
{ 'T', "00111", "10011" },
{ 'U', "10011100", "10100" },
{ 'V', "10011101", "10101" },
{ 'W', "000010", "10110" },
{ 'X', "10010010", "10111" },
{ 'Y', "10010011", "11000" },
{ 'Z', "10010000", "11001" },
};
void solve(string &s){
string bs;
int n = ESIZEOF(table);
FOREACH(it, s){
char c = *it;
REP(i,n){
if(c == table[i].code){
bs += table[i].bs1;
break;
}
}
}
while(bs.size() % 5 != 0){
bs += "0";
}
for(size_t i = 0; i < bs.size(); i += 5){
string sbs = bs.substr(i,5);
REP(j,n){
if(sbs == table[j].bs2){
printf("%c", table[j].code);
break;
}
}
}
printf("\n");
}
int main(){
string s;
while(getline(cin,s)){
solve(s);
}
return 0;
} | 0 | CPP |
#include <iostream>
using namespace std;
int main()
{
unsigned long long n,a,s,g=0,q[100001];
cin>>n>>a>>s;
for(int i=1;i<=n;i++)
cin>>q[i];
for(int i=2;i<=n;i++)
if((q[i]-q[i-1])*a>s)
g+=s;
else
g+=(q[i]-q[i-1])*a;
cout<<g<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
for (int i = 0; i < 10; i++) {
if ((a * 10 + i) % b == 0) {
cout << a << i;
for (; n > 1; n--) cout << 0;
cout << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 7 | CPP |
n=int(input())
s=list(map(int,input().split()))
value=0
for i in range(n):
value+=max(s)-int(s[i])
print(value) | 7 | PYTHON3 |
for _ in range(int(input())):
a,b = map(int,input().split())
dif=abs(a-b)
ans=dif//10
ans += (dif%10 != 0)
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int INF = 0x3f3f3f3f;
struct actor {
int a, b, k, id;
bool operator<(const actor &p) const {
if (!k) return 0;
if (!p.k) return 1;
return b < p.b;
}
} a[maxn], p[maxn];
bool cmp(actor x, actor y) { return x.a < y.a || x.a == y.a && x.b < y.b; }
int n, m, ans[maxn];
int run() {
sort(p, p + n, cmp);
sort(a, a + m, cmp);
multiset<actor> s;
int j = 0;
for (int i = 0; i < n; i++) {
while (j < m && a[j].a <= p[i].a) s.insert(a[j++]);
multiset<actor>::iterator x = s.begin();
multiset<actor>::iterator it = s.lower_bound(p[i]);
if (it == s.end() || it->k == 0) return 0;
ans[p[i].id] = it->id;
actor t = *it;
t.k--;
s.erase(it);
s.insert(t);
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
p[i].id = i;
p[i].k = -1;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a[i].a >> a[i].b >> a[i].k;
a[i].id = i;
}
if (!run())
puts("NO");
else {
cout << "YES\n" << ans[0] + 1;
for (int i = 1; i < n; i++) cout << " " << ans[i] + 1;
cout << endl;
}
return 0;
}
| 11 | CPP |
n=int(input())
l=list(map(int,input().split()))
su=sum(l)
l.sort(reverse=True)
c,x=0,0
for i in l:
if x<=su:
x+=i
su-=i
c+=1
else:
break
print(c) | 7 | PYTHON3 |
n=int(input().strip())
a=[int(x) for x in input().strip().split(' ')]
a.sort(reverse=True)
s=sum(a)
c=0
sum=0
u=0
for i in a:
if(sum>s):
break
u=i
sum+=u
s=s-u
c+=1
print(c) | 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main() {
int n; cin >> n;
for (int rep=0; rep<n; rep++) {
int x = 0, y = 0;
int maxdist = 0, memox = 0;
int ansx = 0, ansy = 0;
while (1) {
int dx, dy; cin >> dx >> dy; if (dx==0 && dy==0) break;
x += dx; y += dy;
int dist = x*x + y*y;
if (maxdist < dist) {
maxdist = dist;
memox = x;
ansx = x; ansy = y;
} else if (maxdist == dist && x > memox) {
maxdist = dist;
memox = x;
ansx = x; ansy = y;
}
}
cout << ansx << " " << ansy << endl;
}
return 0;
} | 0 | CPP |
#include<bits/stdc++.h>
#define rep(i, l, r) for(int i = (l), i##end = (r);i <= i##end;++i)
using std::cin; using std::cout;
const int maxn = 300200;
typedef long long ll;
const int mod = 998244353;
inline ll pow(ll a,int b,int ans = 1) {
for(;b;b >>= 1,a = a * a % mod) if(b & 1)
ans = ans * a % mod;
return ans;
}
inline ll inverse(int x){ return pow(x, mod - 2); }
int w, h, n;
int x[maxn], y[maxn];
const int N = 3e5 + 5;
int tree[maxn << 2], tag[maxn << 2];
inline void put(int cur,int v) {
tree[cur] += v, tag[cur] += v;
}
inline void down(int cur) {
put(cur << 1, tag[cur]);
put(cur << 1 | 1, tag[cur]);
tag[cur] = 0;
}
inline void add(int ql,int qr,int v,int cur = 1,int l = 0,int r = N) {
if(ql <= l && r <= qr) return put(cur, v);
int mid = l + r >> 1; down(cur);
if(ql <= mid) add(ql, qr, v, cur << 1, l, mid);
if(mid < qr) add(ql, qr, v, cur << 1 | 1, mid + 1, r);
tree[cur] = std::max(tree[cur << 1], tree[cur << 1 | 1]);
}
inline int qry(int ql,int qr,int cur = 1,int l = 0,int r = N) {
if(ql <= l && r <= qr) return tree[cur];
int mid = l + r >> 1, ans = -1e9; down(cur);
if(ql <= mid) ans = std::max(ans, qry(ql, qr, cur << 1, l, mid));
if(mid < qr) ans = std::max(ans, qry(ql, qr, cur << 1 | 1, mid + 1, r));
return ans;
}
std::pair<int, int> a[maxn];
inline void build(int cur = 1,int l = 0,int r = N) {
tag[cur] = 0;
if(l == r) return void(tree[cur] = -a[l].first);
int mid = l + r >> 1;
build(cur << 1, l, mid);
build(cur << 1 | 1, mid + 1, r);
tree[cur] = std::max(tree[cur << 1], tree[cur << 1 | 1]);
}
inline int calc(int * x,int * y,int A) {
std::vector<std::pair<int, int>> vector;
rep(i, 1, n) {
a[i] = std::pair<int, int>(x[i], y[i]);
}
std::sort(a + 1,a + n + 1);
build();
static int stack0[maxn], stack1[maxn];
int top0 = 0, top1 = 0, ans = 0;
const int W = A / 2;
for(int i = 1;i <= n;++i) {
if(i > 1) {
add(stack0[top0], i - 1, A);
ans = std::max(ans, a[i].first + qry(0, i - 2));
add(stack0[top0], i - 1, -A);
}
if(a[i].second >= W) {
for(;top0 && a[stack0[top0]].second > a[i].second;--top0)
add(stack0[top0 - 1], stack0[top0] - 1, - a[stack0[top0]].second);
add(stack0[top0], i - 1, a[i].second), stack0[++top0] = i;
} else {
for(;top1 && a[stack1[top1]].second < a[i].second;--top1)
add(stack1[top1 - 1], stack1[top1] - 1, a[stack1[top1]].second);
add(stack1[top1], i - 1, -a[i].second), stack1[++top1] = i;
}
ans = std::max(ans, A + a[i].first - a[i - 1].first);
}
return ans << 1;
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> w >> h >> n;
rep(i, 1, n) {
std::cin >> x[i] >> y[i];
}
x[++n] = w, y[++n] = h;
std::cout << std::max(calc(x, y, h), calc(y, x, w)) << '\n';
}
| 0 | CPP |
#include <iostream>
#include <string>
using namespace std;
int main(){
int a,b[100],c,min;
min=100;
c=0;
cin>>a;
for(int i=0;i<a;i++){
cin>>b[i];
c=c+b[i];
}
if(c%10>0){
cout<<c<<endl;
}
for(int k=0;k<a;k++){
if(min>b[k] && b[k]%10>0){
min=b[k];
}
}
if(min==100){
cout<<0<<endl;
}
if(c%10==0 && min<100){
cout<<c-min<<endl;
}
} | 0 | CPP |
#include <cstdio>
int main() {
int A, B, K;
scanf("%d %d %d", &A, &B, &K);
for (int i = 100; i > 0; --i)
if (A % i == 0 && B % i == 0)
if (--K == 0) return !printf("%d\n", i);
}
| 0 | CPP |
n = int(input())
def evenodd(n):
if n % 2 == 0:
print("Mahmoud")
else:
print("Ehab")
evenodd(n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 1e9 + 7;
const int N = 3e5 + 7;
const int M = 1e6 + 7;
int dfn[N], low[N], sccno[N], scc, times;
int mx[N], mn[N], s[N], siz[N];
long long sum[N];
vector<int> G[N];
stack<int> st;
void dfs(int u, int fa) {
dfn[u] = low[u] = ++times;
st.push(u);
for (int v : G[u]) {
if (v == fa) continue;
if (!dfn[v]) {
dfs(v, u);
low[u] = min(low[u], low[v]);
} else if (!sccno[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
scc++;
while (1) {
siz[scc]++;
int x = st.top();
st.pop();
sccno[x] = scc;
if (x == u) break;
}
}
}
signed main() {
int n, m, q, u, v;
scanf("%d", &n);
scanf("%d", &m);
while (m--) {
scanf("%d", &u);
scanf("%d", &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i, 0);
for (int i = 1; i <= n; i++) mx[sccno[i]] = i, s[i] = n;
for (int i = n; i; i--) mn[sccno[i]] = i;
for (int i = 1; i <= scc; i++)
if (siz[i] > 1) s[mn[i]] = mx[i] - 1;
for (int i = n - 1; i; i--) s[i] = min(s[i], s[i + 1]);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + s[i] - i + 1;
scanf("%d", &q);
while (q--) {
scanf("%d", &u);
scanf("%d", &v);
int p = lower_bound(s + u, s + v + 1, v) - s;
long long ans = 0ll;
ans += sum[p - 1] - sum[u - 1];
ans += (long long)(v - p + 1ll) * (long long)(v - p + 2ll) / 2ll;
printf("%lld\n", ans);
}
return 0;
}
| 9 | CPP |
n = int(input())
seq = list(map(int, input().split()))
cnt = 0
neg = 0
pos = 0
for s in seq:
if s < 0:
neg += 1
elif s > 0:
pos += 1
else:
cnt += 1
if neg > (n - 1) // 2:
print(-1)
elif pos > (n - 1) // 2:
print(1)
else:
print(0)
| 7 | PYTHON3 |
n=int(input())
arr=list(map(int,input().split()))
maxi=arr[0]
mini=arr[0]
miniIndex=0
maxiIndex=0
temp=1
ans=1
for i in range(1,n):
if abs(mini-arr[i])<=1 and abs(maxi-arr[i])<=1:
if mini==arr[i]:
miniIndex=i
if maxi==arr[i]:
maxiIndex=i
temp+=1
else:
if maxi-arr[i]>1:
mini=arr[i]
j=maxiIndex
while j<n and arr[j]==maxi:
j+=1
if j<n:
maxiIndex=j
maxi=arr[j]
miniIndex=i
temp=(miniIndex-maxiIndex+1)
elif arr[i]-mini>1:
maxi=arr[i]
j=miniIndex
while j<n and arr[j]==mini:
j+=1
if j<n:
miniIndex=j
mini=arr[j]
maxiIndex=i
temp=(maxiIndex-miniIndex+1)
ans=max(ans,temp)
print(ans) | 8 | PYTHON3 |
p,q,r,s=sorted(map(int,input().split()))
y=min(s-q-r,r-p-q)
print(["SEGMENT","IMPOSSIBLE","TRIANGLE"][(y>0)-(y<0)])
| 7 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
b = a[::2]
c = a[1::2]
d = b[:] + c[::-1] + b[0:2]
for i in range(1, n + 1):
if d[i] >= d[i - 1] + d[i + 1]:
print('NO')
break
else:
print('YES')
print(*[d[i] for i in range(n)])
| 8 | PYTHON3 |
#include <iostream>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
char s[52][52];
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
cin >> s[i][j];
}
}
bool can = true;
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
if (s[i][j] == '#' && s[i - 1][j] != '#' && s[i][j - 1] != '#' && s[i + 1][j] != '#' && s[i][j + 1] != '#') can = false;
}
}
if (can) cout << "Yes" << endl;
else cout << "No" << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n];
unordered_map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
m[arr[i]]++;
}
int maxVal = 0;
for (auto x : m) {
maxVal = max(maxVal, x.second);
}
cout << n - maxVal;
}
int main() { solve(); }
| 7 | CPP |
from functools import reduce
import os
import sys
from collections import *
#from fractions import *
from math import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value(): return tuple(map(int, input().split())) # multiple values
def arr(): return [int(i) for i in input().split()] # array input
def sarr(): return [int(i) for i in input()] #array from string
def starr(): return [str(x) for x in input().split()] #string array
def inn(): return int(input()) # integer input
def svalue(): return tuple(map(str, input().split())) #multiple string values
def parr(): return [(value()) for i in range(n)] # array of pairs
mo = 1000000007
inf=1e18
div=998244353
#print("Case #{}:".format(_+1),end=" ")
#print("Case #",z+1,":",sep="",end=" ")
# ----------------------------CODE------------------------------#
for _ in range(inn()):
n=inn()
a=arr()
mx=max(a)
ans=-1
for i in range(n):
if(a[i]==mx):
if((i-1>=0 and a[i-1]<a[i]) or (i+1<n and a[i+1]<a[i])):
ans=i+1
break
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
}
double F[1 << 21 | 5], p[1 << 21 | 5], rs[1 << 21 | 5];
int n, K, tp;
inline int cnt(int x) {
int k = 0;
while (x) k++, x -= x & (-x);
return k;
}
int main() {
read(n), read(K), F[0] = 1;
for (int i = 1; i <= n; i++) scanf("%lf", p + i), tp += (p[i] > 0);
if (tp <= K) {
for (int i = 1; i <= n; i++)
if (p[i] > 0)
printf("1 ");
else
printf("0 ");
return putchar('\n'), 0;
}
for (int i = 0; i < (1 << n); i++) {
double tp = 0;
if (cnt(i) > K) continue;
if (cnt(i) == K) {
for (int j = 0; j < n; j++)
if ((i >> j) & 1) rs[j + 1] += F[i];
continue;
}
for (int j = 0; j < n; j++)
if ((i >> j) & 1) tp += p[j + 1];
F[i] /= (1 - tp);
for (int j = 0; j < n; j++)
if ((i >> j) & 1)
;
else
F[i | (1 << j)] += F[i] * p[j + 1];
}
for (int i = 1; i <= n; i++) printf("%.10lf%c", rs[i], i == n ? '\n' : ' ');
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long k;
string f[20], pre[2], suf;
long long add(long long x, long long y) { return min(x + y, k + 1); }
long long calc(string str, string pre) {
int L = str.size(), ans = 0;
for (int i = m; i <= L; ++i)
if (str.substr(L - i, i) < pre) ++ans;
return ans;
}
long long count(string prefix) {
long long Ans = 0, C[2] = {0ll, 0ll};
for (int i = 1; i < m; ++i)
if (suf.substr(200 - i, i) < prefix) ++Ans;
string str = suf + pre[0];
for (int i = 1; i < m; ++i)
if (str.substr(200 - i) < prefix) ++C[0];
str = suf + pre[1];
for (int i = 1; i < m; ++i)
if (str.substr(200 - i) < prefix) ++C[1];
static long long F[210];
F[12] = calc(f[12], prefix);
F[13] = calc(f[13], prefix);
for (int i = 14; i <= n; ++i)
F[i] = add(add(F[i - 2], F[i - 1]), C[(i - 1) & 1]);
return add(F[n], Ans);
}
void solve() {
cin >> n >> k >> m;
if (n <= 13) {
int L = f[n].size();
string s[1010];
for (int i = 1; i <= L; ++i) s[i] = f[n].substr(L - i, i);
nth_element(s + 1, s + k, s + L + 1);
cout << s[k].substr(0, m) << endl;
exit(0);
}
string prefix;
for (int L = 1; L <= m; ++L) {
long long A = count(prefix), B = count(prefix + "0"),
C = count(prefix + "1");
if (A == k - 1 && B == k) break;
if (C < k)
prefix += "1";
else
prefix += "0";
}
cout << prefix << endl;
}
int main() {
f[0] = "0";
f[1] = "1";
for (int i = 2; i <= 14; ++i) f[i] = f[i - 2] + f[i - 1];
pre[0] = f[12].substr(0, 200);
pre[1] = f[13].substr(0, 200);
suf = f[12].substr(f[12].size() - 200, 200);
solve();
return 0;
}
| 13 | CPP |
from sys import stdin, stdout
for _ in range(int(input())):
a, b, c, d = map(int, input().split())
if b >= a:
print(b)
else:
a -= b
if d >= c:
print(-1)
else:
print(b + ((a - 1) // (c - d) + 1) * c) | 7 | PYTHON3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <stdlib.h>
#include <limits.h>
using namespace std;
int main(){
int a,b,x;
cin>>a>>b>>x;
int num=INT_MAX;
for(int i=0;i<21;i++){
int d = x - i*1000;
int cst = a*i;
if(d>0){
cst += ((d + 499)/500)*b;
}
if(num>cst){
num = cst;
}else{
break;
}
}
cout<<num<<endl;
}
| 0 | CPP |
R = lambda: map(int, input().split())
n = R()
a = tuple(R())
s0 = sum(a) / 2
s = 0
for i in range(len(a)):
s += a[i]
if s >= s0:
print(i+1)
break
| 7 | PYTHON3 |
word=input()
a=word[0]
A=a.capitalize()
print(A+word[1:]) | 7 | PYTHON3 |
for _ in range(int(input())):
n,m=map(int,input().split())
arr=[]
for _ in range(n):
arr1=list(map(int,input().split()))
arr.append(arr1)
f=0
for i in range(n):
for j in range(m):
x=2
y=2
if i==0 or i==n-1:
x=x-1
if j==0 or j==m-1:
y=y-1
if arr[i][j]>x+y:
f=1
break
arr[i][j]=x+y
if f==1:
print("NO")
else:
print("YES")
for i in range(n):
print(*arr[i])
| 8 | PYTHON3 |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<ctime>
#include<map>
#define ll long long
#define MAXN 100005
#define uns unsigned
#define INF 0x3f3f3f3f
#define MOD 1000000007ll
#define lowbit(x) ((x)&(-(x)))
using namespace std;
inline ll read(){
ll x=0;bool f=1;char s=getchar();
while((s<'0'||s>'9')&&s>0){if(s=='-')f^=1;s=getchar();}
while(s>='0'&&s<='9')x=(x<<1)+(x<<3)+s-'0',s=getchar();
return f?x:-x;
}
int n,m;
int L[MAXN],R[MAXN],ans[MAXN];
vector<int>ad[MAXN];
struct itn{
int ls,rs,a;itn(){ls=rs=0,a=INF;}
}t[MAXN<<6];
int IN;
inline void add(int x,int l,int r,int z,int d){
t[0]=itn();
if(l==r){t[x].a=min(t[x].a,d);return;}
int mid=(l+r)>>1;
if(z<=mid){
if(!t[x].ls)t[x].ls=++IN,t[IN]=itn();
add(t[x].ls,l,mid,z,d);
}
else{
if(!t[x].rs)t[x].rs=++IN,t[IN]=itn();
add(t[x].rs,mid+1,r,z,d);
}
t[x].a=min(t[t[x].ls].a,t[t[x].rs].a);
}
inline int query(int x,int l,int r,int a,int b){
if(!x||a>b)return INF;
if(l==a&&r==b)return t[x].a;
int mid=(l+r)>>1,res=INF;
if(a<=mid)res=min(res,query(t[x].ls,l,mid,a,min(mid,b)));
if(b>mid)res=min(res,query(t[x].rs,mid+1,r,max(a,mid+1),b));
return res;
}
int rt[MAXN];
inline void add_(int x,int l,int r){
for(;r<=n;r+=lowbit(r)){
if(!rt[r])rt[r]=++IN,t[IN]=itn();
add(rt[r],1,n,l,x);
}
}
inline int query_(int l,int r){
int res=INF;
for(;r>0;r-=lowbit(r))res=min(res,query(rt[r],1,n,l,n));
return res;
}
inline int solve(int l,int r,int x){
if(l>r||r-l+1<x)return 0;
int id=query_(l,r);
if(id>m)return 0;
return solve(l,L[id]-1,x)+solve(R[id]+1,r,x)+R[id]-L[id]+1;
}
signed main()
{
n=read(),m=read();
for(int i=1;i<=m;i++){
L[i]=read(),R[i]=read();
ad[R[i]-L[i]+1].push_back(i);
}
for(int X=n;X>0;X--){
for(uns i=0;i<ad[X].size();i++)
add_(ad[X][i],L[ad[X][i]],R[ad[X][i]]);
ans[X]=solve(1,n,X);
}
for(int i=1;i<=n;i++)printf("%d\n",ans[i]);
return 0;
}
| 13 | CPP |
t = int(input())
for _ in range(t):
n = int(input())
i = int(n**0.5) + 2
k = 0
while i > 0 and n > 1:
while n > 1:
if n >= 3*i*(i - 1) // 2 + 2*i:
k += 1
n -= 3*i*(i - 1) // 2 + 2*i
else:
break
i -= 1
print(k)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int answ = 1;
for (int i = 1; i < n; ++i) {
answ = (answ * 3) % 1000003;
}
cout << answ << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x, y, xx, yy;
cin >> x >> y >> xx >> yy;
cout << (xx - x) * (yy - y) + 1 << '\n';
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, 1, -1, -1, 2, 2, -2, -2},
dy[] = {2, -2, 2, -2, 1, -1, 1, -1};
const int N = 1005;
using pii = pair<int, int>;
int n, m, wx, wy, bx, by, disw[N][N], disb[N][N];
void bfs(int (&dis)[N][N], int sx, int sy) {
memset(dis, -1, sizeof(dis));
queue<pii> q;
q.push(pii(sx, sy));
dis[sx][sy] = 0;
while (!q.empty()) {
pii nd = q.front();
q.pop();
for (int i = 0; i < 8; i++) {
int nx = nd.first + dx[i], ny = nd.second + dy[i];
if (nx <= 0 || nx > n || ny <= 0 || ny > m || dis[nx][ny] != -1) continue;
dis[nx][ny] = dis[nd.first][nd.second] + 1;
q.push(pii(nx, ny));
}
}
}
inline bool can_reach(int x1, int y1, int x2, int y2) {
return (abs(x1 - x2) == 1 && abs(y1 - y2) == 2) ||
(abs(x1 - x2) == 2 && abs(y1 - y2) == 1);
}
void move(int dis[N][N], int sx, int sy, int ex, int ey, int tx, int ty) {
while (sx != tx || sy != ty) {
for (int i = 0; i < 8; i++) {
int nx = sx + dx[i], ny = sy + dy[i];
if (nx <= 0 || nx > n || ny <= 0 || ny > m ||
dis[nx][ny] != dis[sx][sy] - 1 || can_reach(nx, ny, ex, ey))
continue;
cout << nx << ' ' << ny << endl;
sx = nx;
sy = ny;
if (sx == ex && sy == ey) exit(0);
if (sx == tx && sy == ty) break;
cin >> ex >> ey;
break;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
cin >> wx >> wy >> bx >> by;
bfs(disw, n / 2, m / 2);
bfs(disb, n / 2 + 1, m / 2);
if (disw[wx][wy] < disw[bx][by] && disw[wx][wy] <= disb[bx][by]) {
cout << "WHITE" << endl;
move(disw, wx, wy, bx, by, n / 2, m / 2);
return 0;
}
if (disb[bx][by] + 1 < disb[wx][wy] && disb[bx][by] + 1 <= disw[wx][wy]) {
cout << "BLACK" << endl;
cin >> wx >> wy;
move(disb, bx, by, wx, wy, n / 2 + 1, m / 2);
return 0;
}
if ((wx + wy) % 2 != (bx + by) % 2) {
cout << "WHITE" << endl;
if (disw[wx][wy] <= disb[bx][by])
move(disw, wx, wy, bx, by, n / 2, m / 2);
else {
move(disb, wx, wy, bx, by, n / 2 + 1, m / 2);
if (wx != n / 2 + 1 || wy != m / 2) cin >> bx >> by;
wx = n / 2 + 1;
wy = m / 2;
if (can_reach(wx, wy, bx, by)) {
cout << bx << ' ' << by << endl;
return 0;
}
move(disw, wx, wy, bx, by, n / 2, m / 2);
}
} else {
cout << "BLACK" << endl;
cin >> wx >> wy;
if (disb[bx][by] <= disw[wx][wy])
move(disb, bx, by, wx, wy, n / 2 + 1, m / 2);
else {
move(disw, bx, by, wx, wy, n / 2, m / 2);
if (bx != n / 2 || by != m / 2) cin >> wx >> wy;
bx = n / 2;
by = m / 2;
if (can_reach(wx, wy, bx, by)) {
cout << wx << ' ' << wy << endl;
return 0;
}
move(disb, bx, by, wx, wy, n / 2 + 1, m / 2);
}
}
return 0;
}
| 11 | CPP |
def main():
def plus(a,b):
if a=="":
return b
elif b=="":
return a
elif a=="A":
if b=="A":
return "B"
else:
return ""
else:
if b=="A":
return ""
else:
return "A"
def minus(a,b):
if b=="A":
b="B"
elif b=="B":
b="A"
return plus(a,b)
dp1=[""]
dp2=[""]
s=input()
t=input()
q=int(input())
abcd=[list(map(int,input().split())) for _ in [0]*q]
for i in s:
dp1.append(plus(dp1[-1],i))
for i in t:
dp2.append(plus(dp2[-1],i))
for a,b,c,d in abcd:
a,b,c,d=dp1[a-1],dp1[b],dp2[c-1],dp2[d]
print(["NO","YES"][minus(b,a)==minus(d,c)])
main() | 0 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
count=0;count1=0
ans="YES"
for _ in range(n):
a,b=map(int,input().split())
if a<count or b<count1 or a<b or a-count<b-count1:
ans="NO"
else:
count=a;count1=b
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> c(n),s(n),f(n);
for (int i = 0; i < n-1; i++)
{
cin >> c[i] >> s[i] >> f[i];
}
for (int i = 0; i < n-1; i++)
{
int t=0;
for (int j = i; j < n-1; j++)
{
if(t<=s[j]) t=s[j]+c[j];
else if(t%f[j]==0) t+=c[j];
else t+=c[j]+f[j]-t%f[j];
}
cout << t << endl;
}
cout << 0 << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for(int &i : arr) cin >> i;
for(int i = n-2, _min = arr[n-1]; i >= 0; i--) {
if(arr[i]-_min > 1) return cout << "No", 0;
_min = min(_min, arr[i]);
}
cout << "Yes";
}
| 0 | CPP |
def mul(L, x):
m = []
for y in L:
m += [x*y]
return m
def diff(a, b):
d=0
for i, j in zip(a,b):
d+= j-i if j-i < 0 else 0
return d
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
high = 2001
low = 0
while low <= high:
mid = (low+high)//2
d = diff(mul(a, mid), b)
here = False
if k+d == 0:
break
elif k+d < 0:
here = True
high = mid -1
else:
low = mid + 1
print(mid if not here else high) | 10 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
if (90*n)%360: print('NO')
else: print('YES')
| 7 | PYTHON3 |
_,arr = input(), sorted(list(map(int, input().split())), reverse = True)
x = arr[0]
dup = 1
for num in arr:
if num == dup: break
if x % num != 0:break
else:dup = num
print(x, num) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, h;
while (scanf("%d%d", &x, &h), (x || h)) {
double S = x * sqrt(x * x + 4 * h * h) + x * x;
printf("%.10f\n", S);
}
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(void){
string a,b,c;
cin>>a>>b>>c;
char dif='A'-'a';
printf("%c%c%c\n",a[0]+dif,b[0]+dif,c[0]+dif);
return 0;
} | 0 | CPP |
s=input()
if "WUB" in s :
s=s.replace("WUB"," ")
print(s) | 7 | PYTHON3 |
n=int(input())
for i in range(n):
c=0
x, y, z = input().split()
n=(int(z)-int(y))//int(x)
print(n*int(x)+int(y)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
long long first[100010], second[100010];
long long arr[100010 << 2];
int nn;
pair<int, pair<int, int> > p[100010];
long long sum[(100010 << 4)], ans[(100010 << 4)];
int num[(100010 << 4)];
void push_up(int u) {
num[u] = num[(u << 1)] + num[((u << 1) | 1)];
sum[u] = sum[(u << 1)] + sum[((u << 1) | 1)];
ans[u] = ans[(u << 1)] + ans[((u << 1) | 1)];
ans[u] +=
num[(u << 1)] * sum[((u << 1) | 1)] - num[((u << 1) | 1)] * sum[(u << 1)];
}
void update(int u, int L, int R, int l, int r, long long first, int k) {
if (L >= r || R <= l) return;
if (L >= l && R <= r) {
sum[u] = first;
num[u] = k;
return;
}
update((u << 1), L, (L + R >> 1), l, r, first, k);
update(((u << 1) | 1), (L + R >> 1), R, l, r, first, k);
push_up(u);
}
int cnt;
long long s, sz;
void calc(int u, int L, int R, int l, int r) {
if (L >= r || R <= l) return;
if (L >= l && R <= r) {
s += ans[u] + cnt * sum[u] - num[u] * sz;
sz += sum[u];
cnt += num[u];
return;
}
calc((u << 1), L, (L + R >> 1), l, r);
calc(((u << 1) | 1), (L + R >> 1), R, l, r);
}
int main() {
int n, m;
gn(n);
for (int i = 1; i <= n; i++) {
gn(first[i]);
second[i] = first[i];
arr[nn++] = first[i];
}
gn(m);
for (int i = 0; i < m; i++) {
gn(p[i].first, p[i].second.first, p[i].second.second);
int a = p[i].second.first, b = p[i].second.second;
if (p[i].first == 1) {
second[a] += b;
arr[nn++] = second[a];
} else {
arr[nn++] = a;
arr[nn++] = b;
}
}
sort(arr, arr + nn);
nn = unique(arr, arr + nn) - arr;
for (int i = 1; i <= n; i++) {
int id = lower_bound(arr, arr + nn, first[i]) - arr;
update(1, 0, nn, id, id + 1, first[i], 1);
}
for (int i = 0; i < m; i++) {
int a = p[i].second.first, b = p[i].second.second;
if (p[i].first == 1) {
int id = lower_bound(arr, arr + nn, first[a]) - arr;
update(1, 0, nn, id, id + 1, 0, 0);
first[a] += b;
id = lower_bound(arr, arr + nn, first[a]) - arr;
update(1, 0, nn, id, id + 1, first[a], 1);
} else {
int l = lower_bound(arr, arr + nn, a) - arr;
int r = upper_bound(arr, arr + nn, b) - arr;
s = sz = cnt = 0;
calc(1, 0, nn, l, r);
println(s);
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2100;
int n, m, l[N], s[N], c[N * 2], f[N * 2][N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &l[i]);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
for (int i = 1; i <= n + m; i++) scanf("%d", &c[i]);
memset(f, 0xcf, sizeof(f));
for (int i = 1; i <= n + m; i++) f[i][0] = 0;
for (int i = n; i >= 1; i--) {
for (int j = n; j >= 1; j--)
f[l[i]][j] = max(f[l[i]][j], f[l[i]][j - 1] + c[l[i]] - s[i]);
for (int j = l[i] + 1, cur = n; j <= n + m; j++) {
cur >>= 1;
for (int k = 0; k <= cur; k++) {
f[j][k] = max({f[j][k], f[j - 1][k * 2] + k * c[j],
f[j - 1][k * 2 + 1] + k * c[j]});
}
}
}
printf("%d\n", f[n + m][0]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v1, v2;
long long n, m;
bool func(long long x) {
for (long long i = 0; i < m - 1 && i * 2 <= x; i++) {
long long j = x - 2 * i;
j = min(j, n - 2);
if ((v2[i + 1] + v1[j + 1] <= x) && (i * 2 + j >= v2[i + 1] + v1[j + 1]))
return true;
}
return false;
}
void solve() {
cin >> n;
v1.push_back(0);
v2.push_back(0);
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
if (a == 1)
v1.push_back(b);
else
v2.push_back(b);
}
v1.push_back(0);
v2.push_back(0);
sort(v1.rbegin(), v1.rend() - 1);
sort(v2.rbegin(), v2.rend() - 1);
n = v1.size();
m = v2.size();
for (long long i = n - 2; i >= 0; i--) v1[i] += v1[i + 1];
for (long long i = m - 2; i >= 0; i--) v2[i] += v2[i + 1];
long long l = 0, r = 1000000000000;
while (l < r) {
long long m = (l + r) / 2;
if (func(m))
r = m;
else
l = m + 1;
}
cout << r << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll a[5];
int main() {
ll n;
cin>>n;
for(int i=0;i<5;i++)cin>>a[i];
sort(a,a+5);
ll x=(n+a[0]-1)/a[0];
cout<<x+4<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
const int N = 1001000;
bool prime[N];
const ll mod = 1e9+7;
int main(){
fill(prime,prime+N,true);
prime[0] = prime[1] = false;
for(int i=2; i<N; ++i){
if(prime[i]) for(int j=2*i; j<N; j+=i) prime[j] = false;
}
int n;
cin >>n;
vector<int> q(n);
rep(i,n) cin >>q[i];
q.pb(1000999);
vector<ll> dp(n+1);
dp[0] = 1;
rep(i,n)if(prime[q[i]]){
// 1個
if(i+1<=n && prime[q[i+1]] && q[i]<q[i+1]) (dp[i+1] += dp[i]) %= mod;
// 2個
if(i+2<=n && prime[q[i+2]] && q[i]<q[i+2]) (dp[i+2] += dp[i]) %= mod;
}
cout << dp[n] << endl;
return 0;
}
| 0 | CPP |
a, s = [int(i) for i in input().split()], 0
for i in range(0, a[2]):
s += (2*(a[0]+a[1]))-(16*i)-4
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-9;
const int inf = 1e+9;
int n;
int a, b, c;
int mas[7] = {0, 1, 2, 3, 4, 5, 6};
string nm[7] = {"Anka", "Chapay", "Cleo", "Troll",
"Dracul", "Snowy", "Hexadecimal"};
pair<string, string> q[42];
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> q[i].first >> q[i].second >> q[i].second;
}
cin >> a >> b >> c;
int ans1 = 2 * inf;
int ans2 = 0;
do {
for (int i = (0); i <= (7 - 3); ++i) {
for (int j = (i + 1); j <= (7 - 2); ++j) {
int p1 = a / (i + 1);
int p2 = b / (j - i);
int p3 = c / (6 - j);
int minn = p1;
minn = min(minn, p2);
minn = min(minn, p3);
int maxx = p1;
maxx = max(maxx, p2);
maxx = max(maxx, p3);
if (ans1 >= maxx - minn) {
if (ans1 > maxx - minn) ans2 = 0;
ans1 = maxx - minn;
int temp = 0;
for (int l = 0; l < (n); ++l) {
int cc = 0;
for (int k = (0); k <= (i); ++k)
if (nm[mas[k]] == q[l].first || nm[mas[k]] == q[l].second) cc++;
if (cc == 2) temp++;
}
for (int l = 0; l < (n); ++l) {
int cc = 0;
for (int k = (i + 1); k <= (j); ++k)
if (nm[mas[k]] == q[l].first || nm[mas[k]] == q[l].second) cc++;
if (cc == 2) temp++;
}
for (int l = 0; l < (n); ++l) {
int cc = 0;
for (int k = (j + 1); k <= (6); ++k)
if (nm[mas[k]] == q[l].first || nm[mas[k]] == q[l].second) cc++;
if (cc == 2) temp++;
}
ans2 = max(temp, ans2);
}
}
}
} while (next_permutation(mas, mas + 7));
cout << ans1 << " " << ans2;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<ii>;
using vs = vector<string>;
const double PI = acos(-1.0);
const double EPS = 1e-14;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFLL = 4e18;
const int MAX = 50;
struct data {
int fast, slow;
double ch;
};
int N, R;
data arr[MAX + 5];
double memo[MAX + 5][6000];
double top = 1e18, bot = 0.0, mid;
void read() {
cin >> N >> R;
for (int i = 0; i < (int)N; i++) {
cin >> arr[i].fast >> arr[i].slow >> arr[i].ch;
arr[i].ch /= 100.0;
}
}
double dp(int pos, int cur) {
double &ret = memo[pos][cur];
if (ret <= -0.8) {
if (cur > R)
ret = mid;
else if (pos == N)
ret = 0.0;
else {
ret = arr[pos].ch * (arr[pos].fast + dp(pos + 1, cur + arr[pos].fast)) +
(1.0 - arr[pos].ch) *
(arr[pos].slow + dp(pos + 1, cur + arr[pos].slow));
ret = min(ret, mid);
}
}
return ret;
}
void solve() {
for (int loop = 0; loop < (int)200; loop++) {
mid = (top + bot) / 2.0;
for (int i = 0; i < (int)MAX + 5; i++)
for (int j = 0; j < (int)6000; j++) memo[i][j] = -1.0;
if (dp(0, 0) >= mid)
bot = mid;
else
top = mid;
}
cout << fixed << setprecision(10) << (top + bot) / 2.0 << "\n";
}
int main() {
int TC = 1;
while (TC--) {
read();
solve();
}
}
| 10 | CPP |
n,q=map(int,input().split())
a=list(map(int,input().split()))
b=[a[0]]
for i in range(1,n):
b.append(b[i-1]+a[i])
ans=0
for i in range(q):
x,y=map(int,input().split())
temp=b[y-1]
if x!=1:
temp-=b[x-2]
ans=max(ans,ans+temp)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, nr;
int expo(int x, int p) {
int sol = 1;
while (p > 0) {
if (p % 2 == 1) sol = (sol * x) % n;
x = (x * x) % n;
p = p / 2;
}
return sol;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
bool ok = true;
for (int j = 1; j <= n - 2; j++) {
int val = expo(i, j) - 1;
if (val == 0) ok = false;
}
int val = expo(i, n - 1) - 1;
if (val != 0) ok = false;
if (ok) nr++;
}
printf("%d", nr);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int Max(T begin, T end) {
int ret = *begin;
while (begin != end) {
ret = max(ret, *begin);
++begin;
}
return ret;
}
template <typename T>
int Min(T begin, T end) {
int ret = *begin;
while (begin < end) {
ret = min(ret, *begin);
++begin;
}
return ret;
}
int GetLower(const vector<int>& c, int k) {
int l = Min(c.begin(), c.end()), r = Max(c.begin(), c.end()) + 1;
while (r - l > 1) {
int m = (l + r) / 2;
long long s = 0;
for (auto x : c)
if (x < m) s += m - x;
if (s <= k) {
l = m;
} else {
r = m;
}
}
return l;
}
int GetUpper(const vector<int>& c, int k) {
int l = Min(c.begin(), c.end()) - 1, r = Max(c.begin(), c.end());
while (r - l > 1) {
int m = (l + r) / 2;
long long s = 0;
for (auto x : c)
if (x > m) s += x - m;
if (s <= k) {
r = m;
} else {
l = m;
}
}
return r;
}
bool CanBeZero(const vector<int>& c) {
long long s = 0;
for (auto x : c) s += x;
return s % c.size() == 0;
}
int Solve(const vector<int>& c, int k) {
int lower = GetLower(c, k);
int upper = GetUpper(c, k);
int answer = upper - lower;
if (answer <= 0) answer = 0;
return answer == 0 && !CanBeZero(c) ? 1 : answer;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> c(n);
for (int i = 0; i < (int)c.size(); ++i) scanf("%d", &c[i]);
printf("%d\n", Solve(c, k));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 3e5 + 10, M = 1e6 + 10, inf = 1e9 + 7, MOD = 1e9 + 7;
const long long INF = 1e18 + 10, mod = 1e9 + 7;
priority_queue<int> q;
vector<int> ans;
int main() {
int n;
scanf("%d", &n);
int e = n;
ans.push_back(1);
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
q.push(p);
while (!q.empty()) {
if (q.top() == e) {
e--;
q.pop();
} else
break;
}
ans.push_back(q.size() + 1);
}
for (int i = 0; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 | CPP |
s=input().split('@')
b=True
if(len(s)<2):b=False
for i in range(len(s)):
if(i==0 or i==len(s)-1):
if(len(s[i])<1):b=False
elif(len(s[i])<2):b=False
if(b):
for i in range(len(s)):
if(0!=i and i!=len(s)-1):
print("%s,%s@"%(s[i][0:1],s[i][1:len(s[i])]),end="" )
else:
print("%s"%(s[i]),end="" )
if(i==0):print("%s"%("@"),end="")
else:
print("No solution") | 8 | PYTHON3 |
import math
n,x,y=map(int,input().split())
data=[int(x) for x in input().split()]
cnt=0
for q in data:
if(q<=x):
cnt+=1
if(x>y):
print(n)
else:
print(math.ceil(cnt/2)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 123456;
int n, k, l, a[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> l;
for (int i = 1; i <= n * k; i++) cin >> a[i];
sort(a + 1, a + n * k + 1);
int r = 2;
while (r <= n * k && a[r] - a[1] <= l) r++;
r--;
if (r < n) {
cout << 0 << '\n';
return 0;
}
long long ans = 0;
int cnt = 0, i;
for (i = 1; r - (i + k) + 1 >= n - cnt; i += k) {
ans += a[i];
cnt++;
}
ans += a[i];
cnt++;
for (int j = r; cnt < n; cnt++) ans += a[j--];
cout << ans << '\n';
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;cin>>a>>b>>c;
for(int i=1;i<=b;i++){
if( (i*a)%b==c ){
cout<<"YES"<<endl;
return 0;
}
}
cout<<"NO"<<endl;
return 0;
} | 0 | CPP |
n=int(input())
x=0
for i in range(n):
a=list(map(int,input().split()))
if sum(a)>=2:
x+=1
print(x) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using VV = vector<vector<T>>;
template <class T>
inline bool SMIN(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool SMAX(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
const string yes = "YES", no = "NO";
int X, Y, Z, T1, T2, T3;
string solve() {
long long s = abs(X - Y) * T1;
long long e = abs(Z - X) * T2 + abs(X - Y) * T2 + 3LL * T3;
return !(s < e) ? yes : no;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> X >> Y >> Z >> T1 >> T2 >> T3;
cout << solve() << endl;
return 0;
}
| 7 | CPP |
from math import *
from itertools import *
from collections import *
from functools import reduce
def input_ints():
return map(int, input().split())
def input_floats():
return map(float, input().split())
def input_strings():
return input().split()
# Solution written by john21
w, h = input_ints()
u1, d1 = input_ints()
u2, d2 = input_ints()
while h > 0:
w += h
if h == d1:
w -= u1
if h == d2:
w -= u2
w = max(w, 0)
h -= 1
print(w)
| 7 | PYTHON3 |
#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
using namespace std;
////////////////////////////
// 基本要素 (点, 線分)
////////////////////////////
using DD = double;
const DD INF = 1LL<<60; // to be set appropriately
const DD EPS = 1e-6; // to be set appropriately
const DD PI = acos(-1.0);
DD torad(int deg) {return (DD)(deg) * PI / 180;}
DD todeg(DD ang) {return ang * 180 / PI;}
/* Point */
struct Point {
DD x, y;
Point(DD x = 0.0, DD y = 0.0) : x(x), y(y) {}
friend ostream& operator << (ostream &s, const Point &p) {return s << '(' << p.x << ", " << p.y << ')';}
};
inline Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
inline Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
inline Point operator * (const Point &p, DD a) {return Point(p.x * a, p.y * a);}
inline Point operator * (DD a, const Point &p) {return Point(a * p.x, a * p.y);}
inline Point operator * (const Point &p, const Point &q) {return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);}
inline Point operator / (const Point &p, DD a) {return Point(p.x / a, p.y / a);}
inline Point conj(const Point &p) {return Point(p.x, -p.y);}
inline Point rot(const Point &p, DD ang) {return Point(cos(ang) * p.x - sin(ang) * p.y, sin(ang) * p.x + cos(ang) * p.y);}
inline Point rot90(const Point &p) {return Point(-p.y, p.x);}
inline DD cross(const Point &p, const Point &q) {return p.x * q.y - p.y * q.x;}
inline DD dot(const Point &p, const Point &q) {return p.x * q.x + p.y * q.y;}
inline DD norm(const Point &p) {return dot(p, p);}
inline DD abs(const Point &p) {return sqrt(dot(p, p));}
inline DD amp(const Point &p) {DD res = atan2(p.y, p.x); if (res < 0) res += PI*2; return res;}
inline bool eq(const Point &p, const Point &q) {return abs(p - q) < EPS;}
inline bool operator < (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x < q.x : p.y < q.y);}
inline bool operator > (const Point &p, const Point &q) {return (abs(p.x - q.x) > EPS ? p.x > q.x : p.y > q.y);}
inline Point operator / (const Point &p, const Point &q) {return p * conj(q) / norm(q);}
/* Line */
struct Line : vector<Point> {
Line(Point a = Point(0.0, 0.0), Point b = Point(0.0, 0.0)) {
this->push_back(a);
this->push_back(b);
}
friend ostream& operator << (ostream &s, const Line &l) {return s << '{' << l[0] << ", " << l[1] << '}';}
};
////////////////////////////
// 円や直線の交差判定, 距離
////////////////////////////
/*
ccw を用いている
P: point
L: Line
S: Segment
distancePL は、「点」と「直線」の距離
distancePS は、「点」と「線分」の距離
*/
int ccw_for_dis(const Point &a, const Point &b, const Point &c) {
if (cross(b-a, c-a) > EPS) return 1;
if (cross(b-a, c-a) < -EPS) return -1;
if (dot(b-a, c-a) < -EPS) return 2;
if (norm(b-a) < norm(c-a) - EPS) return -2;
return 0;
}
Point proj(const Point &p, const Line &l) {
DD t = dot(p - l[0], l[1] - l[0]) / norm(l[1] - l[0]);
return l[0] + (l[1] - l[0]) * t;
}
Point refl(const Point &p, const Line &l) {
return p + (proj(p, l) - p) * 2;
}
bool isinterPL(const Point &p, const Line &l) {
return (abs(p - proj(p, l)) < EPS);
}
bool isinterPS(const Point &p, const Line &s) {
return (ccw_for_dis(s[0], s[1], p) == 0);
}
bool isinterLL(const Line &l, const Line &m) {
return (abs(cross(l[1] - l[0], m[1] - m[0])) > EPS ||
abs(cross(l[1] - l[0], m[0] - l[0])) < EPS);
}
bool isinterSS(const Line &s, const Line &t) {
if (eq(s[0], s[1])) return isinterPS(s[0], t);
if (eq(t[0], t[1])) return isinterPS(t[0], s);
return (ccw_for_dis(s[0], s[1], t[0]) * ccw_for_dis(s[0], s[1], t[1]) <= 0 &&
ccw_for_dis(t[0], t[1], s[0]) * ccw_for_dis(t[0], t[1], s[1]) <= 0);
}
DD distancePL(const Point &p, const Line &l) {
return abs(p - proj(p, l));
}
DD distancePS(const Point &p, const Line &s) {
Point h = proj(p, s);
if (isinterPS(h, s)) return abs(p - h);
return min(abs(p - s[0]), abs(p - s[1]));
}
DD distanceLL(const Line &l, const Line &m) {
if (isinterLL(l, m)) return 0;
else return distancePL(m[0], l);
}
DD distanceSS(const Line &s, const Line &t) {
if (isinterSS(s, t)) return 0;
else return min(min(distancePS(s[0], t), distancePS(s[1], t)), min(distancePS(t[0], s), distancePS(t[1], s)));
}
int main() {
int N;
while (cin >> N, N) {
double sx, sy, ex, ey; cin >> sx >> sy >> ex >> ey;
Line s(Point(sx, sy), Point(ex, ey));
double res = 1100;
for (int i = 0; i < N; ++i) {
double x[2], y[2], h;
cin >> x[0] >> y[0] >> x[1] >> y[1] >> h;
if (x[0] <= sx && sx <= x[1] && y[0] <= sy && sy <= y[1]) res = 0;
if (x[0] <= ex && ex <= x[1] && y[0] <= ey && ey <= y[1]) res = 0;
vector<Point> vp = {Point(x[0], y[0]), Point(x[1], y[0]), Point(x[1], y[1]), Point(x[0], y[1])};
for (int j = 0; j < 4; ++j) {
Line seg(vp[j], vp[(j+1)%4]);
double d = distanceSS(s, seg);
if (d <= h) res = min(res, d);
else res = min(res, (d*d + h*h)/(h*2));
}
}
cout << fixed << setprecision(10) << res << endl;
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000];
bool check(int a, int b, int c) {
if (a == b || b == c || a == c) return false;
if (c - a > 2) return false;
return true;
}
bool slv() {
for (int i = 0; i < n - 2; i++) {
for (int j = i + 1; j < n - 1; j++) {
for (int k = j + 1; k < n; k++) {
if (check(a[i], a[j], a[k])) {
return true;
}
}
}
}
return false;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
puts(slv() ? "YES" : "NO");
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
double PI = 3.1415926535897932384626433832795;
const long long oo = (long long)1e9 + 1;
const double eps = 1e-9;
const long long mod = 1000000009;
int x[2], y[2], a, b;
bool Check() {
for (int i = 1; i < a; i++)
for (int j = 1; j < a; j++)
if (j * j + i * i == a * a) {
x[0] = j, y[0] = i;
x[1] = -i * b / a, y[1] = j * b / a;
if (x[1] * x[1] + y[1] * y[1] == b * b && y[0] != y[1]) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &a, &b);
if (Check()) {
printf("YES\n0 0\n");
printf("%d %d\n%d %d\n", x[0], y[0], x[1], y[1]);
} else {
printf("NO\n");
}
}
| 7 | CPP |
n=int(input())
l=[]
for i in range(n):
l.append([(j) for j in input()])
c=0
for i in l:
if('+' in i):
c=c+1
else:
c=c-1
print(c) | 7 | PYTHON3 |
for _ in range(int(input())):
a,b,c=map(int,input().split())
ans = c - ((c-b)%a)
print(ans) | 7 | PYTHON3 |
x,y,z=map(int,input().split())
if x%z==0 or y%z==0:
print((x+y)//z,0)
else:
s=x//z
t=y//z
v=(x+y)//z
if s+t==v:
print(v,0)
else:
a=s*z+z-x
b=t*z+z-y
c=min(a,b)
print(v,c)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
class string_operations {
private:
long long length;
std::vector<long long> power, hash;
std::vector<std::vector<char> > bor;
long long HashConst, AlphabetSize;
std::string CurrentString;
public:
inline void Assign(std::string s) {
CurrentString = s, HashConst = 29LL, AlphabetSize = 30;
length = s.size();
power.resize(length + 1), hash.resize(length + 1);
power.clear(), hash.clear();
}
void BuildHash() {
power[0] = 1;
for (int i = 0; i < length; i++)
hash[i + 1] =
(hash[i] + (long long)(CurrentString[i] - 'a' + 1) * power[i]),
power[i + 1] = power[i] * HashConst;
}
inline long long get(int l, int r) {
return ((long long)(hash[r] - hash[l - 1]) * power[length - r]);
}
inline bool EqualSubstring(int l1, int r1, int l2, int r2) {
if (l1 > l2) std::swap(l1, l2), std::swap(r1, r2);
if (r2 - l2 != r1 - l1) return 0;
return (get(l1, r1) == get(l2, r2));
}
};
class Graph_operations {
private:
int vertex, edge;
std::vector<std::vector<int> > g;
std::vector<std::vector<long long> > cost;
std::vector<int> used;
std::vector<int> parent, tin, tout;
bool two_sides, cycle, timer;
inline bool DijekstraOutline(std::vector<long long> &D,
std::set<std::pair<long long, int> > &s) {
if (s.empty()) return 0;
std::pair<long long, int> v = *s.begin();
s.erase(s.begin());
while (!s.empty() && v.first != D[v.second])
v = *s.begin(), s.erase(s.begin());
if (v.first != D[v.second]) return 0;
used[v.second] = 1;
for (int i = 0; i < g[v.second].size(); i++) {
int u = g[v.second][i];
if (!used[u] && D[u] > v.first + cost[v.second][i])
D[u] = D[v.second] + cost[v.second][i],
s.insert(std::make_pair(D[u], u));
}
return 1;
}
public:
inline void InputGraph(int n, int m, bool size, bool orient) {
vertex = n, edge = m;
two_sides = !orient, cycle = 0, timer = 0;
g.resize(vertex + 1), used.resize(vertex + 1, 0), parent.resize(vertex + 1);
cost.resize(vertex + 1);
int x, y;
long long z;
for (int i = 1; i <= edge; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
if (!orient) g[y].push_back(x);
if (!size)
cost[x].push_back(1), cost[y].push_back(1);
else {
scanf("%I64d", &z);
cost[x].push_back(z);
if (!orient) cost[y].push_back(z);
}
}
if (!size)
for (int i = 1; i <= vertex; i++)
std::sort(g[i].begin(), g[i].end()),
g[i].resize(std::distance(g[i].begin(),
std::unique(g[i].begin(), g[i].end()))),
cost[i].resize(std::distance(g[i].begin(), g[i].end()));
}
inline void dfs(int v = 1, int p = -1) {
if (p < 0) timer = 0, tin.assign(vertex + 1, 0), tout.assign(vertex + 1, 0);
tin[v] = ++timer;
parent[v] = p;
used[v] = timer;
for (int i = 0; i < g[v].size(); i++) {
int u = g[v][i];
if (used[u] && (!two_sides || u != p)) cycle = 1;
if (!used[u]) dfs(u, v);
}
tout[v] = ++timer;
}
inline bool IsTree() { return !cycle; }
inline std::vector<long long> Dijekstra(int v) {
std::vector<long long> D(vertex + 1, 2000000000000000000LL);
used.assign(vertex + 1, 0);
std::set<std::pair<long long, int> > s;
D[v] = 0;
s.insert(std::make_pair(D[v], v));
for (int i = 0; i < vertex; i++)
if (!DijekstraOutline(D, s)) break;
return D;
}
};
class Fenwick_tree {
private:
std::vector<long long> t;
int size;
long long get0(int l) {
long long res = 0;
for (; l > 0; l = (l & (l + 1)) - 1) res += t[l];
return res;
}
public:
void Assign(int n) {
size = n;
t.assign(size + 1, 0);
}
void Build(std::vector<long long> &a) {
for (int i = 1; i <= size; i++) t[i] = a[i];
}
long long get(int l, int r) { return get0(r) - get0(l - 1); }
void update(int r, long long x) {
for (; r <= size; r |= (r + 1)) t[r] += x;
}
};
class Interval_tree {
private:
int size;
struct record {
int l, r;
long long dest;
};
std::vector<record> tree;
long long CriticalF;
long long F(int l, int r) { return (tree[l].dest + tree[r].dest); }
void InBuild(std::vector<long long> &a, int v, int l, int r) {
tree[v].l = l, tree[v].r = r;
if (l == r)
tree[v].dest = a[l];
else {
int m = (l + r) / 2;
InBuild(a, v + v, l, m);
InBuild(a, v + v + 1, m + 1, r);
tree[v].dest = F(v + v, v + v + 1);
}
}
public:
void Build(std::vector<long long> &a, int n) {
size = n;
CriticalF = 0;
tree.resize(4 * size + 1);
InBuild(a, 1, 1, n);
}
long long get(int v, int l, int r) {
if (l > r) return CriticalF;
if (tree[v].l == l && tree[v].r == r) return tree[v].dest;
int m = (tree[v].l + tree[v].r) / 2;
return get(v + v, l, m) + get(v + v + 1, m + 1, r);
}
void update(int v, int num, long long value) {
if (tree[v].l == tree[v].r) return (void(tree[v].dest += value));
int m = (tree[v].l + tree[v].r) / 2;
if (num <= m)
update(v + v, num, value);
else
update(v + v + 1, num, value);
}
};
using namespace std;
vector<long long> root, a;
int dfs(int x) {
if (root[x] != 0)
return root[x];
else
return (root[x] = dfs(a[x]));
}
int main() {
int n, x;
cin >> n >> x;
a.resize(n + 1);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
;
int roots = 0;
vector<long long> cnt(n + 1);
root.resize(n + 1);
for (int i = 1; i <= n; i++)
if (a[i] == 0) root[i] = ++roots, cnt[roots] = 1;
int preIn = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) continue;
root[i] = dfs(a[i]);
cnt[root[i]]++;
}
swap(cnt[roots], cnt[root[x]]);
--roots;
int r = x;
while (a[r] != 0) preIn++, r = a[r];
set<int> ans;
for (int mask = 0; mask < (1 << roots); mask++) {
int res = 0;
for (int i = 0; i < roots; i++)
if ((((mask & (1 << i)) > 0) ? (1) : (0))) res += cnt[i + 1];
ans.insert(1 + res + preIn);
}
for (set<int>::iterator it = ans.begin(); it != ans.end(); it++)
printf("%d\n", *it);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vd = vector<ld>;
using vvd = vector<vd>;
using vi = vector<int>;
const ld EPS = 1e-9;
struct LPSolver {
int m, n;
vi B, N;
vvd D;
LPSolver(const vvd &A, const vd &b, const vd &c)
: m(((int)b.size())),
n(((int)c.size())),
N(n + 1),
B(m),
D(m + 2, vd(n + 2)) {
for (int i = 0; i < (m); i++)
for (int j = 0; j < (n); j++) D[i][j] = A[i][j];
for (int i = 0; i < (m); i++) {
B[i] = n + i;
D[i][n] = -1;
D[i][n + 1] = b[i];
}
for (int j = 0; j < (n); j++) {
N[j] = j;
D[m][j] = -c[j];
}
N[n] = -1;
D[m + 1][n] = 1;
}
void Pivot(int r, int s) {
for (int i = 0; i < (m + 2); i++)
if (i != r)
for (int j = 0; j < (n + 2); j++)
if (j != s) D[i][j] -= D[r][j] * D[i][s] / D[r][s];
for (int j = 0; j < (n + 2); j++)
if (j != s) D[r][j] /= D[r][s];
for (int i = 0; i < (m + 2); i++)
if (i != r) D[i][s] /= -D[r][s];
D[r][s] = 1.0 / D[r][s];
swap(B[r], N[s]);
}
bool Simplex(int phase) {
int x = phase == 1 ? m + 1 : m;
while (true) {
int s = -1;
for (int j = 0; j < (n + 1); j++) {
if (phase == 2 && N[j] == -1) continue;
if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
s = j;
}
if (D[x][s] > -EPS) return true;
int r = -1;
for (int i = 0; i < (m); i++) {
if (D[i][s] < EPS) continue;
if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
(D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
r = i;
}
if (r == -1) return false;
Pivot(r, s);
}
}
ld Solve(vd &x) {
int r = 0;
for (int i = 0; i < (m); i++)
if (D[i][n + 1] < D[r][n + 1]) r = i;
if (D[r][n + 1] < -EPS) {
Pivot(r, n);
if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
return -numeric_limits<ld>::infinity();
for (int i = 0; i < (m); i++)
if (B[i] == -1) {
int s = -1;
for (int j = 0; j < (n + 1); j++)
if (s == -1 || D[i][j] < D[i][s] ||
D[i][j] == D[i][s] && N[j] < N[s])
s = j;
Pivot(i, s);
}
}
if (!Simplex(2)) return numeric_limits<ld>::infinity();
x = vd(n);
for (int i = 0; i < (m); i++)
if (B[i] < n) x[B[i]] = D[i][n + 1];
return D[m][n + 1];
}
};
int main() {
cin.tie(0)->sync_with_stdio(0);
ll n, x, color, u, v, w;
cin >> n >> x;
vvd A(n + 2, vd(n));
vd B(n + 2, -1), C(n);
B[n] = 0;
for (int i = 0; i < (n); i++) {
cin >> color;
if (color == 0)
C[i] = -1;
else {
C[i] = 0;
B[n]++;
}
}
vector<vector<ll>> tr(n, vector<ll>(n, 1e15));
for (int i = 0; i < (n); i++) tr[i][i] = 0;
for (int i = 0; i < (n - 1); i++) {
cin >> u >> v >> w;
tr[u - 1][v - 1] = tr[v - 1][u - 1] = w;
}
for (int k = 0; k < (n); k++)
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++)
tr[i][j] = min(tr[i][j], tr[i][k] + tr[k][j]);
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) A[i][j] = tr[i][j] > x ? 0 : -1;
B[n + 1] = -B[n];
B[n] = B[n];
fill(A[n].begin(), A[n].end(), 1);
fill(A[n + 1].begin(), A[n + 1].end(), -1);
LPSolver LPS(A, B, C);
vd X;
ll ans = round(-LPS.Solve(X));
cout << (X.size() < n ? -1 : ans) << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int IINF = INT_MAX;
int getCost(char a, char b) {
int ip = a - 'a', iq = b - 'a';
int mini = min(max(ip, iq) - min(ip, iq), 26 + min(ip, iq) - max(ip, iq));
return mini;
}
int compute(string s, int n, int p) {
--p;
int cnt = 0;
int len = s.size();
int answer = 0;
int left = IINF, right = -IINF;
for (int i = 0; i < len / 2; i++) {
int p = i, q = len - 1 - i;
if (s[p] != s[q]) {
int mini = getCost(s[p], s[q]);
answer += mini;
left = min(left, i);
right = max(right, i);
++cnt;
}
}
p = min(p, n - 1 - p);
int mini = right - left + min(abs(p - left), abs(right - p));
if (answer == 0) mini = 0;
return answer + mini;
}
int main() {
int n, p;
cin >> n >> p;
string s;
cin >> s;
int answer = compute(s, n, p);
cout << answer << endl;
return 0;
}
| 9 | CPP |
N = int(input())
grid = []
for _ in range(N):
grid.append(input())
col_info = [0] * N
for j in range(N):
cnt = 0
for i in range(N):
if grid[i][j] == '#':
cnt += 1
else:
cnt -= 1
if cnt == N:
col_info[j] = 1
elif cnt == -N:
col_info[j] = -1
if sum(col_info) == N:
print(0)
exit()
elif sum(col_info) == -N:
print(-1)
exit()
ans = 10**9
for i in range(N):
ans_new = N - col_info.count(1)
if col_info[i] == -1:
ans_new += 1
for j in range(N):
if grid[i][j] == '.':
ans_new += 1
ans = min(ans, ans_new)
print(ans)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
signed long long int ans = 0, a[100005], n, t, i = 0, m = 0, i1 = 0, i2 = 0,
ca = 0, cb = 0, k = 0;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> t;
while (t--) {
ans = 0;
cin >> n;
k = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
ans += a[i];
}
if (n == 1) {
cout << 1 << " " << a[0] << " " << 0;
} else {
i = 0;
m = 0;
i1 = 0, i2 = 0;
ca = 0, cb = 0;
while (ca + cb < ans) {
if (i1 <= i2) {
i1 = 0;
while (i1 <= i2) {
i1 += a[i];
i++;
if (ca + cb + i1 == ans) {
break;
}
}
ca += i1;
} else {
i2 = 0;
while (i2 <= i1) {
i2 += a[n - m - 1];
m++;
if (ca + cb + i2 == ans) {
break;
}
}
cb += i2;
}
k++;
}
cout << k << " " << ca << " " << cb;
}
cout << endl;
}
}
| 10 | CPP |
n, m = map(int, input().split())
B = list(map(int, input().split()))
G = list(map(int, input().split()))
if min(G) < max(B):
print(-1)
exit(0)
cnt = 0
z = max(B)
y = 0
f = 1
f2 = 0
for i in B:
if i != z or f2:
y = max(y, i)
else:
f2 = 1
for i in G:
if i == z:
f = 0
cnt += i - z
if f:
cnt += z - y
print(cnt + sum(B) * m) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, cnt[23][20003];
string s[23];
int alls[(1 << 23)];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < s[i].size(); j++) cnt[i][s[i][j] - 'a']++;
for (int i = 0; i < (1 << n); i++) {
long long nw = 1;
for (int j = 0; j < 26; j++) {
int minn = mod;
for (int k = 0; k < n; k++)
if ((1 << k) & i) minn = min(minn, cnt[k][j]);
nw = 1ll * nw * (minn + 1) % mod;
}
alls[i] = nw;
}
for (int j = 0; j < n; j++)
for (int i = (1 << n) - 1; i >= 0; i--)
if (!(i & (1 << j))) {
alls[i] -= alls[i + (1 << j)];
if (alls[i] < 0) alls[i] += mod;
}
alls[0] = 0;
for (int j = 0; j < n; j++)
for (int i = 0; i < (1 << n); i++)
if (i & (1 << j)) {
alls[i] += alls[i - (1 << j)];
if (alls[i] >= mod) alls[i] -= mod;
}
long long ans = 0, res;
for (int i = 1; i < (1 << n); i++) {
res = alls[(1 << n) - 1] - alls[(1 << n) - 1 ^ i];
if (res < 0) res += mod;
res = res * __builtin_popcount(i);
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt += (j + 1);
res = res * cnt;
ans ^= res;
}
cout << ans;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 51;
long long f[N][10], ans = 0;
long long num[N];
char c[N];
bool tag;
long long n;
long long dfs(int now, int x) {
if (now > n) return 1;
if (f[now][x] != -1) return f[now][x];
if ((num[now] + x) % 2 == 0)
return f[now][x] = dfs(now + 1, (num[now] + x) / 2);
else
return f[now][x] = dfs(now + 1, (num[now] + x) / 2) +
dfs(now + 1, (num[now] + x + 1) / 2);
}
int main() {
long long i, j, k;
cin >> c + 1;
n = strlen(c + 1);
memset(f, -1, sizeof(f));
for (i = 1; i <= n; i++) num[i] = c[i] - '0';
for (i = 0; i <= 9; i++) ans += dfs(2, i);
tag = true;
for (i = 2; i <= n; i++)
if (num[i] != (num[i - 1] + num[i]) / 2 &&
num[i] != (num[i - 1] + num[i] + 1) / 2)
tag = false;
if (tag)
cout << ans - 1;
else
cout << ans;
return 0;
}
| 14 | CPP |
#include <bits/stdc++.h>
using namespace std;
int rd() { return RAND_MAX == 32767 ? ((rand() << 15) ^ rand()) : rand(); }
const int maxn = 100010;
const int md = 1000000007;
int a[20], sa[maxn], rk[maxn], c1[maxn], c2[maxn], h2[maxn], s1[maxn], s2[maxn],
pw[maxn], dep[maxn], h[maxn][20], d2[maxn][20];
pair<int, int> b[maxn];
struct Rec {
int t, v, c;
} opt[maxn];
bool cmp(int x, int y) {
for (int i = 19; i >= 0; i--)
if (d2[x][i] != -1 && d2[y][i] != -1 && h[x][i] == h[y][i]) {
x = d2[x][i];
y = d2[y][i];
}
return c2[x] < c2[y];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &opt[i].t, &opt[i].v);
while ((opt[i].c = getchar()) && (opt[i].c < 'a' || opt[i].c > 'z'))
;
opt[i].v--;
}
pw[0] = 1;
for (int i = 1; i < n; i++) pw[i] = (long long)pw[i - 1] * 26 % md;
int m = 1;
c2[0] = -1;
h2[0] = 0;
memset(d2, -1, sizeof(d2));
for (int i = 0; i < n; i++)
if (opt[i].t == 2) {
c2[m] = opt[i].c;
h2[m] = ((long long)h2[opt[i].v] * 26 + c2[m]) % md;
d2[m][0] = opt[i].v;
for (int j = 0;; j++) {
if (d2[m][j] != -1)
d2[m][j + 1] = d2[d2[m][j]][j];
else
break;
}
m++;
}
for (int i = 0; i < m; i++) sa[i] = i;
for (int i = 0; i < m; i++)
for (int j = 0; j < 20; j++)
if (d2[i][j] != -1) {
h[i][j] = (h2[i] - (long long)h2[d2[i][j]] * pw[1 << j]) % md;
if (h[i][j] < 0) h[i][j] += md;
}
sort(sa, sa + m, cmp);
for (int i = 0; i < m; i++) rk[sa[i]] = i;
int t = 1, tt = 1;
c1[0] = -1;
dep[0] = 0;
long long res = 1;
memset(s1, 0, sizeof(s1));
memset(s2, 0, sizeof(s2));
for (int k = 1; k <= m; k += k & -k) s2[k]++;
b[0].first = 0;
b[0].second = m;
for (int i = 0; i < n; i++) {
if (opt[i].t == 1) {
c1[t] = opt[i].c;
dep[t] = dep[opt[i].v] + 1;
int k, lt, rt, mid, head, tail, tot = 0;
for (int j = 19, cnt = dep[t] - 1; j >= 0; j--)
if (cnt >= (1 << j)) {
a[tot++] = j;
cnt -= 1 << j;
}
for (lt = b[opt[i].v].first, rt = b[opt[i].v].second; lt < rt;) {
mid = (lt + rt) >> 1;
k = sa[mid];
for (int j = 0; j < tot; j++) k = d2[k][a[j]];
if (k == 0)
lt = mid + 1;
else
c1[t] <= c2[k] ? rt = mid : lt = mid + 1;
}
head = lt;
for (rt = b[opt[i].v].second; lt < rt;) {
mid = (lt + rt) >> 1;
k = sa[mid];
for (int j = 0; j < tot; j++) k = d2[k][a[j]];
if (k == 0)
lt = mid + 1;
else
c1[t] < c2[k] ? rt = mid : lt = mid + 1;
}
tail = lt;
b[t] = make_pair(head, tail);
for (int k = m - head; k; k -= k & -k) res += s1[k];
for (int k = m - tail; k; k -= k & -k) res -= s1[k];
for (int k = head + 1; k <= m; k += k & -k) s2[k]++;
for (int k = tail + 1; k <= m; k += k & -k) s2[k]--;
t++;
} else {
int whi = rk[tt++];
for (int k = whi + 1; k; k -= k & -k) res += s2[k];
for (int k = m - whi; k <= m; k += k & -k) s1[k]++;
}
printf("%I64d\n", res);
}
return 0;
}
| 9 | CPP |
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = (1e+18) + 7;
typedef pair<int, int>P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-6;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;
ll mod_pow(ll a, ll n) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%mod;
a = a * a%mod; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
//ll inv(ll a, ll p) {
// return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
//}
//modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
int dx[4] = { 1,0,-1,0 };
int dy[4] = { 0,1,0,-1 };
typedef complex<ld> Point;
ld dot(Point a, Point b) { return real(conj(a)*b); }
ld cross(Point a, Point b) { return imag(conj(a)*b); }
struct Line {
Point a, b;
};
Point proj(Line l, Point p) {
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
Point is_ll(Line s, Line t) {
Point sv = s.b - s.a; Point tv = t.b - t.a;
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
Point is_rev(Line l, Point p) {
Point q = proj(l, p);
Point res = (ld)2 * q - p;
return res;
}
struct status {
int id; Point p; Line l;
};
status merge(status &a, status &b) {
if (!a.id && !b.id) {
return { 1,0,{a.p,b.p} };
}
else if (!a.id && b.id) {
return { 0,is_rev(b.l,a.p),{0,0} };
}
else if (a.id && !b.id) {
return { 0,is_rev(a.l,b.p),{0,0} };
}
else return { 0,is_ll(a.l,b.l),{0,0} };
}
bool isnum(char &t) {
return '0' <= t && t <= '9';
}
status expr(string &s, int &i);
status point(string &s, int &i);
status expr(string &s, int &i) {
if (isnum(s[i])||s[i]=='-') {
return point(s, i);
}
status res;
bool upd = false;
while (i<s.size()) {
assert(s[i] == '(');
//skip '('
i++;
status nex = expr(s, i);
if (!upd)res = nex,upd=true;
else res = merge(res, nex);
//skip ')'
i++;
if (i < s.size() && s[i] == '@') {
//skip '@'
i++;
}
else break;
}
return res;
}
status point(string &s, int &i) {
string le, ri;
bool m = false;
//skip -
if (s[i] == '-')m = true,++i;
while (i < s.size() && isnum(s[i])) {
le.push_back(s[i]); i++;
}
ld l = stoi(le); if (m)l = -l;
//skip ,
i++;
m = false;
//skip -
if (s[i] == '-')m = true,++i;
while (i < s.size() && isnum(s[i])) {
ri.push_back(s[i]); i++;
}
ld r = stoi(ri); if (m)r = -r;
return status{ 0,Point{l,r},{0,0} };
}
void solve() {
string in;
while (cin >> in) {
if (in == "#")break;
int i = 0;
status ans = expr(in, i);
assert(i == in.size());
ld l = real(ans.p);
ld r = imag(ans.p);
cout << l << " " << r << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(7);
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
stop
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int main(){
int N;
scanf("%d",&N);
ll XOR = 0;
ll tmp,num_KI = 0;
for(int loop = 0; loop < N; loop++){
scanf("%lld",&tmp);
if(tmp%2 == 1)num_KI++;
XOR ^= tmp;
}
if(XOR == 1){
printf("Bob\n");
}else if(XOR == 0){
if(num_KI > 0){
printf("Alice\n");
}else{
printf("Bob\n");
}
}else{
printf("Alice\n");
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define ll long long
#define pb push_back
#define Mid ((L+R)/2)
#define pi pair<int,int>
#define pii pair<int,pi>
#define deb(x) cout<<#x<<"="<<x<<endl
#define go ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
int t;
int is[2020],last[2020];
ll ans[2010];
int main()
{
go;
cin>>t;
while(t--)
{
ll k;
cin>>k;
if(k&1)
{
cout<<-1<<endl;
continue;
}
int sz=1;
ans[1]=2;
is[1]=last[1]=1;
k-=2;
for(int i=2; i<=2000; i++)
{
if(!k)
{
sz=i-1;
break;
}
last[i]=last[i-1];
ans[i]=ans[i-1];
//deb(ans[i]-ans[last[i]-1]);
if(k>=(ans[i]-ans[last[i]-1]+2))
{
ans[i]+=(ans[i]-ans[last[i]-1]+2);
is[i]=0;
}
else
{
is[i]=1;
last[i]=i;
ans[i]+=2;
}
k-=ans[i]-ans[i-1];
}
if(k)
cout<<-1<<endl;
else
{
cout<<sz<<endl;
for(int i=1; i<=sz; i++)
cout<<is[i]<< " " ;
cout<<endl;
}
}
return 0;
}
| 10 | CPP |
#!/usr/local/bin/python3
import bisect
import collections
import functools
import heapq
import itertools
import math
import random
import sys
import time
input = sys.stdin.readline
# sys.setrecursionlimit(500005)
def ri(): return int(input())
def rf(): return list(map(float, input().split()))
def rl(): return list(map(int, input().split()))
def rs(): return input().rstrip()
def out_list(x): return ' '.join(map(str, x))
MOD = 10**9 + 7
INF = float('inf')
def solve_case():
n, m = rl()
A = rl()
s = [(a, i) for i, a in enumerate(A)]
s.sort(key=lambda x: (x[0], -x[1]))
# print('===', s)
res = 0
seats = [INF] * m
idx = 0
for a, i in s:
seats[idx] = i
idx += 1
res += sum(seats[j] < i for j in range(idx))
# print('===', seats)
print(res)
if __name__ == '__main__':
# T = 1
T = int(input())
for test_case in range(1, T + 1):
# print("Case #{}: ".format(test_case), end='')
solve_case()
| 10 | PYTHON3 |
import math
import bisect
def sieve(n):
primes = [-1] * (n)
primes[0] = -1
primes[1] = -1
i = 2
has_comp = False
sqrt_n = int(n ** 0.5 + 1)
while i <= sqrt_n:
if primes[i] == -1:
primes[i] = 1
for j in range(i * i, n, i):
has_comp = True
primes[j] = 2
i += 1
for i in range(sqrt_n, n):
if primes[i] == -1:
primes[i] = 1
return has_comp, primes
n = int(input())
has_comp, res = sieve(n + 2)
if has_comp:
print(2)
else:
print(1)
res_r = ""
for i in res[2:]:
res_r = res_r + str(i) + " "
print(res_r)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, q;
int a[N][10];
struct node {
int nxt[10];
long long sum[10];
} tree[N << 3];
void up(int rt) {
for (int i = 0; i < 10; i++)
tree[rt].sum[i] = tree[(rt << 1)].sum[i] + tree[(rt << 1 | 1)].sum[i];
}
long long sum1[10], sum2[10];
bool vis[10];
void down(int rt) {
for (int i = 0; i < 10; i++) sum1[i] = 0, sum2[i] = 0;
for (int i = 0; i < 10; i++)
tree[(rt << 1)].nxt[i] = tree[rt].nxt[tree[(rt << 1)].nxt[i]],
tree[(rt << 1 | 1)].nxt[i] =
tree[rt].nxt[tree[(rt << 1 | 1)].nxt[i]];
for (int i = 0; i < 10; i++)
sum1[tree[rt].nxt[i]] += tree[(rt << 1)].sum[i],
sum2[tree[rt].nxt[i]] += tree[(rt << 1 | 1)].sum[i];
for (int i = 0; i < 10; i++)
tree[(rt << 1)].sum[i] = sum1[i], tree[(rt << 1 | 1)].sum[i] = sum2[i];
for (int i = 0; i < 10; i++) tree[rt].nxt[i] = i;
}
void build(int l, int r, int rt) {
for (int i = 0; i < 10; i++) tree[rt].nxt[i] = i;
if (l == r) {
for (int i = 0; i < 10; i++) tree[rt].sum[i] = a[l][i];
return;
}
int mid = l + r >> 1;
build(l, mid, (rt << 1));
build(mid + 1, r, (rt << 1 | 1));
up(rt);
}
void update(int L, int R, int l, int r, int rt, int x, int y) {
if (L <= l && r <= R) {
for (int i = 0; i < 10; i++)
if (tree[rt].nxt[i] == x) tree[rt].nxt[i] = y;
tree[rt].sum[y] += tree[rt].sum[x];
tree[rt].sum[x] = 0;
return;
}
down(rt);
int mid = l + r >> 1;
if (L <= mid) update(L, R, l, mid, (rt << 1), x, y);
if (R > mid) update(L, R, mid + 1, r, (rt << 1 | 1), x, y);
up(rt);
return;
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
long long tmp = 0;
for (int i = 0; i < 10; i++) tmp += i * tree[rt].sum[i];
return tmp;
}
down(rt);
int mid = l + r >> 1;
long long tmp = 0;
if (L <= mid) tmp += query(L, R, l, mid, (rt << 1));
if (R > mid) tmp += query(L, R, mid + 1, r, (rt << 1 | 1));
up(rt);
return tmp;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
int base = 1;
while (x) {
a[i][x % 10] += base;
x /= 10;
base *= 10;
}
}
build(1, n, 1);
while (q--) {
int type, l, r, x, y;
scanf("%d", &type);
if (type == 1) {
scanf("%d%d%d%d", &l, &r, &x, &y);
if (x == y) continue;
update(l, r, 1, n, 1, x, y);
} else {
scanf("%d%d", &l, &r);
printf("%I64d\n", query(l, r, 1, n, 1));
}
}
return 0;
}
| 12 | CPP |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
for(;;){
int n;
cin >> n;
if(n==0) break;
unsigned long psum = 0;
for(int i=0; i<n; i++){
int p;
cin >> p;
psum += p;
}
vector<int> j(n-1);
for(int i=0; i<n-1; i++) cin >> j[i];
sort(j.rbegin(),j.rend());
int num = n;
for(int i=0; i<n-1; i++){
if(psum * num >= (psum + j[i]) * (num - 1)) break;
psum += j[i];
num--;
}
cout << psum * num << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
int main() {
long long n;
cin >> n;
vector<pair<long long, long long> > v(n);
long long a, b;
for (long long i = 0; i < n; i++) {
cin >> v[i].first;
cin >> v[i].second;
}
a = v[0].first;
b = v[0].second;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> > >
pq;
multiset<long long> s;
for (long long i = 1; i < n; i++) {
if (v[i].first <= a) {
pq.push(v[i]);
} else {
s.insert(v[i].second - v[i].first + 1);
}
}
long long have = 0;
long long rank = s.size() + 1;
long long cur = 0;
while (a > 0 && pq.size() > 0) {
pair<long long, long long> p = pq.top();
while (p.first == a) {
s.insert(p.second - p.first + 1);
pq.pop();
if (pq.size() == 0) break;
p = pq.top();
}
p = pq.top();
have += a - p.first;
a = p.first;
while (s.size() > 0) {
long long req2 = *(s.begin());
if (req2 > have) {
break;
}
have -= req2;
s.erase(s.begin());
}
long long sz = s.size();
rank = min(rank, sz + 1);
}
if (pq.size() == 0) {
have = a;
while (s.size() > 0) {
long long req2 = *(s.begin());
if (req2 > have) {
break;
}
have -= req2;
s.erase(s.begin());
}
long long sz = s.size();
rank = min(rank, sz + 1);
}
cerr << "a"
<< ": " << a << "\n";
cout << rank;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t, n, m, i, j, q, x, a, y, b, k, p;
cin >> t;
while (t--) {
cin >> n >> p >> k;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int pref[n];
pref[0] = arr[0];
for (i = 1; i < n; i++) pref[i] = arr[i] + pref[i - 1];
long long int ans = 0;
for (i = 0; i < k; i++) {
if (arr[i] > p) break;
long long int count = 0;
if (i == k - 1)
count += k;
else
count = 1;
long long int sum = arr[i];
j = i;
while (j + k < n && sum + arr[j + k] <= p) {
count += k;
j += k;
sum += arr[j];
}
long long int low = j + 1, high = min(n - 1, j + k), index = -1;
if (i != k - 1) {
low = 0, high = i - 1, index = -1;
while (low <= high) {
long long int mid = (low + high) >> 1;
if (sum + pref[mid] <= p) {
index = mid;
low = mid + 1;
} else
high = mid - 1;
}
if (index != -1) {
sum += pref[index];
count += (index + 1);
}
}
low = j + 1, high = n - 1, index = -1;
while (low <= high) {
long long int mid = (low + high) >> 1;
if (sum + pref[mid] - pref[j] <= p) {
index = mid;
low = mid + 1;
} else
high = mid - 1;
}
if (index != -1) count += (index - j);
ans = max(ans, count);
}
cout << ans << "\n";
}
}
| 8 | CPP |
math =input().split("+")
math.sort()
for i in range(len(math)):
print(math[i],end = "")
if i != len(math)-1:
print("+",end = "") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100007;
int A[N], ML[N], ml[N], MR[N], mr[N];
int main() {
int n, p, q, r;
cin >> n >> p >> q >> r;
for (int i = 0; i < n; ++i) cin >> A[i];
ML[0] = ml[0] = A[0];
MR[n - 1] = mr[n - 1] = A[n - 1];
for (int i = 1; i < n; ++i) {
ml[i] = min(ml[i - 1], A[i]);
ML[i] = max(ML[i - 1], A[i]);
}
for (int i = n - 2; i >= 0; --i) {
mr[i] = min(mr[i + 1], A[i]);
MR[i] = max(MR[i + 1], A[i]);
}
long long sum = -3e18, left, right;
for (int i = 0; i < n; ++i) {
left = 1ll * p * ((p < 0) ? ml[i] : ML[i]);
right = 1ll * r * ((r < 0) ? mr[i] : MR[i]);
sum = max(left + right + 1ll * q * A[i], sum);
}
cout << sum;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
int x;
int y;
node(){};
node(int xx, int yy) {
x = xx;
y = yy;
}
bool operator<(const node &b) const { return x > b.x; }
} p[1009], q[1009];
map<pair<int, int>, int> s;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i].x >> p[i].y;
for (int i = 1; i <= n; i++) {
s[make_pair(p[i].x, p[i].y)]++;
}
for (int i = 1; i <= n; i++) cin >> q[i].x >> q[i].y;
for (int i = 1; i <= n; i++) {
int f = 1;
int xx = p[1].x + q[i].x;
int yy = p[1].y + q[i].y;
for (int j = 1; j <= n; j++) {
int dx = xx - q[j].x;
int dy = yy - q[j].y;
if (s[make_pair(dx, dy)]) {
continue;
} else {
f = 0;
break;
}
}
if (f == 1) {
cout << xx << " " << yy << endl;
return 0;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
char s[11];
long long a[100007];
inline long long qp(long long base, long long p, long long mo) {
long long res = 1;
while (p) {
if (p & 1) (res *= base) %= mo;
(base *= base) %= mo;
p >>= 1;
}
return res;
}
signed main() {
std::ios::sync_with_stdio(0);
long long n, k, cnt = 0, tot = 0;
cin >> n >> k;
for (long long i = 0; i <= n; ++i) {
cin >> (s + 1);
if (s[1] == '?') {
++cnt;
a[i] = 1e9;
} else {
++tot;
long long flag = 1;
if (s[1] == '-') flag = -1;
long long len = strlen(s + 1), sum = 0;
for (long long j = 1; j <= len; ++j) {
if (s[j] == '-') continue;
sum = sum * 10 + s[j] - 48;
}
a[i] = sum * flag;
}
}
bool who;
if (tot & 1)
who = 0;
else
who = 1;
if (k == 0) {
if (a[0] == 1e9) {
if (who == 0)
cout << "Yes\n";
else
cout << "No\n";
} else {
if (a[0] != 0) {
cout << "No\n";
} else {
cout << "Yes\n";
}
}
return 0;
}
if (tot == n + 1) {
long long p = 998244353, sum = 0;
for (long long i = 0; i <= n; ++i)
sum = (sum + (a[i] + p) % p * qp(k, i, p) % p + p) % p;
if (sum) {
cout << "No\n";
return 0;
}
p = 1e9 + 7, sum = 0;
for (long long i = 0; i <= n; ++i)
sum = (sum + (a[i] + p) % p * qp(k, i, p) % p + p) % p;
if (sum) {
cout << "No\n";
return 0;
}
p = 1e9 + 9, sum = 0;
for (long long i = 0; i <= n; ++i)
sum = (sum + (a[i] + p) % p * qp(k, i, p) % p + p) % p;
if (sum) {
cout << "No\n";
return 0;
}
cout << "Yes\n";
return 0;
}
if (cnt & 1) {
if (who == 0)
cout << "Yes\n";
else
cout << "No\n";
} else {
if (who == 1)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int mi = 10000000000;
long long int a[100100];
for (int i = 1; i <= n; i++) {
cin >> a[i];
mi = min(mi, a[i]);
}
for (int i = 1; i <= n; i++)
if (a[i] % mi > 0) {
cout << -1;
return 0;
}
cout << mi;
return 0;
}
| 7 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.