solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
---|---|---|
# vowels = ["a", "o", "y", "e", "u", "i"]
# s = list(input().lower())
# ans = ""
# for i in vowels:
# if i in s:
# while i in s:
# s.remove(i)
# for i in range(len(s)):
# s[i] = "." + s[i]
# print(ans.join(s))
# n = int(input())
# ans = 0
# for i in range(n):
#
# s = input()
# if "-" in s:
# ans -= 1
# if "+" in s:
# ans += 1
#
#
# print(ans)
# s1 = input().lower()
# s2 = input().lower()
# isequal = False
# for i in range(len(s1)):
# if s1[i] > s2[i]:
# print("1")
# isequal = True
# break
# if s2[i] > s1[i]:
# print("-1")
# isequal = True
# break
# if not isequal:
# print("0")
# s = list(input())
# not_dangerous = False
# for i in range(len(s)):
# if i != len(s) - 1:
# j = 0
# while i + j <= len(s) - 1 and s[i] == s[i + j]:
# j += 1
# if j >= 7:
# print("YES")
# not_dangerous = True
# break
# if not not_dangerous:
# print("NO")
# s = list(input())
# ans = ""
# while "+" in s:
# s.remove("+")
# s.sort()
# for i in range(len(s)):
# if i != len(s) - 1:
# ans += s[i] + "+"
# else:
# ans += s[i]
#
# print(ans)
# s = list(input())
# capital_letter = s[0]
# s = s[1:]
# ans = ""
# capital_letter = str(capital_letter).capitalize()
# s = [capital_letter] + s
# print(ans.join(s))
# import math
# matrix = []
# for i in range(5):
# matrix.append(list(map(int, input().split())))
# if 1 in matrix[i]:
# (x, y) = i, matrix[i].index(1)
#
# print(str(int(math.fabs(x - 2) + math.fabs(y - 2))))
# input()
# s = list(input())
# ans = []
# counter = 0
# for i in range(len(s) - 1):
# if s[i] == s[i + 1]:
# counter += 1
# else:
# ans.append(s[i + 1])
#
# print(counter)
# s = set(list(input()))
# print("CHAT WITH HER!" if len(s) % 2 == 0 else "IGNORE HIM!")
# input()
# groups = list(map(int, input().split()))
# group_type = [0, 0, 0, 0]
# ans = 0
# for i in groups:
# group_type[i - 1] += 1
# ans += group_type[-1]
#
# group_type[-1] = 0
#
# ans += min(group_type[0], group_type[2])
#
# if group_type[0] < group_type[2]:
# group_type[2] = group_type[2] - group_type[0]
# group_type[0] = 0
# elif group_type[0] == group_type[2]:
# group_type[0] = 0
# group_type[2] = 0
# else:
# group_type[0] = group_type[0] - group_type[2]
# group_type[2] = 0
#
# ans += group_type[1] // 2
#
# group_type[1] = group_type[1] % 2
#
# if group_type[0]:
# taxi = group_type[1] * 2
# for i in range(group_type[0]):
# if taxi == 4:
# ans += 1
# taxi = 0
# taxi += 1
#
# if taxi:
# ans += 1
# else:
# ans += group_type[2]
# if group_type[1]:
# ans += 1
#
# print(ans)
# n = int(input())
# minimum_capacity = 0
# io_list = []
# io_recorder = 0
# for i in range(n):
# io_list.append(tuple(map(int, input().split())))
# if i == 0:
# minimum_capacity = io_list[0][1]
# io_recorder -= io_list[i][0]
# io_recorder += io_list[i][1]
# if minimum_capacity < io_recorder:
# minimum_capacity = io_recorder
# print(minimum_capacity)
# n, index = map(int, input().split())
# value_list = list(map(int, input().split()))
# solved = False
# pointer = 0
# for i in range(len(value_list) + 1):
# if pointer == index - 1:
# print("YES")
# solved = True
# break
# if pointer < len(value_list):
# pointer += value_list[pointer]
# if not solved:
# print("NO")
# import math
#
# n = int(input())
# list1 = list(map(int, input().split()))
# m = int(input())
# list2 = list(map(int, input().split()))
#
# graph = dict()
#
# for i in list1:
# graph[i] = []
# if n > m:
# n, m = m, n
# list1, list2 = list2, list1
#
# for i in list1:
# for j in list2:
# if math.fabs(i - j) == 1:
# graph[i].append(j)
#
# value_list = sorted(list(graph.values()))
# # while graph:
# for i in value_list:
#
# k, n, w = map(int, input().split())
# cost = 0
# for i in range(w):
# cost += (i + 1) * k
# if cost - n > 0:
# print(cost - n)
# else:print("0")
# n = int(input())
# xi = 0
# yi = 0
# zi = 0
# for i in range(n):
# xyz = list(map(int, input().split()))
# xi += xyz[0]
# yi += xyz[1]
# zi += xyz[2]
# if xi == yi == zi == 0:
# print("YES")
# else:
# print("NO")
import sys
s = input()
print("YES" if "H" in s or "Q" in s or "9" in s else (print("NO"), sys.exit()))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5, MAXQ = 1 << 21, MAXM = 5100000;
int sito[MAXM];
void eratosten() {
for (int i = (2); i < (MAXM); i++)
if (!sito[i])
for (int j = i; j < MAXM; j += i) sito[j] = i;
}
vector<int> Prosti(int x) {
vector<int> R;
for (; x > 1;) {
int pr = sito[x], pot = 0;
for (; sito[x] == pr; x /= sito[x], pot++)
;
if (pot % 2) R.push_back(pr);
}
return R;
}
struct event {
int r, val;
};
vector<event> Ev[MAXN];
int gdje[MAXM][8];
int p[MAXN];
void add_num(int pos) {
vector<int> R = Prosti(p[pos]);
int sz = (int)R.size();
for (int msk = (0); msk < (1 << sz); msk++) {
int umn = 1;
for (int j = (0); j < (sz); j++)
if (msk >> j & 1) umn *= R[j];
gdje[umn][sz - __builtin_popcount(msk)] = pos;
}
}
int n, brq;
void gen_events() {
for (int i = (0); i < (MAXM); i++)
for (int j = (0); j < (8); j++) gdje[i][j] = MAXN - 1;
int mn[20];
for (int i = n - 1; i >= 0; i--) {
for (int j = (0); j < (20); j++) mn[j] = MAXN - 1;
vector<int> R = Prosti(p[i]);
int sz = (int)R.size();
for (int msk = (0); msk < (1 << sz); msk++) {
int umn = 1;
for (int j = (0); j < (sz); j++)
if (msk >> j & 1) umn *= R[j];
for (int ost = (0); ost < (8); ost++) {
int pos = gdje[umn][ost];
int val = ost + sz - __builtin_popcount(msk);
mn[val] = min(mn[val], pos);
}
}
for (int j = (0); j < (20); j++) Ev[i].push_back({mn[j], j});
add_num(i);
}
}
int fen[MAXN];
vector<pair<int, int> > Q[MAXN];
int sol[MAXQ];
void upd(int pos, int val) {
pos++;
for (; pos < MAXN; pos += pos & -pos) fen[pos] = min(fen[pos], val);
}
int get(int pos) {
pos++;
int ret = MAXN;
for (; pos; pos -= pos & -pos) ret = min(ret, fen[pos]);
return ret;
}
void solve() {
for (int i = (0); i < (MAXN); i++) fen[i] = MAXN;
for (int i = n - 1; i >= 0; i--) {
for (auto it : Ev[i]) upd(it.r, it.val);
for (auto q : Q[i]) sol[q.second] = get(q.first);
}
}
int main() {
eratosten();
scanf("%d%d", &n, &brq);
for (int i = (0); i < (n); i++) scanf("%d", &p[i]);
for (int i = (0); i < (brq); i++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
Q[l].push_back(pair<int, int>(r, i));
}
gen_events();
solve();
for (int i = (0); i < (brq); i++) printf("%d\n", sol[i]);
return 0;
}
| 14 | CPP |
n = int(input())
l = list(map(int , input().split()))
l.sort()
n-= 1; s = sum(l); a = 0; ans = 0
while n > -1:
if s < a:
break
a += l[n]; s -= l[n]
ans += 1
n -= 1
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)(1e9 + 7);
long long modpow(long long a, long long b) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2) * (b & 1 ? a : 1) % mod;
}
int vmax, a;
long double distance_travel(long double speed, long double time) {
long double ttm = (vmax - speed) / a;
if (ttm < time)
return speed * ttm + 1.00 / 2 * a * ttm * ttm + vmax * (time - ttm);
return speed * time + 1.00 / 2 * a * time * time;
}
long double time_taken(long double speed, long double distance) {
long double ttm = (vmax - speed) / a;
long double d = distance_travel(speed, ttm);
if (d <= distance)
return ttm + (distance - d) / vmax;
else
return (-speed + sqrt(speed * speed + 2 * a * distance)) / a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> a >> vmax;
double l, d, w;
cin >> l >> d >> w;
double ans = 0;
if (w >= vmax)
ans = time_taken(0, l);
else {
long double ttm = w / a;
long double dist = distance_travel(0, ttm);
if (dist > d)
ans = time_taken(0, l);
else
ans = ttm + 2 * time_taken(w, (d - dist) / 2.00) + time_taken(w, l - d);
}
printf("%.6llf", ans);
return 0;
}
| 10 | CPP |
import sys
input = sys.stdin.readline
############ ---- Input Functions ---- #######Start#####
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return((s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
############ ---- Input Functions ---- #######End#####
def main():
[n, m] = inlt()
hashm = {}
middle = ""
out = ""
for i in range (n):
s = insr()
#print(s)
hashm[s] = 1
r_s=''.join(reversed(s))
if r_s in hashm and r_s!= s:
out = r_s +out + s
if r_s == s and len(r_s) > len(middle):
middle = r_s
if len(middle) != 0:
out = out[0:int(len(out)/2)] + middle + out[int(len(out)/2):len(out)]
print(len(out))
print(out)
return out
if __name__== "__main__":
main() | 8 | PYTHON3 |
#!/usr/bin/python3.4
n,m,a = map(int, input().split())
a1 = int(n/a)
if n%a > 0:
a1 = a1 + 1
a2 = int(m/a)
if m%a > 0:
a2 = a2 + 1
print(a1*a2)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, m, ans = 0, i;
cin >> n >> m;
for (i = 2; ans < m; i++) ans = (i * (i - 1)) / 2;
i = i - 2;
ans = (i * (i - 1)) / 2;
if (ans != m) {
for (int j = 1; j <= n; j++) {
if (j == (n - (m - ans) + 1))
cout << 'b';
else if (j == n - i)
cout << 'b';
else
cout << 'a';
}
}
cout << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct cell {
int v;
long long val;
cell() {}
cell(int v, long long val) : v(v), val(val) {}
};
bool operator<(cell a, cell b) {
if (a.val == b.val) return a.v < b.v;
return a.val < b.val;
}
int t, lead[100010], sec[100010];
bool vis[100010];
long long sum[100010];
vector<int> adj[100010], cost[100010];
set<cell> myset;
set<cell>::iterator it;
void dfs(int u) {
vis[u] = true;
if (u != lead[t]) sec[t] = u;
for (int i = 0; i < int(adj[u].size()); i++) {
int v = adj[u][i], w = cost[u][i];
sum[t] += w;
if (!vis[v]) dfs(v);
}
return;
}
int main() {
int n, m, p, q, s, a, b, h = -1;
int v1, v2;
long long sa, sb, len;
scanf("%d%d%d%d", &n, &m, &p, &q);
while (m--) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
adj[u].push_back(v);
cost[u].push_back(w);
adj[v].push_back(u);
cost[v].push_back(w);
}
t = 0;
for (int i = 0; i < n; i++)
if (!vis[i]) {
lead[t] = i;
sec[t] = -1;
sum[t] = 0LL;
dfs(i);
sum[t] /= 2LL;
if (sec[t] != -1) h = t;
t++;
}
if (q > t)
printf("NO\n");
else if (q == t) {
if (!p)
printf("YES\n");
else {
if (h == -1)
printf("NO\n");
else {
printf("YES\n");
while (p--) printf("%d %d\n", lead[h] + 1, sec[h] + 1);
}
}
} else {
s = t - q;
if (s > p)
printf("NO\n");
else {
for (int i = 0; i < t; i++) myset.insert(cell(lead[i], sum[i]));
printf("YES\n");
for (int i = 0; i < s; i++) {
it = myset.begin();
a = it->v;
sa = it->val;
myset.erase(it);
it = myset.begin();
b = it->v;
sb = it->val;
myset.erase(it);
printf("%d %d\n", a + 1, b + 1);
len = min(1000000000LL, sa + sb + 1LL);
myset.insert(cell(a, sa + sb + len));
v1 = a;
v2 = b;
}
p -= s;
if (h != -1) {
while (p--) printf("%d %d\n", lead[h] + 1, sec[h] + 1);
} else {
while (p--) printf("%d %d\n", v1 + 1, v2 + 1);
}
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <long long sz>
using tut = array<long long, sz>;
const long long N = (1 << 17) + 5;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const long double Pi = acos(-1);
void add(long long& a, long long b) { a = (a + b) % mod; }
void sub(long long& a, long long b) { a = ((a - b) % mod + mod) % mod; }
void mul(long long& a, long long b) { a = (a * 1ll * b) % mod; }
long long n, m, k, t, q, ans, res, a[N];
long long dp[4 * N][2][2], used[N];
long long rec(long long l, long long r, long long u, long long d, long long x) {
long long& res = dp[x][u][d];
if (res != -1) return res;
if (l + 1 == r - 1) {
if (u + d != used[l] + used[l + 1])
res = -2;
else
res = (used[l] | used[l + 1]);
return res;
}
res = -2;
long long m = (l + r) >> 1;
for (long long ulx = 0; ulx < 2; ulx++) {
for (long long dlx = 0; dlx < 2; dlx++) {
for (long long urx = 0; urx < 2; urx++) {
for (long long drx = 0; drx < 2; drx++) {
long long lx = rec(l, m, ulx, dlx, x << 1),
rx = rec(m, r, urx, drx, x << 1 | 1);
if (lx == -2 || rx == -2) continue;
if ((ulx == u || urx == u) && (dlx == d || drx == d)) {
long long add = 0;
if (ulx == u) {
if (dlx == d) umax(add, (dlx | urx));
if (drx == d) umax(add, (drx | urx));
}
if (urx == u) {
if (dlx == d) umax(add, (dlx | ulx));
if (drx == d) umax(add, (drx | ulx));
}
umax(res, lx + rx + (ulx | urx) + (dlx | drx) + add);
}
if (ulx == u && (urx == d))
umax(res, lx + rx + (ulx | urx) + (dlx | drx) + (urx | dlx | drx));
if (urx == u && (ulx == d))
umax(res, lx + rx + (ulx | urx) + (dlx | drx) + (ulx | dlx | drx));
}
}
}
}
return res;
}
void solve(long long t_case) {
memset(dp, -1, sizeof dp);
cin >> n >> k;
for (long long i = 1; i <= k; i++) {
long long x;
cin >> x;
used[--x]++;
}
for (long long i = 0; i < 2; i++)
for (long long j = 0; j < 2; j++)
umax(res, rec(0, (1 << n), i, j, 1) + (i | j));
cout << res << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (0) {
long long t;
cin >> t;
for (long long t_case = 1; t_case <= t; t_case++) solve(t_case);
} else
solve(1);
return 0;
}
| 11 | CPP |
n, m = map(int, input().split())
total = (n - 1) + (m - 1) + 1
print(total)
print("1 1")
for i in range(n - 1):
print(i + 2, end=' ')
print(1)
for i in range(m - 1):
print(1, end= ' ')
print(i + 2) | 7 | PYTHON3 |
n, a, b, c, d = map(int, input().split())
def getResult(n, a, b, c, d):
count = 0
for i in range(n):
if (i + 1) + b - c <= n and (i + 1) + b - c > 0:
if (i + 1) + a + b - d - c <= n and (i + 1) + a + b - d - c > 0:
if (i + 1) + a - d <= n and (i + 1) + a - d > 0:
count += 1
#print(i + 1, ",", b, ",", (i + 1) + b - c )
#print(d, ",", 8, ",",c )
#print((i + 1) + a - d, ",", d, ",", (i + 1) + a + b - d - c)
#print()
print(count * n)
getResult(n, a, b, c, d)
| 8 | PYTHON3 |
class CodeforcesTask675BSolution:
def __init__(self):
self.result = ''
self.n_a_b_c_d = []
def read_input(self):
self.n_a_b_c_d = [int(x) for x in input().split(" ")]
def process_task(self):
result = 0
for x in range(1, self.n_a_b_c_d[0] + 1):
y = self.n_a_b_c_d[2] - self.n_a_b_c_d[3] + x
w = self.n_a_b_c_d[1] - self.n_a_b_c_d[4] + x
q = self.n_a_b_c_d[2] - self.n_a_b_c_d[3] + w
if 1 <= y <= self.n_a_b_c_d[0] and 1 <= w <= self.n_a_b_c_d[0] and 1 <= q <= self.n_a_b_c_d[0]:
result += 1
#print(x, y, w, q)
self.result = str(result * (self.n_a_b_c_d[0]))
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask675BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 3e5 + 5;
int n, m, l, r, x, mp[sz], ans[sz];
set<int> st;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) st.insert(i);
memset(ans, 0, sizeof ans);
while (m--) {
cin >> l >> r >> x;
auto it = st.lower_bound(l);
v.clear();
while (it != st.end() && *it <= r) {
if (*it != x) {
ans[*it] = x;
v.push_back(*it);
}
it++;
}
for (auto i : v) st.erase(i);
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
string s;
cin>>s;
int fst=0,scnd=1;
set<char>st;
for(int i=0;i<s.size();++i)
{
st.insert(s[i]);
}
// cout<<s<<endl;
// cout<<((int)(*(max_element(s.begin(),s.end())))-97)<<endl;
if((((int)(*(max_element(s.begin(),s.end())))-96)==st.size())&&(st.size()==s.size()))
{
fst=1;
}
// for(auto i=st.begin();i!=st.end();++i)
// {
// cout<<*(i)<<" ";
// }
// cout<<endl;
// cout<<fst<<endl;
if(fst==1)
{
int p=s.find('a');
for(int i=p;i<s.size()-1;++i)
{
if(s[i]>s[i+1])
{
scnd=0;break;
}
}
for(int i=p;i>0;i--)
{
if(s[i]>s[i-1])
{
scnd=0;break;
}
}
}
if(fst==1&&scnd==1)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
} | 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<int, int>, int> > edge;
vector<pair<int, int> > g[5005];
long long dp[5005], cnt[5005];
long long dfs1(int u, int p) {
dp[u] = 0;
cnt[u] = 1;
long long ans = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, w = g[u][i].second;
if (v == p) continue;
ans += dfs1(v, u);
ans += dp[v] * cnt[u] + w * cnt[u] * cnt[v] + dp[u] * cnt[v];
dp[u] += dp[v] + cnt[v] * w;
cnt[u] += cnt[v];
}
return ans;
}
long long dfs2(int u, int p, int w, int n) {
if (w != -1)
dp[u] = (dp[u] + (dp[p] - dp[u] - cnt[u] * w) + w * (n - cnt[u]));
long long ans = dp[u];
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, w = g[u][i].second;
if (v == p) continue;
ans = min(ans, dfs2(v, u, w, n));
}
return ans;
}
int main() {
int n, a, b, c;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(pair<int, int>(b, c));
g[b].push_back(pair<int, int>(a, c));
edge.push_back(pair<pair<int, int>, int>(pair<int, int>(a, b), c));
}
long long ans = 1e18;
for (int i = 0; i < edge.size(); i++) {
int a = edge[i].first.first, b = edge[i].first.second, c = edge[i].second;
long long res = 0;
res += dfs1(a, b);
res += dfs1(b, a);
res += dfs2(a, b, -1, cnt[a]) * cnt[b] + dfs2(b, a, -1, cnt[b]) * cnt[a] +
cnt[a] * cnt[b] * c;
ans = min(ans, res);
}
printf("%lld\n", ans);
}
| 11 | CPP |
n = int(input())
print(2 * (n // 3) + int(n % 3 != 0)) | 7 | PYTHON3 |
c = t = 0
for _ in range(int(input())):
x, y = input().split()
if x==y:
c+=1
else:
c = 0
t = max(t,c)
if t>=3: print('Yes')
else: print('No')
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T;
cin >> T;
while (T--) {
long long N, R;
cin >> N >> R;
if (N <= R)
cout << (N * (N - 1)) / 2 + 1 << "\n";
else
cout << (R * (R + 1)) / 2 << "\n";
}
}
| 8 | CPP |
n=int(input())
s=input()
j=0
i=1
while j<n:
print(s[j],end='')
j+=i
i+=1 | 7 | PYTHON3 |
from random import getrandbits as R
rb=lambda:R(1)
def modu(p,q):
if len(q)==1:
return [0]
p=p[:]
for d in range(len(p)-1,len(q)-2,-1):
#print(d)
a = p.pop()
b = q[-1]
B = [-k*a/b for k in q[:-1]]
#print(B)
for i in range(len(B)):
p[i+1+len(p)-1-(len(q)-1)] += B[i]
while len(p)>1 and abs(p[-1])<1E-6:
p.pop()
return p
def gcd(p,q):
#print(p,q)
if len(q)==1 and abs(q[0])<1E-6:
return p,1
#if len(q)<=1:
# return q,1
else:
p,iters = gcd(q,modu(p,q))
return p,iters+1
#p,iters = gcd([5,3,2],[-10,1])
#print(p,iters)
#q,iters = gcd([2,5,4,1],[3,4,1])
#print(q,iters)
for n in [int(input())]:#range(150,0,-1):
while True:
p = [1]*(n+1)
q = [1]*(n)
for i in range(n):
p[i]=rb()
for i in range(n-1):
q[i]=rb()
Q,iters = gcd(p,q)
if iters<n+1:
continue
#print(Q,iters)
print(len(p)-1)
print(*p)
print(len(q)-1)
print(*q)
break
| 8 | PYTHON3 |
N = int(input())
res = 0
while N > 0:
x,u = input().split()
res += float(x) if u == 'JPY' else float(x)*380000
N -= 1
print(res) | 0 | PYTHON3 |
n = int(input())
for _ in range(n):
c = int(input())
nums = list(map(int, input().split()))
numSet = set()
removeSet = set()
for num in nums:
if num not in numSet:
if num not in removeSet:
numSet.add(num)
else:
numSet.remove(num)
removeSet.add(num)
if numSet:
minNum = min(numSet)
for i in range(len(nums)):
if nums[i] == minNum:
print(i + 1)
break
else:
print(-1) | 8 | PYTHON3 |
n,m=map(int,input().split())
inp=list(map(int,input().split()))
inp.sort()
pos=1
for i in inp[0:n-1]:
if(pos==inp[n-1]):
break
elif(i>=pos):
pos+=1
print(sum(inp)-(n-1)-(inp[n-1]-pos+1)) | 8 | PYTHON3 |
n = int(input())
xs = [int(x) for x in input().split()]
M = 10**9 + 7
r = 0
for i in range(61):
k = 0
for x in xs:
k += (x >> i) % 2
r = (r + ((n-k) * k % M) * pow(2, i) )% M
print(r)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin >> n;
map<char, long long> s;
for(int i = 0; i < n; ++i){
string tmp;
cin >> tmp;
s[tmp[0]]++;
}
long long ans = 0;
string ma = "MARCH";
for(int i = 0; i < 5; ++i){
for(int j = i+1; j < 5; ++j){
for(int k = j+1; k < 5; ++k){
ans += s[ma[i]]*s[ma[j]]*s[ma[k]];
}
}
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
p, x, y, n, t = [], 0, 0, int(input()), list(map(int, input().split()))
for i in range(n):
if t[i] < 0: x += 1
if x == 3:
p.append(i - y)
x = 1
y = i
p.append(n - y)
print(len(p))
print(' '.join(str(i) for i in p)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
vector<int> g[maxn];
int a[maxn];
bool visited[maxn];
int tot = 0, cur = 0;
unordered_map<int, int> h;
void dfs(int i, int p) {
if (visited[i] == false) {
tot++;
h[a[i]]++;
if (h[a[i]] > cur) {
cur = h[a[i]];
}
visited[i] = true;
int si = g[i].size();
for (int j = 0; j < si; j++) {
if (visited[g[i][j]] == false && g[i][j] != p) {
dfs(g[i][j], i);
}
}
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
visited[i] = false;
}
int l, r;
for (int i = 0; i < m; i++) {
cin >> l >> r;
g[l].push_back(r);
g[r].push_back(l);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
h.clear();
tot = 0, cur = 0;
dfs(i, -1);
ans += (tot - cur);
}
}
cout << ans << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int pre[400005], to[400005], las[400005], inc;
int fa[400005][21], jmp[400005][21], dep[400005], dfn[400005], out[400005], dft;
int n, m, q, ans[400005];
void ins(int a, int b) {
pre[++inc] = las[a];
las[a] = inc, to[inc] = b;
}
void dfs(int x, int par) {
fa[x][0] = par, dfn[x] = ++dft, dep[x] = dep[par] + 1;
for (int i = 1; i <= 20; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = las[x]; i; i = pre[i])
if (to[i] != par) dfs(to[i], x);
out[x] = dft;
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20, delta = dep[x] - dep[y]; i >= 0; i--)
if (delta >> i & 1) x = fa[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
void GetJmp1(int x) {
for (int i = las[x]; i; i = pre[i]) {
int y = to[i];
GetJmp1(y);
if (!jmp[x][0] || (dep[jmp[x][0]] > dep[jmp[y][0]] && jmp[y][0]))
jmp[x][0] = jmp[y][0];
}
}
void GetJmp2(int x) {
for (int i = 1; i <= 20; i++) jmp[x][i] = jmp[jmp[x][i - 1]][i - 1];
for (int i = las[x]; i; i = pre[i]) GetJmp2(to[i]);
}
int C[400005];
void Add(int x, int v) {
for (int i = x; i < 400005; i += (i & -i)) C[i] += v;
}
int Query(int x) {
int ret = 0;
for (int i = x; i; i ^= (i & -i)) ret += C[i];
return ret;
}
struct node {
int x, l, r, ty, id;
} op[400005 * 4];
int tot, sm[400005 * 4];
int cmp(node a, node b) { return a.x == b.x ? a.ty < b.ty : a.x < b.x; }
int main() {
scanf("%d", &n);
for (int i = 2, x; i <= n; i++) scanf("%d", &x), ins(x, i);
dfs(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y, anc;
scanf("%d%d", &x, &y), anc = LCA(x, y);
if (!jmp[x][0] || dep[jmp[x][0]] > dep[anc]) jmp[x][0] = anc;
if (!jmp[y][0] || dep[jmp[y][0]] > dep[anc]) jmp[y][0] = anc;
op[++tot] = (node){dfn[x], dfn[y], 0, 0, 0};
op[++tot] = (node){dfn[y], dfn[x], 0, 0, 0};
}
GetJmp1(1), GetJmp2(1);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int x, y, anc;
scanf("%d%d", &x, &y), anc = LCA(x, y);
if (anc == x || anc == y) {
int p = (anc == x ? y : x);
for (int j = 20; j >= 0; j--)
if (jmp[p][j] && dep[jmp[p][j]] > dep[anc])
p = jmp[p][j], ans[i] += (1 << j);
if (!jmp[p][0] || dep[jmp[p][0]] > dep[anc]) ans[i] = -1;
} else {
for (int j = 20; j >= 0; j--)
if (jmp[x][j] && dep[jmp[x][j]] > dep[anc])
x = jmp[x][j], ans[i] += (1 << j);
for (int j = 20; j >= 0; j--)
if (jmp[y][j] && dep[jmp[y][j]] > dep[anc])
y = jmp[y][j], ans[i] += (1 << j);
ans[i]++;
if (!jmp[x][0] || !jmp[y][0] || dep[jmp[x][0]] > dep[anc] ||
dep[jmp[y][0]] > dep[anc])
ans[i] = -1;
op[++tot] = (node){dfn[x], dfn[y], out[y], -1, i},
op[++tot] = (node){out[x], dfn[y], out[y], 1, i};
}
}
sort(op + 1, op + tot + 1, cmp);
for (int i = 1; i <= tot; i++) {
if (op[i].ty == -1) sm[op[i].id] = Query(op[i].r) - Query(op[i].l - 1);
if (op[i].ty == 0) Add(op[i].l, 1);
if (op[i].ty == 1)
sm[op[i].id] = Query(op[i].r) - Query(op[i].l - 1) - sm[op[i].id];
}
for (int i = 1; i <= q; i++) {
if (ans[i] == -1)
printf("-1\n");
else
printf("%d\n", ans[i] - (sm[i] > 0) + 1);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], p = -1, q = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0)
b[i] = 1;
else
b[i] = -1;
}
int max = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += b[i];
if (sum > max) {
max = sum;
p = p == -1 ? i : p;
q = i;
}
if (sum < 0) {
sum = 0;
p = q = -1;
}
}
if (p == -1 and max == 0) max -= 1;
for (int i = 0; i < n; i++) {
if (a[i] == 1) max += 1;
}
cout << max << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int seed = 131;
const long long LLMAX = 2e18;
const int MOD = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 1e6 + 10;
const int hmod1 = 0x48E2DCE7;
const int hmod2 = 0x60000005;
inline long long sqr(long long x) { return x * x; }
inline int sqr(int x) { return x * x; }
inline double sqr(double x) { return x * x; }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long d;
(b == 0 ? (x = 1, y = 0, d = a)
: (d = exgcd(b, a % b, y, x), y -= a / b * x));
return d;
}
long long qpow(long long a, long long n) {
long long sum = 1;
while (n) {
if (n & 1) sum = sum * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return sum;
}
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return (x > 0 ? 1 : -1);
}
int a[] = {0, 2, 3, 1};
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
for (int i = 0; i <= 60; i += 2) {
if ((1ll << i) <= n && n <= (1ll << (i + 2)) - 1) {
long long b = (1ll << i) * 2, f, x;
n -= (1ll << i), f = n % 3, n /= 3, x = (1ll << i) + n;
if (f == 0)
cout << (1ll << i) + n << endl;
else {
long long bit = (1ll << i) / 4;
while (n) {
b = b + bit * a[n / bit];
n %= bit;
bit >>= 2;
}
if (f == 1)
cout << b << endl;
else
cout << (x ^ b) << endl;
}
break;
}
}
}
return 0;
}
| 11 | CPP |
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
typedef pair<double, int> p;
p a[9], b[9], c[9], d[20];
for (int i = 0; i < 8; i++)cin >> a[i].second >> a[i].first;
for (int i = 0; i < 8; i++)cin >> b[i].second >> b[i].first;
for (int i = 0; i < 8; i++)cin >> c[i].second >> c[i].first;
sort(a, a + 8); sort(b, b + 8); sort(c, c + 8);
int k = 0;
for (int i = 2; i < 4; i++) {
d[k] = a[i]; k++;
d[k] = b[i]; k++;
d[k] = c[i]; k++;
}
sort(d, d + 6);
cout << a[0].second << ' ' << a[0].first << endl;
cout << a[1].second << ' ' << a[1].first << endl;
cout << b[0].second << ' ' << b[0].first << endl;
cout << b[1].second << ' ' << b[1].first << endl;
cout << c[0].second << ' ' << c[0].first << endl;
cout << c[1].second << ' ' << c[1].first << endl;
cout << d[0].second << ' ' << d[0].first << endl;
cout << d[1].second << ' ' << d[1].first << endl;
char ch; cin >> ch;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double INF = 1e6, EPS = 1e-10;
int x11, y11, v1, x, y, v, r;
long double R;
bool equal(long double a, long double b) { return (fabsl(a - b) < EPS); }
bool les(long double a, long double b) { return (b - a > EPS); }
bool mor(long double a, long double b) { return (a - b > EPS); }
struct point {
long double x, y;
point() : x(0), y(0) {}
point(long double a, long double b) : x(a), y(b) {}
point(point a, point b) : x(b.x - a.x), y(b.y - a.y) {}
long double len() { return (sqrtl(x * x + y * y)); }
};
long double dot(point a, point b) { return (a.x * b.x + a.y * b.y); }
long double cross(point a, point b) { return (a.x * b.y - a.y * b.x); }
bool ok(long double t) {
long double phi = v1 * t / R, x2 = x11 * cosl(phi) - y11 * sinl(phi),
y2 = x11 * sinl(phi) + y11 * cosl(phi);
point a(x2, y2), b(x, y), o(0, 0), ao(a, o), ab(a, b), ba(b, a), bo(b, o);
long double sq = fabsl(cross(ao, bo));
if (mor(dot(ao, ab), 0) && mor(dot(bo, ba), 0) && les(sq / ab.len(), r)) {
long double aob = fabsl(atan2l(cross(ao, bo), dot(ao, bo))),
alp = fabsl(acosl(r / ao.len())),
bet = fabsl(acosl(r / bo.len())), gam = aob - alp - bet,
c = gam * r, cao1 = sqrtl(ao.len() * ao.len() - r * r),
cbo1 = sqrtl(bo.len() * bo.len() - r * r);
return (mor(v * t, c + cao1 + cbo1));
}
return (mor(v * t, ab.len()));
}
int main() {
cin >> x11 >> y11 >> v1 >> x >> y >> v >> r;
R = sqrtl(x11 * x11 + y11 * y11);
long double lef = 0, rig = INF;
for (int i = 0; i < 100; i++) {
long double mid = (lef + rig) / 2;
if (ok(mid)) {
rig = mid;
} else {
lef = mid;
}
}
cout.setf(ios::fixed);
cout.precision(20);
cout << rig << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000001;
int A[4][4];
int B[4][4];
long long int vis[4][4];
long long int vis2[4][4];
long long int vis3[4][4];
int Win(int a, int b) {
if (a == 3 && b == 2) return 1;
if (a == 2 && b == 1) return 1;
if (a == 1 && b == 3) return 1;
if (a == 2 && b == 3) return 2;
if (a == 1 && b == 2) return 2;
if (a == 3 && b == 1) return 2;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int k;
int a, b;
cin >> k >> a >> b;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) cin >> A[i + 1][j + 1];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) cin >> B[i + 1][j + 1];
long long int cont = 1;
long long int uno = 0, dos = 0;
while (k > 0) {
if (vis[a][b]) {
long long int more = k / (cont - vis[a][b]);
long long int one = uno - vis2[a][b];
long long int two = dos - vis3[a][b];
uno += more * one;
dos += more * two;
k -= more * (cont - vis[a][b]);
break;
}
vis[a][b] = cont++;
vis2[a][b] = uno;
vis3[a][b] = dos;
int result = Win(a, b);
if (result == 1)
uno++;
else if (result == 2)
dos++;
int aux = a;
a = A[a][b];
b = B[aux][b];
k--;
}
while (k > 0) {
int result = Win(a, b);
if (result == 1)
uno++;
else if (result == 2)
dos++;
int aux = a;
a = A[a][b];
b = B[aux][b];
k--;
}
cout << uno << " " << dos << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1;
int dp1[maxn];
int dp2[maxn];
int dp3[maxn];
vector<int> v[maxn];
void dfs1(int x, int y) {
for (int i = 0; i < v[x].size(); ++i) {
int tmp = v[x][i];
if (tmp != y) {
dfs1(tmp, x);
if (dp1[tmp] != -1 && dp1[tmp] + 1 >= dp1[x]) {
dp2[x] = dp1[x];
dp1[x] = dp1[tmp] + 1;
} else if (dp1[tmp] != -1 && dp1[tmp] + 1 > dp2[x])
dp2[x] = dp1[tmp] + 1;
}
}
}
void dfs2(int x, int y) {
for (int i = 0; i < v[x].size(); ++i) {
int tmp = v[x][i];
if (tmp != y) {
if (dp1[x] == dp1[tmp] + 1) {
int tmp2 = max(dp3[x], dp2[x]) + 1;
if (tmp2 > 0) dp3[tmp] = tmp2;
} else {
int tmp3 = max(dp3[x], dp1[x]) + 1;
if (tmp3 > 0) dp3[tmp] = tmp3;
}
dfs2(tmp, x);
}
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
memset(dp1, -1, sizeof dp1);
memset(dp2, -1, sizeof dp2);
memset(dp3, -1, sizeof dp3);
for (int i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
dp1[x] = dp3[x] = 0;
}
for (int i = 1; i < n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs1(1, -1);
dfs2(1, -1);
int ans = 0;
for (int i = 1; i <= n; ++i)
if (dp3[i] <= k && dp1[i] <= k) ++ans;
printf("%d\n", ans);
}
| 8 | CPP |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int N;
cin >> N;
int tmp = sqrt(N);
cout << tmp*tmp << endl;
} | 0 | CPP |
t=int(input())
for i in range(t):
p=input()
h=input()
l=list(p)
l.sort()
ans=""
if len(p)==len(h):
l2=list(h)
l2.sort()
if l==l2:
ans="YES"
for i in range(len(h)-len(p)+1):
l2=list(h[i:i+len(p)])
l2.sort()
if l==l2:
ans="YES"
if(ans!="YES"):
ans="NO"
print(ans) | 7 | PYTHON3 |
def start(loop):
result = []
result_value = 1
for i in range(int(loop)):
result.append(input())
if i >= 1 :
if result[i] != result[i-1]:
result_value += 1
return result_value
if __name__ == "__main__":
print(start(input())) | 7 | PYTHON3 |
guest=input()
residence=input()
letters=input()
result=guest+residence
result=list(result)
letters=list(letters)
result.sort()
letters.sort()
if result==letters:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, w, h, m, max_height = INT_MIN, landing;
cin >> n;
vector<long long> stairs(n, 0);
for (i = 0; i < n; i++) {
cin >> stairs[i];
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> w >> h;
landing = (stairs[w - 1] > max_height) ? stairs[w - 1] : max_height;
cout << landing << endl;
max_height = landing + h;
}
return 0;
}
| 9 | CPP |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 5
0 0 1
0 1 2
0 2 3
1 0 2
1 1 2
output:
1
2
"""
import sys
from math import ceil, log2, isinf
class SegmentTree(object):
__slots__ = ('dat', 'tree_range')
def __init__(self):
"""
Init a SegmentTree with update and find for RMQ.
"""
self.tree_range = end
self.dat = [float('inf')] * (2 * self.tree_range - 1)
# let A[k]=a
def update(self, k, a):
k += self.tree_range - 1
self.dat[k] = a
while k > 0:
k = (k - 1) // 2
self.dat[k] = min(self.dat[k * 2 + 1], self.dat[k * 2 + 2])
# get min(A[s] A[s+1] ... A[t])
def find(self, s, t, k=0, l=0, r=0):
if r <= s or t <= l:
return float('inf')
if s <= l and r <= t:
return self.dat[k]
else:
vl = self.find(s, t, k * 2 + 1, l, (l + r) // 2)
vr = self.find(s, t, k * 2 + 2, (l + r) // 2, r)
return min(vl, vr)
def action(cmd_list):
for query in cmd_list:
cmd, ele_1, ele_2 = map(int, query)
if cmd == 0:
case.update(ele_1, ele_2)
elif cmd == 1:
res = case.find(s=ele_1, t=ele_2 + 1, r=end)
if isinf(res):
print(INIT_MAX)
else:
print(res)
return case
if __name__ == '__main__':
_input = sys.stdin.readlines()
n_num, q_num = map(int, _input[0].split())
q_list = map(lambda x: x.split(), _input[1:])
end = pow(2, ceil(log2(n_num)))
INIT_MAX = pow(2, 31) - 1
case = SegmentTree()
ans = action(q_list) | 0 | PYTHON3 |
n = int(input())
s = input()
for i in range(1,n+1):
if n%i == 0:
s = s[0:i][::-1]+s[i:]
print(s)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N,M;
string S;
ll mo=1000000007;
ll dp[3030][3030];
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N>>M>>S;
int CR=0,CL=0;
int B[2]={};
dp[0][0]=1;
while(M--) {
int L,R;
cin>>L>>R;
L--,R--;
while(CL<L) {
if(CL==CR) B[S[CR++]=='1']++;
FOR(i,3001) if(dp[CL][i]) {
if(i<B[0]) (dp[CL+1][i+1]+=dp[CL][i])%=mo;
if(CL-i<B[1]) (dp[CL+1][i]+=dp[CL][i])%=mo;
}
CL++;
}
while(CR<=R) B[S[CR++]=='1']++;
}
while(CL<N) {
if(CL==CR) B[S[CR++]=='1']++;
FOR(i,3001) if(dp[CL][i]) {
if(i<B[0]) (dp[CL+1][i+1]+=dp[CL][i])%=mo;
if(CL-i<B[1]) (dp[CL+1][i]+=dp[CL][i])%=mo;
}
CL++;
}
cout<<dp[CL][B[0]]<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n';
FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
solve(); return 0;
}
| 0 | CPP |
n=int(input())
num=input().split()
i=0
num=list(map(int,num))
num.sort()
d=abs(num[0]-num[1])
i=1
j=2
k=1
while j<n:
if abs(num[i]-num[j])<d:
k=1
d=abs(num[i]-num[j])
elif abs(num[i]-num[j])==d:
k=k+1
i=i+1
j=j+1
print(d,k)
| 7 | PYTHON3 |
n = int(input())
counter = 0
for i in range(0, n):
# read input
n_solvers = 0
line = [int(x) for x in input().split()]
for member in line:
if member == 1:
n_solvers = n_solvers + 1
if n_solvers > 1:
counter = counter + 1
break
print(counter) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, temp, cnt = 0;
cin >> a >> b;
while (a > 0 && b > 0) {
if (a >= b) {
cnt += a / b;
a = a % b;
} else {
cnt += b / a;
b = b % a;
}
}
cout << cnt << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
void put(int x) {
if (x < 0) {
putchar('-');
x *= -1;
}
if (x == 0) {
putchar('0');
}
int num = 0;
char c[15];
while (x) {
c[++num] = (x % 10) + 48;
x /= 10;
}
while (num) {
putchar(c[num--]);
}
putchar('\n');
}
inline void in(int &x) {
char ch = getchar();
int flag = 1;
while (!(ch >= '0' && ch <= '9')) {
if (ch == '-') flag *= -1;
ch = getchar();
}
x = ch - '0';
ch = getchar();
while (ch >= '0' && ch <= '9') {
x = ((x << 3) + (x << 1)) + ch - '0';
ch = getchar();
}
x *= flag;
}
string s1, s2;
int sum1, sum2;
int work(char a, char b) {
if (a == '8' && b == '<') return 1;
if (a == '(' && b == ')') return 2;
if (a == '[' && b == ']') return 3;
}
int main() {
cin >> s1 >> s2;
for (int i = 0; i < s1.size(); i += 2) {
int k1 = work(s1[i], s1[i + 1]), k2 = work(s2[i], s2[i + 1]);
if ((k1 == 1 && k2 == 2) || (k1 == 2 && k2 == 3) || (k1 == 3 && k2 == 1))
sum2++;
else if (k1 == k2)
continue;
else
sum1++;
}
if (sum1 > sum2) printf("TEAM 1 WINS\n");
if (sum1 == sum2) printf("TIE\n");
if (sum1 < sum2) printf("TEAM 2 WINS\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, int> a[2005];
pair<long long int, int> b[2005];
int main() {
long long int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i] = make_pair((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y), i);
b[i] = make_pair((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y), i);
}
sort(a, a + n);
sort(b, b + n);
long long int m = 1e17;
for (int i = 0; i < n + 1; i++) {
set<int> s;
long long int r1 = 0, r2 = 0;
if (i < n) {
for (int j = 0; j <= i; j++) {
s.insert(a[j].second);
;
}
} else
r1 = 0;
if ((int)(s.size()) == n) {
r1 = a[i].first;
m = min(r1, m);
}
for (int j = 0; j < n; j++) {
;
s.insert(b[j].second);
if ((int)(s.size()) == n) {
r1 = a[i].first;
r2 = b[j].first;
m = min(r1 + r2, m);
break;
}
}
}
cout << m << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s1[10], s2[10];
int n, x[200005], ee, f1[10], f2[10],
Cnt = 1, tot, sy, y[200005], M[10], dis[500], cnt, g[10], t, p[10][10],
c[10][10], to[500], node[500], val[500], nxt[500], cur[500];
queue<int> q;
void ADD(int x, int y, int v) {
to[++Cnt] = y;
nxt[Cnt] = node[x];
node[x] = Cnt;
val[Cnt] = v;
}
void add(int x, int y, int v) { ADD(x, y, v), ADD(y, x, 0); }
bool bfs() {
memset(dis, -1, sizeof(dis));
q.push(0);
dis[0] = 0;
int x, i;
while (q.size()) {
x = q.front();
q.pop();
for (i = node[x]; i; i = nxt[i]) {
if (val[i] && !~dis[to[i]]) {
dis[to[i]] = dis[x] + 1, q.push(to[i]);
}
}
}
return ~dis[t];
}
int dfs(int now, int flow) {
if (now == t) return flow;
int fl = 0, qwq;
for (int &i = cur[now]; i; i = nxt[i]) {
if (val[i] && dis[to[i]] == dis[now] + 1) {
qwq = dfs(to[i], min(flow, val[i]));
flow -= qwq;
fl += qwq;
val[i] -= qwq;
val[i ^ 1] += qwq;
if (!flow) break;
}
}
return fl;
}
int dinic() {
int ret = 0;
while (bfs()) memcpy(cur, node, sizeof(cur)), ret += dfs(0, 200005);
return ret;
}
int i, l1, l2, j, k;
int main() {
scanf("%d", &n);
g[1] = 1;
g[2] = 10;
g[3] = 100;
g[4] = 1000;
g[5] = 10000;
g[6] = 100000;
g[7] = 1000000;
for (i = 1; i <= 6; ++i) M[i] = min(n, g[i + 1] - 1) - min(n, g[i] - 1);
for (i = 1; i < n; ++i) {
scanf("%s%s", s1, s2);
l1 = strlen(s1);
l2 = strlen(s2);
if (l1 > l2) swap(l1, l2);
++c[l1][l2];
}
for (i = 1; i <= 6; ++i) {
if (M[i] && c[i][i] >= M[i]) return cout << "-1", 0;
if (c[i][i]) {
while (c[i][i]) {
x[++cnt] = g[i];
--M[i];
y[cnt] = g[i] + M[i];
--c[i][i];
}
}
sy += M[i];
}
for (i = 1; i < 6; ++i)
for (j = i + 1; j <= 6; ++j) p[i][j] = ++tot;
for (int ii = 1; ii <= 6; ++ii) {
if (M[ii]) {
--M[ii];
Cnt = 1;
memset(node, 0, sizeof(node));
for (i = 1; i < 6; ++i) {
for (j = i + 1; j <= 6; ++j) {
add(p[i][j], i + tot, c[i][j]);
add(p[i][j], j + tot, c[i][j]);
add(0, p[i][j], c[i][j]);
}
}
t = tot + 7;
for (i = 1; i <= 6; ++i) add(i + tot, t, M[i]);
++M[ii];
i = dinic();
if (i != sy - 1) return cout << "-1", 0;
}
}
tot = 0;
for (i = 1; i < 6; ++i) {
for (j = i + 1; j <= 6; ++j) {
++tot;
if (c[i][j]) {
for (ee = 0, k = node[tot]; k; k = nxt[k])
if (to[k]) f1[++ee] = to[k], f2[ee] = val[k ^ 1];
f1[1] -= 15;
f1[2] -= 15;
while (f2[1]) {
--M[f1[1]];
x[++cnt] = g[f1[1]] + M[f1[1]];
y[cnt] = g[f1[2]];
--f2[1];
}
while (f2[2]) {
--M[f1[2]];
x[++cnt] = g[f1[2]] + M[f1[2]];
y[cnt] = g[f1[1]];
--f2[2];
}
}
}
}
for (i = 1; i <= cnt; ++i) cout << x[i] << " " << y[i] << "\n";
}
| 14 | CPP |
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <deque>
#define ll long long
using namespace std;
//const int INF = 2000000000;
const ll M = 1000000007;
vector<int> used, tin, tout, depth;
vector<vector<int> > graph;
vector<vector<int> > up(200, vector<int>(9));
int n, t = 0;
ll ans = 0;
double ansd = 0;
ll bin_pow(ll base, ll p)
{
if (p == 1)
return base;
if (p % 2 == 0)
{
ll t = bin_pow(base, p / 2);
return t * t % M;
}
else
return bin_pow(base, p - 1) * base % M;
}
void dfs(int v)
{
used[v] = 1;
tin[v] = ++t;
for (int i = 1; i < 9; i++)
up[v][i] = up[up[v][i - 1]][i - 1];
for (auto u: graph[v])
{
if (!used[u])
{
depth[u] = depth[v] + 1;
up[u][0] = v;
dfs(u);
}
}
tout[v] = ++t;
}
int lca(int v, int u)
{
if (tin[v] < tin[u] && tout[v] > tout[u])
return v;
if (tin[v] > tin[u] && tout[v] < tout[u])
return u;
for (int i = 8; i >= 0; --i)
if (!(tin[u] > tin[up[v][i]] && tout[u] < tout[up[v][i]]))
v = up[v][i];
return up[v][0];
}
int main()
{
ios::sync_with_stdio(false);
cin >> n;
graph.resize(n);
for (int i = 0; i < n - 1; ++i)
{
int u, v;
cin >> u >> v;
graph[u - 1].push_back(v - 1);
graph[v - 1].push_back(u - 1);
}
vector<vector<ll> > prob(n + 1, vector<ll>(n + 1));
for (int i = 0; i <= n; ++i)
prob[0][i] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
prob[i][j] = (prob[i - 1][j] + prob[i][j - 1]) * bin_pow(2, M - 2) % M;
used.resize(n);
tin.resize(n);
tout.resize(n);
depth.resize(n);
for (int v = 0; v < n; ++v)
{
used.assign(n, 0);
tin.assign(n, 0);
tout.assign(n, 0);
depth.assign(n, 0);
up.assign(200, vector<int>(9));
up[v][0] = v;
dfs(v);
for (int v = 0; v < n; ++v)
{
for (int u = v + 1; u < n; ++u)
{
if (tin[v] > tin[u] && tout[v] < tout[u])
{
ans += 1;
}
else if (tin[v] > tout[u] || tout[v] < tin[u])
{
ans = (ans + prob[depth[u] - depth[lca(v, u)]][depth[v] - depth[lca(v, u)]]) % M;
}
}
}
}
cout << ans * bin_pow(n, M - 2) % M << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int inf = (int)1e9 + 10;
using namespace std;
char s[110][110], e[110][110];
bool vis[40][1 << 20];
int g[40][1 << 20], d[1 << 20], si[110];
int n;
int f(int x, int t) {
if (vis[x][t]) return g[x][t];
vis[x][t] = 1;
int &r = g[x][t], lt = 0;
r = (x & 1 ? 1 : -1) * inf;
for (int i = 0; i < si[x + 1]; ++i) {
lt = 0;
for (int j = 0; j < si[x + 1]; ++j)
if (e[x + 1][j] == e[x + 1][i])
if (t & (1 << j) || t & (1 << (j + (x < n ? -1 : 1)))) lt += 1 << j;
if (lt)
if (x & 1)
r = min(r, f(x + 1, lt));
else
r = max(r, f(x + 1, lt));
}
return r += (e[x][d[t & -t]] == 'a' ? 1 : (e[x][d[t & -t]] == 'b' ? -1 : 0));
}
int main() {
for (int i = 0; i < 20; ++i) d[1 << i] = i;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) e[i + j + 1][si[i + j + 1]++] = s[i][j];
vis[n * 2 - 1][1] = 1;
g[n * 2 - 1][1] +=
(s[n - 1][n - 1] == 'a' ? 1 : (s[n - 1][n - 1] == 'b' ? -1 : 0));
f(1, 1);
if (g[1][1] < 0)
printf("SECOND");
else if (g[1][1] == 0)
printf("DRAW");
else
printf("FIRST");
}
| 8 | CPP |
a,p= map(int,input().split())
if a>=p:
print(10)
else:
print(0) | 0 | PYTHON3 |
import math
import itertools
import collections
def getdict(n):
d = {}
if type(n) is list or type(n) is str:
for i in n:
if i in d:
d[i] += 1
else:
d[i] = 1
else:
for i in range(n):
t = ii()
if t in d:
d[t] += 1
else:
d[t] = 1
return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def prime(n):
if n == 2:
return True
if n % 2 == 0 or n <= 1:
return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0:
return False
return True
def revn(n):
m = 0
while n > 0:
m = m * 10 + n % 10
n = n // 10
return m
n = ii()
s = input()
cl = getdict(s)
keys = ['A', 'F', 'I']
for key in keys:
if key not in cl:
cl[key] = 0
if cl['I'] == 0:
print(cl['A'])
elif cl['I'] == 1:
print(1)
else:
print(0)
| 8 | PYTHON3 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
b = []
for i in range(n):
b.append([a[i], i + 1])
b.sort()
ans = []
for i in range(n):
if k >= b[i][0]:
k -= b[i][0]
ans.append(b[i][1])
else:
break
print(len(ans))
if len(ans) > 0:
print(*ans)
| 7 | PYTHON3 |
import random
n=int(input(''))
index1=[]
index2=[]
index3=[]
no=input('')
c1=0
c2=0
c3=0
list1=no.split(' ')
#print(list1)
s=0
for i in list1:
s+=1
if i=='1':
index1.append(s)
c1+=1
elif i=='2':
index2.append(s)
c2+=1
else:
index3.append(s)
c3+=1
d=min(c1,c2,c3)
#print(index1,index2,index3)
l1=len(index1)
l2=len(index2)
l3=len(index3)
#print(l1,l2,l3)
#print(l1-d+1)
if(d>0):
print(d)
for j in range(d):
data1=index1[(l1-d)+j]
data2=index2[(l2-d)+j]
data3=index3[(l3-d)+j]
print(data1,data2,data3)
#print(random.choice(index3),sep='\n')
else:
print('0') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MX = 3001;
map<pair<int, int>, bool> forbidden[MX];
struct Graph {
int d[MX][MX];
int parent[MX][MX];
vector<int> adj[MX];
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<int> bfs(int s, int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
d[i][j] = INF;
parent[i][j] = -1;
}
}
d[n][s] = 0;
deque<pair<int, int>> q;
q.push_back({n, s});
while (!q.empty()) {
int a = q.front().first;
int b = q.front().second;
q.pop_front();
for (int c : adj[b]) {
if (d[b][c] == INF && !forbidden[a][{b, c}]) {
d[b][c] = d[a][b] + 1;
parent[b][c] = a;
q.push_back({b, c});
}
}
}
int minDistance = INF;
for (int i = 0; i < n; i++) {
minDistance = min(minDistance, d[i][n - 1]);
}
if (minDistance == INF) return {};
int prev = -1;
for (int i = 0; i < n; i++) {
if (d[i][n - 1] == minDistance) {
prev = i;
break;
}
}
vector<int> path = {n};
int cur = n - 1;
while (prev != n) {
path.push_back(prev + 1);
int aux = prev;
prev = parent[prev][cur];
cur = aux;
}
reverse(path.begin(), path.end());
return path;
}
} G;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
G.addEdge(u, v);
}
for (int i = 0; i < k; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
c--;
forbidden[a][{b, c}] = true;
}
vector<int> path = G.bfs(0, n);
cout << (int)path.size() - 1 << "\n";
for (int u : path) cout << u << " ";
cout << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
size_t cnt=count(s.begin(), s.end(), '1');
cout << min(cnt, s.size()-cnt)*2;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long x) {
if (x == 2) return true;
if (x == 3) return true;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
bool issort(long long a[], long long n) {
for (long long i = 1; i < n; i++) {
if (a[i - 1] >= a[i]) {
return false;
}
}
return true;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long sumofdig(long long x) {
long long r = x, s = 0;
while (r > 0) {
s += r % 10;
r /= 10;
}
return s;
}
vector<long long> primefac(long long x) {
vector<long long> v;
for (long long i = 2; i * i <= x; i++) {
long long k = 0;
while (x % i == 0) {
x /= i;
k = 1;
}
if (k) {
v.push_back(i);
}
}
if (x > 1) v.push_back(x);
return v;
}
long long power(long long a, long long b) {
long long m = 1e9 + 7;
long long x = 1;
while (b != 0) {
if (b % 2 == 1) {
x = (x % m * a % m) % m;
}
a = (a % m * a % m) % m;
b /= 2;
}
return x;
}
long long palndrme(string s, long long l, long long r) {
while (l <= r && s[l] == s[r]) {
l++;
r--;
}
if (r < l) {
return 1;
} else {
return 0;
}
}
void rot(long long n, vector<long long> a[], long long x, long long m) {
for (long long i = 0; i < n; i++) {
long long j, last;
last = a[x][m - 1];
for (j = m - 1; j >= 0; j--) {
a[x][j] = a[x][j - 1];
}
a[x][0] = last;
}
}
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first) {
return a.first < b.first;
}
return a.second < b.second;
}
long long xpow(long long a, long long b) {
long long m = 998244353;
long long x = 1;
while (b != 0) {
if (b % 2 == 1) {
x = (x % m * a % m) % m;
}
a = (a % m * a % m) % m;
b /= 2;
}
return x;
}
vector<long long> facs(long long x) {
vector<long long> v;
long long i;
for (i = 1; i < sqrt(x); i++) {
if (x % i == 0) {
v.push_back(i);
v.push_back(x / i);
}
}
if (i * i == x) {
v.push_back(i);
}
return v;
}
void solve() {
long long n, m, a, b;
cin >> a >> b;
if (b > a) {
swap(a, b);
}
vector<long long> v = facs(a - b);
n = v.size();
long long ans1 = (a * b) / gcd(a, b);
long long k, lc;
long long ans2 = 0;
for (long long i = 0; i < n; i++) {
long long x = v[i];
long long aa, bb, k;
k = x - a % x;
aa = (a + k);
bb = (b + k);
lc = (aa * bb) / gcd(aa, bb);
if (lc < ans1) {
ans1 = lc;
ans2 = k;
}
}
cout << ans2 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
}
| 9 | CPP |
import math
data = input().split()
n=float(data[0])
m=float(data[1])
a=float(data[2])
print (int(math.ceil(m/a)*math.ceil(n/a)))
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
using ll = long long;
int main(){
int D;
cin >> D;
vector<int> c(26);
rep(i, 26) cin >> c[i];
vector<vector<int>> s(D, vector<int> (26));
rep(d, D) {
rep(i, 26) {
cin >> s[d][i];
}
}
vector<int> t(D);
rep(d, D) cin >> t[d];
vector<int> last(26, 0);
int v = 0;
rep(d, D) {
v += s[d][t[d]-1];
// cout << v << endl;
rep(i, 26) {
if (i == t[d]-1) {
last[i] = d + 1;
}
v -= c[i] * (d+1 - last[i]);
}
cout << v << endl;
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int k,a,b;
cin >>k >> a >> b;
if(a%k==0 || b%k==0 || (a/k)!=(b/k))
cout << "OK";
else
cout << "NG";
} | 0 | CPP |
q = int(input())
for i in range(q):
n = int(input())
s = '1' * (n // 2)
if n % 2 == 1:
s = '7' + s[1:]
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e3;
vector<long long> a, b;
char k;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (int i = 1; cin >> k; i++)
if (k == 'l')
a.push_back(i);
else
b.push_back(i);
reverse(a.begin(), a.end());
for (int i = 0; i < b.size(); i++) cout << b[i] << "\n";
for (int i = 0; i < a.size(); i++) cout << a[i] << "\n";
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, coun, m[12][2];
while (cin >> n) {
while (n--) {
coun = 0;
getchar();
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
char c = getchar();
if (c == 'K') {
m[coun][0] = i;
m[coun++][1] = j;
}
}
getchar();
}
int g = m[0][0] - m[1][0];
int f = m[0][1] - m[1][1];
if (g % 4 == 0 && f % 4 == 0)
cout << "YES";
else
cout << "NO";
cout << endl;
}
}
return 0;
}
| 7 | CPP |
for o in range(int(input())):
n = int(input())
a = list(map(int ,input().split()))
if len(set(a))==1:
print(n)
else:
print(1) | 7 | PYTHON3 |
for i in range(int(input())):
l=int(input())
p=[int(x) for x in input().split()]
a=0
for j in range(1,len(p)):
if p[j]>=p[j-1]:
a=a+1
if a>0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <vector>
#define MAXV 10000
using namespace std;
int main() {
int n;
cin >> n;
vector<int> cnt(MAXV, 0);
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
cnt[temp]++;
}
int count = 0;
for (int i = 0; i < cnt.size(); i++) {
while (cnt[i]) {
if (count)
cout << " ";
cout << i;
count++;
cnt[i]--;
}
}
cout << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long double pii = 3.14159265359;
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 200001;
long double dist(int x1, int y1) {
long long x2 = -100, y2 = -100;
return sqrt((x2 - x1) * (x2 - x1) + (long double)(y2 - y1) * (y2 - y1));
}
struct Point {
int x;
int y;
};
bool onSegment(Point p, Point q, Point r) {
if (q.x <= max(p.x, r.x) && q.x >= min(p.x, r.x) && q.y <= max(p.y, r.y) &&
q.y >= min(p.y, r.y))
return true;
return false;
}
int orientation(Point p, Point q, Point r) {
int val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
if (val == 0) return 0;
return (val > 0) ? 1 : 2;
}
bool doIntersect(Point p1, Point q1, Point p2, Point q2) {
int o1 = orientation(p1, q1, p2);
int o2 = orientation(p1, q1, q2);
int o3 = orientation(p2, q2, p1);
int o4 = orientation(p2, q2, q1);
if (o1 != o2 && o3 != o4) return true;
if (o1 == 0 && onSegment(p1, p2, q1)) return true;
if (o2 == 0 && onSegment(p1, q2, q1)) return true;
if (o3 == 0 && onSegment(p2, p1, q2)) return true;
if (o4 == 0 && onSegment(p2, q1, q2)) return true;
return false;
}
float area(int x1, int y1, int x2, int y2, int x3, int y3) {
return abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
}
bool check(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4,
int x, int y) {
float A = area(x1, y1, x2, y2, x3, y3) + area(x1, y1, x4, y4, x3, y3);
float A1 = area(x, y, x1, y1, x2, y2);
float A2 = area(x, y, x2, y2, x3, y3);
float A3 = area(x, y, x3, y3, x4, y4);
float A4 = area(x, y, x1, y1, x4, y4);
return (A == A1 + A2 + A3 + A4);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<pair<int, int> > v1, v2;
long double mx = 0, mn = INT_MAX;
int ind1 = 0, ind2 = 0;
for (int x = 0; x < (4); x++) {
int a, b;
cin >> a >> b;
v1.push_back({a, b});
if (dist(a, b) > mx) {
ind1 = x;
mx = dist(a, b);
}
if (dist(a, b) < mn) {
ind2 = x;
mn = dist(a, b);
}
}
vector<pair<int, int> > p1(4), p2(4);
for (int x = 0; x < (4); x++) {
if (ind1 == x) {
p1[1] = v1[x];
} else if (ind2 == x) {
p1[3] = v1[x];
} else if (v1[x].first == v1[ind1].first) {
p1[2] = v1[x];
} else {
p1[0] = v1[x];
}
}
mx = INT_MIN, mn = INT_MAX;
ind1 = ind2 = 0;
int ind3 = 0, ind4 = 0, mx2 = INT_MIN, mn2 = INT_MAX;
for (int x = 0; x < (4); x++) {
int a, b;
cin >> a >> b;
v2.push_back({a, b});
if (a > mx) {
mx = a;
ind1 = x;
}
if (a < mn) {
mn = a;
ind2 = x;
}
if (b > mx2) {
mx2 = b;
ind3 = x;
}
if (b < mn2) {
mn2 = b;
ind4 = x;
}
}
p2[0] = v2[ind2];
p2[1] = v2[ind3];
p2[2] = v2[ind1];
p2[3] = v2[ind4];
bool flag = false;
if (p2[0].first >= p1[0].first && p2[1].second <= p1[1].second &&
p2[2].first <= p1[2].first && p2[3].second >= p1[3].second)
flag = true;
for (int x = 0; x < (4); x++) {
if (p2[x].first >= p1[0].first && p2[x].first <= p1[1].first &&
p2[x].second >= p1[3].second && p2[x].second <= p1[0].second)
flag = true;
if (check(p2[0].first, p2[0].second, p2[1].first, p2[1].second, p2[2].first,
p2[2].second, p2[3].first, p2[3].second, p1[x].first,
p1[x].second))
flag = true;
}
vector<Point> l1(5), l2(5);
for (int x = 0; x < (4); x++) {
l1[x].x = p1[x].first;
l1[x].y = p1[x].second;
l2[x].x = p2[x].first;
l2[x].y = p2[x].second;
}
l1[4].x = p1[0].first;
l1[4].y = p1[0].second;
l2[4].x = p2[0].first;
l2[4].y = p2[0].second;
for (int x = 1; x < (5); x++) {
for (int y = 1; y < (5); y++)
if (doIntersect(l1[x], l1[x - 1], l2[y], l2[y - 1])) flag = true;
}
if (flag)
cout << "YES" << nl;
else
cout << "NO" << nl;
return 0;
}
| 7 | CPP |
for i in range(int(input())):
n,m=map(int,input().split())
for i in range(0,n):
if i==0:
print("W"+"B"*(m-1))
else:
print("B"*m) | 7 | PYTHON3 |
#include<bits/stdc++.h>
#define inf ((int)(1e9))
using namespace std;
int n,m,s,t;
vector<int> graph[100005];
int main()
{
cin>>n>>m;
for(int i=0;i<m;i++)
{
int u,v;
cin>>u>>v;
--u,--v;
graph[u].push_back(v);
}
cin>>s>>t;
--s,--t;
vector<int> d(n*3,inf);
d[s]=0;
queue<int> q;
q.push(s);
while(!q.empty())
{
int x=q.front();
q.pop();
int now=x%n;
for(int i=0;i<graph[now].size();i++)
{
int dd=d[x]+1;
int y=graph[now][i]+n*(dd%3);
if(d[y]!=inf)
continue;
d[y]=dd;
q.push(y);
}
}
cout<<(d[t]==inf?-1:(d[t]/3))<<endl;
return 0;
}
| 0 | CPP |
x,y=map(int,input().split(" "))
u=(x/y)+(x%y)
j=0
while(u>=y):
p=int(u/y)
u=p+(u%y)
j=j+p
#print(j)
w=int(x+(x/y)+j)
print(w)
| 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
template <class T>
T gcd(T n, T m) {
if (n < 0) n = -n;
if (m < 0) m = -m;
while (m != 0) {
n %= m;
std::swap(n, m);
}
return n;
}
using lint = long long;
lint pow(lint b, lint n, lint m) {
lint x = 1;
b %= m;
while (n > 0) {
if (n & 1) (x *= b) %= m;
n >>= 1;
(b *= b) %= m;
}
return x;
}
lint totient(lint n) {
lint m = n;
for (lint p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
m = m / p * (p - 1);
while (n % p == 0) n /= p;
}
if (n > 1) m = m / n * (n - 1);
return m;
}
void solve() {
lint n;
std::cin >> n;
lint l = 1;
{
auto nn = n;
for (lint p = 2; p * p <= nn; ++p) {
if (nn % p != 0) continue;
l *= (p - 1) / gcd(l, p - 1);
if (nn % (p * p) == 0) {
std::cout << -1 << std::endl;
return;
}
nn /= p;
}
if (nn > 1) {
auto p = nn;
l *= (p - 1) / gcd(l, p - 1);
}
}
if (gcd(n, l) != 1) {
std::cout << -1 << std::endl;
return;
}
auto m = totient(l);
auto ans = m;
for (lint p = 1; p * p <= m; ++p) {
if (m % p != 0) continue;
if (pow(n, p, l) == 1) ans = std::min(ans, p);
if (pow(n, m / p, l) == 1) ans = std::min(ans, m / p);
}
std::cout << ans << std::endl;
}
int main() {
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int n,a[100005];
int main() {
scanf("%d",&n);
for (int i=1;i<=n;++i) scanf("%d",a+i);
sort(a+1,a+n+1,greater<int>());
int p=1;
while (p<n&&a[p+1]>=p+1) ++p;
int q=p;
while (q<n&&a[q+1]==p) ++q;
if ((q-p&1)||(a[p]-p&1)) puts("First");
else puts("Second");
} | 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,d,x;
cin>>n>>d>>x;
vector<vector<int>> p(d,vector<int>(n,0));
for(int i=0;i<d;i++){
for(int j=0;j<n;j++){
cin>>p[i][j];
}
}
for(int i=1;i<d;i++){
vector<vector<int>> dp(n,vector<int>(1e5+1,1000000));
for(int j=0;j<n;j++) dp[j][0]=0;
for(int k=0;k<1e5+1;k++){
if(p[i-1][0]<p[i][0]){
if(k-(p[i][0]-p[i-1][0])>=0)
dp[0][k]=min(dp[0][k],dp[0][k-(p[i][0]-p[i-1][0])]+p[i-1][0]);
else{
dp[0][k]=min(dp[0][k],dp[0][0]+p[i-1][0]);
}
}
}
for(int j=1;j<n;j++){
for(int k=0;k<1e5+1;k++){
if(p[i-1][j]>=p[i][j]){
dp[j][k]=dp[j-1][k];
}
else{
dp[j][k]=dp[j-1][k];
if(k-(p[i][j]-p[i-1][j])>=0){
dp[j][k]=min(dp[j][k],dp[j][k-(p[i][j]-p[i-1][j])]+p[i-1][j]);
}
else{
dp[j][k]=min(dp[j][k],dp[j][0]+p[i-1][j]);
}
}
}
}
int newx=0;
for(int k=0;k<1e5+1;k++){
if(dp[n-1][k]<=x){
newx=max(newx,k);
}
}
x+=newx;
}
cout<<x<<endl;
return 0;
} | 0 | CPP |
t=int(input())
lst=[]
a=0
while t:
t=t-1
lst1=[]
lst1=list(map(str,input().strip().split("|")))
if a==0:
if "OO" in lst1:
lst1[lst1.index("OO")]="++"
a=1
lst.append(lst1)
if a==1:
print("YES")
for i in lst:
print(i[0]+"|"+i[1])
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
int gcd(int a, int b) {
int c = 1;
while (b) {
c = a % b;
a = b;
b = c;
}
return a;
}
using namespace std;
int sum(int a) {
int b = 0;
while (a) b += a % 10, a /= 10;
return b;
}
int main() {
int q;
cin >> q;
while (q--) {
int n, k;
cin >> n >> k;
int mn = 1e9;
int mx = -1e9;
for (int i = 0; i < n; i++) {
int z;
cin >> z;
mn = min(mn, z + k);
mx = max(mx, z + k);
}
if (mn + k + k < mx)
cout << -1;
else
cout << mn;
cout << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int main() {
string s;
cin >> s;
map<pair<int, int>, vector<int> > m;
queue<pair<int, int> > q;
m[make_pair(0, 0)].push_back(0);
q.push(make_pair(0, 0));
int x = 0, y = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'U') {
y++;
} else if (s[i] == 'D') {
y--;
} else if (s[i] == 'L') {
x--;
} else {
x++;
}
m[make_pair(x, y)].push_back(i + 1);
q.push(make_pair(x, y));
}
while (!q.empty()) {
x = q.front().first, y = q.front().second;
q.pop();
if (m[make_pair(x, y)].size() > 1) {
cout << "BUG";
return 0;
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < m[make_pair(x + dx[i], y + dy[i])].size(); j++) {
if (abs(m[make_pair(x, y)][0] - m[make_pair(x + dx[i], y + dy[i])][0]) >
1) {
cout << "BUG";
return 0;
}
}
}
}
cout << "OK";
return 0;
}
| 8 | CPP |
t = int(input())
for _ in range(t):
n, s, k = map(int, input().split())
c = set(map(int, input().split()))
l, u = s, s
for i in range(10000):
if (l not in c) or (u not in c):
print(i)
break
if l > 1:
l -= 1
if u < n:
u += 1
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, len;
char s[2000010], t[2000010 * 2];
void prework() {
for (int i = 1; i <= n * 2 + 1; i++) {
if (i & 1)
t[i] = '#';
else
t[i] = s[i / 2];
}
len = n * 2 + 1;
}
int R[2000010 * 2];
void manacher() {
R[1] = 1;
int p = 1, mx = 1;
for (int i = 2; i <= len; i++) {
if (mx < i)
R[i] = 1;
else {
int j = 2 * p - i;
if (mx - i > R[j])
R[i] = R[j];
else
R[i] = mx - i;
}
while (t[i + R[i]] == t[i - R[i]] && i + R[i] <= len && i - R[i] > 0)
R[i]++;
if (i + R[i] - 1 > mx) {
p = i;
mx = i + R[i] - 1;
}
}
}
struct P {
int l, r;
} p[2000010 * 2];
int top;
int sum[2000010];
int main() {
n = read();
scanf("%s", s + 1);
prework();
manacher();
for (int i = 1; i <= len; i++) {
int l = i - R[i] + 1, r = i + R[i] - 1;
l = (l + 1) / 2;
r = r / 2;
if (l > r) continue;
p[++top].l = l;
p[top].r = r;
}
for (int i = 1; i <= top; i++) {
int L = (p[i].l + p[i].r + 1) / 2;
sum[L]++;
sum[p[i].r + 1]--;
}
for (int i = 1; i <= n; i++) sum[i] = (sum[i] + sum[i - 1]) % 51123987;
for (int i = 1; i <= n; i++) sum[i] = (sum[i] + sum[i - 1]) % 51123987;
for (int i = 1; i <= n; i++) sum[i] = (sum[i] + sum[i - 1]) % 51123987;
int res = 0;
for (int i = 1; i <= top; i++) {
int mid = (p[i].l + p[i].r) / 2;
res = (res + sum[mid - 1] - sum[max(p[i].l - 2, 0)] + 51123987) % 51123987;
}
int now = 0;
for (int i = 1; i <= top; i++)
now = (now + (p[i].r - p[i].l + 2) / 2) % 51123987;
now = 1ll * now * (now - 1) % 51123987 * 25561994 % 51123987;
printf("%d\n", (now - res + 51123987) % 51123987);
return 0;
}
| 11 | CPP |
import sys
input = sys.stdin.readline
n,m = map(int,input().split())
ll = sorted([list(map(int,input().split())) for _ in range(n)])
ans = 0
for p, c in ll:
ans += p*min(m,c)
m -= c
if m < 1:
break
print(ans) | 0 | PYTHON3 |
n,m=map(int,input().split())
dict={}
for i in range(m):
a,b=input().split()
dict[a]=b
k=input().split()
for i in k:
if len(i)>len(dict[i]):
k[k.index(i)]=dict[i]
print(*k) | 8 | PYTHON3 |
def flipcase(c):
if c.isupper():
return c.lower()
return c.upper()
s = input()
c = sum(int(c.isupper()) for c in s)
if c == len(s) or c == len(s) - 1 and s[0].islower():
print("".join(flipcase(c) for c in s))
else:
print(s)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using lpair = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
void print() {}
template <class H, class... T>
void print(H&& h, T&&... t) {
cout << h << " \n"[sizeof...(t) == 0];
print(forward<T>(t)...);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll t;
cin >> t;
for (ll tt = (0); tt < (t); tt++) {
ll N;
cin >> N;
ll pos = N;
ll cur = 1;
while (pos > 0) {
if (pos <= cur * 3) {
break;
} else {
pos -= cur * 3;
cur *= 4;
}
}
ll a = cur, b = cur * 2, c = cur * 3;
ll n = cur;
ll res = 0;
ll abc = (pos - 1) % 3;
pos = (pos - 1) / 3;
while (n > 0) {
ll amari = pos % n;
if (amari < n / 4) {
res += (n / 4) * 0;
} else if (amari < 2 * (n / 4)) {
res += (n / 4) * 2;
} else if (amari < 3 * (n / 4)) {
res += (n / 4) * 3;
} else {
res += (n / 4) * 1;
}
n /= 4;
if (n == 1) break;
}
ll res2 = 0;
n = cur;
while (n > 0) {
ll amari = pos % n;
if (amari < n / 4) {
res2 += (n / 4) * 0;
} else if (amari < 2 * (n / 4)) {
res2 += (n / 4) * 3;
} else if (amari < 3 * (n / 4)) {
res2 += (n / 4) * 1;
} else {
res2 += (n / 4) * 2;
}
n /= 4;
if (n == 1) break;
}
if (abc == 0) {
print(a + pos);
} else if (abc == 1) {
print(b + res);
} else {
print(c + res2);
}
}
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int m,n;
cin>>n>>m;
int c = 0;
long a[n];
for(int i=0;i<n;i++) cin>> a[i];
double votes = accumulate(a,a+n,0);
for(int i =0;i<n;i++) if(a[i] >=(double)(votes/(m*4)) ) c++;
if(c<m) cout<< "No";
else cout << "Yes";
} | 0 | CPP |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=2e5+10,M=2e5+10;
int head[N],ver[M],nxt[M],tot=0;
void add(int x,int y)
{
ver[++tot]=y;
nxt[tot]=head[x];
head[x]=tot;
}
int Head[N],Ver[M],Nxt[M],Tot=0;
void Add(int x,int y)
{
Ver[++Tot]=y;
Nxt[Tot]=Head[x];
Head[x]=Tot;
}
int dis[N];
bool vis[N];
int n,m;
void dij(int s)
{
memset(vis,0,sizeof(vis));
memset(dis,0x3f,sizeof(dis));
dis[s]=0;
priority_queue<pair<int,int> > que;
que.push(make_pair(0,s));
while(!que.empty())
{
int x=que.top().second;que.pop();
if(vis[x]) continue;
vis[x]=1;
for(int i=Head[x];i;i=Nxt[i])
{
int y=Ver[i],z=1;
if(dis[x]+z<dis[y])
{
dis[y]=dis[x]+z;
que.push(make_pair(-dis[y],y));
}
}
}
}
int f[N][2];
void spfa()
{
memset(vis,0,sizeof(vis));
memset(f,0x3f,sizeof(f));
for(int i=1;i<=n;i++) f[i][0]=dis[i];
vis[1]=1;
queue<int> que;
for(int i=1;i<=n;i++) que.push(i);
while(!que.empty())
{
int x=que.front();que.pop();
vis[x]=0;
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(dis[x]>dis[y])
{
if(f[x][0]<f[y][0])
{
f[y][0]=f[x][0];
if(!vis[y])
{
vis[y]=1;
que.push(y);
}
}
if(f[x][1]<f[y][1])
{
f[y][1]=f[x][1];
if(!vis[y])
{
vis[y]=1;
que.push(y);
}
}
}
else if(dis[x]<=dis[y])
{
//f[x][1]->f[y][1]
//f[x][0]->f[y][1]
if(f[x][0]<f[y][1])
{
f[y][1]=f[x][0];
if(!vis[y])
{
vis[y]=1;
que.push(y);
}
}
}
}
}
}
void sol()
{
memset(head,0,sizeof(head));
memset(Head,0,sizeof(Head));
Tot=tot=0;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
int x,y;
scanf("%d%d",&x,&y);
Add(x,y);
add(y,x);
}
dij(1);
// printf("dis:\n");
// for(int i=1;i<=n;i++) printf("%d ",dis[i]);
// putchar('\n');
spfa();
for(int i=1;i<=n;i++) printf("%d ",min(f[i][0],f[i][1]));
putchar('\n');
}
int main()
{
int T;
scanf("%d",&T);
while(T--) sol();
return 0;
} | 13 | CPP |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 200010
int main(){
int n,q,s,t;
ll a[SIZE];
ll dif[SIZE];
scanf("%d%d%d%d",&n,&q,&s,&t);
for(int i=0;i<n+1;i++){
scanf("%lld",a+i);
}
for(int j=1;j<n+1;j++){
dif[j] = a[j] - a[j-1];
}
ll temp = 0;
t *= -1;
s *= -1;
for(int i=1;i<n+1;i++){
if(dif[i] < 0){
temp += t * dif[i];
}else{
temp += s * dif[i];
}
}
for(int i=0;i<q;i++){
int r,l,x;
scanf("%d%d%d",&l,&r,&x);
r += 1;
if(r <= n){
if(dif[r] < 0){
temp -= t * dif[r];
}else{
temp -= s * dif[r];
}
}
if(dif[l] < 0){
temp -= t * dif[l];
}else{
temp -= s * dif[l];
}
dif[r] -= x;
dif[l] += x;
if(r <= n){
if(dif[r] < 0){
temp += t * dif[r];
}else{
temp += s * dif[r];
}
}
if(dif[l] < 0){
temp += t * dif[l];
}else{
temp += s * dif[l];
}
printf("%lld\n",temp);
}
return 0;
} | 0 | CPP |
#include <iostream>
#include <vector>
#include <complex>
#include <algorithm>
#include <cmath>
#include <map>
#include <queue>
using namespace std;
bool isCrossed(complex<double> p1, complex<double> p2, complex<double> p3, complex<double> p4) {
if ( ((p1.real() - p2.real()) * (p3.imag() - p1.imag()) + (p1.imag() - p2.imag()) * (p1.real() - p3.real())) *
((p1.real() - p2.real()) * (p4.imag() - p1.imag()) + (p1.imag() - p2.imag()) * (p1.real() - p4.real())) > 0)
return false;
return true;
}
int main() {
int N = 0;
while (cin>>N && N) {
vector<pair<complex<double>, double> > circles(N);
complex<double> centerize;
for (int n = 0; n < N; n++) {
int x,y,r;
cin>>x>>y>>r;
if (n == 0) {
centerize = complex<double>(x,y);
circles[n] = make_pair(complex<double>(0.0, 0.0), (double)r);
}
circles[n] = make_pair(complex<double>(x,y)-centerize, (double)r);
}
vector<complex<double> > vertices(2 * N);
vertices[0] = circles[0].first;
vertices[1] = circles[N-1].first;
for (int n = 0; n < N-1; n++) {
complex<double> v = circles[n+1].first - circles[n].first;
double a = atan2(v.imag(), v.real());
double theta = acos((norm(v) + circles[n].second*circles[n].second - circles[n+1].second*circles[n+1].second)
/ (2 * abs(v) * circles[n].second));
vertices[2+2*n] = complex<double>(circles[n].second * cos(a+theta), circles[n].second * sin(a+theta)) + circles[n].first;
vertices[3+2*n] = complex<double>(circles[n].second * cos(a-theta), circles[n].second * sin(a-theta)) + circles[n].first;
/*
double a = (v.real()*v.real()+v.imag()*v.imag()+circles[n].second*circles[n].second-circles[n+1].second*circles[n+1].second) / 2.0;
double x1 = ( a*v.real() + v.imag()*sqrt((v.real()*v.real()+v.imag()*v.imag())*circles[n].second*circles[n].second-a*a) )
/ (v.real()*v.real()+v.imag()*v.imag());
double y1 = ( a*v.imag() - v.real()*sqrt((v.real()*v.real()+v.imag()*v.imag())*circles[n].second*circles[n].second-a*a) )
/ (v.real()*v.real()+v.imag()*v.imag());
double x2 = ( a*v.real() - v.imag()*sqrt((v.real()*v.real()+v.imag()*v.imag())*circles[n].second*circles[n].second-a*a) )
/ (v.real()*v.real()+v.imag()*v.imag());
double y2 = ( a*v.imag() + v.real()*sqrt((v.real()*v.real()+v.imag()*v.imag())*circles[n].second*circles[n].second-a*a) )
/ (v.real()*v.real()+v.imag()*v.imag());
vertices[2+2*n] = complex<double>(x1,y1);
vertices[3+2*n] = complex<double>(x2,y2);*/
}
multimap<int, pair<int, double> > ds;
for (int n = 0; n < N; n++) {
for (int s = 0; s < 2; s++) {
for (int i = n+1; i < N+1; i++) {
for (int t = 0; t < 2; t++) {
if (i != N) {
bool flag = true;
for (int u = n+1; u < i; u++) {
if (!(isCrossed(vertices[2*n+s], vertices[2*i+t], vertices[2*u], vertices[2*u+1]) &&
isCrossed(vertices[2*u], vertices[2*u+1], vertices[2*n+s], vertices[2*i+t]))) {
flag = false;
break;
}
}
if (flag) ds.insert(make_pair(2*n+s, make_pair(2*i+t, (double)abs(vertices[2*i+t] - vertices[2*n+s]))));
} else {
bool flag = true;
for (int u = n+1; u < i; u++) {
if (!(isCrossed(vertices[2*n+s], vertices[1], vertices[2*u], vertices[2*u+1]) &&
isCrossed(vertices[2*u], vertices[2*u+1], vertices[2*n+s], vertices[1]))) {
flag = false;
break;
}
}
if (flag) ds.insert(make_pair(2*n+s, make_pair(1, (double)abs(vertices[1] - vertices[2*n+s]))));
break;
}
}
}
if (n == 0) break;
}
}
priority_queue<pair<double, int>, vector<pair<double, int> >, greater<pair<double, int> > > pqueue;
double finalDs[1000] = {};
for (int n = 0; n < N; n++) {
finalDs[2*n] = -1.0;
finalDs[2*n+1] = -1.0;
}
pqueue.push(make_pair(0.0, 0));
while (!pqueue.empty()) {
auto p = pqueue.top();
pqueue.pop();
if (finalDs[p.second] < 0.0) finalDs[p.second] = p.first;
else continue;
auto it = ds.lower_bound(p.second);
auto last = ds.upper_bound(p.second);
for (; it != last; it++) {
pqueue.push(make_pair(p.first+it->second.second, it->second.first));
}
}
cout<<fixed<<finalDs[1]<<endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[200010], vis[200010], ans[200010];
int DFS(int x, int d) {
vis[x] = 1;
if (vis[a[x]] == 1) return ans[x] = d;
return ans[x] = DFS(a[x], d + 1);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
vis[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
DFS(i, 1);
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
return 0;
}
| 8 | CPP |
def pol(l1):
for i in range(len(l1)-2,-1,-1):
for j in range(len(l1)-2,-1,-1):
if l1[i][j]=="1":
if l1[i+1][j]=="1" or l1[i][j+1]=="1":
continue
else:
return ("NO")
return "YES"
t=int(input())
l=[]
for i in range(t):
l1=[]
n=int(input())
for j in range(n):
s=input()
l1.append(s)
l.append(l1)
for l1 in l:
print(pol(l1))
| 11 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int n;
set<int> S;
map<pair<int, int>, int> F;
int calc(int length, int mask) {
if (mask == 0) {
return 0;
}
if (F.count(make_pair(length, mask))) {
return F[make_pair(length, mask)];
}
vector<int> d;
for (int i = 1; i <= length; ++i) {
if (mask & (1 << (i - 1))) {
int nmask = mask;
for (int j = i; j <= length; j += i) {
if (nmask & (1 << (j - 1))) {
nmask ^= (1 << (j - 1));
}
}
d.push_back(calc(length, nmask));
}
}
sort(d.begin(), d.end());
for (int i = 0;; ++i) {
if (!binary_search(d.begin(), d.end(), i)) {
return F[make_pair(length, mask)] = i;
}
}
}
int main() {
vector<int> a(30);
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 1;
a[4] = 4;
a[5] = 3;
a[6] = 2;
a[7] = 1;
a[8] = 5;
a[9] = 6;
a[10] = 2;
a[11] = 1;
a[12] = 8;
a[13] = 7;
a[14] = 5;
a[15] = 9;
a[16] = 8;
a[17] = 7;
a[18] = 3;
a[19] = 4;
a[20] = 7;
a[21] = 4;
a[22] = 2;
a[23] = 1;
a[24] = 10;
a[25] = 9;
a[26] = 3;
a[27] = 6;
a[28] = 11;
a[29] = 12;
cin >> n;
vector<int> length;
for (int i = 2; i * i <= n; ++i) {
long long w = i;
if (S.count(w)) {
continue;
}
int q = 0;
while (w <= (long long)(n)) {
++q;
S.insert(w);
w *= (long long)(i);
}
length.push_back(q);
}
int ones = n - S.size();
int res = 0;
for (int i = 0; i < length.size(); ++i) {
int value = a[length[i]];
res ^= value;
}
if (ones % 2 == 1) {
res ^= 1;
}
if (res == 0) {
cout << "Petya" << endl;
} else {
cout << "Vasya" << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, d, x, y, dis[300005], vis[300005], us[300005];
queue<pair<int, int> > q;
vector<pair<int, int> > E[300005];
vector<int> v;
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= n; i++) dis[i] = 1000000007;
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
q.push({x, 0});
dis[x] = 0;
}
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
E[x].push_back({y, i});
E[y].push_back({x, i});
}
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
q.pop();
if (vis[x] == 1) continue;
vis[x] = 1, us[y] = 1;
for (auto i : E[x]) {
if (dis[i.first] > dis[x] + 1) {
dis[i.first] = dis[x] + 1;
q.push({i.first, i.second});
}
}
}
for (int i = 1; i <= n - 1; i++)
if (!us[i]) v.push_back(i);
printf("%d\n", int(v.size()));
for (auto i : v) {
printf("%d ", i);
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 7;
const int BSIZE = 333;
struct query {
int l, r, id;
};
int n, m;
int res[MAXN], a[MAXN];
query q[MAXN];
int getBlock(int x) { return (x - 1) / BSIZE; }
bool cmp(query u, query v) {
if (getBlock(u.l) != getBlock(v.l)) return getBlock(u.l) < getBlock(v.l);
return u.r < v.r;
}
int ans;
int cnt[MAXN];
void upd(int x, int val) {
if (cnt[x] == x) --ans;
cnt[x] += val;
if (cnt[x] == x) ++ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] > n) a[i] = n + 5;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + m + 1, cmp);
for (int i = 1; i <= m; i++) {
if (i == 1 || getBlock(q[i].l) != getBlock(q[i - 1].l)) {
ans = 0;
memset(cnt, 0, sizeof cnt);
for (int g = q[i].l; g <= q[i].r; g++) {
upd(a[g], 1);
}
res[q[i].id] = ans;
} else {
for (int g = q[i - 1].r + 1; g <= q[i].r; g++) {
upd(a[g], 1);
}
if (q[i - 1].l < q[i].l) {
for (int g = q[i - 1].l; g < q[i].l; g++) upd(a[g], -1);
}
if (q[i - 1].l > q[i].l) {
for (int g = q[i - 1].l - 1; g >= q[i].l; g--) upd(a[g], 1);
}
res[q[i].id] = ans;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", res[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct s {
int x, y, x1, y1;
};
int main() {
int n, m, r, c, x, y;
cin >> n >> m >> r >> c >> x >> y;
vector<vector<char>> a(n, vector<char>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
deque<s> q;
q.push_back({r - 1, c - 1, x, y});
vector<vector<bool>> used(n, vector<bool>(m, false));
int res = 0;
while (!q.empty()) {
s v = q.front();
q.pop_front();
if (!used[v.x][v.y]) {
used[v.x][v.y] = 1;
if (v.x1 > 0 && v.y > 0 && a[v.x][v.y - 1] == '.') {
q.push_back({v.x, v.y - 1, v.x1 - 1, v.y1});
}
if (v.y1 > 0 && v.y < m - 1 && a[v.x][v.y + 1] == '.') {
q.push_back({v.x, v.y + 1, v.x1, v.y1 - 1});
}
if (v.x > 0 && a[v.x - 1][v.y] == '.') {
q.push_front({v.x - 1, v.y, v.x1, v.y1});
}
if (v.x < n - 1 && a[v.x + 1][v.y] == '.') {
q.push_front({v.x + 1, v.y, v.x1, v.y1});
}
res += 1;
}
}
cout << res;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int col[200001];
int addr[200001];
int amount_of_colors[200001];
struct Node {
int val;
int next;
} nodes[200001];
struct Tree {
int used;
int first;
int last;
} vTr[100001];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
col[i] = x;
}
int cur = 0, nTr = 0;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (addr[a] == 0) {
if (addr[b] == 0) {
nodes[++cur].val = a;
nodes[cur].next = cur + 1;
nodes[++cur].val = b;
vTr[++nTr].used = 1;
vTr[nTr].first = cur - 1;
vTr[nTr].last = cur;
addr[a] = nTr;
addr[b] = nTr;
} else {
nodes[++cur].val = a;
nodes[vTr[addr[b]].last].next = cur;
vTr[addr[b]].last = cur;
addr[a] = addr[b];
}
} else {
if (addr[b] == 0) {
nodes[++cur].val = b;
nodes[vTr[addr[a]].last].next = cur;
vTr[addr[a]].last = cur;
addr[b] = addr[a];
} else {
if (addr[a] != addr[b]) {
vTr[addr[b]].used = 0;
nodes[vTr[addr[a]].last].next = vTr[addr[b]].first;
vTr[addr[a]].last = vTr[addr[b]].last;
for (int j = vTr[addr[b]].first; j; j = nodes[j].next) {
addr[nodes[j].val] = addr[a];
}
}
}
}
}
int res = 0;
for (int i = 1; i <= nTr; i++) {
if (vTr[i].used == 1) {
int max_amount = 0, sum = 0;
for (int j = vTr[i].first; j; j = nodes[j].next) {
amount_of_colors[col[nodes[j].val]]++;
if (amount_of_colors[col[nodes[j].val]] > max_amount)
max_amount = amount_of_colors[col[nodes[j].val]];
sum++;
}
for (int j = vTr[i].first; j; j = nodes[j].next)
amount_of_colors[col[nodes[j].val]] = 0;
res += sum - max_amount;
}
}
cout << res << '\n';
return 0;
}
| 9 | CPP |
n,k = map(int,input().split())
x = (((9+8*(n+k))**0.5)-3)/2
s = x*(x+1)/2
print(round(s-k)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d1[3003][3003], d2[3003][3003];
vector<int> v[3003], f[3003];
pair<int, int> mv[3003][9], mf[3003][9];
int mx, a[9];
void bfs(int xi) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
for (int i = 1; i <= n; i++) {
d1[xi][i] = n + 1;
}
d1[xi][xi] = 0;
q.push(make_pair(0, xi));
int k;
do {
int k = q.top().second;
q.pop();
for (int i = v[k].size() - 1; i >= 0; i--) {
if (d1[xi][v[k][i]] > d1[xi][k] + 1) {
d1[xi][v[k][i]] = d1[xi][k] + 1;
q.push(make_pair(d1[xi][k] + 1, v[k][i]));
}
}
} while (q.size());
}
void fbs(int xi) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
for (int i = 1; i <= n; i++) {
d2[xi][i] = n + 1;
}
d2[xi][xi] = 0;
q.push(make_pair(0, xi));
int k;
do {
int k = q.top().second;
q.pop();
for (int i = f[k].size() - 1; i >= 0; i--) {
if (d2[xi][f[k][i]] > d2[xi][k] + 1) {
d2[xi][f[k][i]] = d2[xi][k] + 1;
q.push(make_pair(d2[xi][k] + 1, f[k][i]));
}
}
} while (q.size());
}
int main() {
scanf("%d %d", &n, &m);
int t1, t2;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &t1, &t2);
v[t1].push_back(t2);
f[t2].push_back(t1);
}
for (int i = 1; i <= n; i++) {
bfs(i);
fbs(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (d1[i][j] == n + 1) {
d1[i][j] = -n * 10;
}
if (d2[i][j] == n + 1) {
d2[i][j] = -n * 10;
}
}
}
for (int i = 1; i <= n; i++) {
priority_queue<pair<int, int> > q;
for (int j = 1; j <= n; j++) {
q.push(make_pair(d1[i][j], j));
}
mv[i][1] = q.top();
q.pop();
mv[i][2] = q.top();
q.pop();
mv[i][3] = q.top();
q.pop();
mv[i][4] = q.top();
q.pop();
}
for (int i = 1; i <= n; i++) {
priority_queue<pair<int, int> > q;
for (int j = 1; j <= n; j++) {
q.push(make_pair(d2[i][j], j));
}
mf[i][1] = q.top();
q.pop();
mf[i][2] = q.top();
q.pop();
mf[i][3] = q.top();
q.pop();
mf[i][4] = q.top();
q.pop();
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
continue;
}
int s = i;
int e = j;
int l1 = d1[i][j];
for (int k = 1; k <= 4; k++) {
if (mf[i][k].second == i || mf[i][k].second == j) {
continue;
}
for (int l = 1; l <= 4; l++) {
if (mv[j][l].second == i || mv[j][l].second == j) {
continue;
}
if (mf[i][k].second == mv[j][l].second) {
continue;
}
if (mx < l1 + mv[j][l].first + mf[i][k].first) {
mx = l1 + mv[j][l].first + mf[i][k].first;
a[1] = mf[i][k].second;
a[2] = i;
a[3] = j;
a[4] = mv[j][l].second;
}
}
}
}
}
for (int i = 1; i <= 4; i++) {
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 90000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
const int MX = 201000;
vector<int> adjList[MX];
int bad[MX], sz[MX], k, dis[MX];
int dfs1(int u, int p) {
sz[u] = bad[u];
for (auto v : adjList[u])
if (v != p) sz[u] += dfs1(v, u);
return sz[u];
}
int dfs2(int u, int p) {
for (auto v : adjList[u]) {
if (v == p) continue;
if (sz[v] > k) return dfs2(v, u);
}
return u;
}
void dfs3(int u, int p, int score) {
dis[u] = score;
for (auto v : adjList[u]) {
if (v != p) dfs3(v, u, score + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n >> k;
for (int i = 0; i < 2 * k; ++i) {
int u;
cin >> u;
bad[u - 1]++;
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adjList[u - 1].push_back(v - 1);
adjList[v - 1].push_back(u - 1);
}
dfs1(0, -1);
int x = dfs2(0, -1);
dfs3(x, -1, 0);
long long ans = 0LL;
for (int i = 0; i < n; ++i)
if (bad[i]) ans += dis[i];
cout << ans;
return 0;
}
| 8 | CPP |
a,b = map(int,input().split(' '))
s = input()
sum = 0
min = a
list = [0]*b
for i in s:
list[ord(i)-65]+=1
for i in list:
if i<min:
min = i
for i in list:
sum+=i-min
print(a-sum)
| 7 | PYTHON3 |
from sys import stdin,stdout
t = int(stdin.readline())
for z in range(t):
n=int(stdin.readline())
arr=list(map(int,stdin.readline().split()))
ans = 0
arr.sort()
i=0
while(i<n):
count=1
while(i<n):
if(arr[i]==count):
break
i+=1
count+=1
if(i<n):
ans+=1
i+=1
stdout.write(f"{ans}\n")
| 8 | PYTHON3 |
for _ in range(int(input())) :
x, y, a, b = map(int, input().split())
if (y - x) % (a + b) :
print(-1)
else :
print((y - x) // (a + b))
| 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int f;
cin >> f;
cout << (f-30)/2 << endl;
return 0;
}
| 0 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.