solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#undef local
//#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define fori(i,n) for(ll i=0;i<n;i++)
#define ford(i,n) for(ll i = n-1;i >= 0;i--)
#define pb push_back
#define ll long long int
//#define mod 998244353
#define pi pair<int,int>
#define pll pair<ll,ll>
#define mp make_pair
#define fi first
#define se second
#ifdef local
#define debug(x) cout<<#x<<" = "<<x<<endl
#define debug2(x,y) cout<<#x<<" = "<<x<<", "<<#y<<" = "<<y<<endl
#define debug3(x,y,z) cout<<#x<<" = "<<x<<", "<<#y<<" = "<<y<<", "<<#z<<" = "<<z<<endl
#define debug4(x,y,z,q) cout<<#x<<" = "<<x<<", "<<#y<<" = "<<y<<", "<<#z<<" = "<<z<<", "<<#q<<" = "<<q<<endl
#define debugV(v) cout <<#v<<" = ";fori(i,(int) v.size()) {cout << v[i] << " ";} cout << endl << endl;
#define printVector(v) {fori(i,(int) v.size()) {cout << v[i] << " ";} cout << "\n";}
#else
#define debug(x) 1
#define debug2(x,y) 1
#define debug3(x,y,z) 1
#define debug4(x,y,z,q) 1
#define debugV(v) 1
#define printVector(v) {fori(i,(int) v.size()) {cout << v[i] << " ";} cout << "\n";}
#endif
std::mt19937 rng((unsigned int) std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
void solve(int ttt)
{
ll n,mod;
cin >> n >> mod;
int T = n*(n-1)+1;
ll * withDiff = new ll[T],*pref = new ll[T];
ll * nwithDiff = new ll[T],*npref = new ll[T];
memset(withDiff,0,sizeof(ll)*T);
memset(pref,0,sizeof(ll)*T);
auto get = [&](int l,int r,ll * v)
{
r = min(r,T-1);
l = max(l,0);
if(l > r) return 0LL;
ll res = v[r];
if(l > 0) res -= v[l-1];
res += mod;
res %= mod;
return res;
};
int offset = (n*(n-1))/2;
withDiff[0+offset] = 1;
for(int k = 0;k <= n*(n-1);k++)
{
pref[k] += withDiff[k];
if(k) pref[k] += pref[k-1];
pref[k] %= mod;
}
vector<ll> ans(n+1,0);
for(int i = 2;i <= n;i++)
{
memset(nwithDiff,0,sizeof(ll)*T);
memset(npref,0,sizeof(ll)*T);
ll res = 0;
int d = -(i*(i-1))/2;
int dd = d + offset;
nwithDiff[dd] = 1;
d++;
for(;d <= (i*(i-1)/2);d++)
{
res = 0;
int dd = d + offset;
res += nwithDiff[dd-1] - get(dd-1-(i-1),dd-1,pref) + get(dd,dd+i-1,pref);
res += mod;
res %= mod;
nwithDiff[dd] = res;
}
for(int k = 0;k <= n*(n-1);k++)
{
npref[k] = nwithDiff[k];
if(k) npref[k] += npref[k-1];
npref[k] %= mod;
}
{
ll res = 0;
for(int j = 0;j < i;j++)
{
for(int k = j+1;k < i;k++)
{
int dd = k - j + 1 + offset;
if(dd <= n*(n-1))
res += get(dd,n*(n-1),pref);
res %= mod;
}
}
res += (ans[i-1] * (i))%mod;
res %= mod;
ans[i] = res;
}
swap(withDiff,nwithDiff);
swap(pref,npref);
}
debug(clock());
cout << ans[n] << "\n";
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int ttt;
ttt = 1;
//cin >> ttt;
fori(i,ttt) solve(i);
}
| 11 | CPP |
n=int(input())
z=0
for i in range(n):
t,x,y= map(int,input().split())
if x+y <= t and (x+y)%2 == t%2:
z+=1
if z==n:
print('Yes')
else:
print('No') | 0 | PYTHON3 |
t = int(input())
def max_gcd(n):
# if n == 2:
# return 1
# lo, hi = 1, n // 2
# for i in range(1, n):
# if n // i < 2:
# return i-1
return n//2
for _ in range(t):
n = int(input())
print(max_gcd(n)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
struct Team {
string name;
int pnts, wn, ls;
void print() {
cout << name << " " << pnts << "pts " << wn << ":" << ls << endl;
}
};
map<string, int> mp;
vector<Team> v;
void Add(string name, int win, int lose) {
for (int i = 0; i < v.size(); i++) {
if (v[i].name == name) {
if (win > lose) {
v[i].pnts += 3;
}
if (win == lose) {
v[i].pnts += 1;
}
v[i].wn += win;
v[i].ls += lose;
if (debug) {
cout << "Added:";
v[i].print();
}
return;
}
}
Team t;
t.pnts = 0;
t.name = name;
if (win > lose) {
t.pnts = 3;
}
if (win == lose) {
t.pnts = 1;
}
t.wn = win;
t.ls = lose;
if (debug) {
cout << "New Team:";
t.print();
}
v.push_back(t);
}
bool cmp(Team a, Team b) {
if (a.pnts != b.pnts) return a.pnts > b.pnts;
if (a.wn - a.ls != b.wn - b.ls) return a.wn - a.ls > b.wn - b.ls;
if (a.wn != b.wn) return a.wn > b.wn;
return a.name <= b.name;
}
void Del(string name, int win, int lose) {
for (int i = 0; i < v.size(); i++) {
if (v[i].name == name) {
if (win > lose) {
v[i].pnts -= 3;
}
if (win == lose) {
v[i].pnts -= 1;
}
v[i].wn -= win;
v[i].ls -= lose;
if (debug) {
cout << "Del:";
v[i].print();
}
return;
}
}
}
int main(int argc, char* argv[]) {
for (int i = 0; i < 5; i++) {
string a, b;
int c, d;
cin >> a >> b;
scanf("%d:%d", &c, &d);
mp[a]++;
mp[b]++;
Add(a, c, d);
Add(b, d, c);
}
string enemy;
for (map<string, int>::iterator it = mp.begin(); it != mp.end(); it++) {
if (it->second == 2 && it->first != "BERLAND") {
enemy = it->first;
break;
}
}
int mnx = -1, mny = -1, mnd = 1e9;
for (int y = 100; y >= 0; y--) {
for (int d = 1; d <= 100; d++) {
int x = y + d;
Add("BERLAND", x, y);
Add(enemy, y, x);
sort(v.begin(), v.end(), cmp);
if (v[0].name == "BERLAND" || v[1].name == "BERLAND") {
if ((y < mny || mny == -1) && d <= mnd) {
mny = y;
mnx = x;
mnd = d;
}
}
Del("BERLAND", x, y);
Del(enemy, y, x);
}
}
if (mnx == -1 || mny == -1)
cout << "IMPOSSIBLE";
else
cout << mnx << ":" << mny << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int brojac = 0;
while (n > 0 && m > 0) {
if (n >= m) {
n -= 2;
m--;
if (n >= 0 && m >= 0) brojac++;
} else {
n--;
m -= 2;
if (n >= 0 && m >= 0) brojac++;
}
}
cout << brojac;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long a[1000000];
long long Fac[1000000], Inv[1000000], inv[1000000];
void ini() {
Fac[0] = Inv[0] = Fac[1] = Inv[1] = inv[1] = 1;
for (int i = 2; i < 1000000; i++) {
Fac[i] = Fac[i - 1] * i % mod;
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
Inv[i] = Inv[i - 1] * inv[i] % mod;
}
}
long long C(int n, int m) { return Fac[n] * Inv[m] % mod * Inv[n - m] % mod; }
int op(int n, int s) {
if (n % 4 == 1) return n;
for (int i = 1; i < n; i++) {
a[i] = a[i] + s * a[i + 1];
a[i] %= mod;
s *= -1;
}
return op(n - 1, s);
}
int solve(int n, int s) {
if (n == 1) return (a[1] + mod) % mod;
for (int i = 1; i < n; i++) {
a[i] = a[i] + s * a[i + 1];
a[i] %= mod;
s *= -1;
}
return (solve(n - 1, s) + mod) % mod;
}
int main() {
ini();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
if (n < 100) {
printf("%d", solve(n, 1));
} else {
while (n % 4 != 1) {
n = op(n, 1);
}
long long res = 0;
for (int i = 1; i <= n; i++) {
if (i % 2) {
res += a[i] * C(n / 2, i / 2) % mod;
res %= mod;
}
}
cout << (res + mod) % mod;
}
return 0;
}
| 8 | CPP |
s = input()
s1 = "hello"
j = 0
count = 0
for i in s:
if(i == s1[j]):
j = j + 1
count = count + 1
if(count == 5):
break
if(count == 5):
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M;
long long test;
long long arr[1003][1003];
long long i, j;
long long r[1003], c[1003];
char ch;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M >> test;
for (long long int i = 1; i < N + 1; i++) {
for (long long int j = 1; j < M + 1; j++) {
cin >> arr[i][j];
}
}
for (long long int i = 1; i < N + 1; i++) r[i] = i;
for (long long int i = 1; i < M + 1; i++) c[i] = i;
for (long long int i = 0; i < test; i++) {
long long x, y;
cin >> ch >> x >> y;
if (ch == 'g') {
cout << arr[r[x]][c[y]] << "\n";
} else if (ch == 'r') {
swap(r[x], r[y]);
} else
swap(c[x], c[y]);
}
return 0;
}
| 8 | CPP |
n=int(input())
r,s=0,0
for i in [0]*n:
r+=eval('-'.join(input().split()))
s=min(s,r)
print(-s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<n;++i)
using namespace std;
typedef pair<int,int>P;
const int MAX_N = 100005;
ll a[MAX_N];
int n,Q;
ll cnt(ll x)
{
int l=0,r=0;
ll res=0;
ll win=0;
while(r<=n+1){
if(win<=x){
win += a[r];
r++;
}else{
res += r-l-1;
win -= a[l];
l++;
}
}
return res;
}
int main()
{
scanf("%d%d",&n,&Q);
rep(i,n){
scanf("%lld",&a[i]);
}
a[n] = (1LL<<60);
rep(i,Q){
ll x;
scanf("%lld",&x);
printf("%lld\n",cnt(x));
}
return 0;
} | 0 | CPP |
import sys
input = sys.stdin.readline
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
numberOfProblems = inp()
problemSolved = 0
for i in range(numberOfProblems):
currLine = insr()
count = 0
for char in currLine:
if char.isdigit():
count += int(char)
if count > 1:
problemSolved += 1
print (problemSolved) | 7 | PYTHON3 |
for i in range(int(input())):
n = input()
k = 0
a = []
for j in n:
k = k + 1
if j != '0':
a.append(j + (len(n) - k) * '0')
print(len(a))
print(" ".join(a))
| 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<map>
#include<stdint.h>
#define sqr(x) (x)*(x)
#define int __int128
using namespace std;
int n,m,i,j,wyx=998244353;
map<int,int> dp[111];
string st;
int dfs(int x,int y)
{
if (x==0) return 1;
if (x==1) return y+1;
if (dp[x].count(y)) return dp[x][y];
int i,j,now=0;
now+=dfs(x-1,y>>1)*((y&1)+1)%wyx;
for (i=1;i<=x;i++)
{
int t=(y&((((int)1)<<i)-1));
for (j=1;i*j<=x;j++)
{
if (j>1)
{
now+=dfs(x-i*j,y>>(i*j))*dfs(i,t)%wyx;
now%=wyx;
}
t&=(y>>(i*j));
}
}
return dp[x][y]=now;
}
signed main()
{
cin>>st;
for (i=0;i<st.size();i++) if (st[i]=='1') n|=(((int)1)<<i);
cout<<((long long)dfs(st.size(),n));
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<char, int> a;
map<char, int> b;
map<char, set<int>> a1;
map<char, set<int>> b1;
vector<pair<int, int>> ans;
int main() {
int n;
string s1, s2;
cin >> n >> s1 >> s2;
for (int i = 0; i < s1.length(); i++) {
a[s1[i]]++;
a1[s1[i]].insert(i);
}
for (int i = 0; i < s2.length(); i++) {
b[s2[i]]++;
b1[s2[i]].insert(i);
}
for (char i = 'a'; i <= 'z'; i++) {
int m = min(a[i], b[i]);
a[i] -= m;
b[i] -= m;
for (int j = 0; j < m; j++) {
ans.push_back({*a1[i].begin(), *b1[i].begin()});
a1[i].erase(*a1[i].begin());
b1[i].erase(*b1[i].begin());
}
}
int q = a['?'];
for (auto i : b) {
if (i.first != '?') {
int m = i.second;
if (q < m) {
b[i.first] -= q;
int ty = q;
for (int j = 0; j < ty; j++) {
ans.push_back({*a1['?'].begin(), *b1[i.first].begin()});
a1['?'].erase(*a1['?'].begin());
b1[i.first].erase(*b1[i.first].begin());
q--;
}
} else {
b[i.first] -= m;
for (int j = 0; j < m; j++) {
ans.push_back({*a1['?'].begin(), *b1[i.first].begin()});
a1['?'].erase(*a1['?'].begin());
b1[i.first].erase(*b1[i.first].begin());
q--;
}
}
}
if (q == 0) break;
}
a['?'] = q;
q = b['?'];
for (auto i : a) {
int m = i.second;
if (q < m) {
int ty = q;
for (int j = 0; j < ty; j++) {
ans.push_back({*a1[i.first].begin(), *b1['?'].begin()});
a1[i.first].erase(*a1[i.first].begin());
b1['?'].erase(*b1['?'].begin());
q--;
}
} else {
for (int j = 0; j < m; j++) {
ans.push_back({*a1[i.first].begin(), *b1['?'].begin()});
a1[i.first].erase(*a1[i.first].begin());
b1['?'].erase(*b1['?'].begin());
q--;
}
}
if (q == 0) break;
}
cout << ans.size() << endl;
for (auto i : ans) {
cout << i.first + 1 << ' ' << i.second + 1 << endl;
}
return 0;
}
| 10 | CPP |
def luck(x): # x is list
if x.count('4') + x.count('7') == len(x):
return 1
def nl(x):
if luck(str(x.count('4')+x.count('7'))) == 1:
return 1
n = list(input())
if nl(n) == 1:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
t=int(input())
while t>0:
n,k = map(int,input().split())
l=[]
if n%2==1 and k%2==1:
if n>=k:
print("YES")
for i in range(k-1):
l.append(1)
l.append(n-k+1)
print(*l)
else:
print("NO")
elif n%2==0 and k%2==1:
if n>=2*k:
print("YES")
for i in range(k-1):
l.append(2)
l.append(n-2*(k-1))
print(*l)
else:
print("NO")
elif n%2==0 and k%2==0:
if n>=k:
print("YES")
for i in range(k-1):
l.append(1)
l.append(n-k+1)
print(*l)
else:
print("NO")
else:
print("NO")
t=t-1
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int(i) = 0; (i) < (((int)((t).size()))); ++(i)) s << t[i] << " ";
return s;
}
namespace karkkainen {
inline bool leq(int a1, int a2, int b1, int b2) {
return (a1 < b1 || (a1 == b1 && a2 <= b2));
}
inline bool leq(int a1, int a2, int a3, int b1, int b2, int b3) {
return (a1 < b1 || (a1 == b1 && leq(a2, a3, b2, b3)));
}
static void radixPass(int* a, int* b, int* r, int n, int K) {
vector<int> c(K + 1, 0);
for (int(i) = 0; (i) < (n); ++(i)) c[r[a[i]]]++;
int sum = 0;
for (int(i) = (0); (i) <= (K); ++i) {
int t = c[i];
c[i] = sum;
sum += t;
}
for (int(i) = 0; (i) < (n); ++(i)) b[c[r[a[i]]]++] = a[i];
}
void suffixArray(int* s, int* SA, int n, int K) {
int n0 = (n + 2) / 3, n1 = (n + 1) / 3, n2 = n / 3, n02 = n0 + n2;
int* s12 = new int[n02 + 3];
s12[n02] = s12[n02 + 1] = s12[n02 + 2] = 0;
int* SA12 = new int[n02 + 3];
SA12[n02] = SA12[n02 + 1] = SA12[n02 + 2] = 0;
int* s0 = new int[n0];
int* SA0 = new int[n0];
for (int i = 0, j = 0; i < n + (n0 - n1); i++)
if (i % 3 != 0) s12[j++] = i;
radixPass(s12, SA12, s + 2, n02, K);
radixPass(SA12, s12, s + 1, n02, K);
radixPass(s12, SA12, s, n02, K);
int name = 0, c0 = -1, c1 = -1, c2 = -1;
for (int(i) = 0; (i) < (n02); ++(i)) {
if (s[SA12[i]] != c0 || s[SA12[i] + 1] != c1 || s[SA12[i] + 2] != c2) {
name++;
c0 = s[SA12[i]];
c1 = s[SA12[i] + 1];
c2 = s[SA12[i] + 2];
}
if (SA12[i] % 3 == 1) {
s12[SA12[i] / 3] = name;
} else {
s12[SA12[i] / 3 + n0] = name;
}
}
if (name < n02) {
suffixArray(s12, SA12, n02, name);
for (int(i) = 0; (i) < (n02); ++(i)) s12[SA12[i]] = i + 1;
} else {
for (int(i) = 0; (i) < (n02); ++(i)) SA12[s12[i] - 1] = i;
}
for (int i = 0, j = 0; i < n02; ++i)
if (SA12[i] < n0) s0[j++] = 3 * SA12[i];
radixPass(s0, SA0, s, n0, K);
int p = 0, t = n0 - n1;
for (int(k) = 0; (k) < (n); ++(k)) {
int i = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
int j = SA0[p];
if (SA12[t] < n0 ? leq(s[i], s12[SA12[t] + n0], s[j], s12[j / 3])
: leq(s[i], s[i + 1], s12[SA12[t] - n0 + 1], s[j],
s[j + 1], s12[j / 3 + n0])) {
SA[k] = i;
t++;
if (t == n02) {
for (k++; p < n0; p++, k++) SA[k] = SA0[p];
}
} else {
SA[k] = j;
p++;
if (p == n0) {
for (k++; t < n02; t++, k++)
SA[k] = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
}
}
}
delete[] s12;
delete[] SA12;
delete[] SA0;
delete[] s0;
}
}; // namespace karkkainen
struct SuffixArray {
int *sa, *lcp, *rank, n;
vector<int> t;
SuffixArray(const vector<int>& str) : t(str) {
n = ((int)((t).size()));
if (n <= 1) {
sa = new int[5];
sa[0] = 0;
} else {
int* arr = new int[n + 3];
sa = new int[n + 3];
for (int(i) = 0; (i) < (n); ++(i)) arr[i] = t[i];
arr[n] = arr[n + 1] = arr[n + 2] = 0;
karkkainen::suffixArray(arr, sa, n, *max_element(arr, arr + n));
delete[] arr;
}
rank = new int[n + 3];
for (int(i) = 0; (i) < (n); ++(i)) rank[sa[i]] = i;
lcp = new int[n + 3];
for (int i = 0, k = 0; i < n; i++) {
if (k > 0) k--;
if (rank[i] == n - 1) {
lcp[n - 1] = -1;
k = 0;
continue;
}
int j = sa[rank[i] + 1];
while (t[i + k] == t[j + k]) k++;
lcp[rank[i]] = k;
}
}
~SuffixArray() {
delete[] sa;
delete[] rank;
delete[] lcp;
}
};
const int LOGN = 18, N = 1 << LOGN;
int rm[LOGN][N];
void init(int* tab, int n) {
for (int(i) = 0; (i) < (n); ++(i)) rm[0][i] = tab[i];
for (int(k) = (1); (k) <= (LOGN - 1); ++k)
for (int(i) = (0); (i) <= (n - (1 << k)); ++i)
rm[k][i] = min(rm[k - 1][i], rm[k - 1][i + (1 << (k - 1))]);
}
int query(int a, int b) {
int k = 31 - __builtin_clz(b - a + 1);
return min(rm[k][a], rm[k][b - (1 << k) + 1]);
}
int inp[N];
int word[N];
int ans[N];
int newword[N];
struct Todo {
int from, to, maxIndex, whichQuery, multiplier, uniq;
};
bool operator<(const Todo& t, const Todo& r) {
return t.maxIndex != r.maxIndex ? t.maxIndex < r.maxIndex : t.uniq < r.uniq;
}
namespace Fenwick {
int a[200007];
void add(int n, int x) {
for (; n < 200007; n |= n + 1) a[n] += x;
}
int sum(int n) {
int s = 0;
while (n >= 0) {
s += a[n];
n = (n & (n + 1)) - 1;
}
return s;
}
}; // namespace Fenwick
int main() {
int(n);
scanf("%d", &(n));
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%d", inp + i);
}
for (int(i) = 0; (i) < (n - 1); ++(i)) {
word[i] = inp[i + 1] - inp[i];
}
word[n - 1] = INT_MAX;
for (int(i) = 0; (i) < (n - 1); ++(i)) {
word[n + i] = -word[i];
}
int len = 2 * n - 1;
map<int, int> mapa;
int now = 1;
for (int(i) = 0; (i) < (len); ++(i)) mapa[word[i]] = now++;
for (int(i) = 0; (i) < (len); ++(i)) newword[i] = mapa[word[i]];
SuffixArray sa(vector<int>(newword, newword + len));
init(sa.lcp, sa.n);
vector<Todo> todo;
int uniquer = 0;
int(queries);
scanf("%d", &(queries));
for (int(q) = 0; (q) < (queries); ++(q)) {
int(l), (r);
scanf("%d %d", &(l), &(r));
--l;
--r;
if (l == r) {
ans[q] = n - 1;
} else {
int indexInSa = sa.rank[n + l];
int a = indexInSa, b = indexInSa;
{
int from = 0, to = indexInSa - 1;
while (from <= to) {
int mid = (from + to) / 2;
if (query(mid, indexInSa - 1) < r - l) {
from = mid + 1;
} else {
a = mid;
to = mid - 1;
}
}
}
{
int from = indexInSa + 1, to = sa.n - 1;
while (from <= to) {
int mid = (from + to) / 2;
if (query(indexInSa, mid - 1) < r - l) {
to = mid - 1;
} else {
b = mid;
from = mid + 1;
}
}
}
ans[q] = 0;
if (r + 1 <= n - 2) {
todo.push_back((Todo){a, b, n - 2, q, 1, uniquer++});
todo.push_back((Todo){a, b, r, q, -1, uniquer++});
}
if (0 <= l - (r - l + 1)) {
todo.push_back((Todo){a, b, l - (r - l + 1), q, 1, uniquer++});
}
}
}
sort(todo.begin(), todo.end());
int nowToAddIndex = 0;
for (typeof(todo.begin()) td = todo.begin(); td != todo.end(); td++) {
for (; nowToAddIndex <= td->maxIndex; ++nowToAddIndex) {
Fenwick::add(sa.rank[nowToAddIndex], 1);
}
int res =
Fenwick::sum(td->to) - (td->from == 0 ? 0 : Fenwick::sum(td->from - 1));
ans[td->whichQuery] += td->multiplier * res;
}
for (int(q) = 0; (q) < (queries); ++(q)) pisz(ans[q]);
}
| 10 | CPP |
#include<iostream>
using namespace std;
long g(long a,long b){return b?g(b,a%b):a;}
long l(long a,long b){return a/g(a,b)*b;}
long i,n,t,r;
int main()
{
for(r=1,cin>>n;i++<n;cin>>t,r=l(r,t));
cout<<r;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, mapa[1000000 + 100];
string str;
vector<int> v;
int main() {
cin >> n;
v.push_back(1);
int cnt = 0;
int levo = n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cnt++;
mapa[x] = 1;
while (mapa[levo]) levo--, cnt--;
v.push_back(cnt + 1);
}
for (int i = 0; i < v.size(); i++) cout << v[i] << ' ';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
priority_queue<pair<int, int> > Q;
int ans[3][100001];
int main() {
int n, a;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a;
if (mp.find(a) == mp.end())
mp[a] = 1;
else
mp[a]++;
}
map<int, int>::iterator it = mp.begin();
while (it != mp.end()) {
Q.push(pair<int, int>(it->second, it->first));
it++;
}
int p = 0;
while (Q.size() >= 3) {
pair<int, int> top[3];
for (int i = 0; i < 3; ++i) {
top[i] = Q.top();
Q.pop();
}
if (top[0].second < top[1].second) swap(top[0], top[1]);
if (top[1].second < top[2].second) swap(top[1], top[2]);
if (top[0].second < top[1].second) swap(top[0], top[1]);
for (int i = 0; i < 3; ++i) {
ans[i][p] = top[i].second;
top[i].first--;
if (top[i].first) Q.push(top[i]);
}
++p;
}
cout << p << endl;
for (int i = 0; i < p; ++i)
cout << ans[0][i] << " " << ans[1][i] << " " << ans[2][i] << endl;
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
if(a<=12)
b=b/2;
if(a<=5)
b=0;
cout<<b<<'\n';
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-' && c != -1)
;
if (c == -1) return;
if (c == '-') sg = 1, c = getchar();
for (x = 0; c >= '0' && c <= '9';
x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
if (sg) x = -x;
}
template <class T>
void print(T x) {
if (x < 0) return putchar('-'), print(-x);
if (x < 10) {
putchar(x + '0');
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
template <class U, class V>
inline void gn(U &u, V &v) {
gn(u);
gn(v);
}
template <class U, class V, class W>
inline void gn(U &u, V &v, W &w) {
gn(u);
gn(v, w);
}
template <class T>
void println(T x) {
print(x);
putchar('\n');
}
template <class T>
void printsp(T x) {
print(x);
putchar(' ');
}
template <class U, class V>
inline void print(U u, V v) {
printsp(u);
println(v);
}
template <class U, class V, class W>
inline void print(U u, V v, W w) {
printsp(u);
print(v, w);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; a = (long long)a * a % m, b >>= 1)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
long long judge[1 << 22];
char s[55][55];
int c[55][55];
double p[55];
void pre(int m) {
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
for (int i = 0; i <= m; i++) p[i] = 1.0 / c[m][i];
}
int main() {
int n;
gn(n);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
int nn = strlen(s[0]);
pre(nn);
if (n == 1) {
puts("0.000000000");
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int tot = 0;
if (i == j) continue;
for (int k = 0; k < nn; k++) {
if (s[i][k] == s[j][k]) tot += (1 << k);
}
judge[tot] |= (1ll << i);
judge[tot] |= (1ll << j);
}
}
for (int i = (1 << nn); --i;) {
for (int j = 0; j < nn; j++) {
if (i & (1 << j)) {
judge[i ^ (1 << j)] |= judge[i];
}
}
}
for (int i = 0; i < n; i++) judge[0] |= (1ll << i);
double ans = 0;
for (int i = 1; i < (1 << nn); i++) {
int cnt = (__builtin_popcount(i));
for (int j = 0; j < nn; j++) {
if (i & (1 << j)) {
long long tmp = judge[i] ^ judge[i ^ (1 << j)];
ans +=
p[cnt - 1] * (__builtin_popcountll(tmp)) / (nn - (cnt - 1)) * cnt;
}
}
}
cout << fixed << setprecision(20) << ans / n << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[1000005], b[1000005];
int n, tot, cnt[1000005];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
long long ans = 1;
srand(time(NULL));
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
for (int step = 0; step < 10; step++) {
long long val = a[(rand() << 15 | rand()) % n];
tot = 0;
for (long long i = 1; i * i <= val; i++) {
if (val % i == 0) {
b[tot++] = i;
if (i != val / i) {
b[tot++] = val / i;
}
}
}
sort(b, b + tot);
fill(cnt, cnt + tot, 0);
for (int i = 0; i < n; i++) {
cnt[lower_bound(b, b + tot, gcd(a[i], val)) - b]++;
}
for (int i = tot - 1; i >= 0; i--) {
if (b[i] <= ans) break;
int sum = 0;
for (int j = i; j < tot; j++) {
if (b[j] % b[i] == 0) sum = sum + cnt[j];
}
if (sum * 2 >= n) {
ans = b[i];
}
}
}
printf("%I64d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = (int)1e9 + 7;
const int MAXN = (int)1e6 + 7;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
string second;
int n;
int open, close;
int nxtPlus[MAXN];
int prvPlus[MAXN];
int nxtMult[MAXN];
int prvMult[MAXN];
bool inside(int pt, int l, int r) { return l <= pt && pt <= r; }
long long calc(int l, int r) {
if (l == r) return second[l] - '0';
bool flag = 0;
if (l >= open && r <= close) {
if (nxtPlus[l] <= r)
return calc(l, nxtPlus[l] - 1) + calc(nxtPlus[l] + 1, r);
else
return calc(l, nxtMult[l] - 1) * calc(nxtMult[l] + 1, r);
}
if (!inside(nxtPlus[l], open, close) && nxtPlus[l] <= r)
return calc(l, nxtPlus[l] - 1) + calc(nxtPlus[l] + 1, r);
if (!inside(prvPlus[r], open, close) && prvPlus[r] >= l)
return calc(l, prvPlus[r] - 1) + calc(prvPlus[r] + 1, r);
if (!inside(nxtMult[l], open, close) && nxtMult[l] <= r)
return calc(l, nxtMult[l] - 1) * calc(nxtMult[l] + 1, r);
if (!inside(prvMult[r], open, close) && prvMult[r] >= l)
return calc(l, prvMult[r] - 1) * calc(prvMult[r] + 1, r);
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> second;
n = (int)second.size();
prvMult[0] = -1;
prvPlus[0] = -1;
for (int i = 1; i < n; i++) {
prvMult[i] = prvMult[i - 1];
prvPlus[i] = prvPlus[i - 1];
if (second[i] == '+') prvPlus[i] = i;
if (second[i] == '*') prvMult[i] = i;
}
nxtMult[n - 1] = n;
nxtPlus[n - 1] = n;
for (int i = n - 2; i >= 0; i--) {
nxtMult[i] = nxtMult[i + 1];
nxtPlus[i] = nxtPlus[i + 1];
if (second[i] == '+') nxtPlus[i] = i;
if (second[i] == '*') nxtMult[i] = i;
}
long long ans = 0;
for (int l = 0; l < n; l++) {
if (second[l] == '*') {
for (int r = l + 1; r < n; r++) {
if (isdigit(second[r])) {
open = l + 1;
close = r;
ans = max(ans, calc(0, n - 1));
}
}
}
}
for (int r = 0; r < n; r++) {
if (second[r] == '*') {
for (int l = r - 1; l >= 0; l--) {
if (isdigit(second[l])) {
open = l;
close = r - 1;
ans = max(ans, calc(0, n - 1));
}
}
}
}
ans = max(ans, calc(0, n - 1));
cout << ans;
return 0;
}
| 11 | CPP |
#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 = 100005;
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 n, m, a[105][105], x, y, ans[2005], b[2005];
bool dfs(int x, int s, bool ok) {
ans[s] = x;
if (s == m) return ok;
int t = ok ? 1 : b[s + 1];
for (int i = (t); i <= (n); ++i)
if (a[x][i]) {
a[x][i] = a[i][x] = 0;
if (dfs(i, s + 1, ok | i > b[s + 1])) return 1;
a[x][i] = a[i][x] = 1;
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &x), b[0] = x;
for (int i = (1); i <= (m); ++i)
scanf("%d", &y), a[x][y] = a[y][x] = 1, x = y, b[i] = y;
if (dfs(x, 0, 0))
for (int i = (0); i <= (m); ++i) printf("%d ", ans[i]);
else
printf("No solution\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INFint = 1e9+1;
const ll INFll = (ll)1e18+1;
ll MOD=998244353;
ll dp[3001][3001] = {0};
int main(){
ll N;
ll S;
cin>>N>>S;
vector<ll> A(N);
for(int i(0);i<N;i++){
cin>>A[i];
}
dp[0][0] = 1;
for(int i(0);i<N;i++){
for(int j(0);j<=S;j++){
dp[i+1][j] += dp[i][j]*2;
dp[i+1][j] %= MOD;
if(j+A[i] <= S){
dp[i+1][j+A[i]] += dp[i][j];
dp[i+1][j+A[i]] %= MOD;
}
}
}
cout << dp[N][S]%MOD << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mn = 2005;
int n, m, k;
struct edge {
int u, v, color, id;
int to(int x) { return x == u ? v : u; }
} e[100005];
int d[mn];
int usedcolor[mn][mn];
int ans;
void dfs(int x, int c1, int c2) {
edge &E = e[usedcolor[x][c1]];
int nxt = E.to(x);
if (usedcolor[nxt][c2])
dfs(nxt, c2, c1);
else
usedcolor[nxt][c1] = 0;
E.color = c2;
usedcolor[nxt][c2] = E.id;
usedcolor[x][c2] = E.id;
}
void paint() {
for (int i = 1; i <= k; i++) {
if (!e[i].color) {
int c1 = -1, c2 = 0;
bool flag = 0;
for (int j = 1; j <= ans; j++) {
if (!usedcolor[e[i].u][j]) c1 = j;
if (!usedcolor[e[i].v][j]) c2 = j;
if (c1 == c2) {
flag = 1;
break;
}
}
if (!flag) dfs(e[i].v, c1, c2);
e[i].color = c1;
usedcolor[e[i].u][c1] = i;
usedcolor[e[i].v][c1] = i;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[i].u = u;
e[i].v = v + n;
d[u]++;
d[v + n]++;
e[i].id = i;
}
for (int i = 1; i <= n + m; i++) ans = max(ans, d[i]);
printf("%d\n", ans);
paint();
for (int i = 1; i <= k; i++) printf("%d ", e[i].color);
return 0;
}
| 12 | CPP |
#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <set>
using namespace std;
#define inf 1e9
struct item{
int l = inf, r = 0, t = inf, b = 0;
void init() {
l = inf, r = 0, t = inf, b = 0;
}
};
vector<string> g(50);
vector<item> a(26);
vector<int> x;
bool f;
void perm(vector<int> p, int bit, int n) {
if (f) return;
if (n == x.size()) {
bool ff = true;
for (int i = 0; i < p.size(); i++) {
int ho = x[p[i]];
set<int> se;
for (int j = i; j < x.size(); j++) se.insert(x[p[j]]);
for (int h = a[ho].t; h < a[ho].b + 1; h++) {
for (int w = a[ho].l; w < a[ho].r + 1; w++) {
int c = g[h][w]-'A';
set<int>::iterator it = se.find(c);
if (it == se.end()) ff = false;
if (!ff) break;
}
if (!ff) break;
}
if (!ff) break;
}
if (ff) f = true;
return ;
}
for (int i = 0; i < x.size(); i++) {
if (bit & 1<<i) continue;
vector<int> a = p;
a.push_back(i);
perm(a, bit | 1<<i, n+1);
}
}
int main(void){
int n;
cin >> n;
while (n--) {
int h, w;
cin >> h >> w;
g.clear();
x.clear();
a.clear();
for (int i = 0; i < 26; i++) a[i].init();
f = false;
for (int i = 0; i < h; i++) {
cin >> g[i];
for (int j = 0; j < w; j++) if (g[i][j] != '.') {
char c = g[i][j];
int t = c - 'A';
a[t].l = min(a[t].l, j);
a[t].r = max(a[t].r, j);
a[t].t = min(a[t].t, i);
a[t].b = max(a[t].b, i);
t = g[i][j]-'A';
x.push_back(t);
}
}
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
vector<int> t;
perm(t,0,0);
if (f) cout << "SAFE" << endl;
else cout << "SUSPICIOUS" << endl;
}
} | 0 | CPP |
for i in range(int(input())):
a,b,c=map(int,input().split())
x=0
if c//2>0 and b>=1:
for j in range(c//2):
if b==0:
break
x+=3
b-=1
if b//2>0 and a>=1:
for j in range(b//2):
if a==0:
break
x+=3
a-=1
print(x) | 7 | PYTHON3 |
#include<iostream>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
if(a==b&&b==c)cout<<"No"<<endl;
else if(a==b|a==c|b==c)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T1 = int, typename T2 = int, typename T3 = int>
void debug(T1 x, T2 y = T2(), T3 z = T3()) {
cout << x << " " << y << " " << z << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int n, k;
cin >> n >> k;
long long int org = k;
vector<bool> fixed(n + 1);
if (k < n * (n + 1) / 2) {
cout << -1 << endl;
return 0;
}
k -= n * (n + 1) / 2;
long long int right = n;
long long int diff = n - 1;
long long int left = 1;
vector<long long int> p, p1;
while (k && left <= right) {
if (k < diff) {
while (diff - k) {
p.push_back(left);
p1.push_back(left);
left++;
diff--;
}
}
p.push_back(right);
p1.push_back(left);
if (right != left) {
p.push_back(left);
p1.push_back(right);
}
k -= diff;
left++;
right--;
diff -= 2;
}
for (long long int i = left; i <= right; i++) {
p.push_back(i);
p1.push_back(i);
}
cout << (org - k) << endl;
for (long long int x : p) cout << x << " ";
cout << endl;
for (long long int x : p1) cout << x << " ";
cout << endl;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<string> ans;
int main() {
string s;
cin >> s;
int len = s.length();
int a, b, c, x;
a = b = c = 0;
for (int i = 0; i < len; i++) {
a += s[i] == '1';
b += s[i] == '0';
c += s[i] == '?';
}
if (b + c > a) ans.push_back("00");
if (a + c > b + 1) ans.push_back("11");
if (s[len - 1] == '0') {
x = (c + b - a + len % 2) / 2;
if (x >= 0 && c - x >= 0) ans.push_back("10");
} else if (s[len - 1] == '1') {
x = (c + b - a + len % 2) / 2;
if (x >= 0 && c - x >= 0) ans.push_back("01");
} else {
c--, b++;
x = (c - a + b + len % 2) / 2;
if (x >= 0 && c - x >= 0) ans.push_back("10");
b--, a++;
x = (c - a + b + len % 2) / 2;
if (x >= 0 && c - x >= 0) ans.push_back("01");
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
}
| 11 | CPP |
tc = int(input())
for _ in range(tc):
n, k = map(int, (input().split(" ")))
coordX = sorted(list(map(int, (input().split(" ")))))
input()
l = 0
left = [0] * n
left[l] = 1
for r in range(1, n):
while coordX[r] - coordX[l] > k:
l += 1
left[r] = r - l + 1
left[r] = max(left[r], left[r - 1])
r = n - 1
right = [0] * n
right[r] = 1
for l in reversed(range(n - 1)):
while coordX[r] - coordX[l] > k:
r -= 1
right[l] = r - l + 1
right[l] = max(right[l], right[l + 1])
answer = 1
for i in range(n - 1):
answer = max(answer, right[i + 1] + left[i])
print(answer)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, x, mx = -1, asdf, cost = 0, mn = 500;
vector<int> v1;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> x;
v1.push_back(x);
if (x > mx) {
mx = x;
}
if (mn > x) {
mn = x;
}
}
if (mx == mn || abs(mn - mx) == 1) {
cout << mx << " " << 0 << "\n";
return 0;
} else if (mx - mn == 2) {
cout << mn + 1 << " " << 0 << "\n";
return 0;
} else {
sort(v1.begin(), v1.end());
int min = 2e9;
for (int i = mn; i <= mx; i++) {
cost = 0;
for (int j = 0; j < v1.size(); j++) {
if (v1[j] < i) {
cost += (i - 1) - v1[j];
} else if (v1[j] == i) {
continue;
} else if (v1[j] > i) {
cost += v1[j] - (i + 1);
}
}
if (cost < min) {
min = cost;
asdf = i;
}
}
cout << asdf << " " << min << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
const int N = 1.5e6 + 233;
int n, m;
std::vector<int> G[N];
int fa[N], son[N], size[N], top[N], dep[N], id[N], num;
void dfs1(int x, int dad) {
fa[x] = dad, dep[x] = dep[dad] + 1, size[x] = 1;
for (int y : G[x])
if (y != dad) {
dfs1(y, x);
if (size[son[x]] < size[y]) son[x] = y;
size[x] += size[y];
}
}
void dfs2(int x, int topf) {
top[x] = topf, id[x] = ++num;
if (son[x]) dfs2(son[x], topf);
for (int y : G[x])
if (y != fa[x] && y != son[x]) dfs2(y, y);
}
int tot;
std::vector<int> seg[N];
inline void addedge(int x, int y) {
G[x].push_back(y), G[y ^ 1].push_back(x ^ 1);
}
void modify(int p, int l, int r, int v, int L, int R) {
if (l <= L && r >= R) return seg[p].push_back(v), void();
if (l <= ((L + R) >> 1)) modify((p << 1), l, r, v, L, ((L + R) >> 1));
if (r > ((L + R) >> 1))
modify(((p << 1) | 1), l, r, v, ((L + R) >> 1) + 1, R);
}
void build(int p, int L, int R, int last) {
int l = ++tot, r = tot + seg[p].size();
tot = r;
if (seg[p].empty()) {
if (last) addedge(last * 2, l * 2);
} else {
addedge((r - 1) * 2, r * 2);
}
for (int i = 0; i < (int)seg[p].size(); ++i) {
int id = seg[p][i];
if (i > 0)
addedge((l + i - 1) * 2, (l + i) * 2);
else if (last)
addedge(last * 2, l * 2);
addedge(id, (l + i) * 2);
if (i > 0)
addedge((l + i - 1) * 2, id ^ 1);
else if (last)
addedge(last * 2, id ^ 1);
}
if (L != R) {
build((p << 1), L, ((L + R) >> 1), r);
build(((p << 1) | 1), ((L + R) >> 1) + 1, R, r);
}
}
inline void insert(int a, int b, int v) {
while (top[a] != top[b]) {
if (dep[top[a]] < dep[top[b]]) std::swap(a, b);
modify(1, id[top[a]], id[a], v, 2, n);
a = fa[top[a]];
}
if (a == b) return;
if (dep[a] > dep[b]) std::swap(a, b);
modify(1, id[a] + 1, id[b], v, 2, n);
}
int dfn[N], low[N], baka, stk[N], stop, ins[N], cnt, bel[N];
void tarjan(int x) {
dfn[x] = low[x] = ++baka;
stk[++stop] = x, ins[x] = 1;
for (int y : G[x]) {
if (!dfn[y]) {
tarjan(y);
low[x] = std::min(low[x], low[y]);
} else if (ins[y])
low[x] = std::min(low[x], dfn[y]);
}
if (low[x] == dfn[x]) {
int y;
++cnt;
do {
y = stk[stop--];
ins[y] = 0;
bel[y] = cnt;
} while (x != y);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y), G[y].push_back(x);
}
dfs1(1, 0), dfs2(1, 1);
for (int i = 1; i <= n; ++i) G[i].clear();
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
insert(a, b, i * 2);
insert(c, d, i * 2 + 1);
}
tot = m;
build(1, 2, n, 0);
for (int i = 1; i <= tot * 2 + 1; ++i)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= m; ++i)
if (bel[i * 2] == bel[i * 2 + 1]) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= m; ++i) {
printf("%d\n", (bel[i * 2] > bel[i * 2 + 1]) + 1);
}
return 0;
}
| 10 | CPP |
#include <iostream>
#include <algorithm>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
#define INF 1000000000LL
using namespace std;
typedef long long ll;
ll N, M, A[300][300];
int main(void) {
cin >> N >> M;
REP(i, 0, N) REP(j, 0, M) cin >> A[i][j], A[i][j]--;
ll ans = INF, cnt[300];
REP(i, 0, M) {
REP(j, 0, M) cnt[j] = 0;
REP(j, 0, N) REP(k, 0, M) if(A[j][k] != -1) {
cnt[A[j][k]]++;
break;
}
ll d = max_element(cnt, cnt + M) - cnt;
REP(j, 0, N) *find(A[j], A[j] + M, d) = -1;
ans = min(ans, cnt[d]);
}
cout << ans << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, cnt[2][2];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
char x;
cin >> x;
cnt[0][0] += (x == 'r' && i % 2 == 0);
cnt[0][1] += (x == 'b' && i & 1);
cnt[1][0] += (x == 'r' && i & 1);
cnt[1][1] += (x == 'b' && i % 2 == 0);
}
int ans = max(cnt[0][1], cnt[0][0]);
ans = min(ans, max(cnt[1][1], cnt[1][0]));
cout << ans << "\n";
return 0;
}
| 8 | CPP |
#define PI 3.14159265359
#include<stdio.h>
int main(){
double r;
scanf("%lf",&r);
printf("%lf %lf\n",r*r*PI,2*r*PI);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct Dinic {
int n, m, h[10005], l[10005], s, t, w[10005];
struct eg {
int v, c, f, x;
} e[(10005 * 4)];
bool bfs() {
static int q[10005];
for (int i(0); i < n; i++) l[i] = -1;
int B(l[s] = 0), E(1);
q[0] = s;
while (B < E)
for (int k(q[B++]), i(h[k]); ~i; i = e[i].x)
if (e[i].f < e[i].c && !~l[e[i].v])
l[e[i].v] = l[k] + 1, q[E++] = e[i].v;
return ~l[t];
}
int dfs(int u, int f) {
if (u == t) return f;
int mf;
for (int i(w[u]); ~i; i = e[i].x)
if (e[i].f < e[i].c && l[u] + 1 == l[e[i].v])
if ((mf = dfs(e[i].v, min(f, e[i].c - e[i].f))) > 0)
return e[i].f += mf, e[i ^ 1].f -= mf, mf;
return 0;
}
void ini(int N, int f, int d) {
n = N;
s = f;
t = d;
m = 0;
for (int i(0); i < n; i++) h[i] = -1;
}
int ade(int u, int v, int c = 1, int rc = 0) {
e[m] = eg{v, c, 0, h[u]};
h[u] = m++;
e[m] = eg{u, rc, 0, h[v]};
h[v] = m++;
return m - 2;
}
int mf() {
int a(0), d;
while (bfs()) {
memcpy(w, h, sizeof(int) * n);
do a += d = dfs(s, int(1e9 + 1));
while (d);
}
return a;
}
} H;
int N, M, A[10005], B[10005], a, I[10005], f[10005], G[10005], C[10005];
bool ok(int t) {
H.ini(((N + M) + 1) + 1, (N + M), ((N + M) + 1));
for (int i(0); i < M; i++) H.ade((N + M), i);
for (int i(0); i < N; i++) H.ade(M + i, ((N + M) + 1), t);
for (int i(0); i < M; i++) I[i] = H.ade(i, A[i] + M), H.ade(i, B[i] + M);
return H.mf() == M;
}
bool OK(int t) {
memcpy(G, f, sizeof(f)), (memset(C, 0, sizeof(C)));
int F = 0, x, O = 0;
H.ini(((N + M) + 1) + 1, (N + M), ((N + M) + 1));
for (int i(0); i < M; i++) H.ade((N + M), i);
for (int i(0); i < N; i++) H.ade(M + i, ((N + M) + 1), t);
while (666) {
x = 0;
for (int i(0); i < M; i++) {
if (C[i]) continue;
if (G[A[i]] > t && G[B[i]] > t)
;
else
--G[A[i]], --G[B[i]], ++C[i], x = 1;
}
if (!x) break;
}
for (int i(0); i < M; i++)
if (G[A[i]] > t && G[B[i]] > t) H.ade(i, A[i] + M), H.ade(i, B[i] + M), ++F;
for (int i(0); i < N; i++) O += G[i] > t;
if (O * t < F) return 0;
return H.mf() == F;
}
int bs(int B = 0, int E = int(1e9 + 1)) {
int M;
while (B < E)
if (OK(M = (B + E) >> 1))
E = M;
else
B = M + 1;
return B;
}
int hup() {
memcpy(G, f, sizeof(f)), (memset(C, 0, sizeof(C)));
for (int i(0); i < M; i++)
if (G[A[i]] < G[B[i]])
++C[A[i]], --G[B[i]];
else
++C[B[i]], --G[A[i]];
return *max_element(C, C + N);
}
int main(void) {
scanf("%d%d", &N, &M);
for (int i(0); i < M; i++)
scanf("%d%d", A + i, B + i), ++f[--A[i]], ++f[--B[i]];
a = bs(0, hup()), printf("%d\n", a), ok(a);
for (int i(0); i < M; i++)
if (!H.e[I[i]].f)
printf("%d %d\n", B[i] + 1, A[i] + 1);
else
printf("%d %d\n", A[i] + 1, B[i] + 1);
return 0;
}
| 16 | CPP |
n = int(input())
log = []
aboard = [0]
for i in range(n):
i = [int(x) for x in input().split()]
log.append(i[0])
log.append(i[1])
for i in range(len(log)-1):
if i%2==0:
Sum = aboard[i]+log[i+1]
aboard.append(Sum)
else:
Dif = aboard[i]-log[i+1]
aboard.append(Dif)
print(max(aboard)) | 7 | PYTHON3 |
t=int(input())
start=1
while(start<=t):
w=input()
if len(w)<=100 and w.islower():
if (len(w)>10):
print(w[0],len(w)-2,w[-1],sep="")
else:
print(w)
start+=1 | 7 | PYTHON3 |
#include <cstdio>
#include <algorithm>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
vector<pair<ll, bool>>slot;//first:cost second:flag
ll w, h;
ll p[123456];
ll q[123456];
int main()
{
scanf("%lld %lld", &w, &h);
for (int i = 0; i < w; ++i)
{
scanf("%lld", p + i);
slot.emplace_back(p[i], true);
}
for (int j = 0; j < h; ++j)
{
scanf("%lld", q + j);
slot.emplace_back(q[j], false);
}
sort(slot.begin(), slot.end());
ll pnum = w + 1;
ll qnum = h + 1;
ll ans = 0;
for (auto sl : slot)
{
ans += sl.first * (sl.second ? qnum : pnum);
if (sl.second)
{
--pnum;
}
else
{
--qnum;
}
}
printf("%lld\n", ans);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
int n, k;
int c = 0;
vector<int> a;
cin >> n >> k;
while (n--) {
int e;
cin >> e;
a.push_back(e);
}
k = k - 1;
for (int i = 1; i < a.size(); i++) {
if (a[i] != a[i - 1]) c++;
}
if (c == 0) {
cout << 1 << endl;
} else {
if (k == 0)
cout << "-1" << endl;
else
cout << (c + (k - 1)) / k << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long R = pow(10, 9) + 7;
template <typename T>
T last(vector<T>& v) {
return v[v.size() - 1];
}
template <typename T>
void prll(vector<T>& v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << ' ';
}
cout << endl;
}
template <typename T1, typename T2>
void prll(vector<pair<T1, T2>>& v) {
cout << "[";
for (long long i = 0; i < v.size(); i++) {
cout << '(' << v[i].first << ',' << v[i].second << "),";
}
cout << "]" << endl;
}
template <typename T>
void prll(vector<vector<T>>& v) {
cout << "[";
for (long long i = 0; i < v.size(); i++) {
prll(v[i]);
}
cout << "]" << endl;
}
template <typename T>
void prll(set<T>& v) {
cout << "{";
for (auto i : v) {
cout << i << ' ';
}
cout << "}" << endl;
}
template <typename T1, typename T2>
void prll(map<T1, T2>& v) {
cout << "{";
for (auto i : v) {
cout << i.first << ':' << i.second << ',';
}
cout << "}" << endl;
}
template <typename T>
bool in(set<T>& indices, T x) {
return indices.find(x) != indices.end();
}
template <typename T, typename T_>
bool in(map<T, T_>& indices, T x) {
return indices.find(x) != indices.end();
}
long long power(long long x, long long y) {
long long res = 1;
x = x % R;
if (x == 0) return 0;
while (y > 0) {
if (y % 2 == 1) res = (res * x) % R;
y /= 2;
x = (x * x) % R;
}
return res;
}
bool compare(long long a, long long b) { return (a < b); }
vector<long long> parent;
vector<long long> set_size;
void make_set(long long v) {
parent[v] = v;
set_size[v] = 1;
}
long long find_set(long long v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (set_size[a] < set_size[b]) swap(a, b);
parent[b] = a;
set_size[a] += set_size[b];
}
}
void TestCase() {
long long n, m;
cin >> n >> m;
parent.resize(n);
set_size.resize(n);
for (long long i = 0; i < n; i++) {
make_set(i);
}
map<long long, vector<pair<long long, long long>>> dic;
for (long long i = 0; i < m; i++) {
long long a, b, w;
cin >> a >> b >> w;
a--;
b--;
if (dic.find(w) == dic.end())
dic[w] = vector<pair<long long, long long>>(0);
dic[w].push_back(make_pair(a, b));
}
long long ans = 0;
while (!dic.empty()) {
long long w = dic.begin()->first;
vector<pair<long long, long long>> v = dic.begin()->second;
vector<pair<long long, long long>> u;
for (auto i : v) {
if (find_set(i.first) != find_set(i.second)) {
u.push_back(i);
}
}
for (auto i : u) {
if (find_set(i.first) == find_set(i.second)) {
if (dic.find(w + 1) == dic.end())
dic[w + 1] = vector<pair<long long, long long>>(0);
dic[w + 1].push_back(i);
ans++;
} else {
union_sets(i.first, i.second);
}
}
dic.erase(dic.begin());
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T;
T = 1;
for (long long tt = 1; tt <= T; tt++) {
TestCase();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int b, r, g, y, de[101];
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '!') {
de[c++] = i;
} else if (s[i] == 'B') {
b = i % 4;
} else if (s[i] == 'R') {
r = i % 4;
} else if (s[i] == 'Y') {
y = i % 4;
} else
g = i % 4;
}
int b1 = 0, g1 = 0, r1 = 0, y1 = 0;
for (int i = 0; i < c; i++) {
int k = de[i] % 4;
if (k == g) {
g1++;
} else if (k == y) {
y1++;
} else if (k == b) {
b1++;
} else {
r1++;
}
}
cout << r1 << " " << b1 << " " << y1 << " " << g1 << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s[8];
int main() {
int n, k, ans = 1000000000;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> s[i];
vector<int> p;
for (int i = 0; i < k; ++i) p.push_back(i);
do {
string cs[8];
for (int i = 0; i < n; ++i) cs[i] = s[i];
for (int i = 0; i < k; ++i)
for (int j = 0; j < n; ++j) cs[j][i] = s[j][p[i]];
int mx = 0, mn = 1000000000;
for (int i = 0; i < n; ++i) {
int val = 0;
for (int j = 0; j < k; ++j) val = val * 10 + cs[i][j] - '0';
mx = max(mx, val);
mn = min(mn, val);
}
ans = min(ans, mx - mn);
} while (next_permutation(p.begin(), p.end()));
cout << ans << endl;
return 0;
}
| 8 | CPP |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <ctype.h>
using namespace std;
using ll = long long;
using PAIR = pair<int, int>;
using PAIRLL = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
#define TR ","
#define fi first
#define se second
#define rep(i,N) for(ll i=0;i<(ll)N;++i)
#define repe(i,a,b) for(ll i=a;i<(ll)b;++i)
#define all(v) v.begin(), v.end()
#define IO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define INF 100000000
ll gcd(ll a, ll b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y) {
return x / gcd(x, y) * y;
}
ll waz = 76543217;
ll inv(ll x) {
if (x == 1) { return 1; }
if (x == 0) { return 0; }
else {
ll a = (waz - inv(waz % x) * (waz / x)) % waz;
if (a >= 0) { return a; }
else { return waz + a; }
}
}
void printVector(const vector<int>& vec) {
for (int value : vec) {
cout << value << " ";
}
cout << endl;
}
vector<ll> p;
ll phi(ll x) {
ll a = x;
ll b = x;
for (ll k = 0; k != p.size(); ++k) {
if (a % p[k] == 0) {
while (a % p[k] == 0) {
a /= p[k];
}
b = b / p[k] * (p[k] - 1);
}
if (a == 1) { break; }
}
return b;
}
bool my_compare(pair<string, int> a, pair<string, int> b) {
if (a.first != b.first) {
return a.first < b.first;
}
if (a.second != b.second) {
return a.second > b.second;
}
else {
return true;
}
}
int main()
{
IO;
ll n; cin >> n;
vector<ll> a(n);
rep(i, n) a[i] = i + 1;
do {
rep(i, a.size() - 1) {
cout << a[i] << " ";
}
cout << a[a.size() - 1] << endl;
} while (next_permutation(all(a)));
}
| 0 | CPP |
d,h,v,e =map(int,input().split())
if int(v)*(10**-6) < (int(e)/100)*3.141592*((int(d)/200)**2):
print('NO')
else:
print('YES')
t= int(h)/100*3.141592*((int(d)/200)**2)/(int(v)*(10**-6) - (int(e)/100)*3.141592*((int(d)/200)**2))
print(t)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 2000000010, Ding = 1000000005;
struct sl {
int l, r;
} q[N];
struct csl {
int lson, rson;
vector<int> c;
} tree[5000005];
int n, m, z, x, y, fa[N], num, node, root, L, R, p, o;
inline int findfather(int l) {
return (fa[l] == l ? l : fa[l] = findfather(fa[l]));
}
inline void hb(int x, int y) {
p = findfather(x);
o = findfather(y);
if (p != o) {
fa[p] = o;
q[o].l = min(q[o].l, q[p].l);
q[o].r = max(q[o].r, q[p].r);
}
}
inline void merge(int &now, long long l, long long r, int x) {
if (now == 0) return;
while (tree[now].c.size() > 0) {
hb(tree[now].c[tree[now].c.size() - 1], num);
tree[now].c.pop_back();
}
if (l == r) return;
long long mid = (l + r) >> 1LL;
if (x <= mid)
merge(tree[now].lson, l, mid, x);
else
merge(tree[now].rson, mid + 1, r, x);
}
inline void ins(int &now, long long l, long long r, int x, int y) {
if (now == 0) now = ++node;
if (x <= l && r <= y) {
tree[now].c.push_back(num);
return;
}
long long mid = (l + r) >> 1LL;
if (x <= mid) ins(tree[now].lson, l, mid, x, y);
if (y > mid) ins(tree[now].rson, mid + 1, r, x, y);
}
int main() {
scanf("%d", &n);
node = num = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &z, &x, &y);
if (z == 1) {
++num;
L = q[num].l = x + Ding;
R = q[num].r = y + Ding;
fa[num] = num;
merge(root, 1, M, L);
merge(root, 1, M, R);
if (L + 1 <= R - 1) ins(root, 1, M, q[num].l + 1, q[num].r - 1);
} else {
p = findfather(x);
o = findfather(y);
if (p == o || (q[x].l > q[o].l && q[x].l < q[o].r) ||
(q[x].r > q[o].l && q[x].r < q[o].r))
printf("YES\n");
else
printf("NO\n");
}
}
}
| 11 | CPP |
n=int(input())
sp=list(map(int,input().split()))
count=1
sont=set()
for x in sp:
sont^={x}
if len(sont)>count: count=len(sont)
print(count) | 7 | PYTHON3 |
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
count=0
for i in range(n):
if len(b)>0:
if a[i]<=b[0]:
count+=1
b.remove(b[0])
elif len(b)==0:
break
print(count)
| 7 | PYTHON3 |
n, w = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
if (2*a[0] <= a[n]):
ans = min(3 * n * a[0], w)
else:
ans = min(3/2 * n * a[n], w)
print(ans) | 8 | PYTHON3 |
n=int(input())
l=list(map(int,input().split()))
a=[]
b=[]
j=n
for i in range(1,n+1):
a.append(l[i-1])
if(i<n):
if(l[i]<l[i-1]):
j=i
b=l[i:]
break
if(b+a==sorted(l)):
print(n-j)
else:
print(-1) | 8 | PYTHON3 |
li=list(sorted(map(int,input().split()),reverse=True))
a=li[0]
c=li[1]+li[2]
if c>a:
print("0")
else:
print(abs(c-a-1)) | 7 | PYTHON3 |
N=int(input())
*A, = map(int,input().split())
print(sum(sorted(A)[N::2])) | 0 | PYTHON3 |
from sys import stdin
import math
def inp():
return stdin.readline().strip()
t = int(inp())
for _ in range(t):
a, b = [int(x) for x in inp().split()]
print(min((a+b)//3, a, b)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace task {
int64_t l, r;
int main() {
cin >> l >> r;
cout << "YES\n";
for (int64_t i = l; i < r; i += 2) {
cout << i << ' ' << i + 1 << '\n';
}
return 0;
}
} // namespace task
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(11);
cout.setf(ios::fixed);
return task::main();
}
| 8 | CPP |
n = int(input())
A = list(map(int,input().split()))
an = []
for i, q in enumerate(A):
s = set([i])
q -= 1
while q not in s:
s.add(q)
q = A[q] - 1
print(q + 1, end=' ') | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int A[3010], N;
struct Node {
int mx, p;
Node() { p = mx = 0; }
Node(int pos) {
p = pos;
mx = A[p];
}
};
Node st[12010];
Node join(Node p1, Node p2) { return p1.mx > p2.mx ? p1 : p2; }
void create(int n = 1, int l = 0, int r = N) {
if (l == r)
st[n] = Node(l);
else {
int m = (l + r) / 2;
create(2 * n, l, m);
create(2 * n + 1, m + 1, r);
st[n] = join(st[2 * n], st[2 * n + 1]);
}
}
Node query(int x, int y, int n = 1, int l = 0, int r = N) {
if (x <= l && r <= y)
return st[n];
else {
int m = (l + r) / 2;
if (y <= m) return query(x, y, 2 * n, l, m);
if (x > m) return query(x, y, 2 * n + 1, m + 1, r);
return join(query(x, y, 2 * n, l, m), query(x, y, 2 * n + 1, m + 1, r));
}
}
int main() {
int n;
cin >> n;
N = n - 1;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
A[N] = a[N].first;
for (int i = 0; i + 1 < n; i++) A[i] = a[i].first - a[i + 1].first;
create();
int m1 = -1, m2, m3;
int i1, i2, i3;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int s1 = i + 1, s2 = j - i;
if (s1 < s2) swap(s1, s2);
if (s2 * 2 < s1) continue;
s2 *= 2, s1 = (s1 + 1) / 2;
if (s1 > s2 || j + s1 >= n) continue;
Node Q = query(j + s1, min(n - 1, j + s2));
if (A[i] > m1) m1 = A[i], m2 = -1;
if (A[i] == m1) {
if (A[j] > m2) m2 = A[j], m3 = -1;
if (A[j] == m2) {
if (Q.mx > m3) m3 = Q.mx, i1 = i, i2 = j, i3 = Q.p;
}
}
}
}
for (int i = 0; i <= i1; i++) A[i] = 1;
for (int i = i1 + 1; i <= i2; i++) A[i] = 2;
for (int i = i2 + 1; i <= i3; i++) A[i] = 3;
for (int i = i3 + 1; i < n; i++) A[i] = -1;
vector<int> anw(n);
for (int i = 0; i < n; i++) anw[a[i].second] = A[i];
for (int i = 0; i < n; i++) {
if (i) cout << ' ';
cout << anw[i];
}
cout << endl;
}
| 11 | CPP |
count1=0
count2=0
count3=0
v1=0
v2=1
z=int(input())
x=list(map(int,input().split()))
for c in range(z):
if c==v1:
count1+=x[c]
v1+=3
elif c==v2:
count2+=x[c]
v2+=3
else:
count3+=x[c]
#print('count1',count1)
#print('count2',count2)
#print('count3',count3)
if count1>count2 and count1>count3:
print("chest")
elif count2>count1 and count2>count3:
print( "biceps")
else:
print("back")
| 7 | PYTHON3 |
s = input()
n1 = n2 = n3 = 0
for i in range (0, len(s),2):
if s[i] == "1":
n1 += 1
elif s[i] == "2":
n2 +=1
else:
n3 +=1
ss = "1+" * n1 + "2+" * n2 + "3+" * n3
print(ss[:-1])
| 7 | PYTHON3 |
# 701A
# θ(n^2) time
# θ(n) space
__author__ = 'artyom'
# SOLUTION
def main():
n = read()
a = read(3)
k = 2 * sum(a) // n
b = [False] * n
for i in range(n - 1):
if not b[i]:
for j in range(i + 1, n):
if not b[j] and a[i] + a[j] == k:
print(i + 1, j + 1)
b[i] = b[j] = True
break
# HELPERS
def read(mode=1, size=None):
# 0: String
# 1: Integer
# 2: List of strings
# 3: List of integers
# 4: Matrix of integers
if mode == 0: return input().strip()
if mode == 1: return int(input().strip())
if mode == 2: return input().strip().split()
if mode == 3: return list(map(int, input().strip().split()))
a = []
for _ in range(size):
a.append(read(3))
return a
main() | 7 | PYTHON3 |
#include <iostream>
#include <queue>
#include <iomanip>
#include <algorithm>
using namespace std;
int main(){
int N,K,T,U,V,L;
cin >> N >> K >> T >> U >> V >> L;
queue<int> caro;
for(int i=0; i<N; i++){
int tmp;
cin >> tmp;
caro.push(tmp);
}
double time = 0;
int now = 0;
int stock = 0;
while(1){
//printf("now %d, time: %f, stock:%d\n", now, time, stock);
if(stock==0){
if(!caro.empty() && now+U >= caro.front()){
time += (caro.front()-now)/(double)U;
now = caro.front();
caro.pop();
stock++;
}else if(now+U >= L){
time += (L-now)/(double)U;
now = L;
break;
}else{
time += 1;
now += U;
}
}else{
stock--;
if(now + T*V >= L){
time += (L-now)/(double)V;
now = L;
break;
}
else{
time += T;
now += T*V;
int last;
bool over=false;
while(!caro.empty() && caro.front()<=now){
stock++;
if(stock>K){
stock=K;
over=true;
last = caro.front();
}
caro.pop();
}
if(over){
time -= (now-last)/(double)V;
now = last;
stock++;
}
}
}
}
cout << fixed;
cout << setprecision(10);
cout << time << endl;
return 0;
} | 0 | CPP |
a,b=map(int,input().split())
print(-1 if max(a,b) > 9 else a*b) | 0 | PYTHON3 |
from sys import stdin
input = stdin.readline
n = int(input())
stones = [int(item) for item in input().split(' ')]
q = int(input())
u = [0]
v = [0]
s = 0
for item in stones:
s += item
v.append(s)
s = 0
for item in sorted(stones):
s += item
u.append(s)
while q:
q -= 1
[type, l, r] = [int(item) for item in input().split(' ')]
arr = v if type == 1 else u
print(arr[r] - arr[l - 1])
| 8 | PYTHON3 |
#include <iostream>
using namespace std;
int main(void){
long long n,k;
cin>>n>>k;
long long ans=0;
if(k==0){cout<<n*n<<endl;return 0;}
for(int i=1;i<=n;i++){
ans+=max(0LL,(i-k)*(n/i));
ans+=max(0LL,n%i-k+1);
}
cout<<ans<<endl;
}
| 0 | CPP |
# import sys,os,io
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
PI = 3.141592653589793238460
INF = float('inf')
MOD = 1000000007
# MOD = 998244353
def add(x,y):
return (x+y)%MOD
def sub(x,y):
return (x-y+MOD)%MOD
def mul(x,y):
return (x*y)%MOD
def gcd(x,y):
if y == 0:
return x
return gcd(y,x%y)
def lcm(x,y):
return (x*y)//gcd(x,y)
def power(x,y):
res = 1
x%=MOD
while y!=0:
if y&1 :
res = mul(res,x)
y>>=1
x = mul(x,x)
return res
def mod_inv(n):
return power(n,MOD-2)
def prob(p,q):
return mul(p,power(q,MOD-2))
def ii():
return int(input())
def li():
return [int(i) for i in input().split()]
def ls():
return [i for i in input().split()]
def fun():
for i in vis:
if i == -1:
return 1
return 0
for t in range(ii()):
t+=1
n,k = li()
s = input()
f = [0 for i in range(26)]
store = []
for i in s:
f[ord(i) - 97]+=1
for i in f:
store.append(i)
store.sort()
store.reverse()
ans = 1
# print(store)
for i in range(2,n+1):
# iterate over each length
x = k%i
if x == 0:
# yes we can take
ans = i
else:
need = i // gcd(i,x)
cnt = 0
for j in store:
d = j//need
cnt+=d*need
if cnt >= i:
ans = i
print(ans)
| 11 | PYTHON3 |
s=input()
c=0
if(s[0]!='1'):
print("NO")
c=-1
else:
for i in range(1,len(s)):
if(i<len(s)-2):
if(s[i]=='4' and s[i+1]=='4' and s[i+2]=='4'):
print("NO")
c=-1
break
if s[i] not in ['1','4']:
print("NO")
c=-1
break
if(c==0):
print("YES")
| 7 | PYTHON3 |
#include <iostream>
#include <stdio.h>
#include <cmath>
using namespace std;
int N,K;
long double res=0.0L;
int main(){
cin >> N >> K;
for(int i=1;i<=N;i++){
int cnt=0;
while(i*pow(2,cnt)<K) cnt++;
res+=(1.0L/N)*pow(0.5,cnt);
}
printf("%.9Lf\n",res);
return 0;
}
| 0 | CPP |
N=int(input())
A=list(map(int,input().split()))
ans=0
for i in A:
while i%2==0:
ans+=1
i=i/2
print(ans) | 0 | PYTHON3 |
int(input())
s=input()
for j in range(s.count('n')):
print(1,end=' ')
for j in range(s.count('z')):
print(0,end=' ')
| 7 | PYTHON3 |
n, m = int(input()), int(input())
a, b = [int(i) for i in input().split()], [int(i) for i in input().split()]
def check(t):
for i in range(n):
t -= (t + m) / a[i]
if t < 0:
return 0
t -= (t + m) / b[(i + 1) % n]
if t < 0:
return 0
return 1
l, r = 0, 10 ** 10
if not check(r):
print(-1)
else:
for i in range(300):
mid = (l + r) / 2
if check(mid):
r = mid
else:
l = mid
print(l)
| 7 | PYTHON3 |
import math
if __name__ == "__main__":
n, x = int(input()), [int(i) for i in input().split()]
min_index, max_index = x.index(min(x)), x.index(max(x))
print(max([min_index, max_index, n-1-min_index, n-1-max_index]))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct lex_compare {
public:
bool operator()(const pair<long long, long long>& lhs,
const pair<long long, long long>& rhs) const {
if (lhs.second == rhs.second) return lhs.first < rhs.first;
return (lhs.second > rhs.second);
}
};
class trp {
public:
long long a, b, c;
trp() {
this->a = 0;
this->b = 0;
this->c = 0;
}
trp(long long a, long long b, long long c) {
this->a = a;
this->b = b;
this->c = c;
}
};
class node {
public:
long long id, a, l;
vector<node*> v;
vector<pair<node*, long long>> vm;
node() { id = 0, a = 0, l = 0; }
void adn(node* t) {
v.push_back(t);
this->l++;
}
void adn(node* t, long long x) { vm.push_back({t, x}), l++; }
};
node* nnd(long long a = 0, long long i = 1) {
node* t = new node();
t->a = a;
t->id = i;
return t;
}
long long pw(long long a, long long b, long long m) {
if (b == 0) return 1;
long long t = (pw(a, b / 2, m)) % m;
t = (t * t) % m;
if (b % 2 == 0) return t;
return (a * t) % m;
}
long long gc(long long a, long long b) {
if (b == 0) return a;
return gc(b, a % b);
}
vector<string> splt(string x, char w) {
vector<string> v;
string s;
int l = x.length();
for (int i = 0; i < l; i++) {
if (x[i] == w) {
v.push_back(s);
s = "";
} else {
s.push_back(x[i]);
}
}
v.push_back(s);
return v;
}
void ioe() {
freopen("in_1.txt", "r", stdin);
freopen("out_1.txt", "w", stdout);
freopen("er_1.txt", "w", stderr);
}
void solve() {
string s;
cin >> s;
long long n = s.length();
long long x = 0, y = 0, c = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'M')
c++;
else {
x += c;
if (x != 0) y = max(y - c + 1, 0ll);
c = 0;
}
}
cout << (x + y) << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
long long f = t;
while (f--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
const int MAXN = 5e5 + 5;
int x[MAXN], y[MAXN];
int n;
char str[MAXN];
int ansx, ansy;
inline bool chk(int k) {
int lx = 0, rx = 1e9, ly = 0, ry = 1e9, lxy = -1e9, rxy = 1e9;
ansx = ansy = -1;
for (int i = 1; i <= n; ++i)
lx = std::max(lx, x[i] - k), rx = std::min(rx, x[i] + k),
ly = std::max(ly, y[i] - k), ry = std::min(ry, y[i] + k),
lxy = std::max(lxy, x[i] - y[i] - k), rxy = std::min(rxy, x[i] - y[i] + k);
if (lx <= rx && ly <= ry && lxy <= rxy) {
int ll = lx - ry, rr = rx - ly;
for (int y = ly; y <= ry; ++y) {
int llx = std::max({lx, lxy + y, ll + y}),
rrx = std::min({rx, rxy + y, rr + y});
if (llx <= rrx && (y || rrx > 0)) {
ansx = rrx;
ansy = y;
return 1;
}
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", str + 1);
int len = strlen(str + 1);
for (int j = 1; j <= len; ++j) {
if (str[j] == 'B')
x[i]++;
else
y[i]++;
}
}
int l = 0, r = 500000 + 5, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (chk(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
chk(ans);
for (int i = 1; i <= ansx; ++i) putchar('B');
for (int i = 1; i <= ansy; ++i) putchar('N');
puts("");
return 0;
}
| 9 | CPP |
x = int(input())
y = []
z, m = 0, 0
y = list(map(int, input().split()))
if len(y) == x:
for i in range(x - 1):
if y[i+1] - y[i] >= 0:
z += 1
if z >= m:
m = z
else:
z = 0
print(m + 1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void debugMode() {}
struct Line {
long long m, c;
Line() { m = c = 0x7fffffffffffffff; }
Line(long long m, long long c) : m(m), c(c) {}
long long operator()(long long x) { return m * x + c; }
bool parallel(Line l) { return m == l.m; }
pair<long double, long double> intersect(Line l) {
long double x, y;
x = (long double)(l.c - c) / (m - l.m);
y = (long double)m * x + c;
return {x, y};
}
};
struct LctElement {
Line l;
LctElement *lft, *rht;
LctElement() { lft = rht = NULL; }
};
class DynamicLCT {
LctElement* root;
bool minTree;
void updateMin(LctElement* v, int vl, int vr, Line nl) {
if (v->l.m == 0x7fffffffffffffff) {
v->l = nl;
return;
}
if (vl == vr) {
if (nl(vl) < v->l(vl)) {
v->l = nl;
}
return;
}
if (v->l.m > nl.m) {
swap(v->l, nl);
}
int mid = (vl + vr) / 2;
if (nl(mid) > v->l(mid)) {
if (v->lft == NULL) v->lft = new LctElement();
updateMin(v->lft, vl, mid, nl);
} else {
swap(v->l, nl);
if (v->rht == NULL) v->rht = new LctElement();
updateMin(v->rht, mid + 1, vr, nl);
}
}
void updateMax(LctElement* v, int vl, int vr, Line nl) {
if (v->l.m == 0x7fffffffffffffff) {
v->l = nl;
return;
}
if (vl == vr) {
if (nl(vl) > v->l(vl)) {
v->l = nl;
}
return;
}
if (v->l.m == nl.m) {
if (nl(vl) > v->l(vl)) {
v->l = nl;
}
return;
}
if (v->l.m > nl.m) {
swap(v->l, nl);
}
int mid = (vl + vr) / 2;
if (nl(mid) > v->l(mid)) {
swap(v->l, nl);
if (v->lft == NULL) v->lft = new LctElement();
updateMax(v->lft, vl, mid, nl);
} else {
if (v->rht == NULL) v->rht = new LctElement();
updateMax(v->rht, mid + 1, vr, nl);
}
}
long long queryMin(LctElement* v, int vl, int vr, long long x) {
if (v == NULL) return 0x7fffffffffffffff;
if (vl == vr) {
if (v->l.m == 0x7fffffffffffffff) return 0x7fffffffffffffff;
return v->l(x);
}
long long res = 0x7fffffffffffffff;
if (v->l.m != 0x7fffffffffffffff) res = v->l(x);
int mid = (vl + vr) / 2;
if (x <= mid)
return min(res, queryMin(v->lft, vl, mid, x));
else
return min(res, queryMin(v->rht, mid + 1, vr, x));
}
long long queryMax(LctElement* v, int vl, int vr, long long x) {
if (v == NULL) return -0x7fffffffffffffff;
if (vl == vr) {
if (v->l.m == 0x7fffffffffffffff) return -0x7fffffffffffffff;
return v->l(x);
}
long long res = -0x7fffffffffffffff;
if (v->l.m != 0x7fffffffffffffff) res = v->l(x);
int mid = (vl + vr) / 2;
if (x <= mid)
return max(res, queryMax(v->lft, vl, mid, x));
else
return max(res, queryMax(v->rht, mid + 1, vr, x));
}
void freeMemory(LctElement* node) {
if (node == NULL) return;
freeMemory(node->lft);
freeMemory(node->rht);
delete node;
}
public:
DynamicLCT(bool MinTree = true) {
root = new LctElement();
minTree = MinTree;
}
void update(int vl, int vr, Line nl) {
if (minTree)
updateMin(root, vl, vr, nl);
else
updateMax(root, vl, vr, nl);
}
long long query(int vl, int vr, long long x) {
if (minTree)
return queryMin(root, vl, vr, x);
else
return queryMax(root, vl, vr, x);
}
~DynamicLCT() { freeMemory(root); }
};
DynamicLCT bit[100001];
void add(int i, Line nl) {
while (i > 0) {
bit[i].update(0, 1e5, nl);
i -= ((i) & (-(i)));
}
}
long long min(int n, int i, int qp) {
long long ans = LLONG_MAX;
while (i <= n) {
ans = min(ans, bit[i].query(0, 1e5, (long long)qp));
i += ((i) & (-(i)));
}
return ans;
}
void solve(int cse) {
int n;
cin >> n;
vector<int> a(n + 1);
vector<long long> sig(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
sig[i] = sig[i - 1] + a[i];
}
int m;
cin >> m;
vector<vector<pair<int, int>>> Q(100001);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x = y - x + 1;
Q[y].push_back({i, x});
}
vector<long long> ans(m);
for (int i = 1; i <= n; i++) {
add(i, {-a[i], (long long)(i + 1) * a[i] - sig[i]});
for (auto e : Q[i]) {
ans[e.first] = min(n, e.second, e.second) + sig[i];
}
}
for (auto e : ans) cout << e << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
}
| 11 | CPP |
#include <iostream>
#include <algorithm>
using namespace std;
int main( void )
{
int n, s;
short map[20000];
while(cin >> n >> s, n | s) {
for(int i=0; i < n; ++i) cin >> map[i];
sort(map, map+n);
int count = 0;
for(int i=0; i < n; ++i)
for(int j=i+1; j < n; ++j) {
if(map[i] + map[j] > s) {
count += n - j;
break;
}
}
cout << count << endl;
}
return 0;
} | 0 | CPP |
from collections import defaultdict, deque
from bisect import bisect_left as lower
import heapq
import sys, threading
input = sys.stdin.readline
def put():
return map(int, input().split())
def dfs(tree,i, sum, p):
if len(tree[i])==1 and i!=0:
return 1
c=0
for j,k in tree[i]:
if j!=p:
z=dfs(tree,j, sum+k, i)
c+=z
arr.append((k, z))
return c
def solve():
t = int(input())
for _ in range(t):
n, w = put()
tree = [[] for i in range(n)]
for i in range(n-1):
x,y,z = put()
x,y = x-1,y-1
tree[x].append((y,z))
tree[y].append((x,z))
c =dfs(tree, 0,0,-1)
s = 0
for i in range(len(arr)):
s+= arr[i][0]*arr[i][1]
d = []
while arr:
i,j = arr.pop()
while i>0:
d.append((i-i//2)*j)
i//=2
d.sort()
i = len(d)-1
cnt=0
while s>w:
s-=d[i]
i-=1
cnt+=1
print(cnt)
arr = []
max_recur_size = 10**5*2 + 1000
max_stack_size = max_recur_size*500
sys.setrecursionlimit(max_recur_size)
threading.stack_size(max_stack_size)
thread = threading.Thread(target=solve)
thread.start() | 11 | PYTHON3 |
#include <stdio.h>
#include <math.h>
bool sosuu[1000000];
int main(void)
{
int n;
int sq;
int i,j;
int count;
bool flag;
int m;
for(i=2;i<=1000;i++)
{
for(j=2;j<=int(1000000/i);j++)
sosuu[i*j]=true;
}
while(~scanf("%d",&n))
{
count=0;
for(m=2;m<=n;m++)
{
if(sosuu[m] == false)
count++;
}
printf("%d\n",count);
}
return 0;
} | 0 | CPP |
n=int(input())
l=list(map(int,input().split()))[:n]
sum=0
for i in l:
sum=sum+i
vol=sum/n
print(format(vol,".5f"))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
int main() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
int mul = lcm(c, d);
a *= mul;
b *= mul;
int r = 1;
while (r * c <= a && r * d <= b) {
r++;
}
c *= (r - 1);
d *= (r - 1);
long long ans = gcd(a * b - c * d, a * b);
cout << (a * b - c * d) / ans << "/" << a * b / ans << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int main() {
char res[3][102] = {"Freda's", "Rainbow's", "OMG>.< I don't know!"};
char a[102];
int sum, r, f, n, i, x;
while (scanf("%d", &n) != EOF) {
getchar();
for (i = 0; i < n; i++) {
sum = 0;
f = 0;
r = 0;
gets(a);
x = strlen(a);
if (a[0] == 'm' && a[1] == 'i' && a[2] == 'a' && a[3] == 'o' &&
a[4] == '.') {
sum++;
f++;
}
if (a[x - 5] == 'l' && a[x - 4] == 'a' && a[x - 3] == 'l' &&
a[x - 2] == 'a' && a[x - 1] == '.') {
sum++;
r++;
}
if (sum == 1) {
if (f != 0) {
printf("%s\n", res[1]);
}
if (r != 0) {
printf("%s\n", res[0]);
}
} else {
printf("%s\n", res[2]);
}
}
}
}
| 7 | CPP |
def craft(a,b):
if a==0 or b==0:
return 0
ans=(a+b)//3
m=min(a,b)
if ans<=m:
return ans
else:
return m
T=int(input())
for i in range(T):
a,b=[int(i) for i in input().split()]
print(craft(a,b)) | 7 | PYTHON3 |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <P,P> PP;
typedef pair <int,PP> PPP;
static const double eps = 1e-8;
bool cards[300001];
int main(){
int total_cards;
int total_questions;
while(~scanf("%d %d",
&total_cards,
&total_questions)){
memset(cards,false,sizeof(cards));
int tmp_max = 0;
for(int card_i = 0; card_i < total_cards; card_i++){
int card;
scanf("%d",&card);
cards[card] = true;
}
for(int question_i = 0; question_i < total_questions; question_i++){
int divisor;
scanf("%d",&divisor);
int res = 0;
for(int target = divisor - 1; target >= 0; target--){
for(int i = target; i <= 300000; i+= divisor){
if(cards[i]){
res = target;
goto found;
}
}
}
found:;
printf("%d\n",res);
}
}
} | 0 | CPP |
n= int(input())
li= input()
a=li.find("1")
if a==-1:
print("Easy")
else:
print ("Hard")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000000], sm[1000000];
int n, pt = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
for (int j = 0; j < i; j++) sm[pt++] = arr[i] + arr[j];
}
sort(sm, sm + pt);
int res = 0;
for (int i = 0; i < pt; i++) {
int j = i;
while (j < pt && sm[j] == sm[i]) j++;
res = max(res, (j - i));
i = j - 1;
}
cout << res << endl;
return 0;
}
| 8 | CPP |
s=input()
ans=s
i=0
vo="aeiou "
while i<len(ans)-2:
if ans[i]==ans[i+1] and ans[i]==ans[i+2]:
i+=1
continue
if ans[i] not in vo and ans[i+1] not in vo and ans[i+2] not in vo:
ans=ans[:i+2]+' '+ans[i+2:]
i+=1
print(ans) | 7 | PYTHON3 |
w = int(input())
print("YES" if w % 2 == 0 and w > 2 else "NO", end="") | 7 | PYTHON3 |
arr = list(map(int,input().split()))
arr = sorted(arr)
a = arr[3] - arr[2]
b = arr[3] - arr[1]
c = arr[3] - arr[0]
print(a,b,c)
| 7 | PYTHON3 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
import sys
input = sys.stdin.readline
N,M,K = map(int,input().split())
uf = UnionFind(N)
lst=[0]*(N)
for i in range(M):
A,B=map(int,input().split())
uf.union(A-1,B-1)
lst[A-1]-=1
lst[B-1]-=1
for i in range(K):
A,B=map(int,input().split())
if uf.same(A-1,B-1):
lst[A-1]-=1
lst[B-1]-=1
lst=[lst[i]+uf.size(i)-1 for i in range(N)]
L=[str(a) for a in lst]
L=' '.join(L)
print(L)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<string> a(n - 2);
for (int i = 0; i < n - 2; i++) cin >> a[i];
string ans = "";
int b = 0;
ans += a[0][0];
for (int i = 1; i < n - 2; i++) {
if (a[i - 1][1] != a[i][0]) {
ans += a[i - 1][1];
b = 1;
}
ans += a[i][0];
}
ans += a[n - 3][1];
if (b == 0) ans += a[n - 3][1];
cout << ans << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define dbg(...) cerr << #__VA_ARGS__ << " ->", debug_out(__VA_ARGS__)
#define dbg_p(x) cerr<<#x": "<<(x).first<<' '<<(x).second<<endl
#define dbg_v(x, n) {cerr<<#x"[]: ";for(long long _=0;_<n;++_)cerr<<(x)[_]<<' ';cerr<<endl;}
#define all(v) v.begin(), v.end()
#define fi first
#define se second
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << H; debug_out(T...);}
template<typename T1, typename T2>
ostream& operator <<(ostream &out, const pair<T1, T2> &item) {
out << '(' << item.first << ", " << item.second << ')';
return out;
}
template <typename T>
ostream& operator <<(ostream &out, const vector<T>& v) {
for(const auto &item : v) out << item << ' ';
return out;
}
const int N = 1010;
int bad[N];
long double chance[N];
int getPred(const string &s, int rounds) {
int sc0 = 0, sc1 = 0, minim = 1e9;
long double beta = 3.0/4;
long double total = 0;
for(int i = 0; i < s.length(); ++i) {
minim = min(minim, bad[i]);
}
for(int i = 0; i < s.length(); ++i)
{
chance[i] = pow(beta, bad[i] - minim);
total += chance[i];
}
long double hit = rand() * total / RAND_MAX;
for(int i = 0; i < s.length(); ++i)
{
if (hit <= chance[i])
{
return s[i] == '1';
}
hit -= chance[i];
}
return s[s.length()] == '1';
}
int main()
{
ios_base::sync_with_stdio(false);
srand(time(NULL));
int n, m, actual;
string s;
cin >> n >> m;
for(int i = 0; i < m; ++i) {
cin >> s;
int pred = getPred(s, i);
cout << pred << endl;
cin >> actual;
for(int i = 0; i < n; ++i) bad[i] += ((s[i] - '0') != actual);
}
return 0;
} | 15 | CPP |
n = int(input())
for i in range(n):
a = int(input())
if a%2==0:
if a>2:
print(0)
else:
print(2)
else:
print(1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long md=998244353;
const int maxn=300100;
long long fac[maxn],inv[maxn];
long long powd(long long x,long long y){
long long res=1;
while(y){
if(y&1) res=res*x%md;
x=x*x%md;
y>>=1;
}
return res;
}
void csh(){
fac[0]=1;
for(int i=1;i<=300000;i++)
fac[i]=fac[i-1]*i%md;
inv[300000]=powd(fac[300000],md-2);
for(int i=300000;i>=1;i--)
inv[i-1]=inv[i]*i%md;
}
long long C(int x,int y){
return fac[x]*inv[y]%md*inv[x-y]%md;
}
int main(){
csh();
long long N, A, B, K;
cin >> N >> A >> B >> K;
long long ans = 0;
for (int i=0; i<N+1; i++){
if (((K - i*A) % B != 0) || (K - i*A < 0) || ((K-i*A)/B > N)) continue;
ans = (ans + C(N,i) * C(N,(K-i*A)/B)) % md;
}
cout << ans << endl;
}
| 0 | CPP |
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <vector>
#include <queue>
#include <bitset>
#include <string>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define repa(i,s,e) for(int i=s; i<=e; i++)
#define repd(i,s,e) for(int i=s; i>=e; i--)
#define PB(a) push_back(a)
#define MP(i,s) make_pair(i,s)
typedef long long ll;
const int dx[4] = {-1, 0, 0, 1};
const int dy[4] = {0, -1, 1, 0};
const int field[5][5] = {
{0, 0, 1, 0, 0},
{0, 1, 1, 1, 0},
{1, 1, 1, 1, 1},
{0, 1, 1, 1, 0},
{0, 0, 1, 0, 0},
};
const int ans[5][5] = {
{0, 0, 0, 0, 0},
{0, 1, 2, 3, 0},
{4, 5, 6, 7, 8},
{0, 9, 10, 11, 0},
{0, 0, 0, 0, 0}
};
const int px[13] = {2, 1, 2, 3, 0, 1, 2, 3, 4, 1, 2, 3, 2};
const int py[13] = {0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4};
int P[5][5];
map<ll,int> used;
map<ll,int> H;
ll hash_val() {
ll h = 0;
rep(i,13) {
h *= 13;
h += P[py[i]][px[i]];
}
return h;
}
void make_ans(int m, int d) {
ll h = hash_val();
map<ll,int>::iterator it = H.find(h);
if(it == H.end()) {
H.insert(MP(h,m));
} else if((*it).second > m) {
(*it).second = m;
} else {
return;
}
if(m == d) return;
rep(i,13) {
int x = px[i];
int y = py[i];
if(P[y][x] == 0) {
rep(k,4) {
int xx = x + dx[k];
int yy = y + dy[k];
if(xx>=0 && yy>=0 && xx<5 && yy<5 && field[yy][xx] == 1 && P[yy][xx] != 0) {
swap(P[y][x], P[yy][xx]);
make_ans(m+1, d);
swap(P[y][x], P[yy][xx]);
}
}
}
}
}
int dfs(int m, int d) {
map<ll,int>::iterator it;
ll h = hash_val();
it = H.find(h);
if(it != H.end()) return m + (*it).second;
if(m == d) return -1;
it = used.find(h);
if(it == used.end()) {
used.insert(MP(h,m));
} else if((*it).second > m) {
(*it).second = m;
} else {
return -1;
}
rep(i,13) {
int x = px[i];
int y = py[i];
if(P[y][x] == 0) {
rep(k,4) {
int xx = x + dx[k];
int yy = y + dy[k];
if(xx>=0 && yy>=0 && xx<5 && yy<5 && field[yy][xx] == 1 && P[yy][xx] != 0) {
swap(P[y][x], P[yy][xx]);
int a = dfs(m+1, d);
if(a >= 0) return a;
swap(P[y][x], P[yy][xx]);
}
}
}
}
return -1;
}
void solve() {
repa(d,0,10) {
used.clear();
int a = dfs(0, d);
if(a >= 0) {
printf("%d\n", a);
return;
}
}
printf("NA\n");
}
int main() {
memcpy(P, ans, sizeof(P));
make_ans(0, 10);
for(;;) {
rep(i,13) {
scanf("%d", &P[py[i]][px[i]]);
if(P[py[i]][px[i]] < 0) return 0;
}
solve();
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
map<int, queue<int> > p;
vector<int> ans(m + 1);
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
p[a].push(b);
p[b].push(a);
}
int i = 1;
queue<int> q;
while (p.size() != 0) {
while (p[i].size() != 0) {
int x = p[i].front();
if (ans[x] == 0) {
ans[x] = i;
q.push(x);
}
p[i].pop();
}
p.erase(i);
i = q.front();
q.pop();
}
cout << "Yes" << endl;
for (int i = 2; i <= n; i++) cout << ans[i] << endl;
} | 0 | CPP |
# map(int, input().split())
import math
def getKey(item):
return item[1]
n, r, avg = map(int, input().split())
score = 0
l = []
for i in range(n):
a, b = map(int, input().split())
score+= a
if a <r:
l.append([a, b])
essays= 0
needed = n* avg - score
if needed <= 0:
print(essays)
else:
l = sorted(l, key= getKey)
for i in l:
points = r - i[0]
if needed >= points:
essays += (points* i[1])
needed-= points
else:
essays+= (needed * i[1])
needed= 0
break
print(essays) | 9 | PYTHON3 |
b = input()
a = b.split('/')
s = ''
for i in a:
if len(i) > 0:
s += i + '/'
if len(s) == 0:
print('/')
else:
if b[0] == '/':
print('/'+s[0:-1])
else:
print(s[0:-1])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int dim = 1000000;
int n, a[dim], b[dim], cnt, poz[dim];
map<int, int> mp;
int st_poz1, dr_poz1, st_poz2, dr_poz2, rasp;
vector<int> v[dim];
const long long baza1 = 1386383;
const long long baza2 = 1386383;
const long long mod1 = 827345797;
const long long mod2 = 827345797;
long long put_baza1[dim], put_baza2[dim];
long long h1[dim], h2[dim];
bool sunt_egale(int st1, int dr1, int st2, int dr2) {
long long f1, g1, f2, g2;
f1 = h1[st1 - 1] * put_baza1[dr1 - st1 + 1] % mod1;
f1 = (h1[dr1] - f1 + mod1) % mod1;
g1 = h2[st1 - 1] * put_baza2[dr1 - st1 + 1] % mod2;
g1 = (h2[dr1] - g1 + mod2) % mod2;
f2 = h1[st2 - 1] * put_baza1[dr2 - st2 + 1] % mod1;
f2 = (h1[dr2] - f2 + mod1) % mod1;
g2 = h2[st2 - 1] * put_baza2[dr2 - st2 + 1] % mod2;
g2 = (h2[dr2] - g2 + mod2) % mod2;
return (f1 == f2 && g1 == g2);
}
int main() {
int i, j;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> a[i];
if (mp.count(a[i]) == 0) {
++cnt;
mp[a[i]] = cnt;
b[cnt] = a[i];
}
a[i] = mp[a[i]];
poz[i] = v[a[i]].size();
v[a[i]].push_back(i);
}
put_baza1[0] = put_baza2[0] = 1;
for (i = 1; i <= n; ++i) put_baza1[i] = put_baza1[i - 1] * baza1 % mod1;
for (i = 1; i <= n; ++i) put_baza2[i] = put_baza2[i - 1] * baza2 % mod2;
h1[0] = h2[0] = 0;
for (i = 1; i <= n; ++i) {
h1[i] = h1[i - 1] * baza1 % mod1;
h1[i] = (h1[i] + a[i]) % mod1;
h2[i] = h2[i - 1] * baza2 % mod2;
h2[i] = (h2[i] + a[i]) % mod2;
}
rasp = 1;
for (i = 1; i <= n; ++i) {
for (j = poz[i] + 1; j < v[a[i]].size(); ++j) {
st_poz1 = i;
st_poz2 = v[a[i]][j];
dr_poz1 = st_poz2 - 1;
dr_poz2 = st_poz2 + dr_poz1 - st_poz1;
if (dr_poz2 > n) break;
if (sunt_egale(st_poz1, dr_poz1, st_poz2, dr_poz2) == true) {
rasp = st_poz2;
i = st_poz2 - 1;
break;
}
}
}
cout << n - rasp + 1 << endl;
for (i = rasp; i <= n; ++i) cout << b[a[i]] << ' ';
return 0;
}
| 9 | CPP |
Subsets and Splits