solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using std::sort;
struct thing {
int v;
int po;
} arr[200005];
int ipt[200005];
int next[200005];
int dp[200005];
int cmpv(thing t1, thing t2) {
if (t1.v == t2.v) return t1.po <= t2.po;
return t1.v < t2.v;
}
int p[2];
int n;
int bins(int k) {
int l = 0, r = n + 1, m;
while (l + 1 < r) {
m = (l + r) / 2;
if (arr[m].v < k)
l = m;
else
r = m;
}
return r;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", ipt + i);
arr[i].v = ipt[i];
arr[i].po = i;
}
sort(arr + 1, arr + n + 1, cmpv);
int ma = 0, fr;
for (int i = n; i >= 1; --i) {
next[i] = i;
dp[i] = 1;
for (int t = bins(ipt[i] + 1); arr[t].v == ipt[i] + 1 && t <= n; ++t) {
if (arr[t].po < i) continue;
if (dp[arr[t].po] + 1 > dp[i]) {
dp[i] = dp[arr[t].po] + 1;
next[i] = arr[t].po;
break;
}
}
if (ma < dp[i]) {
ma = dp[i];
fr = i;
}
}
printf("%d\n", ma);
for (int t = fr;; t = next[t]) {
printf("%d ", t);
if (t == next[t]) break;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, r = 0, t = 0, a[200000], s[200000];
cin >> q;
for (w = 0; w < q; w++) scanf("%d", &a[w]);
for (w = 0; w < q; w++) scanf("%d", &s[w]);
for (w = 0; w < q; w++) {
for (; (r < q) && (s[r] != a[w]); r++)
;
if (r >= q) break;
t++;
}
cout << q - t;
return 0;
}
| 7 | CPP |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdlib>
using namespace std;
typedef long long LL;
const int MAXN=300;
LL b,a[MAXN],c;
int n,m;
LL gcd(LL a,LL b){
if (!b) return a;
else return gcd(b,a%b);
}
int main()
{
while (cin>>n,n){
m=0;c=-1;
for (int i=0;i<n*(n+1)/2;i++){
cin>>b;
if (b%2==0) a[m++]=b;
else{
if (c==-1) c=b;
else if (b<c) c=b;
}
}
LL t;
sort(a,a+m);
LL u=a[0]/gcd(a[0],c);
c/=gcd(a[0],c);
LL v=a[1]/c;
t=(LL)(sqrt(u*v));
for (int i=0;i<m;i++){
a[i]/=t;
}
cout<<t<<'\n';
for (int i=0;i<m-1;i++)cout<<a[i]<<" ";
cout<<a[m-1]<<'\n';
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 1e5 + 10, sq = 310;
int64_t q, n;
string second;
char ch;
int64_t pos, l, r;
int64_t a[N], ans[sq + 15];
int64_t w(int64_t a) {
int64_t ret = 0;
while (a) {
ret += (a & 1);
a >>= 1;
}
return ret;
}
void up(int64_t x) {
ans[x] = 0;
for (int64_t i = 0; i < sq && x * sq + i < second.size(); i++) {
ans[x] |= (1 << a[x * sq + i]);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> second >> q;
for (int64_t i = 0; i < second.size(); i++) {
a[i] = second[i] - 'a';
}
for (int64_t i = 0; i < (second.size() + sq - 1) / sq; i++) {
up(i);
}
while (q--) {
cin >> n;
if (n == 1) {
cin >> pos >> ch;
pos--;
second[pos] = ch;
a[pos] = ch - 'a';
up(pos / sq);
} else {
int64_t Ans = 0;
cin >> l >> r;
l--;
if (l / sq == r / sq) {
while (l < r) {
Ans = (Ans | (1 << a[l]));
l++;
}
cout << w(Ans) << '\n';
continue;
}
while (l % sq != 0) {
Ans = (Ans | (1 << a[l]));
l++;
}
while (r % sq != 0) {
Ans = (Ans | (1 << a[r - 1]));
r--;
}
for (int64_t i = l / sq; i < r / sq; i++) {
Ans |= ans[i];
}
cout << w(Ans) << '\n';
}
}
}
| 10 | CPP |
import math
import sys
#you are a gay if you copy my code
#####sorting a dictionary#####
def dict_sort(ans):
ans=sorted(ans.items(),reverse=True,key=lambda kv:(kv[1]))
def is_prime(n):
if n==1:
return 0
for i in range(2,int(math.sqrt(n))+1):
if n%i==0:
return False
return True
def inp():
ls=list(map(int,input().split()))
return ls
n=int(input())
teams={}
for i in range(n):
s=input()
if s in teams:
teams[s]+=1
else:
teams[s]=1
for i in teams.items():
if i[1]==max(teams.values()):
print(i[0])
break | 7 | PYTHON3 |
for t in range(int(input())):
b=input()
s=b[1:len(b)-1]
st=""
st+=b[0]
for i in s[::2]:
st+=i
st+=b[len(b)-1]
print(st)
| 7 | PYTHON3 |
import sys
input = sys.stdin.readline
n=int(input())
l=[[] for i in range(n)]
ans={}
initial=[]
for i in range(n-1):
a,b=list(map(int,input().split()))
initial.append((a-1,b-1))
ans[(a-1,b-1)]=-1
ans[(b-1,a-1)]=-1
l[a-1].append(b-1)
l[b-1].append(a-1)
flag=0
for i in range(len(l)):
if len(l[i])>2:
flag=1
index=i
break
if flag==0:
for i in range(n-1):
print (i)
else:
for i in range(3):
ans[(index,l[index][i])]=i
ans[(l[index][i],index)]=i
k=3
#print (ans)
for i in range(n-1):
if ans[(initial[i][0],initial[i][1])]==-1:
print (k)
k+=1
else:
print (ans[(initial[i][0],initial[i][1])]) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1111, inf = 111111111;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
int n, m, dist[3][max_n][max_n], a[3][3];
char s[max_n][max_n];
bool is_in(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
void bfs(int num) {
queue<pair<int, int> > q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
dist[num][i][j] = inf;
if (s[i][j] == num + '1') {
q.push(make_pair(i, j));
dist[num][i][j] = 0;
}
}
}
a[num][0] = a[num][1] = a[num][2] = inf;
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
int nx = v.first + dx[i];
int ny = v.second + dy[i];
if (is_in(nx, ny) && dist[num][nx][ny] == inf && s[nx][ny] != '#') {
dist[num][nx][ny] = dist[num][v.first][v.second] + 1;
q.push(make_pair(nx, ny));
if ('1' <= s[nx][ny] && s[nx][ny] <= '3') {
a[num][s[nx][ny] - '1'] =
min(a[num][s[nx][ny] - '1'], dist[num][nx][ny]);
}
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
bfs(0);
bfs(1);
bfs(2);
int ans = min(a[0][1] + a[0][2] - 2,
min(a[0][1] + a[1][2] - 2, a[0][2] + a[1][2] - 2));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
ans = min(ans, dist[0][i][j] + dist[1][i][j] + dist[2][i][j] - 2);
}
}
if (ans >= inf - 10) {
ans = -1;
}
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, q, s, tot, root1, root2, lc[100005 * 4], rc[100005 * 4];
struct edge {
int next, to, sum;
edge() {}
edge(int x, int y, int z) : next(x), to(y), sum(z) {}
} e[100005 * 20];
int h[100005 * 4], cnt;
void addedge(int x, int y, int z) {
e[++cnt] = edge(h[x], y, z);
h[x] = cnt;
}
void build1(int &v, int l, int r) {
if (l == r) {
v = l;
return;
}
v = ++tot;
int mid = (l + r) / 2;
build1(lc[v], l, mid);
build1(rc[v], mid + 1, r);
addedge(v, lc[v], 0);
addedge(v, rc[v], 0);
}
void build2(int &v, int l, int r) {
if (l == r) {
v = l;
return;
}
v = ++tot;
int mid = (l + r) / 2;
build2(lc[v], l, mid);
build2(rc[v], mid + 1, r);
addedge(lc[v], v, 0);
addedge(rc[v], v, 0);
}
void add(int v, int l, int r, int u, int tl, int tr, int w, int opt) {
if (l > tr || r < tl) return;
if (tl <= l && r <= tr) {
if (opt == 2)
addedge(u, v, w);
else
addedge(v, u, w);
return;
}
int mid = (l + r) / 2;
add(lc[v], l, mid, u, tl, tr, w, opt);
add(rc[v], mid + 1, r, u, tl, tr, w, opt);
}
long long dis[100005 * 4];
bool b[100005 * 4];
void spfa(int rt) {
queue<int> q;
int x, y;
memset(dis, 0x3f, sizeof(dis));
dis[rt] = 0;
q.push(rt);
while (!q.empty()) {
x = q.front();
q.pop();
for (int i = h[x]; i; i = e[i].next) {
y = e[i].to;
if (dis[y] > dis[x] + e[i].sum) {
dis[y] = dis[x] + e[i].sum;
if (!b[y]) b[y] = 1, q.push(y);
}
}
b[x] = 0;
}
}
int main() {
int opt, x, y, w, l, r;
scanf("%d %d %d", &n, &q, &s);
tot = n;
build1(root1, 1, n);
build2(root2, 1, n);
while (q--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d %d %d", &x, &y, &w);
addedge(x, y, w);
} else {
scanf("%d %d %d %d", &x, &l, &r, &w);
add(opt == 2 ? root1 : root2, 1, n, x, l, r, w, opt);
}
}
spfa(s);
for (int i = 1; i <= n; i++) {
if (dis[i] == dis[0])
printf("-1 ");
else
printf("%lld ", dis[i]);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M;
const int MAXN = 300010;
map<int, vector<int> > k;
long long w[MAXN], a[MAXN], b[MAXN], tmp[MAXN], ans[MAXN];
int main() {
scanf(" %d", &N);
for (int i = 1; i <= N; i++) cin >> w[i];
scanf(" %d", &M);
for (int i = 1; i <= M; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= M; i++) k[b[i]].push_back(i);
map<int, vector<int> >::iterator it;
for (it = k.begin(); it != k.end(); it++) {
int asd = it->first;
if ((int)it->second.size() > asd / 2) {
for (int i = 1; i <= N; i++) tmp[i] = w[i];
for (int i = N - asd; i >= 1; i--) tmp[i] += tmp[i + asd];
for (int i = 0; i < (int)it->second.size(); i++)
ans[it->second[i]] = tmp[a[it->second[i]]];
} else
for (int i = 0; i < (int)it->second.size(); i++) {
int sira = (it->second)[i];
ans[sira] = 0;
for (int j = a[sira]; j <= N; j += b[sira]) ans[sira] += w[j];
}
}
for (int i = 1; i <= M; i++) cout << ans[i] << endl;
return 0;
}
| 10 | CPP |
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <cstring>
#include <deque>
#include <cstdio>
#include <cmath>
#include <complex>
using namespace std;
#define reep(i,f,t) for(int i=f ; i<int(t) ; ++i)
#define rep(i,n) reep(i, 0, n)
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
typedef vector<double> vd;
typedef vector<vd> vvd;
struct Store
{
int id;
int dist;
int money;
};
int main()
{
int n;
scanf("%d", &n);
vector<Store> stores(n);
rep(i, n){
scanf("%d%d%d", &stores[i].id, &stores[i].dist, &stores[i].money);
}
vvd t(1<<n, vd(n, 1e20));
vvi w(1<<n, vi(n));
vvi p(1<<n, vi(n));
rep(i, n){
t[1<<i][i] = 0.0;
w[1<<i][i] = stores[i].money * 20;
p[1<<i][i] = -1;
}
rep(i, 1<<n){
rep(j, n){
rep(k, n){
if(j==k || (i&(1<<j)) == 0 || (i&(1<<k)) == 0)
continue;
int pre = i ^ (1<<k);
double tmp = t[pre][j] + abs(stores[j].dist - stores[k].dist) * (70.0 + w[pre][j]) / 2000.0;
if(tmp < t[i][k]){
t[i][k] = tmp;
w[i][k] = w[pre][j] + stores[k].money * 20;
p[i][k] = j;
}
}
}
}
vector<int> path;
int minid = distance(t[(1<<n)-1].begin(), min_element(t[(1<<n)-1].begin(), t[(1<<n)-1].end()));
path.push_back(minid);
for(int i=(1<<n)-1; p[i][minid]!=-1;){
int tmp = minid;
minid = p[i][minid];
i ^= 1 << tmp;
path.push_back(minid);
}
for(int i=path.size()-1; i>=0; --i)
printf("%d%s", stores[path[i]].id, i?" ":"");
puts("");
return 0;
} | 0 | CPP |
def diff(a,b,d):
return abs(a+b-d)
eps = 10**(-6)
for _ in range(int(input())):
n = int(input())
if(n==0):
print("Y 0 0")
continue
if(n==1 or n==2 or n==3):
print("N")
continue
l , h , flag = 0 , n , False
while l <= h and h!=0:
a = (l+h)/2;
b = n-a;
# print(a,b)
if diff(a,b,a*b) <= eps and diff(a,b,n) <= eps:
print("Y" , a , b)
flag = True
break
elif a*b < n:
l = a
else:
h = a
if(not flag):
print("N") | 9 | PYTHON3 |
"""
Solution for 263A - Beautiful Matrix
Made by Raigiku
"""
def main():
"""Main function"""
element_position = []
for row in range(5):
matrix = input().split()
if '1' in matrix:
element_position.append(row)
element_position.append(matrix.index('1'))
minimum_moves = 0
if not (element_position[0] == 2 and element_position[1] == 2):
while element_position:
for i, _ in enumerate(element_position):
minimum_moves += abs(element_position[i] - 2)
element_position.pop(i)
print(minimum_moves)
if __name__ == "__main__":
main()
| 7 | PYTHON3 |
#define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for(int i=0; i<(n); ++i)
#define FOR(i, m, n) for(int i=(m); i<(n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define pb push_back
#define Cout(x) cout << (x) << endl
#define Cout2(x, y) cout << (x) << " " << (y) << endl
#define dump(x) cout << #x << " = " << (x) << endl;
#define forauto(i, a) for(auto i : a)cout << i << " "; puts("");
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
const int inf = 1e9;
const double pi = acos(-1.0);
int main() {
VS str = { "alert","safe","warning" };
int n; cin >> n;
rep(i, n) {
int h, m; char c;
cin >> h >> c >> m;
double a1 = (double)h * 30. + (double)m * 0.5, a2 = (double)m * 6.;
double diff = abs(a1 - a2);
diff = diff > 180. ? 360. - diff : diff;
int ans;
if (0. <= diff && diff < 30.)ans = 0;
else if (90. <= diff && diff <= 180.)ans = 1;
else ans = 2;
Cout(str[ans]);
//cout << "Angle : " << diff << endl;
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e5 + 5;
int main() {
int n;
scanf("%d\n", &n);
map<double, int> str;
double p[maxn];
str.clear();
for (int i = 0; i < n; i++) {
int a, b, c;
scanf("(%d+%d)/%d\n", &a, &b, &c);
p[i] = (double)(a + b) / c;
str[p[i]]++;
}
for (int i = 0; i < n; i++) printf("%d ", str[p[i]]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n], i, j = 0, num1 = 0, k = 0;
int count[n + 1], c = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 1) c++;
}
if (c == n)
cout << n - 1;
else {
int ans, ans2, pans = 0, l, sum = 0;
for (i = 0; i < n; i++) {
num1 = 0;
for (j = i; j < n; j++) {
if (arr[j] == 1) num1++;
k = j - i + 1 - num1;
l = c - num1;
if (k > num1 && pans < k + l)
pans = k + l;
else if (pans < num1 + l)
pans = num1 + l;
}
}
cout << pans << endl;
}
return 0;
}
| 7 | CPP |
from collections import deque
import sys
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n + 1)]
for _ in range(m):
u, v = list(map(int, input().split()))
edges[u].append(v)
s, t = list(map(int, input().split()))
visited = [[] for _ in range(n + 1)]
q = deque()
q.append((s, 0))
while q:
node, cnt = q.popleft()
if cnt % 3 in visited[node]:
continue
if node == t and cnt % 3 == 0:
print(cnt // 3)
sys.exit()
else:
visited[node].append(cnt % 3)
for e in edges[node]:
q.append((e, cnt + 1))
print(-1)
| 0 | PYTHON3 |
s = set(list(input().strip()))
if len(s) % 2 == 1: print("IGNORE HIM!")
else: print("CHAT WITH HER!") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,A=0;
string S;
cin>>N>>S;
vector<int> p(N);
vector<int> q(N);
for(int i=N-1;i>=0;i--){
if(S[i]=='1'){
A++;
}
}
int Q=A-1,W=A+1;
int X=0,Y=0,E=1,R=1;
for(int i=N-1;i>=0;i--){
p[i]=E;
q[i]=R;
if(S[i]=='1'){
X+=p[i];
Y+=q[i];
if(Q!=0){
X%=Q;
}
Y%=W;
}
E*=2;
if(Q!=0){
E%=Q;
}
R*=2;
R%=W;
}
for(int i=0;i<N;i++){
int b,Z=1;
if(A==1&&S[i]=='1'){
cout<<"0"<<endl;
continue;
}
if(S[i]=='1'){
b=(X-p[i]+Q)%Q;
}
else{
b=(Y+q[i])%W;
}
while(b!=0){
int D=b,T=1,P=0;
while(D!=0){
if(D%(T*2)!=0){
D-=T;
P++;
}
T*=2;
}
b%=P;
Z++;
}
cout<<Z<<endl;
}
} | 0 | 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<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<numeric>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define rep(i,n) for(int i=0;i<n;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 stop char nyaa;cin>>nyaa;
//keta,Nより小さい,51?3の回数
ll dp[19][2][5];
void solve() {
int n, m, q;
cin >> n >> m >> q;
vector<int> d(m + q), a(m + q), b(m + q);
rep(i, m + q) {
cin >> d[i] >> a[i] >> b[i];
--a[i]; --b[i];
}
vector<int> ord(m + q);
iota(ord.begin(), ord.end(), 0);
sort(ord.begin(), ord.end(), [&](int x, int y) {
if (d[x] == d[y])return x > y;
return d[x] < d[y];
});
set<pair<int, int>> st;
rep(i, n + 2) {
st.insert({ i - 1,i-1 });
}vector<string> ans(q);
for (auto i : ord) {
if (i >= m) {
if (a[i] > b[i])ans[i - m] = "Yes";
else {
auto itr = st.lower_bound({ a[i],a[i] });
if (itr->first > a[i])--itr;
if (itr->second >= b[i])ans[i - m] = "Yes";
else ans[i - m] = "No";
}
}
else {
auto itr = st.lower_bound({ a[i],a[i] });
if (itr->first > a[i])--itr;
int l = itr->first;
int r = b[i];
while (itr->second < b[i]) {
r = itr->second;
itr = st.erase(itr);
}
r = itr->second;
itr = st.erase(itr);
st.insert({ l,r });
}
}
rep(i, q) {
cout << ans[i] << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
stop
return 0;
}
| 0 | CPP |
n=int(input())
ch=input().split()
ch=[int(x) for x in ch]
a=ch.index(min(ch))
b=ch.index(max(ch))
if a>b:
print(max(a,n-1-b))
else:
print(max(b,n-1-a))
| 7 | PYTHON3 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat May 25 19:12:54 2019
@author: gk
"""
t = int(input()[2:]);s=input()
while t:s = s.replace('BG','GB');t-=1
print(s) | 8 | PYTHON3 |
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#define INF 1000000000
using namespace std;
struct edge{int to, cost;};
vector<edge> A[100000];
int d[100000];
typedef pair<int,int> P;
int main(){
int V,E,R;
cin >> V >> E >> R;
for(int i=0;i<E;i++){
int s,t,d;
cin >> s >> t >> d;
edge a;
a.to=t;
a.cost=d;
A[s].push_back(a);
}
priority_queue<P, vector<P>, greater<P>> que;
fill(d,d+V,INF);
d[R]=0;
que.push(P(0,R));
while(!que.empty()){
P p=que.top();que.pop();
int v=p.second;
if(d[v] < p.first)continue;
for(int i=0;i < A[v].size();i++){
edge e = A[v][i];
if(d[e.to] > d[v]+e.cost){
d[e.to]=d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
for(int i=0;i<V;i++){
if(d[i]==INF){
cout << "INF" << endl;
}else{
cout << d[i] << endl;
}
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string S;
getline(cin, S);
long long tam = S.size();
long long e;
sort(S.begin(), S.end());
long long total = 0;
for (long long i = 0; i < tam; i++) {
e = count(S.begin(), S.end(), S[i]);
total += pow(e, 2);
i = S.find_last_of(S[i]);
}
cout << total;
}
| 8 | CPP |
def check_symmetry():
n, m = map(int, input().split(" "))
can_build = False
for _ in range(n):
_, d1 = map(int, input().split(" "))
d2, _ = map(int, input().split(" "))
# se m % 2 != n dá pra ter ctz que vai conseguir juntar com os outros tiles pra deixar simetrico
# Symmetric with respect to the main diagonal matrix is such a square s that
# for each pair (i,j) the condition s[i][j]=s[j][i] holds. -> logo d1 tem que ser igual d2
if d1 == d2 and (m % 2 == 0):
can_build = True
return can_build
t = int(input())
for _ in range(t):
can_build = check_symmetry()
if can_build:
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int IINF = INT_MAX;
bool isValid(int len, int x) { return 0 <= x && x < len; }
bool check(const string &s, int L, int R, int len) {
int slen = s.size();
for (int i = 0; i < len; i++) {
if (!isValid(slen, L) || !isValid(slen, R)) return false;
if (s[L] == '?' || s[R] == '?') {
} else if (s[L] != s[R])
return false;
L++, R++;
}
return true;
}
int getMax(string s) {
for (int i = s.size(); i >= 1; i--) {
if (i * 2 > s.size()) continue;
for (int j = 0; j < s.size(); j++)
if (check(s, j, j + i, i)) return i * 2;
}
return 0;
}
int main() {
string s;
cin >> s;
int k;
cin >> k;
s += string(k, '?');
cout << getMax(s) << endl;
return 0;
}
| 8 | CPP |
s=input()
if s.swapcase()==s.title():
print(s.title())
elif s.swapcase()==s.lower():
print(s.lower())
else:
print(s)
| 7 | PYTHON3 |
def sol(n):
if n == 1:
return "FastestFinger"
if n % 2 == 1 or n == 2:
return "Ashishgup"
for i in range(3, int(n**0.5) + 1):
if n % i == 0:
if i % 2 == 1 or (n // i) % 2 == 1:
return "Ashishgup"
return "FastestFinger"
t = int(input())
for _ in range(t):
print(sol(int(input()))) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[101];
int main() {
int N, one = 0, zero = 0, two = 0, flag = 0, start = 0, endi = 0;
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i];
if (a[i] == 1 && !flag) start = i, flag = 1;
if (i > start && a[i] == 1) endi = i;
}
int len;
if (start > endi)
len = 1;
else if (start == endi)
len = 0;
else {
len = endi - start + 1;
for (int x = start; x <= endi; x++) {
if (a[x] == 0) {
zero++;
} else {
if (zero >= 2) len = len - zero;
zero = 0;
}
}
}
cout << len << endl;
return 0;
}
| 7 | CPP |
def multi_chain_multiplication(n, P):
M = [[0]*(n+1) for _ in range(n+1)]
if n > 1:
for l in range(2, n+1):
for i in range(1, n-l+2):
j = i + l - 1
M[i][j] = float('inf')
for k in range(i, j):
M[i][j] = min(M[i][j], M[i][k] + M[k+1][j] + P[i-1] * P[k] * P[j])
return M[i][j]
else:
return 0
def read_and_print_min_multiplication(n):
P = [0] * (n+1)
for i in range(n):
A = [int(i) for i in input().split()]
if i == 0:
P[i] = A[0]
P[i+1] = A[1]
else:
P[i+1] = A[1]
print(multi_chain_multiplication(n, P))
n = int(input())
read_and_print_min_multiplication(n)
| 0 | PYTHON3 |
def get_len( n ):
if n <= 1:
return 1
return get_len( n // 2 ) * 2 + 1
def dvcq( n, ll, rr ):
if ll == rr:
return 0
if n <= 1:
return n
mid = get_len( n // 2 )
if rr <= mid:
return dvcq( n // 2, ll, rr )
elif mid < ll:
return dvcq( n // 2, ll - ( mid + 1 ), rr - ( mid + 1 ) )
else:
return ( n & 1 ) + dvcq( n // 2, ll, mid ) + dvcq( n // 2, 0, rr - ( mid + 1 ) )
N, L, R = map( int, input().split() )
print( dvcq( N, L - 1, R ) )
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
string dp[50][500];
struct edge {
int to;
string s;
};
struct S {
int v;
string s;
bool operator <(const S& x) const {
return s > x.s;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, a, s, g;
while(cin >> n >> a >> s >> g, n) {
vector<edge> G[50];
for(int i = 0; i < a; i++) {
int x, y;
string str;
cin >> x >> y >> str;
G[x].push_back({ y, str });
}
for(int i = 0; i < n; i++) {
for(int j = 0; j < 400; j++) {
dp[i][j] = "{";
}
}
priority_queue<S> q;
q.push({ s, "" });
dp[s][0] = "";
while(q.size()) {
int v = q.top().v;
string str = q.top().s;
q.pop();
if(dp[v][str.size()] < str) continue;
//cerr << "v : " << v << ", t : " << t << ", str : " << str << endl;
if(str.size() >= 400) continue;
for(auto e : G[v]) {
string ns = str + e.s;
if(ns.size() >= 400) continue;
if(dp[e.to][ns.size()] > ns) {
dp[e.to][ns.size()] = ns;
q.push({ e.to, ns });
}
}
}
string ans = "{";
for(int i = 1; i < 300; i++) {
if(dp[g][i] == "{") continue;
bool flag = true;
for(int j = i + 1; j < 400; j++) {
if(dp[g][i] > dp[g][j]) {
flag = false;
break;
}
}
if(flag) {
ans = dp[g][i];
break;
}
}
if(ans == "{") cout << "NO" << endl;
else cout << ans << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[26];
int main() {
int n, i;
string st;
cin >> n >> st;
for (i = 0; i < st.size() - 1; i++) {
if (st[i] != st[i + 1]) {
cout << "Yes" << endl;
cout << st[i] << st[i + 1] << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 7 | CPP |
input()
p = -1
ans = 0
L = 0
for x in map(int, input().split()):
if x >= p:
L += 1
else:
L = 1
p = x
ans = max(ans, L)
print(ans) | 7 | PYTHON3 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2767>
問題文============================================================
=================================================================
解説=============================================================
================================================================
*/
ll solve(){
ll res = 0;
ll N; cin >> N;
string S; cin >> S;
vector<int> alpha;
for(int i = 0; i < 26;i++){
int x = (int)count(S.begin(),S.end(),'a'+i);
if(x == 0) continue;
alpha.push_back(x);
}
for(int x = 1; x <= 9; x++){
int y = (int)count(alpha.begin(),alpha.end(),x);
if(y == 0) continue;
if(x == 1){
res += (2*y-1);
}else{
if(y == 1){
res += 3*y;
}else{
res += (4+2*y-1);
}
}
}
sort(alpha.begin(),alpha.end());
alpha.erase(unique(alpha.begin(),alpha.end()),alpha.end());
res += alpha.size()-1;
return res;
}
int main(void) {
cin.tie(0); ios_base::sync_with_stdio(false);
cout << solve() << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, X, Y;
bool dif[10];
int ask(int bit1, int bit2) {
int cnt = 0;
for (int i = 1; i <= N; i++) cnt += ((1 << bit1) & i) && ((1 << bit2) & i);
if (cnt == 0) return 0;
cout << "? " << cnt;
for (int i = 1; i <= N; i++)
if (((1 << bit1) & i) && ((1 << bit2) & i)) cout << " " << i;
cout << "\n";
fflush(stdout);
int ret;
cin >> ret;
return ret;
}
void getDif() {
for (int i = 0; i < 10; i++) {
int q = ask(i, i);
dif[i] = q == Y || q == (X ^ Y);
}
}
int main() {
cin >> N >> X >> Y;
getDif();
int ans1 = 0, ans2 = 0, difBit = -1;
for (int i = 0; i < 10; i++)
if (dif[i]) {
ans1 |= 1 << i;
difBit = i;
break;
}
for (int i = 0; i < 10; i++) {
if (i == difBit) continue;
int q = ask(i, difBit);
if (q == Y || q == (X ^ Y)) {
ans1 |= 1 << i;
if (!dif[i]) ans2 |= 1 << i;
} else {
if (dif[i]) ans2 |= (1 << i);
}
}
if (ans1 > ans2) swap(ans1, ans2);
cout << "! " << ans1 << " " << ans2 << "\n";
fflush(stdout);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int64_t> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
int64_t ans = 10000000000000000;
for (int tmp = 0; tmp < (1 << N); tmp++) {
bitset<15> s(tmp);
int64_t M = 0;
int C = 0;
int64_t H = 0;
for (int i = 0; i < N; i++) {
if (a.at(i) > M) {
C++;
M = a.at(i);
}
else if (s.test(i)) {
C++;
M++;
H += (M - a.at(i));
}
}
if (C == K) {
ans = min(ans, H);
}
}
cout << ans << endl;
} | 0 | CPP |
n, k = map(int, input().split())
arr = list(sorted(map(int, input().split()), reverse=True))
dup = set()
recs = dict()
for idx, v in enumerate(arr):
dup.add(v)
recs[v] = idx + 1
height = arr[0]
weight = recs[height]
res = list()
for i in range(height, 0, -1):
if i in recs:
weight = recs[i]
if weight != n:
res.append(weight)
else:
break
res.reverse()
left = ans = 0
for v in res:
if left + v > k:
ans += 1
left = v
elif left + v == k:
ans += 1
left = 0
else:
left += v
if left != 0:
ans += 1
print(ans)
| 9 | PYTHON3 |
c = input()
l = ['a','i','u','o','e']
print(('consonant','vowel')[c in l])
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000;
const int INF = 1000000000;
char s[MAXN + 10];
int r[MAXN + 10], lef[MAXN + 10];
vector<pair<char, int> > st;
int bL = -1, bR = -1;
int main() {
scanf("%s", s);
int len = strlen(s);
memset(r, 0, sizeof(r));
for (int i = 0; i < len; i++) {
r[i + 1] = r[i] + (s[i] == '[');
}
int best = 0;
for (int i = 0; i <= len + 1; i++) lef[i] = -1;
for (int i = 0; i < len; i++) {
if (st.size() > 0 && ((st.back().first == '(' && s[i] == ')') ||
(st.back().first == '[' && s[i] == ']'))) {
int pos = st.back().second - 1;
while (lef[pos] >= 0) pos = lef[pos];
if (r[i + 1] - r[pos] > best) {
best = r[i + 1] - r[pos];
bL = pos;
bR = i;
}
lef[i + 1] = pos;
st.pop_back();
} else {
st.push_back(make_pair(s[i], i + 1));
}
}
printf("%d\n", best);
if (best > 0) {
for (int i = bL; i <= bR; i++) printf("%c", s[i]);
printf("\n");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ax, ay, bx, by, cx, cy;
int main() {
scanf("%lld%lld%lld%lld%lld%lld", &ax, &ay, &bx, &by, &cx, &cy);
if ((by - ay) * (bx - cx) != (by - cy) * (bx - ax) &&
(cy - by) * (cy - by) + (cx - bx) * (cx - bx) ==
(bx - ax) * (bx - ax) + (by - ay) * (by - ay))
printf("Yes\n");
else
printf("No\n");
}
| 8 | CPP |
stroka = input()
k = int(input())
n1 = stroka.count('*')
n2 = stroka.count('?')
t = 0
p = ''
if n1 > 0 and n2 > 0:
for i in range(len(stroka)):
if stroka[i+t]=='?'and (len(stroka)-stroka.count('?')-stroka.count('*')-stroka.count('!'))>k:
stroka = stroka[:i+t-1]+'!!'+stroka[i+t+1:]
elif stroka[i+t]=='?'and (len(stroka)-stroka.count('?')-stroka.count('*')-stroka.count('!'))<=k:
stroka = stroka[:i+t]+'!'+stroka[i+t+1:]
elif stroka[i+t] =='*' and (len(stroka)-stroka.count('?')-stroka.count('*')-stroka.count('!'))>k:
stroka = stroka[:i+t - 1] + '!!' + stroka[i+t + 1:]
elif stroka[i+t] =='*' and (len(stroka)-stroka.count('?')-stroka.count('*')-stroka.count('!'))==k:
stroka = stroka[:i +t] + '!' + stroka[i +t+ 1:]
elif stroka[i+t] =='*' and (len(stroka)-stroka.count('?')-stroka.count('*')-stroka.count('!'))<k:
y = abs((len(stroka)-stroka.count('?')-stroka.count('*')-stroka.count('!'))-k)
stroka = stroka[:i+t] + stroka[i+t-1]*y + stroka[i+t + 1:]
t+=y-1
elif n1 > 0 and n2 ==0:
for i in range(len(stroka)):
if stroka[i+t] == '*' and (len(stroka) - stroka.count('*')-stroka.count('!')) > k:
stroka = stroka[:i+t - 1] + '!!' + stroka[i+t + 1:]
elif stroka[i+t] == '*' and (len(stroka) - stroka.count('*')-stroka.count('!')) == k:
stroka = stroka[:i+t] + '!' + stroka[i +t+ 1:]
elif stroka[i+t] == '*' and (len(stroka) - stroka.count('*')-stroka.count('!')) < k:
y = abs((len(stroka) - stroka.count('*')-stroka.count('!')) - k)
stroka = stroka[:i + t] + stroka[i + t - 1] * y + stroka[i + t + 1:]
t += y-1
elif n1==0 and n2 > 0:
for i in range(len(stroka)):
if stroka[i] == '?' and (len(stroka) - stroka.count('?') -stroka.count('!')) > k:
stroka = stroka[:i - 1] + '!!' + stroka[i + 1:]
elif stroka[i] == '?' and (len(stroka) - stroka.count('?') -stroka.count('!')) <= k:
stroka = stroka[:i] + '!' + stroka[i + 1:]
for i in range(len(stroka)):
if stroka[i]!='!':
p += stroka[i]
if len(p)==k:
print(p)
else:
print('Impossible') | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
int main() {
int i, j;
int n;
while (scanf("%d", &n) != EOF) {
if (n == 0) break;
int a[50001], v[50001];
memset(v, 0, sizeof(v));
int count = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!v[a[i]] && a[i] <= n) {
count++;
v[a[i]] = 1;
}
}
printf("%d\n", n - count);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = 1e6 + 10;
const int MOD = 1e9 + 7;
double const pi = acos(-1);
const double eps = 1e-8;
void fre() { freopen("in.txt", "r", stdin); }
int n, k;
long double p[25], ans[25], f[1 << 21];
long double dp(int x) {
if (x == 0) f[x] = 1;
long double tot = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if ((x & (1 << (i - 1))) == 0)
tot += p[i];
else
cnt++;
}
if (cnt >= k) {
if (cnt > k) return 0;
for (int i = 1; i <= n; i++) {
if (x & (1 << (i - 1))) ans[i] += f[x];
}
return f[x];
}
for (int i = 1; i <= n; i++) {
if ((x & (1 << (i - 1))) == 0) {
int t = x | (1 << (i - 1));
f[t] += f[x] * (p[i] / tot);
}
}
return f[x];
}
int main() {
scanf("%d%d", &n, &k);
int m = n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i] <= 1e-10) m--;
}
k = min(m, k);
for (int i = 0; i < (1 << n); i++) dp(i);
for (int i = 1; i <= n; i++) printf("%.9lf ", (double)ans[i]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int N = 1510;
int n, m, a[N][N], b[N][N];
int p[N], q[N];
int cnt[N];
bool was[N];
bool cmp(int i, int j)
{
for (int q = 0; q < m; q++)
if (a[i][q] != a[j][q])
return a[i][q] < a[j][q];
return 0;
}
bool cmp2(int i, int j)
{
for (int q = 0; q < m; q++)
if (b[i][q] != b[j][q])
return b[i][q] < b[j][q];
return 0;
}
void no()
{
puts("-1");
exit(0);
}
bool eql(int i, int j)
{
for (int q = 0; q < m; q++)
if (a[i][q] != a[j][q])
return 0;
return 1;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
scanf("%d", &b[i][j]);
for (int i = 0; i < n; i++)
p[i] = q[i] = i;
sort(p, p + n, cmp);
sort(q, q + n, cmp2);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[p[i]][j] != b[q[i]][j])
no();
for (int i = 0, j = 0; i < n; i = j)
{
while (j < n && eql(p[i], p[j]))
j++;
sort(p + i, p + j);
sort(q + i, q + j);
for (int k = i; k < j; k++)
b[q[k]][m] = p[k];
}
for (int j = 0; j <= m; j++)
for (int i = 1; i < n; i++)
if (b[i - 1][j] > b[i][j])
cnt[j]++;
// for (int i = 0; i < n; i++)
// {
// for (int j = 0; j <= m; j++)
// cerr << b[i][j] << " ";
// cerr << endl;
// }
// for (int j = 0; j <= m; j++)
// cerr << cnt[j] << " ";
// cerr << endl;
vector<int> ans;
while (true)
{
int j = -1;
for (int i = 0; i <= m; i++)
if (cnt[i] == 0)
j = i;
// cerr << j << endl;
if (j == m)
break;
if (j == -1)
no();
cnt[j] = -1;
ans.pb(j);
for (int i = 1; i < n; i++)
{
if (!was[i] && b[i - 1][j] < b[i][j])
{
was[i] = 1;
for (int j = 0; j <= m; j++)
if (b[i - 1][j] > b[i][j])
cnt[j]--;
}
}
}
reverse(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (auto x : ans)
printf("%d ", x + 1);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
long long a[3105];
long long x[3105], y[3105], t1, t2, b[3105];
int tot;
int main() {
scanf("%d%d", &n, &k);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%lld", a + i);
for (int i = 0, j; i < n; i = j + 1) {
for (j = i; j < n && a[j] < a[j + 1]; j++)
;
if (i == j) continue;
while (t1 && x[t1] > a[i]) {
b[++tot] = x[t1--] - y[t2--];
}
x[++t1] = a[i];
while (t2 && y[t2] < a[j]) {
b[++tot] = x[t1--] - y[t2--];
}
y[++t2] = a[j];
}
while (t2) b[++tot] = x[t1--] - y[t2--];
k = min(tot, k);
nth_element(b + 1, b + k, b + tot + 1);
long long ans = 0;
for (int(i) = 1; (i) <= (int)(k); (i)++) ans -= b[i];
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
if int(input()) in {3,5,7}:
print('YES')
else:
print('NO') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-7;
inline bool eq(long double x, long double y) { return fabs(x - y) < EPS; }
inline bool le(long double x, long double y) { return x < y + EPS; }
inline bool lt(long double x, long double y) { return x + EPS < y; }
inline int sgn(long double x) { return eq(x, 0) ? 0 : x < 0 ? -1 : 1; }
struct point {
long double x, y;
point(long double x = 0, long double y = 0) : x(x), y(y) {}
point operator+(const point& p) const { return point(x + p.x, y + p.y); }
point operator-(const point& p) const { return point(x - p.x, y - p.y); }
point operator*(long double s) const { return point(x * s, y * s); }
point operator/(long double s) const { return point(x / s, y / s); }
long double operator*(const point& p) const { return x * p.x + y * p.y; }
long double operator%(const point& p) const { return x * p.y - y * p.x; }
long double norm_sq() { return *this * *this; }
long double norm() { return sqrt(*this * *this); }
bool operator==(const point& p) const { return eq(x, p.x) && eq(y, p.y); }
bool operator<(const point& p) const {
return eq(y, p.y) ? lt(x, p.x) : lt(y, p.y);
}
};
ostream& operator<<(ostream& o, const point& p) {
return o << "(" << p.x << " " << p.y << ")";
}
int ccw(point a, point b, point c) { return sgn((b - a) % (c - b)); }
struct line {
point a, ab;
line(point a, point b) : a(a), ab(b - a) {}
point b() { return a + ab; }
bool areParallel(const line& l) const { return eq(ab % l.ab, 0); }
};
bool areIntersect(line l1, line l2, point& res) {
if (l1.areParallel(l2)) return 0;
long double ls = (l2.a - l1.a) % l2.ab, rs = l1.ab % l2.ab;
res = l1.a + l1.ab * ls / rs;
return 1;
}
bool areInterLineSeg(line l, point a, point b, point& res) {
if (!areIntersect(l, line(a, b), res)) return 0;
if (le((a - res) * (b - res), 0)) return 1;
return 0;
}
int pointVsPolygon(point p, const vector<point>& vp) {
int wn = 0, n = (int)vp.size() - 1;
for (int i = 0; i < n; i++) {
int cs = ccw(vp[i + 1], vp[i], p);
if (cs == 0 && (vp[i + 1] - p) * (vp[i] - p) <= 0) return 0;
if (vp[i].y <= p.y) {
if (vp[i + 1].y > p.y && cs > 0) wn++;
} else {
if (vp[i + 1].y <= p.y && cs < 0) wn--;
}
}
return wn == 0 ? 1 : -1;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<point> poly;
for (int i = 0; i < n; ++i) {
double x, y;
scanf("%lf %lf", &x, &y);
poly.push_back(point(x, y));
}
poly.push_back(poly.front());
for (int i = 0; i < m; ++i) {
double xa, xb, ya, yb;
scanf("%lf %lf %lf %lf", &xa, &ya, &xb, &yb);
point a(xa, ya), b(xb, yb);
line l(a, b);
vector<pair<point, pair<int, int> > > ints;
point p;
for (int j = 0; j < n; ++j) {
if (!areInterLineSeg(l, poly[j], poly[j + 1], p)) continue;
int pre = ccw(a, b, poly[j]), nxt = ccw(a, b, poly[j + 1]);
ints.push_back({p, {pre, nxt}});
}
sort(ints.begin(), ints.end());
long double ans = 0;
int inside = -1, prev = 0;
point last;
for (int j = 0; j < ints.size(); ++j) {
point c = (ints[j].first + ints[j + 1].first) / 2.0;
if (inside >= 0) ans += (ints[j].first - last).norm();
last = ints[j].first;
if (inside == 0) {
int cur = ((ints[j].second.first + ints[j].second.second));
assert(ints[j].second.first == 0 || ints[j].second.second == 0);
if (cur != 0) {
if (cur == prev)
inside = 1;
else
inside = -1;
}
} else if (ints[j].second.first * ints[j].second.second < 0) {
if (inside >= 0)
inside = -1;
else
inside = 1;
} else {
prev = (ints[j].second.first + ints[j].second.second) * inside;
inside = 0;
}
}
printf("%.20lf\n", (double)ans);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
pair<int, int> arr[MAXN];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
int ans = 0;
for (int i = 0; i < n; i++) {
bool ok = false;
for (int j = 0; j < n; j++)
if (i != j && arr[i].first == arr[j].second) ok = true;
if (!ok) ++ans;
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
N = int(input())
A = list(map(int,input().split()))
j = 'APPROVED'
for a in A:
if a%2==0:
if (a%3!=0)and(a%5!=0):
j = 'DENIED'
break
print(j) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
map<pair<int, int>, int> dp;
int getans(int remb, int curr) {
if (curr == n || remb == 0) return 1;
int ret = 0;
if (dp.find(make_pair(remb, curr)) != dp.end())
return dp[make_pair(remb, curr)];
if (remb == 1) {
return n - curr + 1;
}
ret = (getans(remb - 1, curr) + getans(remb, curr + 1)) % 1000000007;
dp[make_pair(remb, curr)] = ret;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
;
cin.tie(NULL);
int t = 1;
while (t--) {
dp.clear();
cin >> n >> m;
cout << getans(2 * m, 1);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long x, y;
vector<long long> ans;
bool ok = 1;
void go(long long x, long long y) {
if (x > y) {
if (x % y == 0 && y != 1) {
ok = 0;
return;
}
ans.push_back(x / y);
if (y == 1) {
ans.back()--;
} else {
go(x % y, y);
}
} else {
if (y % x == 0 && x != 1) {
ok = 0;
return;
}
ans.push_back(y / x);
if (x == 1) {
ans.back()--;
} else {
go(x, y % x);
}
}
}
int main() {
scanf("%lld%lld", &x, &y);
go(x, y);
if (!ok) {
puts("Impossible");
} else {
if (ans.back() == 0) ans.pop_back();
char c = x > y ? 'A' : 'B';
for (int i = 0; i < ans.size(); ++i) {
printf("%lld", ans[i]);
putchar(c);
c = 'A' + ('B' - c);
}
putchar('\n');
}
return 0;
}
| 9 | CPP |
t=int(input())
c=[]
for i in range(t):
n,k1,k2=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
if(max(a)<max(b)):
c.append("NO")
else:
c.append("YES")
for i in c:
print(i) | 7 | PYTHON3 |
import sys
input=sys.stdin.readline
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
def find(self, a):
acopy = a
while a != self.parent[a]:
a = self.parent[a]
while acopy != a:
self.parent[acopy], acopy = a, self.parent[acopy]
return a
def merge(self, a, b):
self.parent[self.find(b)] = self.find(a)
def kruskal(n, U, V, W):
union = UnionFind(n)
cost, merge_cnt = 0, 0
mst_u, mst_v,rej = [], [],[]
order = sorted(range(len(W)), key=lambda x: W[x])
for i in range(len(W)):
u, v ,w= U[order[i]], V[order[i]],W[order[i]]
find_u, find_v = union.find(u), union.find(v)
if find_u != find_v:
cost += W[order[i]]
merge_cnt += 1
union.parent[find_v] = find_u
mst_u.append(w)
else:
rej.append(w)
rej.sort()
return mst_u ,rej
for _ in range(int(input())):
n,m,k=map(int,input().split())
X=[]
Y=[]
W=[]
for _ in range(m):
xi,yi,wi=map(int,input().split())
X.append(xi);Y.append(yi);W.append(wi)
u,v=kruskal(len(X)+2,X,Y,W)
ans=0
closest1=100000000000
closest2=0
for i in v:
if i>=k:
closest1=min(closest1,i)
else:closest2=max(closest2,i)
if closest1-k<k-closest2:
closest=closest1
else:closest=closest2
flag=0
for i in u:
if i>=k:
flag=1
ans+=(i-k)
if not flag:
ans=abs(closest-k)
for i in u:
ans=min(ans,k-i)
print(ans) | 16 | PYTHON3 |
from math import *
def solver():
a, b, c = map(int, input().split())
s = ''
t = True
if b == 0:
if a:
print('0' * (a + 1))
else:
print('1' * (c + 1))
return
while b + 1:
if t:
s += '1'
else:
s += '0'
t = not t
b -= 1
s = '1' * c + '1' + '0' * a + s[1:]
print(s)
for _ in range(int(input())):
solver()
| 12 | PYTHON3 |
for _ in range(int(input())):
n = int(input())-1
arr = list(map(int, input().split()))[1:] + [-1]
ar2 = []
prev = -1
curr = 0
for e in arr:
if e > prev:
curr += 1
else:
ar2.append(curr)
curr = 1
prev = e
h = 1
ptr = 1
s = ar2[0]
while ptr < len(ar2):
ptr, s = ptr + s, sum(ar2[ptr:ptr+s])
h += 1
print(h)
| 10 | PYTHON3 |
n, m, k = map(int, input().split())
print("Yes" if (n <= m) and (n <= k) else "No") | 7 | PYTHON3 |
def main():
_ = input().split(" ")
n, k = [int(i) for i in _]
if n % 2 == 0:
last_odd_index = n // 2
else:
last_odd_index = n // 2 + 1
if k > last_odd_index:
# even number
k = k - last_odd_index
print(k * 2)
else:
print(k * 2 - 1)
if __name__ == "__main__":
main() | 7 | PYTHON3 |
n = int(input())
ans = 'No'
for i in range(1, 10):
if n%i == 0 and n/i <= 9:
ans = 'Yes'
print(ans)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000100;
const int inf = 2147483647;
int n, m;
int Son[maxN][2], Opt[maxN];
char str[10];
int F[maxN], Cover[maxN], Cnt[maxN];
void dfs1(int u);
void dfs2(int u, int c);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", str);
if (str[0] == 'A') {
Opt[i] = 1;
int u, v;
scanf("%d%d", &u, &v);
Son[i][0] = u;
Son[i][1] = v;
}
if (str[0] == 'O') {
Opt[i] = 2;
int u, v;
scanf("%d%d", &u, &v);
Son[i][0] = u;
Son[i][1] = v;
}
if (str[0] == 'X') {
Opt[i] = 3;
Cnt[i] = 1;
int u, v;
scanf("%d%d", &u, &v);
Son[i][0] = u;
Son[i][1] = v;
}
if (str[0] == 'N') {
Opt[i] = 4;
Cnt[i] = 1;
int u;
scanf("%d", &u);
Son[i][0] = u;
}
if (str[0] == 'I') {
Opt[i] = 5;
scanf("%d", &F[i]);
}
}
dfs1(1);
for (int i = 1; i <= n; i++)
if (Opt[i] == 1) {
if (F[Son[i][0]] == 0) Cover[Son[i][1]] = 1;
if (F[Son[i][1]] == 0) Cover[Son[i][0]] = 1;
} else if (Opt[i] == 2) {
if (F[Son[i][0]] == 1) Cover[Son[i][1]] = 1;
if (F[Son[i][1]] == 1) Cover[Son[i][0]] = 1;
}
dfs2(1, Cover[1]);
for (int i = 1; i <= n; i++)
if (Opt[i] == 5) {
if (Cover[i])
printf("%d", F[1]);
else
printf("%d", F[1] ^ 1);
}
return 0;
}
void dfs1(int u) {
if (Opt[u] == 5)
return;
else if (Opt[u] == 4) {
Cnt[Son[u][0]] += Cnt[u];
dfs1(Son[u][0]);
F[u] = !F[Son[u][0]];
} else {
Cnt[Son[u][0]] += Cnt[u];
Cnt[Son[u][1]] += Cnt[u];
dfs1(Son[u][0]);
dfs1(Son[u][1]);
if (Opt[u] == 1) F[u] = F[Son[u][0]] & F[Son[u][1]];
if (Opt[u] == 2) F[u] = F[Son[u][0]] | F[Son[u][1]];
if (Opt[u] == 3) F[u] = F[Son[u][0]] ^ F[Son[u][1]];
}
return;
}
void dfs2(int u, int c) {
Cover[u] |= c;
if (Opt[u] == 5)
return;
else if (Opt[u] == 4)
dfs2(Son[u][0], Cover[u]);
else {
dfs2(Son[u][0], Cover[u]);
dfs2(Son[u][1], Cover[u]);
}
return;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 2e5 + 7;
const int maxn = 3e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long n, num[maxn], ans = 0, cnt = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> num[i];
for (long long i = 1; i <= n; i++) {
long long temp = min(num[i] / 2, cnt);
ans += temp;
cnt -= temp;
num[i] -= 2 * temp;
ans += num[i] / 3;
num[i] = num[i] % 3;
cnt += num[i];
}
return cout << ans << endl, 0;
}
| 11 | CPP |
#include "bits/stdc++.h"
using namespace std;
int main(){
int n;
while(cin>>n){
vector<bool> a(n+1,true);
for(int i=2;i<=n+1;i++){
if(a[i]){
for(int j=i*2;j<n+1;j+=i){
a[j]=false;
}
}
}
int ans=0;
for(int i=2;i<n+1;i++){
if(a[i])ans++;
}
cout<<ans<<endl;
}
return 0;
} | 0 | CPP |
import sys, math
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
import collections as col
def solve():
N, K = getInts()
word = input()
#the sub-word of k letters must be a palindrome
#in this case, we have s1 = s(k) = s(k+1) = s(2*k) = ... = s(n*k-n+1) = s(n*k)
#s2 = s(k-1) = s(k+2) = s(2*k-1) = ...
#s3 = s3 = s(k+3) = s(k+3) = ...
#there are n//k such subwords
#for each possible starting letter
changes = 0
for i in range(math.ceil(K/2)):
counts = col.defaultdict(int)
total_count = 0
for j in range(N//K):
letter = word[j*K+i]
counts[letter] += 1
total_count += 1
if (j+1)*K-i-1 != j*K+i:
letter = word[(j+1)*K-1-i]
counts[letter] += 1
total_count += 1
best = 0
for letter in counts:
best = max(best,counts[letter])
changes += total_count-best
return changes
T = getInt()
for t in range(T):
print(solve())
| 9 | PYTHON3 |
import sys
from collections import namedtuple, deque
INF = sys.maxsize
Edge = namedtuple('Edge', 's t d')
V, E, r = map(int, input().split())
edges = []
for _ in range(E):
s, t, d = map(int, input().split())
edges.append(Edge(s, t, d))
def solve():
costs = [INF] * V
costs[r] = 0
for i in range(V):
for edge in edges:
if costs[edge.s] != INF and costs[edge.t] > costs[edge.s] + edge.d:
if i == V - 1:
print('NEGATIVE CYCLE')
return
costs[edge.t] = costs[edge.s] + edge.d
for x in costs:
print(x if x != INF else 'INF')
solve()
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin >> s;
int len = s.size();
vector<int> a(len + 1, 0);
for(int i = 0, j = 0; i < len; i = j){
while(j < len && s[i] == s[j]) j++;
int sz = j - i;
if(s[i] == '<'){
for(int k = i; k <= j; k++) a[k] = max(a[k], k - i);
} else {
for(int k = j; k >= i; k--) a[k] = max(a[k], j - k);
}
}
long long ans = 0;
for(int i = 0; i <= len; i++) ans += a[i];
cout << ans << endl;
return 0;
}
| 0 | CPP |
n= int(input())
lst= list()
for i in range(n):
wrd= input()
if len(wrd)>10:
out= wrd[0]+str(len(wrd)-2)+wrd[len(wrd)-1]
lst.append(out)
else:
lst.append(wrd)
for i in range(n):
print(lst[i]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double inf = 1e9 + 7;
const double eps = 1e-10;
const int N = 1e3 + 2;
double h, w, dis[N][N];
pair<double, double> pts[N];
int n, idx[N], num, now;
pair<double, int> lis[4 * N];
bool cmp(pair<double, int> first, pair<double, int> second) {
return first.first < second.first;
}
void add1(double l, double r, int v) {
if (l <= 0) {
now += v;
} else {
num++;
lis[num] = {l, v};
}
if (r < 2 * PI) {
num++;
lis[num] = {r + eps, -v};
}
}
void add(double l, double r, int v) {
while (l < 0) {
l += 2 * PI;
}
while (l >= 2 * PI) {
l -= 2 * PI;
}
while (r < 0) {
r += 2 * PI;
}
while (r >= 2 * PI) {
r -= 2 * PI;
}
if (l <= r) {
add1(l, r, v);
} else {
add1(0, r, v);
add1(l, 2 * PI, v);
}
}
bool check(int id, double rad) {
num = 0;
now = 0;
double polar, angle;
for (int i = 1; i <= n; i++) {
if (dis[id][i] > 0 && dis[id][i] < 2 * rad) {
polar =
atan2(pts[i].second - pts[id].second, pts[i].first - pts[id].first),
angle = acos(dis[id][i] / 2 / rad);
add(polar - angle, polar + angle, 1);
}
}
if (pts[id].first < rad) {
polar = PI, angle = acos(pts[id].first / rad);
add(polar - angle, polar + angle, 2);
}
if (pts[id].second < rad) {
polar = 3 * PI / 2, angle = acos(pts[id].second / rad);
add(polar - angle, polar + angle, 2);
}
if (pts[id].first + rad > w) {
polar = 0, angle = acos((w - pts[id].first) / rad);
add(polar - angle, polar + angle, 2);
}
if (pts[id].second + rad > h) {
polar = PI / 2, angle = acos((h - pts[id].second) / rad);
add(polar - angle, polar + angle, 2);
}
if (now < 2) {
return true;
}
sort(lis + 1, lis + 1 + num, cmp);
for (int i = 1; i <= num; i++) {
now += lis[i].second;
if (now < 2) {
return true;
}
}
return false;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin >> w >> h >> n;
double ans = 0, lef, rig, mid, maxx = sqrt(h * h + w * w);
int i, j;
for (i = 1; i <= n; i++) {
idx[i] = i;
cin >> pts[i].first >> pts[i].second;
for (j = 1; j < i; j++) {
dis[i][j] = dis[j][i] = sqrt(
(pts[i].first - pts[j].first) * (pts[i].first - pts[j].first) +
(pts[i].second - pts[j].second) * (pts[i].second - pts[j].second));
}
}
shuffle(idx + 1, idx + 1 + n, rng);
for (i = 1; i <= n; i++) {
if (check(idx[i], ans + eps)) {
lef = ans;
rig = maxx;
for (j = 1; j <= 60; j++) {
mid = (lef + rig) / 2;
if (check(idx[i], mid)) {
lef = mid;
} else {
rig = mid;
}
}
ans = lef;
}
}
cout << fixed << setprecision(9) << ans;
}
| 11 | CPP |
order=list(input().split('+'))
order.sort()
insert='+'
result=insert.join(order)
print(result) | 7 | PYTHON3 |
n,k=map(int,input().split())
l=[]
for i in range(n):
l.append(input())
s=input()
d=len(s)
x,y=0,0
for i in l:
if(len(i)<d):
x=x+1
if(len(i)==d and i!=s):
y=y+1
xx=x+(x//k)*5
yy=x+y+((x+y)//k)*5
print(xx+1,yy+1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int ret = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (i == n - 1 && j == m - 1) {
} else if (i == n - 1) {
ret += c == 'D';
} else if (j == m - 1) {
ret += c == 'R';
}
}
}
cout << ret << "\n";
}
return 0;
}
| 8 | CPP |
import sys
def getAndParseInt(num=1):
string = (sys.stdin.readline()).strip()
if num==1:
return int(string)
else:
return [int(part) for part in string.split()]
def getAndParseString(num=1,delim=""):
string = (sys.stdin.readline()).strip()
if num==1:
return string
else:
if delim!="":
return [part for part in string.split(delim)]
else:
return [part for part in string.split()]
w,h = getAndParseInt(2)
u1,d1 = getAndParseInt(2)
u2,d2 = getAndParseInt(2)
for cur_h in reversed(range(h+1)):
w+=cur_h
if cur_h == d1:
w+=-u1
elif cur_h == d2:
w+=-u2
w=max(0,w)
print(w)
| 7 | PYTHON3 |
arr = []
for i in range(5):
arr.append(list(map(int,input().split())))
maxi = 0
maxj = 0
for i in range(len(arr)):
for j in range(len(arr[0])):
if arr[i][j] == 1:
maxi = i
maxj = j
break
maxi+=1
maxj+=1
print(abs(3-maxi)+abs(3-maxj)) | 7 | PYTHON3 |
# import sys
# sys.stdin=open("input.in","r")
# sys.stdout=open("output.out","w")
n=int(input())
l=[['.' for i in range(n)]for j in range(n)]
c=0
for i in range(n):
for j in range(n):
if i%2==0:
if j%2==0:
l[i][j]='C'
c+=1
else:
if j%2!=0:
l[i][j]='C'
c+=1
print(c)
for i in range(n):
s=''.join(l[i])
print(s) | 7 | PYTHON3 |
#include<iostream>
#include<vector>
#include<map>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<stack>
#include<queue>
#include<set>
#include<bitset>
#include<iomanip>
#define BUG puts("no bug")
#define sci(x) scanf("%d",&x)
#define scl(x) scanf("%lld",&x)
#define ll long long
#define ull unsigned long long
#define REP(a,b,c) for(int a=b;a<=c;a++)
#define PER(a,b,c) for(int a=b;a>=c;a--)
#define lb(a) (a&(-a))
#define pp (p<<1)
#define ppp (p<<1|1)
#define pi pair<int,int>
#define pii pair<pair<int,int>,int>
using namespace std;
const int MAXN=1e6+5;
int n,m,t;
char a[MAXN],b[MAXN],c[MAXN];
int ab[MAXN],bc[MAXN],ac[MAXN];
int o=1e4;
int check(char x,char y){
return x=='?'||y=='?'||x==y;
}
int main(){
cin>>a+1>>b+1>>c+1;
int la=strlen(a+1),lb=strlen(b+1),lc=strlen(c+1);
REP(i,-4000,4000)ab[i+o]=ac[i+o]=bc[i+o]=1;
REP(i,1,la)REP(j,1,lb){
if(!check(a[i],b[j]))ab[i-j+o]=0;
}
REP(i,1,la)REP(j,1,lc){
if(!check(a[i],c[j]))ac[i-j+o]=0;
}
REP(i,1,lb)REP(j,1,lc){
if(!check(b[i],c[j]))bc[i-j+o]=0;
}
int ans=la+lb+lc;
REP(i,-4000,4000)REP(j,-4000,4000){
if(ab[i+o]&&ac[j+o]&&bc[j-i+o]){
ans=min(ans,max(la,max(i+lb,j+lc))-min(1,min(1+i,1+j))+1);
}
}
cout<<ans;
} | 0 | CPP |
s = input()
if(len(s)==1):
print(s.swapcase())
elif(s.isupper() or s[1:].isupper()):
print(s.swapcase())
else:
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
const long long inf = std::numeric_limits<long long>::max();
using namespace std;
vector<int> g[200100];
bool used[200100];
map<pair<int, int>, int> mp;
bool seen[200100];
int depth[200100];
int mother[200100];
int all[200100];
int k, n, m;
vector<string> ans;
void solve(bool u[], int v, int c) {
if (v == 0) return;
if (depth[v] == 1) {
string st;
for (int i = 0; i < m; i++) {
if (u[i]) {
if (st.empty())
st = '1';
else
st += '1';
} else {
if (st.empty())
st = '0';
else
st += '0';
}
}
ans.push_back(st);
k--;
} else {
solve(u, all[c - 1], c - 1);
}
for (int i : g[v]) {
if (depth[i] == depth[v] - 1 && !u[mp[{i, v}]]) {
int cc = mother[v];
u[mp[{cc, v}]] = false;
u[mp[{i, v}]] = true;
if (k == 0) return;
if (c > 0) solve(u, all[c - 1], c - 1);
u[mp[{cc, v}]] = true;
u[mp[{i, v}]] = false;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
mp[{x, y}] = i;
mp[{y, x}] = i;
}
int kk = k;
queue<int> bfs;
stack<int> out;
bfs.push(0);
int ccc = 0;
seen[0] = true;
while (!bfs.empty()) {
int v = bfs.front();
bfs.pop();
for (int i : g[v]) {
if (!seen[i]) {
seen[i] = true;
bfs.push(i);
used[mp[{v, i}]] = true;
all[ccc++] = i;
depth[i] = depth[v] + 1;
mother[i] = v;
}
}
}
solve(used, all[ccc - 1], ccc - 1);
cout << min((int)ans.size(), kk) << endl;
for (int i = 0; i < min((int)ans.size(), kk); i++) cout << ans[i] << endl;
return 0;
}
| 12 | CPP |
n = int(input())
a = list(map(int,input().split()))
m = []
c = 0
b = max(a)
for i in a:
if i == b:
c = c + 1
else:
m.append(c)
c = 0
m.append(c)
print(max(m)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,a[4][3][10],b,c,d,e;
cin>>n;
for(int x=0;x<4;x++) for(int y=0;y<3;y++) for(int z=0;z<10;z++) a[x][y][z]=0;
for(int i=0;i<n;i++){
cin>>b>>c>>d>>e;
a[b-1][c-1][d-1]+=e;
}
for(int x=0;x<4;x++){
for(int y=0;y<3;y++){
for(int z=0;z<10;z++) cout<<" "<<a[x][y][z];
cout<<endl;
}
if(x<3) cout<<"####################"<<endl;
}
return 0;
} | 0 | CPP |
# Anuneet Anand
T = int(input())
while T:
n = input()
d = len(n)
X = []
for i in range(d):
if n[i]!="0":
X.append(int(n[i]+("0"*(d-i-1))))
print(len(X))
print(*X)
T = T - 1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, p[10], t[10];
long long ans;
void rec(int sz) {
if (sz == k - 1) {
for (int j = 0; j < k; j++) {
memset(t, -1, sizeof(t));
int v = j;
while (t[v] == -1) {
t[v] = 1;
v = p[v];
}
if (!t[0]) return;
}
ans++;
} else {
for (int j = 0; j < k; j++) {
p[sz] = j;
rec(sz + 1);
}
}
}
int main() {
while (cin >> n >> k) {
ans = 0;
rec(0);
for (int i = 0; i < n - k; i++) ans = (ans * (n - k)) % 1000000007;
cout << ans << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2500002;
vector<long long> adj[100002];
long long vis[100002], insert[100002], low[100002], timer;
bool flag, art[100002];
long long ans;
vector<pair<long long, long long> > v;
void dfs(long long node, long long par) {
vis[node] = 1;
insert[node] = low[node] = timer;
timer++;
long long children = 0;
for (auto it : adj[node]) {
if (it == par) continue;
if (vis[it]) {
low[node] = min(insert[it], low[node]);
} else {
dfs(it, node);
low[node] = min(low[it], low[node]);
if (insert[node] <= low[it] && par != -1 && art[node] == false) {
art[node] = true;
ans++;
}
children++;
}
}
if (par == -1 && children > 1 && art[node] == false) {
art[node] = true;
ans++;
}
}
void clear() {
for (long long i = 0; i < 100002; i++) {
adj[i].clear();
vis[i] = 0;
art[i] = false;
low[i] = 0;
insert[i] = 0;
}
}
void solve() {
long long n, m;
cin >> n >> m;
string s[n];
long long a[n][m];
long long x = 1;
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (s[i][j] == '#') {
a[i][j] = x;
x++;
}
}
}
if (x <= 3) {
cout << -1;
return;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (s[i][j] == '#') {
if (i + 1 < n && s[i + 1][j] == '#')
adj[a[i][j]].push_back(a[i + 1][j]);
if (j + 1 < m && s[i][j + 1] == '#')
adj[a[i][j]].push_back(a[i][j + 1]);
if (i - 1 >= 0 && s[i - 1][j] == '#')
adj[a[i][j]].push_back(a[i - 1][j]);
if (j - 1 >= 0 && s[i][j - 1] == '#')
adj[a[i][j]].push_back(a[i][j - 1]);
}
}
}
ans = 0, timer = 0;
dfs(1, -1);
cout << ((ans == 0) ? 2 : 1) << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
solve();
}
}
| 7 | CPP |
m, n = input().split()
m, n = int(m), int(n)
counter = 0
if m % 2 == 0:
counter += ((m / 2) * n)
elif n % 2 == 0:
counter += ((n / 2) * m)
else:
if n == 1:
pass
elif m > 1:
counter += ((m - 1) / 2) * n
counter += (n - 1) / 2
else:
counter += (n - 1) / 2
print(int(counter))
| 7 | PYTHON3 |
#include<cstdio>
#include<complex>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<iostream>
#include<cassert>
#include<algorithm>
using namespace std;
typedef double Real;
typedef complex<Real> Point;
typedef pair<Point,Point> Line;
typedef pair<Point,Point> Segment;
typedef vector<Point> Polygon;
const Real eps=1e-7;
const Real eps2=5e-7;
const Real PI=acos(-1.0);
const Point NPoint=Point(NAN,NAN);
const Real inf=1e9;
int cnt=0;
template<class T> bool eq(T a, T b){
return abs(a-b)<eps;
}
template<class T> int sgn(T a){
if(eq(a,(T)0)) return 0;
if(a>0) return 1;
return -1;
}
void print(Point p,char ch='\n'){
printf("(%f %f)%c",p.real(),p.imag(),ch);
}
void print(Polygon poly){
printf("----\n");
for(int i=0;i<poly.size();i++){
print(poly[i]);
}
printf("----\n");
}
Polygon poly;
Point vec;
vector<Real> xs;
Real doP(Point a,Point b){
return (conj(a)*b).real();
}
Real crP(Point a,Point b){
return (conj(a)*b).imag();
}
bool onSeg(Point p,Point q,Point r){
return eq(abs(p-q),abs(p-r)+abs(r-q));
}
Point toVec(Line l){
return l.second-l.first;
}
bool isPara_(Line l1,Line l2){
return eq(crP(toVec(l1),toVec(l2)),(Real)0);
}
Real getArea(Polygon poly){
Real res=0;
for(int i=0;i+1<poly.size();i++){
res+=crP(poly[i],poly[i+1])/2;
}
res=abs(res);
return res;
}
void rot(){
Point p=Point(0,1);
vec/=abs(vec);
Point m=p/vec;
for(int i=0;i<poly.size();i++){
poly[i]*=m;
}
vector<Real> tmp;
for(int i=0;i+1<poly.size();i++){
bool ok=true;
for(int j=0;j<tmp.size();j++){
if(eq(tmp[j],poly[i].real())) ok=false;
}
if(ok) tmp.push_back(poly[i].real());
}
for(int i=0;i<poly.size();i++){
for(int j=0;j<tmp.size();j++){
if(eq(poly[i].real(),tmp[j])){
poly[i]=Point(tmp[j],poly[i].imag());
break;
}
}
}
xs=tmp;
sort(xs.begin(),xs.end());
}
Point cmp_c;
bool cmp_ang(const Point &p1,const Point &p2){
return arg(p1-cmp_c)<arg(p2-cmp_c);
}
struct PLexCmp{
bool operator()(const Point &p1,const Point &p2) const {
if(p1.real()!=p2.real()) return p1.real()<p2.real();
return p1.imag()<p2.imag();
}
};
struct SegLexCmp{
bool operator()(const Segment &s1,const Segment &s2) const {
if(s1.first.real()!=s2.first.real()) return s1.first.real()<s2.first.real();
if(s1.first.imag()!=s2.first.imag()) return s1.first.imag()<s2.first.imag();
if(s1.second.real()!=s2.second.real()) return s1.second.real()<s2.second.real();
return s1.second.imag()<s2.second.imag();
}
};
map<Point,vector<Point>,PLexCmp> con_pts;
vector<Real> ys;
set<Segment,SegLexCmp> invalid_es;
bool genConPts(Real x){
map<Point,vector<Point>,PLexCmp> emptyMap;
swap(emptyMap,con_pts);
ys.clear();
set<Segment,SegLexCmp> emptySet;
swap(invalid_es,emptySet);
for(int i=0;i+1<poly.size();i++){
Point p=poly[i],q=poly[i+1];
if(p.real()==x){
ys.push_back(p.imag());
}
// bool swapped=false;
if(p.real()>q.real()){
// swapped=true;
swap(p,q);
}
if(q.real()<=x||p.real()>=x){
con_pts[p].push_back(q);
con_pts[q].push_back(p);
invalid_es.insert(Segment(poly[i+1],poly[i]));
continue;
}
Real y=p.imag()+((q.imag()-p.imag())*(x-p.real())/(q.real()-p.real()));
if(y==p.imag()){
if(p.imag()>q.imag()) y+=eps;
else y-=eps;
}
ys.push_back(y);
Point r=Point(x,y);
con_pts[p].push_back(r);
con_pts[r].push_back(p);
con_pts[q].push_back(r);
con_pts[r].push_back(q);
invalid_es.insert(Segment(poly[i+1],r));
invalid_es.insert(Segment(r,poly[i]));
}
sort(ys.begin(),ys.end());
int ln=ys.size();
ys.erase(unique(ys.begin(),ys.end()),ys.end());
if(ln!=ys.size()) return false;
for(int i=0;i+1<ys.size();i++){
Point p=Point(x,ys[i]);
Point q=Point(x,ys[i+1]);
con_pts[p].push_back(q);
con_pts[q].push_back(p);
}
map<Point,vector<Point>,PLexCmp> :: iterator it=con_pts.begin();
for(;it!=con_pts.end();it++){
vector<Point> &vec=it->second;
cmp_c=it->first;
sort(vec.begin(),vec.end(),cmp_ang);
vec.erase(unique(vec.begin(),vec.end()),vec.end());
/* vector<Point> vec2;
for(int i=0;i<vec.size();i++){
if(i==0||(vec[i].real()!=vec[i-1].real()||vec[i].imag()!=vec[i-1].imag())){
vec2.push_back(vec[i]);
}
}
vec=vec2;*/
}
for(it=con_pts.begin();it!=con_pts.end();it++){
for(int i=0;i<(it->second).size();i++){
Point p=(it->second)[i];
assert(con_pts.find(p)!=con_pts.end());
}
}
return true;
}
void stroke(vector<Point> &vec,Point cur,Point prv,Point ini){
vector<Point> pts=con_pts[cur];
cmp_c=cur;
int id=distance(pts.begin(),lower_bound(pts.begin(),pts.end(),prv,cmp_ang));
assert(prv==pts[id]);
id--;
if(id==-1) id=pts.size()-1;
assert(0<=id&&id<pts.size());
Point nxt=pts[id];
vec.push_back(nxt);
if(nxt==ini) return;
stroke(vec,nxt,cur,ini);
}
int whichSide(Polygon poly,Real x){
bool le=false,ri=false;
for(int i=0;i<poly.size();i++){
if(poly[i].real()<x) le=true;
if(poly[i].real()>x) ri=true;
}
if(le&&ri) return 0;
else if(le) return -1;
else if(ri) return 1;
printf("error whichSide\n");
printf("%f\n",x);
print(poly);
for(int i=0;i<ys.size();i++){
printf("%f\n",ys[i]);
}
vector<Point> vec=con_pts[poly[0]];
print(poly[0]);
for(int i=0;i<vec.size();i++){
printf("-");
print(vec[i]);
}
printf("\n\n\n");
map<Point,vector<Point>,PLexCmp> ::iterator it=con_pts.begin();
for(;it!=con_pts.end();it++){
print(it->first);
for(int i=0;i<(it->second).size();i++){
printf("-");
print((it->second)[i]);
}
}
exit(0);
}
bool isValid_(Polygon poly){
for(int i=0;i+1<poly.size();i++){
Segment seg=Segment(poly[i],poly[i+1]);
if(invalid_es.find(seg)!=invalid_es.end()) return false;
}
return true;
}
pair<Real,Real> calcArea(Real x){
Real le=0,ri=0;
bool flg=genConPts(x);
if(flg==false){
return make_pair(inf,inf);
}
if(ys.size()<=1){
return make_pair(inf,inf);
}/*
for(map<Point,vector<Point>,PLexCmp>::iterator it=con_pts.begin();it!=con_pts.end();it++){
print(it->first,':');
vector<Point> vec=it->second;
for(int i=0;i<vec.size();i++){
print(vec[i]);
}
}*/
for(int i=0;i+1<ys.size();i++){
Point p=Point(x,ys[i]);
Point q=Point(x,ys[i+1]);
vector<Point> poly;
stroke(poly,p,q,p);
poly.push_back(poly[0]);
//bool flg=isRight(poly,x);
int side=whichSide(poly,x);
Real area=getArea(poly);/*
if(flg) ri=max(ri,area);
else {}//le=max(le,area);*/
bool flg=isValid_(poly);
if(side==1&&flg) ri=max(ri,area);
//print(poly);
poly.clear();
stroke(poly,q,p,q);
poly.push_back(poly[0]);
//print(poly);
//flg=isRight(poly,x);
side=whichSide(poly,x);
area=getArea(poly);/*
if(flg) {}//ri=max(ri,area);
else le=max(le,area);*/
flg=isValid_(poly);
if(side==-1&&flg) le=max(le,area);
}
return make_pair(le,ri);
}
Real calcEdgeCase(){
Real res=getArea(poly);
for(int i=1;i+1<xs.size();i++){
pair<Real,Real> p=calcArea(xs[i]);
// printf("%f %f %f\n",xs[i],p.first,p.second);
res=min(res,max(p.first,p.second));
}
return res;
}
Real calc(Real lb,Real ub,Real cur_best){
Real res=inf;
pair<Real,Real> p1,p2;
p1=calcArea(lb);
p2=calcArea(ub);
// printf("a%f %f %f\n",lb,ub,cur_best);
if(lb>ub) return cur_best;
//if(max(p1.first,p1.second)>cur_best||max(p2.first,p2.second)>cur_best) return cur_best;
if(p1.first>p1.second) return min(cur_best,p1.first);
if(p2.first<p2.second) return min(cur_best,p2.second);
for(int stage=0;stage<100;stage++){
Real mid=(ub+lb)/2;
pair<Real,Real> p=calcArea(mid);
if(p.first>0&&p.second>0){
res=min(res,max(p.first,p.second));
}
if(p.first==0||p.second==0){
if(stage<50){
Real tmp=cur_best;
Real a=calc(lb+eps,mid-eps,tmp);
tmp=min(tmp,a);
a=calc(mid+eps,ub-eps,tmp);
tmp=min(tmp,a);
return tmp;
}
}
// printf("%f %f %f\n",mid,p.first,p.second);
if(p.first<p.second){
lb=mid;
}else{
ub=mid;
}
}
return res;
}
Real solve(){
rot();
Real res=calcEdgeCase();
//printf("edge case best = %f\n",res);
/* for(int i=0;i+1<xs.size();i++){
Real lb=xs[i]+eps2,ub=xs[i+1]-eps2;
Real tmp=calc(lb,ub,res);
res=min(res,tmp);
}*/
Real l=inf,r=-inf;
vector<Real> xs;
for(int i=0;i+1<poly.size();i++){
l=min(l,poly[i].real());
r=max(r,poly[i].real());
Point p=poly[i],q=poly[i+1],r=poly[i+2>=poly.size()?0:i+2];
if(crP(p-q,r-q)>0){
if(p.real()==q.real()||q.real()==r.real()) continue;
if(p.real()<q.real()!=q.real()<r.real()){
xs.push_back(q.real());
}
}
}
xs.push_back(l);
xs.push_back(r);
sort(xs.begin(),xs.end());
for(int i=0;i+1<xs.size();i++){
Real lb=xs[i]+eps2,ub=xs[i+1]-eps2;
Real tmp=calc(lb,ub,res);
res=min(res,tmp);
}
return res;
}
void init(){
poly.clear();
xs.clear();
ys.clear();
map<Point,vector<Point>,PLexCmp> tmp;
swap(con_pts,tmp);
}
void input(){
int N;
scanf("%d",&N);
if(N==0) exit(0);
int x,y;
scanf("%d%d",&x,&y);
vec=Point(x,y);
for(int i=0;i<N;i++){
int x,y;
scanf("%d%d",&x,&y);
poly.push_back(Point(x,y));
}
poly.push_back(poly[0]);
cnt++;
}
int main(){
while(true){
init();
input();
Real ans=solve();
printf("%f\n",ans);
// cout<<ans<<"\n";
// break;
}
return 0;
} | 0 | CPP |
def fn(l):
for i in range(1,len(l)):
if l[i] in vow and l[i-1] in vow:
#print(l[i],l[i-1])
return i
return 0
n = int(input())
s = list(input())
vow = ["a","e","i","o","u","y"]
while True:
if len(s) > 1:
i = fn(s)
if i != 0:
#print(len(s),i)
del s[i]
#print(s)
else:
break
else:
break
print("".join(s)) | 7 | PYTHON3 |
# from sys import exit
while(True):
N = int(input())
if N == 0:
break
L = []
for i in range(N):
r = [int(n) for n in input().split()]
time = sum([r[i]*60 + r[i+1] for i in range(1, 9, 2)])
L.append((r[0], time))
# print(abs(22- w/((h/100)**2)))
L = sorted(L, key=lambda x: x[1])
print(L[0][0])
print(L[1][0])
print(L[-2][0])
| 0 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
arr = list(map(int,input().split()))
odd_p=0
even_p=0
for i in range(n):
if(i%2==0 and arr[i]%2!=0):
odd_p+=1
elif(i%2==1 and arr[i]%2==0):
even_p+=1
if(odd_p==even_p):
print(even_p)
else:
print(-1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T &a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T &a, Others &...b) {
a = read(a);
read(b...);
}
struct Node {
int len;
long long sum;
vector<long long> v;
} node[1000010 << 2];
int n, m, p, a[1000010];
void merge(int k) {
for (int x = 0, y = 0; x <= node[k << 1].len; x++) {
if (y) y -= 1;
while (y <= node[k << 1 | 1].len) {
if (node[k << 1].v[x + 1] - 1 - 1ll * x * p + node[k << 1].sum <
node[k << 1 | 1].v[y]) {
if (y) y -= 1;
break;
}
long long t = node[k << 1 | 1].v[y] + 1ll * x * p - node[k << 1].sum;
node[k].v[x + y] = min(node[k].v[x + y], max(node[k << 1].v[x], t));
y += 1;
}
}
}
void build(int k, int l, int r) {
node[k].len = r - l + 1;
node[k].v.resize(r - l + 3, INF);
node[k].v[0] = -INF;
if (l == r) {
node[k].sum = a[l];
node[k].v[1] = p - a[l];
return;
}
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
node[k].sum = node[k << 1].sum + node[k << 1 | 1].sum;
merge(k);
}
void query(int k, int l, int r, int x, int y, long long &ans) {
if (l >= x && r <= y) {
int t = upper_bound(node[k].v.begin(), node[k].v.end(), ans) -
node[k].v.begin() - 1;
ans += node[k].sum - 1ll * t * p;
return;
}
int mid = (l + r) >> 1;
if (y <= mid) return query(k << 1, l, mid, x, y, ans);
if (x > mid) return query(k << 1 | 1, mid + 1, r, x, y, ans);
query(k << 1, l, mid, x, y, ans);
query(k << 1 | 1, mid + 1, r, x, y, ans);
}
signed main() {
read(n, m, p);
for (int i = 1; i <= n; i++) read(a[i]);
build(1, 1, n);
for (int i = 1; i <= m; i++) {
int l, r;
read(l, r);
long long ans = 0;
query(1, 1, n, l, r, ans);
printf("%lld\n", ans);
}
return 0;
}
| 12 | CPP |
import re
s = input().lower()
ans = re.sub(r'[aoyeui]', '', s)
ans = re.sub(r'(.)', r'.\1', ans)
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 102;
const int K = 102;
const long long MOD = 1e6 + 3;
const long long MOD2 = MOD * MOD * 7LL;
struct Matrix {
int mat[N][N];
int row, col;
};
Matrix multiply(Matrix A, Matrix B) {
Matrix ret;
ret.row = A.row;
ret.col = B.col;
for (int i = 1; i <= ret.row; i++) {
for (int j = 1; j <= ret.col; j++) {
long long sum = 0;
for (int k = 1; k <= A.col; k++) {
sum += 1LL * A.mat[i][k] * B.mat[k][j];
}
ret.mat[i][j] = sum % MOD;
}
}
return ret;
}
Matrix expo(Matrix base, long long p) {
if (p == 1) return base;
if (p & 1) return multiply(base, expo(base, p - 1));
Matrix ret = expo(base, p / 2);
return multiply(ret, ret);
}
long long c, h, w;
long long dp[N];
void init() {
dp[0] = 1;
for (int i = 1; i <= w; i++) {
long long mul = 1;
for (int j = 0; j <= w; j++) {
if (i - j - 1 >= 0) dp[i] += mul * dp[i - j - 1];
if (i - j == 0) dp[i] += mul;
dp[i] %= MOD;
mul *= h;
mul %= MOD;
}
}
}
int main() {
cin >> c >> w >> h;
init();
if (c <= w) {
cout << dp[c] << endl;
return 0;
}
Matrix base;
base.row = w + 1;
base.col = w + 1;
memset(base.mat, 0, sizeof(base.mat));
long long mul = 1;
for (int i = 1; i <= w + 1; i++) {
base.mat[1][i] = mul;
mul *= h;
mul %= MOD;
}
for (int i = 2; i <= w + 1; i++) {
base.mat[i][i - 1] = 1;
}
Matrix ret = expo(base, c - w);
long long ans = 0;
for (int i = 1; i <= w + 1; i++) {
ans += 1LL * ret.mat[1][i] * dp[w - i + 1], ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, x2, y2, turn;
scanf("%d%d%d%d", &x, &y, &x2, &y2);
turn = 0;
while (1) {
if (!turn) {
if (!x)
y--;
else if (!y)
x--;
else {
if (y2 > y)
x--;
else
y--;
}
if (make_pair(x, y) == make_pair(x2, y2)) {
printf("Vasiliy\n");
return 0;
}
if (make_pair(x, y) == make_pair(0, 0)) {
printf("Polycarp\n");
return 0;
}
turn = 1;
} else {
if (!x2)
y2--;
else if (!y2)
x2--;
else
x2--, y2--;
if (make_pair(x, y) == make_pair(x2, y2)) {
printf("Polycarp\n");
return 0;
}
if (make_pair(x2, y2) == make_pair(0, 0)) {
printf("Vasiliy\n");
return 0;
}
turn = 0;
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100001;
vector<vector<long long> > G(N);
long long lca[N][18];
long long t[N];
long long level[N];
long long tim = 0;
vector<long long> be;
vector<long long> en;
vector<long long> im;
vector<vector<long long> > g;
vector<long long> reverse_map;
long long ans = 0;
long long rec(long long s) {
long long cnt = 0;
long long lans = 0;
for (auto it : g[s]) {
lans += rec(it);
if (im[it] && level[reverse_map[s]] == level[reverse_map[it]] - 1) cnt++;
}
if (im[s] && cnt) {
ans = 1000000;
return 1;
}
if (im[s]) {
ans += lans;
return 1;
}
if (lans > 1) {
ans += 1;
return 0;
}
if (im[s] && lans == 0) lans = 1;
return lans;
}
void dfs(long long s, long long par, long long lev) {
tim++;
be[s] = tim;
t[s] = par;
level[s] = lev;
for (auto it : G[s]) {
if (it != par) {
dfs(it, s, lev + 1);
}
}
en[s] = tim;
}
void init(long long n) {
for (long long i = 1; i <= n; i++) lca[i][0] = t[i];
for (long long j = 1; j <= 17; j++) {
for (long long i = 1; i <= n; i++) {
lca[i][j] = lca[lca[i][j - 1]][j - 1];
}
}
}
long long LCA(long long u, long long v) {
if (level[u] < level[v]) swap(u, v);
for (long long j = 17; j >= 0; j--) {
if (level[lca[u][j]] >= level[v]) u = lca[u][j];
}
if (u == v) return u;
for (long long j = 17; j >= 0; j--) {
if (lca[u][j] != lca[v][j]) {
u = lca[u][j];
v = lca[v][j];
}
}
return t[u];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
be.resize(n + 1);
en.resize(n + 1);
dfs(1, 1, 1);
init(n);
long long q;
cin >> q;
while (q--) {
long long k;
cin >> k;
vector<pair<long long, long long> > temp(k);
set<pair<long long, long long> > s;
map<long long, long long> m;
for (long long i = 0; i < k; i++) {
cin >> temp[i].second;
temp[i].first = be[temp[i].second];
m[temp[i].second] = 1;
}
if (k == 1) {
cout << 0 << "\n";
continue;
}
sort(temp.begin(), temp.end());
for (long long i = 0; i < k - 1; i++) {
long long h = LCA(temp[i].second, temp[i + 1].second);
s.insert(make_pair(be[h], h));
s.insert(temp[i]);
if (i == k - 2) s.insert(temp[i + 1]);
}
vector<pair<long long, long long> > v(s.begin(), s.end());
long long sz = v.size();
long long c = 1;
im.clear();
im.resize(sz + 1, 0);
reverse_map.clear();
reverse_map.resize(v.size() + 1);
stack<long long> st;
st.push(1);
reverse_map[1] = v[0].second;
if (m[v[0].second]) im[1] = 1;
c++;
g.clear();
g.resize(sz + 1);
for (long long i = 1; i < sz; i++) {
while (!st.empty() && en[reverse_map[st.top()]] < be[v[i].second])
st.pop();
if (!st.empty()) {
g[st.top()].push_back(c);
}
st.push(c);
reverse_map[c] = v[i].second;
if (m[v[i].second]) im[c] = 1;
c++;
}
ans = 0;
rec(1);
if (ans > n) ans = -1;
cout << ans << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int id[150];
int n;
int a[60], b[60];
bool dp[55][55][55][55];
bool check(int x, int y) { return (a[x] == a[y]) || (b[x] == b[y]); }
bool dfs(int i, int c1, int c2, int c3) {
if (i == 0) return true;
if (i >= 2) {
if (dp[i][c1][c2][c3]) return false;
dp[i][c1][c2][c3] = 1;
}
if (check(c1, c2) && dfs(i - 1, c1, c3, i - 3)) return true;
if (i - 3 >= 0 && check(c1, i - 3) && dfs(i - 1, c2, c3, c1)) return true;
return false;
}
int main() {
id['S'] = 0;
id['D'] = 1;
id['H'] = 2;
id['C'] = 3;
id['2'] = 0;
id['3'] = 1;
id['4'] = 2;
id['5'] = 3;
id['6'] = 4;
id['7'] = 5;
id['8'] = 6;
id['9'] = 7;
id['T'] = 8;
id['J'] = 9;
id['Q'] = 10;
id['K'] = 11;
id['A'] = 12;
scanf("%d", &n);
char str[10];
for (int i = 0; i < n; i++) {
scanf("%s", str);
a[i] = id[str[0]];
b[i] = id[str[1]];
}
if (dfs(n - 1, n - 1, n - 2, n - 3))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 | CPP |
B=[]
while 1:
n,m=map(int,input().split())
if n==0 and m==0:
break
A=list(map(int,input().split()))
A.sort()
max=0
for i in range(n):
if A[i]>m:
break
for j in range(i+1,n):
sum=A[i]+A[j]
if sum>m:
break
elif sum>max:
max=sum
if max==0:
B.append("NONE")
else:
B.append(max)
for b in B:
print(b)
| 0 | PYTHON3 |
t = int(input())
for i in range(t):
s = input()
a=-1
B=-1
c=-1
for j in range(len(s)):
if a==-1 and ('a'<=s[j]<='z'):
a=j
if B==-1 and ('A'<=s[j]<='Z'):
B=j
if c==-1 and ('0'<=s[j]<='9'):
c=j
if a!=-1 and B!=-1 and c!=-1:
break
if a!=-1 and B!=-1 and c!=-1:
print(s)
else:
if a!=-1 and B!=-1:
c = 0 if a!=0 and B!=0 else (1 if a!=1 and B!=1 else 2)
s=s[:c]+'0'+s[c+1:]
print(s)
else:
if a!=-1 and c!=-1:
B = 0 if a!=0 and c!=0 else (1 if a!=1 and c!=1 else 2)
s=s[:B]+'A'+s[B+1:]
print(s)
else:
if B!=-1 and c!=-1:
a = 0 if c!=0 and B!=0 else (1 if c!=1 and B!=1 else 2)
s=s[:a]+'a'+s[a+1:]
print(s)
else:
if a!=-1:
r = 0 if a>1 else(1 if a==0 else 2)
if r==2:
s='1'+s[1]+'A'+s[3:]
else:
s=s[:r]+"1A"+s[r+2:]
print(s)
else:
if B!=-1:
r = 0 if B>1 else(1 if B==0 else 2)
if r==2:
s='1'+s[1]+'a'+s[3:]
else:
s=s[:r]+"1a"+s[r+2:]
print(s)
else:
r = 0 if c>1 else(1 if c==0 else 2)
if r==2:
s='A'+s[1]+'a'+s[3:]
else:
s=s[:r]+"aA"+s[r+2:]
print(s)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5 + 1;
bool flag[mxn + 11];
void init() {
memset(flag, true, sizeof(flag));
for (int i = 2; i <= mxn; i++) {
if (flag[i]) {
for (int j = i + i; j <= mxn; j += i) {
flag[j] = false;
}
}
}
return;
}
int main() {
init();
int n;
scanf("%d", &n);
if (n <= 2)
puts("1");
else
puts("2");
for (int i = 2; i <= n + 1; i++) {
if (flag[i])
printf("1 ");
else
printf("2 ");
}
printf("\n");
return 0;
}
| 8 | CPP |
import os
import sys
from io import BytesIO, IOBase
import math
import itertools
import bisect
import heapq
def main():
pass
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def binary(n):
return (bin(n).replace("0b", ""))
def decimal(s):
return (int(s, 2))
def pow2(n):
p = 0
while (n > 1):
n //= 2
p += 1
return (p)
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
l.append(i)
n = n / i
if n > 2:
l.append(int(n))
return (l)
def isPrime(n):
if (n == 1):
return (False)
else:
root = int(n ** 0.5)
root += 1
for i in range(2, root):
if (n % i == 0):
return (False)
return (True)
def maxPrimeFactors(n):
maxPrime = -1
while n % 2 == 0:
maxPrime = 2
n >>= 1
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
maxPrime = i
n = n / i
if n > 2:
maxPrime = n
return int(maxPrime)
def countcon(s, i):
c = 0
ch = s[i]
for i in range(i, len(s)):
if (s[i] == ch):
c += 1
else:
break
return (c)
def lis(arr):
n = len(arr)
lis = [1] * n
for i in range(1, n):
for j in range(0, i):
if arr[i] > arr[j] and lis[i] < lis[j] + 1:
lis[i] = lis[j] + 1
maximum = 0
for i in range(n):
maximum = max(maximum, lis[i])
return maximum
def isSubSequence(str1, str2):
m = len(str1)
n = len(str2)
j = 0
i = 0
while j < m and i < n:
if str1[j] == str2[i]:
j = j + 1
i = i + 1
return j == m
def maxfac(n):
root = int(n ** 0.5)
for i in range(2, root + 1):
if (n % i == 0):
return (n // i)
return (n)
def p2(n):
c=0
while(n%2==0):
n//=2
c+=1
return c
def seive(n):
primes=[True]*(n+1)
primes[1]=primes[0]=False
for i in range(2,n+1):
if(primes[i]):
for j in range(i+i,n+1,i):
primes[j]=False
p=[]
for i in range(0,n+1):
if(primes[i]):
p.append(i)
return(p)
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def denofactinverse(n,m):
fac=1
for i in range(1,n+1):
fac=(fac*i)%m
return (pow(fac,m-2,m))
def numofact(n,m):
fac = 1
for i in range(1, n + 1):
fac = (fac * i) % m
return(fac)
def chk(val):
temp=[-1]*n
for i in range(0,n):
if(l[i]>=val):
temp[i]=1
pre=[temp[0]]
for i in range(1,n):
pre.append(pre[-1]+temp[i])
mnl=0
#print(pre,temp,val)
if(pre[k-1]>0):
return True
for i in range(k,n):
mnl=min(mnl,pre[i-k])
if((pre[i]-mnl)>0):
return True
return False
n,k=map(int,input().split())
l=list(map(int,input().split()))
f,r=1,n+1
while((r-f)>1):
mid=(r+f)//2
if(chk(mid)):
f=mid
else:
r=mid
print(f) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, p, i, h, m, res, s;
char c;
char str[21];
int main() {
scanf("%d", &n);
gets(str);
p = 1000000000;
for (i = 0; i < n; i++) {
scanf("[%d:%d %c.m.]: ", &h, &m, &c);
gets(str);
h = h % 12;
if (c == 'p') h += 12;
m += 60 * h;
if (m == p)
if (s == 10) {
s = 1;
res++;
} else
s++;
else if (m < p) {
res++;
s = 1;
} else
s = 1;
p = m;
}
printf("%d\n", res);
return 0;
}
| 10 | CPP |
#include<bits/stdc++.h>
using namespace std;
int n, ans;
vector< pair<int, int> > red, blue;
bool comp(pair<int, int> a, pair<int, int> b){
return a.second < b.second;
}
int main(){
cin >> n;
red.resize(n); blue.resize(n);
for(int i = 0; i < n; ++i) cin >> red[i].first >> red[i].second;
for(int i = 0; i < n; ++i) cin >> blue[i].first >> blue[i].second;
sort(blue.begin(), blue.end());
sort(red.begin(), red.end(), comp);
reverse(red.begin(), red.end());
while(blue.size() > 0){
auto bml = blue.begin();
for(auto itr = red.begin(); itr != red.end(); itr++){
if(itr->first < bml->first && itr->second < bml->second){
ans++;
red.erase(itr);
break;
}
}
blue.erase(bml);
}
cout << ans << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MN = 5050;
int maxi[MN][MN];
int mini[MN][MN];
int a[MN];
int main() {
int n, i, j;
scanf("%d", &n);
for ((i) = 0; (i) < (int)(n); ++(i)) scanf("%d", a + i);
for ((i) = 0; (i) < (int)(n); ++(i)) {
for (int j = 1; j < n; ++j) maxi[i][j] = maxi[i][j - 1] + (a[j - 1] > i);
for (int j = n - 2; j >= 0; --j)
mini[i][j] = mini[i][j + 1] + (a[j + 1] < i);
}
int swaps = 0;
for ((i) = 0; (i) < (int)(n); ++(i)) swaps += mini[a[i]][i];
int ans = swaps, ctr = 0;
for ((i) = 0; (i) < (int)(n); ++(i))
for ((j) = 0; (j) < (int)(n); ++(j)) {
if (i >= j || (i < j && a[i] < a[j])) continue;
swaps -= mini[a[i]][i];
swaps -= maxi[a[i]][i];
swaps -= mini[a[j]][j];
swaps -= maxi[a[j]][j];
swaps += mini[a[i]][j];
swaps += maxi[a[i]][j];
swaps += mini[a[j]][i];
swaps += maxi[a[j]][i];
if (swaps + 1 < ans) {
ans = swaps + 1, ctr = 1;
} else if (swaps + 1 == ans)
++ctr;
swaps -= mini[a[i]][j];
swaps -= maxi[a[i]][j];
swaps -= mini[a[j]][i];
swaps -= maxi[a[j]][i];
swaps += mini[a[i]][i];
swaps += maxi[a[i]][i];
swaps += mini[a[j]][j];
swaps += maxi[a[j]][j];
}
printf("%d %d\n", ans, ctr);
return 0;
}
| 9 | CPP |
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
int H,W,N;
cin>>H>>W>>N;
if((N+H-1)/H<(N+W-1)/W)cout<<(N+H-1)/H;
else cout<<(N+W-1)/W;
} | 0 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.